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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
2425866adff023a7f6d19d87d0103349179527239e4285cbd726127691bca042
| 11,916 |
.sol
|
Solidity
| false |
454395313
|
solidproof/projects
|
e4944c9bb61ee5a4776813b37db72129ff648eb2
|
Launchwall/PPOOL.sol
| 2,931 | 11,511 |
// SPDX-License-Identifier: Unlicensed
pragma solidity 0.8.17;
// ===== Start: Imports =====
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Caller is not the owner");
_;
}
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 {
require(newOwner != address(0), "ZERO ADDRESS");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
}
// ===== End: Imports =====
contract PPool is Context, Ownable {
using SafeMath for uint256;
receive() external payable {}
fallback() external payable {}
// DATA STRUCTURES
struct User {
uint256 predictionAmount; //
uint256 claimedAmount;
uint256 predictionType; // 0:empty, 1:yes, 2:no
}
struct UserStats {
uint256 totalAmountPredicted;
uint256 totalAmountClaimed;
uint256[] predictionsAped;
}
struct TotalStats {
uint256 totalAmountPredicted;
uint256 totalTimesPredicted;
uint256 totalAmountToBuyback;
uint256 percentBuyback;
uint256 nextId;
}
struct Prediction {
uint256 id;
string link;
string name;
uint256 yesAmount;
uint256 noAmount;
uint256 totalAmount;
uint256 status; // 0:accepting, 1:closed, 2:yes, 3:no, 4:cancelled
uint256 contributors; // number of contributors
uint256 creationTime;
mapping (address => User) usersAped;
}
mapping (uint256 => Prediction) public predictions;
mapping (address => UserStats) public users;
TotalStats public totalStats;
constructor() {
totalStats = TotalStats(0,0,0,10,0); // init values of totalStats
}
// EVENTS
event updateBuybackPercentEvent(uint256 percentBuyback_);
event createPredictionEvent(string link_, string name_, uint256 id_);
event updatePredictionStatusEvent(uint256 id_, uint256 status_);
event apePredictionEvent(uint256 id_, uint256 amount_, bool type_, address user_);
event claimPredictionEvent(uint256 id_, uint256 amount_, address user_);
// FUNCTIONS
// ===== Start: Owner Functions =====
function updateBuybackPercent(uint256 percentBuyback_) external onlyOwner {
require(percentBuyback_ <= 10, "too high");
totalStats.percentBuyback = percentBuyback_;
emit updateBuybackPercentEvent(percentBuyback_);
}
function createPrediction(string memory link_, string memory name_) external onlyOwner {
Prediction storage newPrediction = predictions[totalStats.nextId];
newPrediction.id = totalStats.nextId;
newPrediction.link = link_;
newPrediction.name = name_;
newPrediction.creationTime = block.timestamp;
emit createPredictionEvent(link_, name_, totalStats.nextId);
totalStats.nextId++;
}
function updatePredictionStatus(uint256 id_, uint256 status_) external onlyOwner {
require(predictions[id_].status < 2, "prediction over");
require(status_ < 5, "too high");
if (status_ == 2 || status_ == 3) {
require(predictions[id_].yesAmount != 0 && predictions[id_].noAmount != 0, "0-side"); // check for no empty side
predictions[id_].status = status_;
uint256 toBuyback = predictions[id_].totalAmount.mul(totalStats.percentBuyback).div(100);
totalStats.totalAmountToBuyback += toBuyback; // update app stats for total amount to buyback
payable(owner()).transfer(toBuyback);
} else {
predictions[id_].status = status_;
}
emit updatePredictionStatusEvent(id_, status_);
}
// ===== End: Owner Functions =====
// ===== Start: User Functions =====
function apePrediction(uint256 id_, uint256 amount_, bool type_) external payable {
require(id_ < totalStats.nextId, "id"); // check prediction exists
require(predictions[id_].status == 0, "status"); // check prediction accepting
require(msg.sender.balance >= amount_, "insuff"); // check sufficient user balance
require(msg.value == amount_, "incorrect sent"); // check amount_ sent
if (type_) { // if aping "yes"
require(predictions[id_].usersAped[msg.sender].predictionType != 2, "single-side no"); // check didn't predict "no" prior
predictions[id_].yesAmount += amount_; // update prediction "yes" amount
if (predictions[id_].usersAped[msg.sender].predictionType == 0) { // if 1st user ape for this prediction
predictions[id_].usersAped[msg.sender].predictionType = 1; // update predction type for user
users[msg.sender].predictionsAped.push(id_); // add prediction id to history of user predictions
predictions[id_].contributors++ ; // update contributor number
}
} else { // if aping "no"
require(predictions[id_].usersAped[msg.sender].predictionType != 1, "single-side yes"); // check didn't predict "yes" prior
predictions[id_].noAmount += amount_; // update prediction "no" amount
if (predictions[id_].usersAped[msg.sender].predictionType == 0) { // if 1st user ape for this prediction
predictions[id_].usersAped[msg.sender].predictionType = 2; // update predction type for user
users[msg.sender].predictionsAped.push(id_); // add prediction id to history of user predictions
predictions[id_].contributors++ ; // update contributor number
}
}
predictions[id_].usersAped[msg.sender].predictionAmount += amount_; // update user prediction amount
predictions[id_].totalAmount += amount_; // update prediction amount
users[msg.sender].totalAmountPredicted += amount_; // update user stats for total amount predicted
totalStats.totalAmountPredicted += amount_; // updated app stats for total amount predicted
totalStats.totalTimesPredicted++; // update app stats for total times predicted
emit apePredictionEvent(id_, amount_, type_, msg.sender);
}
function claimPrediction(uint256 id_) external {
require(predictions[id_].status > 1, "not claimable");
require(predictions[id_].usersAped[msg.sender].claimedAmount == 0, "already claimed"); // check if already claimed
require(predictions[id_].usersAped[msg.sender].predictionAmount > 0, "no contribution"); // check if participated
require(// require claimable only if user won / or if cancelled
(predictions[id_].status == 2 && predictions[id_].usersAped[msg.sender].predictionType == 1) || // if YES won & user aped YES
(predictions[id_].status == 3 && predictions[id_].usersAped[msg.sender].predictionType == 2) || // if NO won & user aped NO
(predictions[id_].status == 4), // if cancelled
"lost");
uint256 total = predictions[id_].totalAmount.mul(100-totalStats.percentBuyback).div(100);
// if YES won & user aped YES
if (predictions[id_].status == 2 && predictions[id_].usersAped[msg.sender].predictionType == 1) {
// (user prediction / yes amount) * total
uint256 claimed = predictions[id_].usersAped[msg.sender].predictionAmount.mul(total).div(predictions[id_].yesAmount);
predictions[id_].usersAped[msg.sender].claimedAmount = claimed;
payable(msg.sender).transfer(claimed);
emit claimPredictionEvent(id_, claimed, msg.sender);
}
// if NO won & user aped NO
if (predictions[id_].status == 3 && predictions[id_].usersAped[msg.sender].predictionType == 2) {
// (user prediction / no amount) * total
uint256 claimed = predictions[id_].usersAped[msg.sender].predictionAmount.mul(total).div(predictions[id_].noAmount);
predictions[id_].usersAped[msg.sender].claimedAmount = claimed;
payable(msg.sender).transfer(claimed);
emit claimPredictionEvent(id_, claimed, msg.sender);
}
// if cancelled
if (predictions[id_].status == 4) {
uint256 claimed = predictions[id_].usersAped[msg.sender].predictionAmount;
predictions[id_].usersAped[msg.sender].claimedAmount = claimed;
payable(msg.sender).transfer(claimed);
emit claimPredictionEvent(id_, claimed, msg.sender);
}
}
// for safety, pools open longer than 4 weeks can be cancelled by anyone
function fallbackCancel(uint256 id_) external {
require(predictions[id_].creationTime + 4 weeks < block.timestamp, "Too early");
require(predictions[id_].status <=2, "Already concluded");
predictions[id_].status = 4;
}
// ===== End: User Functions =====
// ===== Start: Data Functions =====
// user data for given prediction
function getUserPredictionData(uint256 id_, address user_) external view returns (User memory) {
return predictions[id_].usersAped[user_];
}
// ===== End: Data Functions =====
}
| 173,224 | 11,500 |
1ce57865c51741a3c1a065e8e23c99345a5c09e50a420b2bffab027c031e30a6
| 14,499 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0xf6e7ea2e29e64f62b667d5c6e0cf65ebb5ab5b5d.sol
| 3,239 | 12,679 |
pragma solidity ^0.5.1;
contract X3ProfitInMonthV3 {
struct Investor {
// Restart iteration index
int iteration;
// array containing information about beneficiaries
uint deposit;
// sum locked to remove in predstart period, gived by contract for
// compensation of previous iteration restart
uint lockedDeposit;
//array containing information about the time of payment
uint time;
//array containing information on interest paid
uint withdrawn;
//array containing information on interest paid (without tax)
uint withdrawnPure;
// Vote system for start iteration
bool isVoteProfit;
// Vote system for restart iteration
bool isVoteRestart;
// Default at any deposit we debt to user
bool isWeHaveDebt;
}
mapping(address => Investor) public investors;
//fund to transfer percent for MAIN OUR CONTRACT EasyInvestForeverProtected2
address payable public constant ADDRESS_MAIN_FUND = 0x3Bd33FF04e1F2BF01C8BF15C395D607100b7E116;
address payable public constant ADDRESS_ADMIN = 0x6249046Af9FB588bb4E70e62d9403DD69239bdF5;
//time through which you can take dividends
uint private constant TIME_QUANT = 1 days;
//start percent 10% per day
uint private constant PERCENT_DAY = 10;
uint private constant PERCENT_DECREASE_PER_ITERATION = 1;
uint private constant PERCENT_DECREASE_MINIMUM = 1;
//Adv tax for withdrawal 10%
uint private constant PERCENT_MAIN_FUND = 10;
//All percent should be divided by this
uint private constant PERCENT_DIVIDER = 100;
uint public countOfInvestors = 0;
uint public countOfAdvTax = 0;
uint public countStartVoices = 0;
uint public countReStartVoices = 0;
int public iterationIndex = 1;
int private undoDecreaseIteration = 0;
uint public countOfReturnDebt = 0;
uint public amountDebt = 0;
uint public amountReturnDebt = 0;
uint public amountOfCharity = 0;
// max contract balance in ether for overflow protection in calculations only
// 340 quintillion 282 quadrillion 366 trillion 920 billion 938 million 463 thousand 463
uint public constant maxBalance = 340282366920938463463374607431768211456 wei; //(2^128)
uint public constant maxDeposit = maxBalance / 1000;
// X3 Mode status
bool public isProfitStarted = false;
bool public isContractSealed = false;
modifier isUserExists() {
require(investors[msg.sender].iteration == iterationIndex, "Deposit not found");
_;
}
modifier timePayment() {
require(isContractSealed || now >= investors[msg.sender].time + TIME_QUANT, "Too fast payout request");
_;
}
//return of interest on the deposit
function collectPercent() isUserExists timePayment internal {
uint payout = payoutAmount(msg.sender);
_payout(msg.sender, payout, false);
}
function dailyPercent() public view returns(uint) {
uint percent = PERCENT_DAY;
int delta = 1 + undoDecreaseIteration;
if (delta > iterationIndex) delta = iterationIndex;
uint decrease = PERCENT_DECREASE_PER_ITERATION * (uint)(iterationIndex - delta);
if(decrease > percent - PERCENT_DECREASE_MINIMUM)
decrease = percent - PERCENT_DECREASE_MINIMUM;
percent -= decrease;
return percent;
}
//calculate the amount available for withdrawal on deposit
function payoutAmount(address addr) public view returns(uint) {
Investor storage inv = investors[addr];
if(inv.iteration != iterationIndex)
return 0;
if (isContractSealed)
{
if(inv.withdrawnPure >= inv.deposit) {
uint delta = 0;
if(amountReturnDebt < amountDebt) delta = amountDebt - amountReturnDebt;
// Sealed contract must transfer funds despite of complete debt payed
if(address(this).balance > delta)
return address(this).balance - delta;
return 0;
}
uint amount = inv.deposit - inv.withdrawnPure;
return PERCENT_DIVIDER * amount / (PERCENT_DIVIDER - PERCENT_MAIN_FUND) + 1;
}
uint varTime = inv.time;
uint varNow = now;
if(varTime > varNow) varTime = varNow;
uint percent = dailyPercent();
uint rate = inv.deposit * percent / PERCENT_DIVIDER;
uint fraction = 100;
uint interestRate = fraction * (varNow - varTime) / 1 days;
uint withdrawalAmount = rate * interestRate / fraction;
if(interestRate < fraction) withdrawalAmount = 0;
return withdrawalAmount;
}
//make a deposit
function makeDeposit() private {
if (msg.value > 0.000000001 ether) {
Investor storage inv = investors[msg.sender];
if (inv.iteration != iterationIndex) {
inv.iteration = iterationIndex;
countOfInvestors ++;
if(inv.deposit > inv.withdrawnPure)
inv.deposit -= inv.withdrawnPure;
else
inv.deposit = 0;
if(inv.deposit + msg.value > maxDeposit)
inv.deposit = maxDeposit - msg.value;
inv.withdrawn = 0;
inv.withdrawnPure = 0;
inv.time = now;
inv.lockedDeposit = inv.deposit;
amountDebt += inv.lockedDeposit;
inv.isVoteProfit = false;
inv.isVoteRestart = false;
inv.isWeHaveDebt = true;
}
if (!isContractSealed && now >= inv.time + TIME_QUANT) {
collectPercent();
}
if (!inv.isWeHaveDebt)
{
inv.isWeHaveDebt = true;
countOfReturnDebt--;
amountReturnDebt -= inv.deposit;
}
inv.deposit += msg.value;
amountDebt += msg.value;
} else {
collectPercent();
}
}
//return of deposit balance
function returnDeposit() isUserExists private {
if(isContractSealed)return;
Investor storage inv = investors[msg.sender];
uint withdrawalAmount = 0;
uint activDep = inv.deposit - inv.lockedDeposit;
if(activDep > inv.withdrawn)
withdrawalAmount = activDep - inv.withdrawn;
if(withdrawalAmount > address(this).balance){
withdrawalAmount = address(this).balance;
}
//Pay the rest of deposit and take taxes
_payout(msg.sender, withdrawalAmount, true);
//delete user record
_delete(msg.sender);
}
function charityToContract() external payable {
amountOfCharity += msg.value;
}
function() external payable {
if(msg.data.length > 0){
amountOfCharity += msg.value;
return;
}
require(msg.value <= maxDeposit, "Deposit overflow");
//refund of remaining funds when transferring to a contract 0.00000112 ether
Investor storage inv = investors[msg.sender];
if (!isContractSealed &&
msg.value == 0.00000112 ether && inv.iteration == iterationIndex) {
inv.deposit += msg.value;
if(inv.deposit > maxDeposit) inv.deposit = maxDeposit;
returnDeposit();
} else {
//start/restart X3 Mode on 0.00000111 ether / 0.00000101 ether
if ((!isContractSealed &&
(msg.value == 0.00000111 ether || msg.value == 0.00000101 ether)) ||
(msg.value == 0.00000102 ether&&msg.sender == ADDRESS_ADMIN))
{
if(inv.iteration != iterationIndex)
makeDeposit();
else
inv.deposit += msg.value;
if(inv.deposit > maxDeposit) inv.deposit = maxDeposit;
if(msg.value == 0.00000102 ether){
isContractSealed = !isContractSealed;
if (!isContractSealed)
{
undoDecreaseIteration++;
restart();
}
}
else
if(msg.value == 0.00000101 ether)
{
if(!inv.isVoteRestart)
{
countReStartVoices++;
inv.isVoteRestart = true;
}
else{
countReStartVoices--;
inv.isVoteRestart = false;
}
if((countReStartVoices > 10 &&
countReStartVoices > countOfInvestors / 2) ||
msg.sender == ADDRESS_ADMIN)
{
undoDecreaseIteration++;
restart();
}
}
else
if(!isProfitStarted)
{
if(!inv.isVoteProfit)
{
countStartVoices++;
inv.isVoteProfit = true;
}
else{
countStartVoices--;
inv.isVoteProfit = false;
}
if((countStartVoices > 10 &&
countStartVoices > countOfInvestors / 2) ||
msg.sender == ADDRESS_ADMIN)
start(msg.sender);
}
}
else
{
require(msg.value > 0.000000001 ether ||
address(this).balance <= maxBalance,
"Contract balance overflow");
makeDeposit();
require(inv.deposit <= maxDeposit, "Deposit overflow");
}
}
}
function start(address payable addr) private {
if (isContractSealed) return;
isProfitStarted = true;
uint payout = payoutAmount(ADDRESS_ADMIN);
_payout(ADDRESS_ADMIN, payout, false);
if(addr != ADDRESS_ADMIN){
payout = payoutAmount(addr);
_payout(addr, payout, false);
}
}
function restart() private {
if (isContractSealed) return;
if(dailyPercent() == PERCENT_DECREASE_MINIMUM)
{
isContractSealed = true;
return;
}
countOfInvestors = 0;
iterationIndex++;
countStartVoices = 0;
countReStartVoices = 0;
isProfitStarted = false;
amountDebt = 0;
amountReturnDebt = 0;
countOfReturnDebt = 0;
}
//Pays out, takes taxes according to holding time
function _payout(address payable addr, uint amount, bool retDep) private {
if(amount == 0)
return;
if(amount > address(this).balance) amount = address(this).balance;
if(amount == 0){
restart();
return;
}
Investor storage inv = investors[addr];
//Calculate pure payout that user receives
uint activDep = inv.deposit - inv.lockedDeposit;
bool isDeleteNeed = false;
if(!isContractSealed && !retDep && !isProfitStarted && amount + inv.withdrawn > activDep / 2)
{
if(inv.withdrawn < activDep / 2)
amount = (activDep/2) - inv.withdrawn;
else{
if(inv.withdrawn >= activDep)
{
_delete(addr);
return;
}
amount = activDep - inv.withdrawn;
isDeleteNeed = true;
}
}
uint interestPure = amount * (PERCENT_DIVIDER - PERCENT_MAIN_FUND) / PERCENT_DIVIDER;
//calculate money to charity
uint advTax = amount - interestPure;
inv.withdrawnPure += interestPure;
inv.withdrawn += amount;
inv.time = now;
//send money
if(advTax > 0)
{
(bool success, bytes memory data) = ADDRESS_MAIN_FUND.call.value(advTax)("");
if(success)
countOfAdvTax += advTax;
else
inv.withdrawn -= advTax;
}
if(interestPure > 0) addr.transfer(interestPure);
if(inv.isWeHaveDebt && inv.withdrawnPure >= inv.deposit)
{
amountReturnDebt += inv.deposit;
countOfReturnDebt++;
inv.isWeHaveDebt = false;
}
if(isDeleteNeed)
_delete(addr);
if(address(this).balance == 0)
restart();
}
//Clears user from registry
function _delete(address addr) private {
Investor storage inv = investors[addr];
if(inv.iteration != iterationIndex)
return;
amountDebt -= inv.deposit;
if(!inv.isWeHaveDebt){
countOfReturnDebt--;
amountReturnDebt-=inv.deposit;
inv.isWeHaveDebt = true;
}
inv.iteration = -1;
countOfInvestors--;
}
}
| 214,229 | 11,501 |
8fe3f5ddc53406054f9c7899f39f0918079f2a04a2d36f9c8cf1dde68beb8134
| 19,924 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs-wild-clean-contracts/0x2107a4aa352d92b73d0ea959a2a02384d68d8bfc.sol
| 4,848 | 19,051 |
pragma solidity 0.4.18;
contract Token { // ERC20 standard
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 SafeMath {
function safeMul(uint a, uint b) pure internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeSub(uint a, uint b) pure internal returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) pure internal returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
function safeNumDigits(uint number) pure internal returns (uint8) {
uint8 digits = 0;
while (number != 0) {
number /= 10;
digits++;
}
return digits;
}
// mitigate short address attack
// TODO: doublecheck implication of >= compared to ==
modifier onlyPayloadSize(uint numWords) {
assert(msg.data.length >= numWords * 32 + 4);
_;
}
}
contract StandardToken is Token, SafeMath {
uint256 public totalSupply;
function transfer(address _to, uint256 _value) onlyPayloadSize(2) public returns (bool success) {
require(_to != address(0));
require(balances[msg.sender] >= _value && _value > 0);
balances[msg.sender] = safeSub(balances[msg.sender], _value);
balances[_to] = safeAdd(balances[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) onlyPayloadSize(3) public returns (bool success) {
require(_to != address(0));
require(balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0);
balances[_from] = safeSub(balances[_from], _value);
balances[_to] = safeAdd(balances[_to], _value);
allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender], _value);
Transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
// 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
function approve(address _spender, uint256 _value) public onlyPayloadSize(2) returns (bool success) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function changeApproval(address _spender, uint256 _oldValue, uint256 _newValue) public onlyPayloadSize(3) returns (bool success) {
require(allowed[msg.sender][_spender] == _oldValue);
allowed[msg.sender][_spender] = _newValue;
Approval(msg.sender, _spender, _newValue);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
}
contract GRO is StandardToken {
// FIELDS
string public name = "Gron Digital";
string public symbol = "GRO";
uint256 public decimals = 18;
string public version = "10.0";
// Nine Hundred and Fifty million with support for 18 decimals
uint256 public tokenCap = 950000000 * 10**18;
// crowdsale parameters
uint256 public fundingStartBlock;
uint256 public fundingEndBlock;
// vesting fields
address public vestingContract;
bool private vestingSet = false;
// root control
address public fundWallet;
// control of liquidity and limited control of updatePrice
address public controlWallet;
// time to wait between controlWallet price updates
uint256 public waitTime = 5 hours;
// fundWallet controlled state variables
// halted: halt buying due to emergency, tradeable: signal that GRON platform is up and running
bool public halted = false;
bool public tradeable = false;
// -- totalSupply defined in StandardToken
// -- mapping to token balances done in StandardToken
uint256 public previousUpdateTime = 0;
Price public currentPrice;
uint256 public minAmount = 0.05 ether; // 500 GRO
// map participant address to a withdrawal request
mapping (address => Withdrawal) public withdrawals;
// maps previousUpdateTime to the next price
mapping (uint256 => Price) public prices;
// maps addresses
mapping (address => bool) public whitelist;
// TYPES
struct Price { // tokensPerEth
uint256 numerator;
}
struct Withdrawal {
uint256 tokens;
uint256 time; // time for each withdrawal is set to the previousUpdateTime
}
// EVENTS
event Buy(address indexed participant, address indexed beneficiary, uint256 weiValue, uint256 amountTokens);
event AllocatePresale(address indexed participant, uint256 amountTokens);
event BonusAllocation(address indexed participant, string participant_addr, string txnHash, uint256 bonusTokens);
event Mint(address indexed to, uint256 amount);
event Whitelist(address indexed participant);
event PriceUpdate(uint256 numerator);
event AddLiquidity(uint256 ethAmount);
event RemoveLiquidity(uint256 ethAmount);
event WithdrawRequest(address indexed participant, uint256 amountTokens);
event Withdraw(address indexed participant, uint256 amountTokens, uint256 etherAmount);
// MODIFIERS
modifier isTradeable { // exempt vestingContract and fundWallet to allow dev allocations
require(tradeable || msg.sender == fundWallet || msg.sender == vestingContract);
_;
}
modifier onlyWhitelist {
require(whitelist[msg.sender]);
_;
}
modifier onlyFundWallet {
require(msg.sender == fundWallet);
_;
}
modifier onlyManagingWallets {
require(msg.sender == controlWallet || msg.sender == fundWallet);
_;
}
modifier only_if_controlWallet {
if (msg.sender == controlWallet) _;
}
modifier require_waited {
require(safeSub(currentTime(), waitTime) >= previousUpdateTime);
_;
}
modifier only_if_decrease (uint256 newNumerator) {
if (newNumerator < currentPrice.numerator) _;
}
// CONSTRUCTOR
function GRO() public {
fundWallet = msg.sender;
whitelist[fundWallet] = true;
previousUpdateTime = currentTime();
}
// Called after deployment
// Not all deployment clients support constructor arguments.
// This function is provided for maximum compatibility.
function initialiseContract(address controlWalletInput, uint256 priceNumeratorInput, uint256 startBlockInput, uint256 endBlockInput) external onlyFundWallet {
require(controlWalletInput != address(0));
require(priceNumeratorInput > 0);
require(endBlockInput > startBlockInput);
controlWallet = controlWalletInput;
whitelist[controlWallet] = true;
currentPrice = Price(priceNumeratorInput);
fundingStartBlock = startBlockInput;
fundingEndBlock = endBlockInput;
previousUpdateTime = currentTime();
}
// METHODS
function setVestingContract(address vestingContractInput) external onlyFundWallet {
require(vestingContractInput != address(0));
vestingContract = vestingContractInput;
whitelist[vestingContract] = true;
vestingSet = true;
}
function updatePrice(uint256 newNumerator) external onlyManagingWallets {
require(newNumerator > 0);
require_limited_change(newNumerator);
// either controlWallet command is compliant or transaction came from fundWallet
currentPrice.numerator = newNumerator;
// maps time to new Price (if not during ICO)
prices[previousUpdateTime] = currentPrice;
previousUpdateTime = currentTime();
PriceUpdate(newNumerator);
}
function require_limited_change (uint256 newNumerator)
private
view
only_if_controlWallet
require_waited
only_if_decrease(newNumerator)
{
uint256 percentage_diff = 0;
percentage_diff = safeMul(newNumerator, 100) / currentPrice.numerator;
percentage_diff = safeSub(100, percentage_diff);
// controlWallet can only increase price by max 20% and only every waitTime
require(percentage_diff <= 20);
}
function mint(address participant, uint256 amountTokens) private {
require(vestingSet);
// 40% of total allocated for Founders, Team incentives & Bonuses.
// Solidity v0.4.18 - floating point is not fully supported,
// integer division results in truncated values
// Therefore we are multiplying out by 1000000... for
// precision. This allows ratios values up to 0.0000x or 0.00x percent
uint256 precision = 10**18;
uint256 allocationRatio = safeMul(amountTokens, precision) / safeMul(570000000, precision);
uint256 developmentAllocation = safeMul(allocationRatio, safeMul(380000000, precision)) / precision;
// check that token cap is not exceeded
uint256 newTokens = safeAdd(amountTokens, developmentAllocation);
require(safeAdd(totalSupply, newTokens) <= tokenCap);
// increase token supply, assign tokens to participant
totalSupply = safeAdd(totalSupply, newTokens);
balances[participant] = safeAdd(balances[participant], amountTokens);
balances[vestingContract] = safeAdd(balances[vestingContract], developmentAllocation);
Mint(fundWallet, newTokens);
Transfer(fundWallet, participant, amountTokens);
Transfer(fundWallet, vestingContract, developmentAllocation);
}
// amountTokens is not supplied in subunits. (without 18 0's)
function allocatePresaleTokens(address participant_address,
string participant_str,
uint256 amountTokens,
string txnHash)
external onlyFundWallet {
require(currentBlock() < fundingEndBlock);
require(participant_address != address(0));
uint256 bonusTokens = 0;
uint256 totalTokens = safeMul(amountTokens, 10**18); // scale to subunit
if (firstDigit(txnHash) == firstDigit(participant_str)) {
// Calculate 10% bonus
bonusTokens = safeMul(totalTokens, 10) / 100;
totalTokens = safeAdd(totalTokens, bonusTokens);
}
whitelist[participant_address] = true;
mint(participant_address, totalTokens);
// Events
Whitelist(participant_address);
AllocatePresale(participant_address, totalTokens);
BonusAllocation(participant_address, participant_str, txnHash, bonusTokens);
}
// returns the first character as a byte in a given hex string
// address Given 0x1abcd... returns 1
function firstDigit(string s) pure public returns(byte){
bytes memory strBytes = bytes(s);
return strBytes[2];
}
function verifyParticipant(address participant) external onlyManagingWallets {
whitelist[participant] = true;
Whitelist(participant);
}
function buy() external payable {
buyTo(msg.sender);
}
function buyTo(address participant) public payable onlyWhitelist {
require(!halted);
require(participant != address(0));
require(msg.value >= minAmount);
require(currentBlock() >= fundingStartBlock && currentBlock() < fundingEndBlock);
// msg.value in wei - scale to GRO
uint256 baseAmountTokens = safeMul(msg.value, currentPrice.numerator);
// calc lottery amount excluding potential ico bonus
uint256 lotteryAmount = blockLottery(baseAmountTokens);
uint256 icoAmount = safeMul(msg.value, icoNumeratorPrice());
uint256 tokensToBuy = safeAdd(icoAmount, lotteryAmount);
mint(participant, tokensToBuy);
// send ether to fundWallet
fundWallet.transfer(msg.value);
// Events
Buy(msg.sender, participant, msg.value, tokensToBuy);
}
// time based on blocknumbers, assuming a blocktime of 15s
function icoNumeratorPrice() public constant returns (uint256) {
uint256 icoDuration = safeSub(currentBlock(), fundingStartBlock);
uint256 numerator;
uint256 firstBlockPhase = 80640; // #blocks = 2*7*24*60*60/15 = 80640
uint256 secondBlockPhase = 161280; // // #blocks = 4*7*24*60*60/15 = 161280
uint256 thirdBlockPhase = 241920; // // #blocks = 6*7*24*60*60/15 = 241920
//uint256 fourthBlock = 322560; // #blocks = Greater Than thirdBlock
if (icoDuration < firstBlockPhase) {
numerator = 13000;
return numerator;
} else if (icoDuration < secondBlockPhase) {
numerator = 12000;
return numerator;
} else if (icoDuration < thirdBlockPhase) {
numerator = 11000;
return numerator;
} else {
numerator = 10000;
return numerator;
}
}
function currentBlock() private constant returns(uint256 _currentBlock) {
return block.number;
}
function currentTime() private constant returns(uint256 _currentTime) {
return now;
}
function blockLottery(uint256 _amountTokens) private constant returns(uint256) {
uint256 divisor = 10;
uint256 winning_digit = 0;
uint256 tokenWinnings = 0;
if (currentBlock() % divisor == winning_digit) {
tokenWinnings = safeMul(_amountTokens, 10) / 100;
}
return tokenWinnings;
}
function requestWithdrawal(uint256 amountTokensToWithdraw) external isTradeable onlyWhitelist {
require(currentBlock() > fundingEndBlock);
require(amountTokensToWithdraw > 0);
address participant = msg.sender;
require(balanceOf(participant) >= amountTokensToWithdraw);
require(withdrawals[participant].tokens == 0); // participant cannot have outstanding withdrawals
balances[participant] = safeSub(balances[participant], amountTokensToWithdraw);
withdrawals[participant] = Withdrawal({tokens: amountTokensToWithdraw, time: previousUpdateTime});
WithdrawRequest(participant, amountTokensToWithdraw);
}
function withdraw() external {
address participant = msg.sender;
uint256 tokens = withdrawals[participant].tokens;
require(tokens > 0); // participant must have requested a withdrawal
uint256 requestTime = withdrawals[participant].time;
// obtain the next price that was set after the request
Price price = prices[requestTime];
require(price.numerator > 0); // price must have been set
uint256 withdrawValue = tokens / price.numerator;
// if contract ethbal > then send + transfer tokens to fundWallet, otherwise give tokens back
withdrawals[participant].tokens = 0;
if (this.balance >= withdrawValue) {
enact_withdrawal_greater_equal(participant, withdrawValue, tokens);
}
else {
enact_withdrawal_less(participant, withdrawValue, tokens);
}
}
function enact_withdrawal_greater_equal(address participant, uint256 withdrawValue, uint256 tokens)
private
{
assert(this.balance >= withdrawValue);
balances[fundWallet] = safeAdd(balances[fundWallet], tokens);
participant.transfer(withdrawValue);
Withdraw(participant, tokens, withdrawValue);
}
function enact_withdrawal_less(address participant, uint256 withdrawValue, uint256 tokens)
private
{
assert(this.balance < withdrawValue);
balances[participant] = safeAdd(balances[participant], tokens);
Withdraw(participant, tokens, 0); // indicate a failed withdrawal
}
function checkWithdrawValue(uint256 amountTokensToWithdraw) public constant returns (uint256 etherValue) {
require(amountTokensToWithdraw > 0);
require(balanceOf(msg.sender) >= amountTokensToWithdraw);
uint256 withdrawValue = safeMul(amountTokensToWithdraw, currentPrice.numerator);
require(this.balance >= withdrawValue);
return withdrawValue;
}
// allow fundWallet or controlWallet to add ether to contract
function addLiquidity() external onlyManagingWallets payable {
require(msg.value > 0);
AddLiquidity(msg.value);
}
// allow fundWallet to remove ether from contract
function removeLiquidity(uint256 amount) external onlyManagingWallets {
require(amount <= this.balance);
fundWallet.transfer(amount);
RemoveLiquidity(amount);
}
function changeFundWallet(address newFundWallet) external onlyFundWallet {
require(newFundWallet != address(0));
fundWallet = newFundWallet;
}
function changeControlWallet(address newControlWallet) external onlyFundWallet {
require(newControlWallet != address(0));
controlWallet = newControlWallet;
}
function changeWaitTime(uint256 newWaitTime) external onlyFundWallet {
waitTime = newWaitTime;
}
function updateFundingStartBlock(uint256 newFundingStartBlock) external onlyFundWallet {
require(currentBlock() < fundingStartBlock);
require(currentBlock() < newFundingStartBlock);
fundingStartBlock = newFundingStartBlock;
}
function updateFundingEndBlock(uint256 newFundingEndBlock) external onlyFundWallet {
require(currentBlock() < fundingEndBlock);
require(currentBlock() < newFundingEndBlock);
fundingEndBlock = newFundingEndBlock;
}
function halt() external onlyFundWallet {
halted = true;
}
function unhalt() external onlyFundWallet {
halted = false;
}
function enableTrading() external onlyFundWallet {
require(currentBlock() > fundingEndBlock);
tradeable = true;
}
function claimTokens(address _token) external onlyFundWallet {
require(_token != address(0));
Token token = Token(_token);
uint256 balance = token.balanceOf(this);
token.transfer(fundWallet, balance);
}
// prevent transfers until trading allowed
function transfer(address _to, uint256 _value) public isTradeable returns (bool success) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public isTradeable returns (bool success) {
return super.transferFrom(_from, _to, _value);
}
}
| 134,589 | 11,502 |
419379eb1292946816aa6a18cafa4cb56cf5bfe40132fd03eef4a3d5189a555a
| 10,243 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xb8d24ac55866236b2c7b8fb046ca110d488fba02.sol
| 2,708 | 9,083 |
pragma solidity ^0.4.13;
// Interface to ZBR ICO Contract
contract DaoToken {
uint256 public CAP;
uint256 public totalEthers;
function proxyPayment(address participant) payable;
function transfer(address _to, uint _amount) returns (bool success);
}
contract ZiberToken {
// Store the amount of ETH deposited by each account.
mapping (address => uint256) public balances;
// Store whether or not each account would have made it into the crowdsale.
mapping (address => bool) public checked_in;
// ico for executing buy.
uint256 public ico;
// Track whether the contract has bought the tokens yet.
bool public bought_tokens;
// Record the time the contract bought the tokens.
uint256 public time_bought;
uint256 public extra_time_bought;
// Emergency kill switch in case a critical bug is found.
bool public kill_switch;
string public name;
string public symbol;
uint8 public decimals;
// Ratio of ZBR tokens received to ETH contributed
// 1.000.000 BGP = 80.000.000 ZBR
// 1ETH = 218 BGP (03.07.2017: https://www.coingecko.com/en/price_charts/ethereum/gbp)
// 1 ETH = 17440 ZBR
uint256 ZBR_per_eth = 17440;
//Total ZBR Tokens Reserve
uint256 ZBR_total_reserve = 100000000;
// ZBR Tokens for Developers
uint256 ZBR_dev_reserved = 10000000;
// ZBR Tokens for Selling over ICO
uint256 ZBR_for_selling = 80000000;
// ZBR Tokens for ico
uint256 ZBR_for_ico= 10000000;
// ETH for activate kill-switch in contract
uint256 min_eth_to_end = 50000 ether;
uint256 max_eth_to_end = 100000 ether;
uint registredTo;
uint256 loadedRefund;
uint256 _supply;
string _name;
string _symbol;
uint8 _decimals;
// The ZBR Token address and sale address are the same.
DaoToken public token = DaoToken(0xa9d585CE3B227d69985c3F7A866fE7d0e510da50);
// The developer address.
address developer_address = 0x004B74Ea737AFD25ce083573fB45a49da762aCD4;
mapping (address => uint256) public balanceOf;
event Transfer(address indexed from, address indexed to, uint256 value);
function ZiberToken() {
_supply = 10000000000;
balanceOf[msg.sender] = _supply;
name = "ZIBER LTD Crowdsale Tokens";
symbol = "ZBR";
decimals = 2;
}
/// SafeMath contract - math operations with safety checks
/// @author dev@smartcontracteam.com
function safeMul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint a, uint b) internal returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
function safeSub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
function 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;
}
}
function loadRefund() payable {
if(msg.value == 0) throw;
loadedRefund = safeAdd(loadedRefund, msg.value);
}
function refund() private {
uint256 weiValue = this.balance;
if (weiValue == 0) throw;
uint256 weiRefunded;
weiRefunded = safeAdd(weiRefunded, weiValue);
refund();
if (!msg.sender.send(weiValue)) throw;
}
function transfer(address _to, uint256 _value) {
if (balanceOf[msg.sender] < _value) throw;
if (balanceOf[_to] + _value < balanceOf[_to]) throw;
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
Transfer(msg.sender, _to, _value);
}
// Allows the developer to shut down everything except withdrawals in emergencies.
function activate_kill_switch() {
// Only allow the developer to activate the kill switch.
if (msg.sender != developer_address) throw;
// Irreversibly activate the kill switch.
kill_switch = true;
}
// Withdraws all ETH deposited or ZBR purchased by the sender.
function withdraw(){
// If called before the ICO, cancel caller's participation in the sale.
if (!bought_tokens) {
// Store the user's balance prior to withdrawal in a temporary variable.
uint256 eth_amount = balances[msg.sender];
// Update the user's balance prior to sending ETH to prevent recursive call.
balances[msg.sender] = 0;
// Return the user's funds. Throws on failure to prevent loss of funds.
msg.sender.transfer(eth_amount);
}
// Withdraw the sender's tokens if the contract has already purchased them.
else {
// Store the user's ZBR balance in a temporary variable (1 ETHWei -> 2000 ZBRWei).
uint256 ZBR_amount = balances[msg.sender] * ZBR_per_eth;
// Update the user's balance prior to sending ZBR to prevent recursive call.
balances[msg.sender] = 0;
// No fee for withdrawing if the user would have made it into the crowdsale alone.
uint256 fee = 0;
// 1% fee if the user didn't check in during the crowdsale.
if (!checked_in[msg.sender]) {
fee = ZBR_amount / 100;
// Send any non-zero fees to developer.
if(!token.transfer(developer_address, fee)) throw;
}
// Send the user their tokens. Throws if the crowdsale isn't over.
if(!token.transfer(msg.sender, ZBR_amount - fee)) throw;
}
}
// Allow developer to add ETH to the buy execution ico.
function add_to_ico() payable {
// Only allow the developer to contribute to the buy execution ico.
if (msg.sender != developer_address) throw;
// Disallow adding to ico if kill switch is active.
if (kill_switch) throw;
// Disallow adding to the ico if contract has already bought the tokens.
if (bought_tokens) throw;
// Update ico to include received amount.
ico += msg.value;
}
// Buys tokens in the crowdsale and rewards the caller, callable by anyone.
function claim_ico(){
// Short circuit to save gas if the contract has already bought tokens.
if (bought_tokens) return;
// Disallow buying into the crowdsale if kill switch is active.
if (kill_switch) throw;
// Record that the contract has bought the tokens.
bought_tokens = true;
// Record the time the contract bought the tokens.
time_bought = now + 1 days;
// Transfer all the funds (less the ico) to the ZBR crowdsale contract
// to buy tokens. Throws if the crowdsale hasn't started yet or has
// already completed, preventing loss of funds.
token.proxyPayment.value(this.balance - ico)(address(this));
// Send the caller their ico for buying tokens for the contract.
if(this.balance > max_eth_to_end)
{
msg.sender.transfer(ico);
}
else {
extra_time_bought = now + 1 days * 10;
if(this.balance < min_eth_to_end) throw;
else {
if (now > extra_time_bought) {
msg.sender.transfer(ico);
}
}
}
}
//Check is msg_sender is contract dev
modifier onlyOwner() {
if (msg.sender != developer_address) {
throw;
}
_;
}
// Send fund when ico end
function withdrawEth() onlyOwner {
msg.sender.transfer(this.balance);
}
//Kill contract
function kill() onlyOwner {
selfdestruct(developer_address);
}
// A helper function for the default function, allowing contracts to interact.
function default_helper() payable {
// Check if ICO Started: 27.07.2017 12:00 GMT to get ETH //1501156800
if (now < 1500655200) throw;
else {
// Treat near-zero ETH transactions as check ins and withdrawal requests.
if (msg.value <= 1 finney) {
// Check in during the crowdsale.
if (bought_tokens) {
// Only allow checking in before the crowdsale has reached the cap.
if (token.totalEthers() >= token.CAP()) throw;
// Mark user as checked in, meaning they would have been able to enter alone.
checked_in[msg.sender] = true;
}
// Withdraw funds if the crowdsale hasn't begun yet or is already over.
else {
withdraw();
}
}
// Deposit the user's funds for use in purchasing tokens.
else {
// Disallow deposits if kill switch is active.
if (kill_switch) throw;
// Only allow deposits if the contract hasn't already purchased the tokens.
if (bought_tokens) throw;
// Update records of deposited ETH to include the received amount.
balances[msg.sender] += msg.value;
}
}
}
// Default function. Called when a user sends ETH to the contract.
function () payable {
// Delegate to the helper function.
default_helper();
}
}
| 182,267 | 11,503 |
a4aabcb31a3e94687b86654bf827208135d9919f88662c2b6b827ecfab42bd54
| 16,855 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TU/TUuXyCPRcEBRByefhMQrrszPNn2jDc2G91_CyberChain.sol
| 4,739 | 15,995 |
//SourceUnit: cyberchain.tron.sol
pragma solidity 0.5.12;
interface ICyberChain {
enum Overflow {
DOWN,
DIRECT,
UP,
OUTRUN
}
event Register(address indexed addr, address indexed upline, uint256 id, uint40 time);
event BuyLevel(address indexed addr, uint8 level, uint40 time);
event SetFirstLine(address indexed addr, address indexed upline, uint8 level, Overflow overflow, uint40 time);
event SetSecondLine(address indexed addr, address indexed upline, uint8 level, Overflow overflow, uint40 time);
event Reinvest(address indexed addr, uint8 level, uint40 time);
event Profit(address indexed addr, uint256 amount, uint40 time);
event Lost(address indexed addr, uint256 amount, uint40 time);
function register(address payable _upline) payable external;
function register(uint256 _upline_id) payable external;
function upgrade() payable external returns(uint8 level);
function contractInfo() view external returns(uint256 _last_id, uint256 _turnover);
function getUserById(uint256 _id) view external returns(address addr, address upline);
function userInfo(address _addr) view external returns(uint256 id, address upline, uint8 level, uint256 profit, uint256 lost);
function userStructure(address _addr) view external returns(uint256[12] memory reinvests, uint256[12][4] memory referrals, uint256[12][3] memory referrals_line1, uint8[12][3] memory overflow_line1, uint256[12][8] memory referrals_line2, uint8[12][8] memory overflow_line2);
function userLevelStructure(address _addr, uint8 _level) view external returns(bool active, address upline, uint256 reinvests, uint256[4] memory referrals, uint256[3] memory referrals_line1, uint8[3] memory overflow_line1, uint256[8] memory referrals_line2, uint8[8] memory overflow_line2);
}
contract CyberChain is ICyberChain {
struct Level {
bool active;
address payable upline;
address payable[] referrals_line1;
Overflow[] overflow_line1;
address payable[] referrals_line2;
Overflow[] overflow_line2;
uint256 reinvest;
mapping(uint8 => uint256) referrals;
}
struct User {
uint256 id;
address payable upline;
uint256 profit;
uint256 lost;
mapping(uint8 => Level) levels;
}
uint8 public constant MAX_LEVEL = 12;
address public migrate_owner;
uint256 public migrate_offset;
address payable public root;
uint256 public last_id;
uint256 public turnover;
uint256[] public levels;
mapping(address => User) public users;
mapping(uint256 => address payable) public users_ids;
address payable public fee1;
address payable public fee2;
modifier onlyMigrate() {
require(msg.sender == migrate_owner, "Migrate already close");
_;
}
modifier migrateEnd() {
require(migrate_owner == address(0), "Migrate open");
_;
}
constructor() public {
migrate_owner = msg.sender;
root = 0xC1EB5eE972868165AD1b11f446eBaB1E9eeD4031;
fee1 = 0xb5629f6d439C4c949F67870203D4b98C1e117754;
fee2 = 0x632Bd3265cA3f60cc09D1390E55Aa7e8C74d1Cdb;
_addUser(root, address(0));
for(uint8 i = 0; i < MAX_LEVEL; i++) {
levels.push(i > 0 ? (levels[i - 1] * (i > 6 ? 3 : 2)) : 1e8);
users[root].levels[i].active = true;
emit BuyLevel(root, i, uint40(block.timestamp));
}
}
function() payable external {
_register(msg.sender, _bytesToAddress(msg.data), msg.value);
}
function _addUser(address payable _user, address payable _upline) private {
users[_user].id = ++last_id;
users[_user].upline = _upline;
users_ids[last_id] = _user;
emit Register(_user, _upline, last_id, uint40(block.timestamp));
}
function _send(address payable _addr, uint256 _value) private {
if(migrate_owner != address(0)) return;
if(_addr == address(0) || !_addr.send(_value)) {
root.transfer(_value);
}
else {
users[_addr].profit += _value;
emit Profit(_addr, _value, uint40(block.timestamp));
}
}
function _sendComm() private {
fee1.transfer(address(this).balance / 2);
fee2.transfer(address(this).balance);
}
function _setLevelUpline(address payable _user, address payable _upline, uint8 _level, bool _second, Overflow _overflow) private {
users[_upline].levels[_level].referrals[uint8(_overflow)]++;
if(_second) {
users[_upline].levels[_level].referrals_line2.push(_user);
users[_upline].levels[_level].overflow_line2.push(_overflow);
emit SetSecondLine(_user, _upline, _level, _overflow, uint40(block.timestamp));
}
else {
users[_user].levels[_level].upline = _upline;
users[_upline].levels[_level].referrals_line1.push(_user);
users[_upline].levels[_level].overflow_line1.push(_overflow);
emit SetFirstLine(_user, _upline, _level, _overflow, uint40(block.timestamp));
}
}
function _reinvest(address payable _user, uint8 _level) private {
users[_user].levels[_level].referrals_line1 = new address payable[](0);
users[_user].levels[_level].overflow_line1 = new Overflow[](0);
users[_user].levels[_level].referrals_line2 = new address payable[](0);
users[_user].levels[_level].overflow_line2 = new Overflow[](0);
users[_user].levels[_level].reinvest++;
emit Reinvest(_user, _level, uint40(block.timestamp));
if(_user != root) _buyLevel(_user, _level, true);
}
function _buyLevel(address payable _user, uint8 _level, bool _reinv) private {
if(!_reinv) {
users[_user].levels[_level].active = true;
emit BuyLevel(_user, _level, uint40(block.timestamp));
}
address payable upline = _findUplineHasLevel(users[_user].upline, _level);
bool overflow = users[_user].upline != upline;
if(overflow && migrate_owner == address(0)) {
users[users[_user].upline].lost += levels[_level];
emit Lost(users[_user].upline, levels[_level], uint40(block.timestamp));
}
if(users[upline].levels[_level].referrals_line1.length < 3) {
_setLevelUpline(_user, upline, _level, false, overflow ? Overflow.OUTRUN : Overflow.DIRECT);
address payable sup_upline = users[upline].levels[_level].upline;
if(sup_upline != address(0)) {
if(!_reinv) {
_send(upline, levels[_level] / 2);
if(users[sup_upline].levels[_level].referrals_line2.length > 7) _send(_findUplineHasLevel(users[users[_user].upline].upline, _level), levels[_level] / 2);
else if(users[sup_upline].levels[_level].referrals_line2.length > 6) _send(_findUplineHasLevel(users[_user].upline, _level), levels[_level] / 2);
else _send(sup_upline, levels[_level] / 2);
}
if(users[sup_upline].levels[_level].referrals_line2.length < 8) {
_setLevelUpline(_user, sup_upline, _level, true, overflow ? Overflow.OUTRUN : Overflow.DOWN);
}
else _reinvest(sup_upline, _level);
}
else if(!_reinv) _send(upline, levels[_level]);
}
else {
address payable sub_upline = _findFreeReferrer(upline, _level);
_setLevelUpline(_user, sub_upline, _level, false, overflow ? Overflow.OUTRUN : Overflow.UP);
if(!_reinv) {
_send(sub_upline, levels[_level] / 2);
if(users[upline].levels[_level].referrals_line2.length > 7) _send(_findUplineHasLevel(_findUplineOffset(_user, 3), _level), levels[_level] / 2);
else if(users[upline].levels[_level].referrals_line2.length > 6) _send(_findUplineHasLevel(_findUplineOffset(_user, 2), _level), levels[_level] / 2);
else _send(upline, levels[_level] / 2);
}
if(users[upline].levels[_level].referrals_line2.length < 8) {
_setLevelUpline(_user, upline, _level, true, overflow ? Overflow.OUTRUN : Overflow.DIRECT);
}
else _reinvest(upline, _level);
}
}
function _register(address payable _user, address payable _upline, uint256 _value) private migrateEnd {
require(_value == this.levelPriceWithComm(0), "Invalid amount");
require(users[_user].upline == address(0) && _user != root, "User already exists");
require(users[_upline].upline != address(0) || _upline == root, "Upline not found");
_addUser(_user, _upline);
_buyLevel(_user, 0, false);
_sendComm();
turnover += levels[0];
}
function register(address payable _upline) payable external {
_register(msg.sender, _upline, msg.value);
}
function register(uint256 _upline_id) payable external {
_register(msg.sender, users_ids[_upline_id], msg.value);
}
function upgrade() payable external migrateEnd returns(uint8 level) {
require(users[msg.sender].upline != address(0), "User not register");
for(uint8 i = 1; i < MAX_LEVEL; i++) {
if(!users[msg.sender].levels[i].active) {
level = i;
break;
}
}
require(level > 0, "All levels active");
require(msg.value == this.levelPriceWithComm(level), "Invalid amount");
_buyLevel(msg.sender, level, false);
_sendComm();
turnover += levels[level];
}
function _bytesToAddress(bytes memory _data) private pure returns(address payable addr) {
assembly {
addr := mload(add(_data, 20))
}
}
function _findUplineHasLevel(address payable _user, uint8 _level) private view returns(address payable) {
if(_user == root || (users[_user].levels[_level].active && (users[_user].levels[_level].reinvest == 0 || users[_user].levels[_level + 1].active || _level + 1 == MAX_LEVEL))) return _user;
return _findUplineHasLevel(users[_user].upline, _level);
}
function _findUplineOffset(address payable _user, uint8 _offset) private view returns(address payable) {
if(_user == root || _offset == 0) return _user;
return _findUplineOffset(users[_user].upline, _offset - 1);
}
function _findFreeReferrer(address payable _user, uint8 _level) private view returns(address payable) {
for(uint8 i = 0; i < 3; i++) {
address payable ref = users[_user].levels[_level].referrals_line1[i];
if(users[ref].levels[_level].referrals_line1.length < 3) {
return ref;
}
}
}
function levelPriceWithComm(uint8 _level) view external returns(uint256) {
return levels[_level] + (levels[_level] / 100 * 4);
}
function contractInfo() view external returns(uint256 _last_id, uint256 _turnover) {
return (last_id, turnover);
}
function getUserById(uint256 _id) view external returns(address addr, address upline) {
return (users_ids[_id], users[users_ids[_id]].upline);
}
function userInfo(address _addr) view external returns(uint256 id, address upline, uint8 level, uint256 profit, uint256 lost) {
for(uint8 l = 0; l < MAX_LEVEL; l++) {
if(!users[_addr].levels[l].active) break;
level = l;
}
return (users[_addr].id, users[_addr].upline, level, users[_addr].profit, users[_addr].lost);
}
function userStructure(address _addr) view external returns(uint256[12] memory reinvests, uint256[12][4] memory referrals, uint256[12][3] memory referrals_line1, uint8[12][3] memory overflow_line1, uint256[12][8] memory referrals_line2, uint8[12][8] memory overflow_line2) {
for(uint8 l = 0; l < MAX_LEVEL; l++) {
if(!users[_addr].levels[l].active) break;
reinvests[l] = users[_addr].levels[l].reinvest;
for(uint8 i = 0; i < 4; i++) {
referrals[i][l] = users[_addr].levels[l].referrals[i];
}
for(uint8 i = 0; i < 3; i++) {
if(i >= users[_addr].levels[l].referrals_line1.length) break;
referrals_line1[i][l] = users[users[_addr].levels[l].referrals_line1[i]].id;
overflow_line1[i][l] = uint8(users[_addr].levels[l].overflow_line1[i]);
}
for(uint8 i = 0; i < 8; i++) {
if(i >= users[_addr].levels[l].referrals_line2.length) break;
referrals_line2[i][l] = users[users[_addr].levels[l].referrals_line2[i]].id;
overflow_line2[i][l] = uint8(users[_addr].levels[l].overflow_line2[i]);
}
}
}
function userLevelStructure(address _addr, uint8 _level) view external returns(bool active, address upline, uint256 reinvests, uint256[4] memory referrals, uint256[3] memory referrals_line1, uint8[3] memory overflow_line1, uint256[8] memory referrals_line2, uint8[8] memory overflow_line2) {
active = users[_addr].levels[_level].active;
upline = users[_addr].levels[_level].upline;
reinvests = users[_addr].levels[_level].reinvest;
for(uint8 i = 0; i < 4; i++) {
referrals[i] = users[_addr].levels[_level].referrals[i];
}
for(uint8 i = 0; i < 3; i++) {
if(i >= users[_addr].levels[_level].referrals_line1.length) break;
referrals_line1[i] = users[users[_addr].levels[_level].referrals_line1[i]].id;
overflow_line1[i] = uint8(users[_addr].levels[_level].overflow_line1[i]);
}
for(uint8 i = 0; i < 8; i++) {
if(i >= users[_addr].levels[_level].referrals_line2.length) break;
referrals_line2[i] = users[users[_addr].levels[_level].referrals_line2[i]].id;
overflow_line2[i] = uint8(users[_addr].levels[_level].overflow_line2[i]);
}
}
function migrateList(uint256 _migrate_offset, bool[] calldata _updates, address payable[] calldata _users, uint256[] calldata _upline_ids__values) external onlyMigrate {
require(migrate_offset == _migrate_offset, "Bad offset");
for(uint256 i = 0; i < _updates.length; i++) {
if(!_updates[i]) {
require(users[_users[i]].upline == address(0) && _users[i] != root, "User already exists");
require(users[users_ids[_upline_ids__values[i]]].upline != address(0) || users_ids[_upline_ids__values[i]] == root, "Upline not found");
_addUser(_users[i], users_ids[_upline_ids__values[i]]);
_buyLevel(_users[i], 0, false);
}
else {
require(users[_users[i]].upline != address(0), "User not register");
uint8 level = 0;
for(uint8 j = 1; j < MAX_LEVEL; j++) {
if(!users[_users[i]].levels[j].active) {
level = j;
break;
}
}
require(level > 0, "All levels active");
require(_upline_ids__values[i] == this.levelPriceWithComm(level), "Bad value");
_buyLevel(_users[i], level, false);
}
}
migrate_offset += _updates.length;
}
function migrate(CyberChain _contract, uint256 _start, uint256 _limit) external onlyMigrate {
require(_start > 0 && _limit > 0, "Zero limit or start");
for(uint256 i = _start; i <= last_id && i < _start + _limit; i++) {
(,,, uint256 profit, uint256 lost) = _contract.userInfo(users_ids[i]);
users[users_ids[i]].profit = profit;
users[users_ids[i]].lost = lost;
}
}
function migrateClose(CyberChain _contract) external onlyMigrate {
turnover = _contract.turnover();
migrate_owner = address(0);
}
}
| 302,809 | 11,504 |
49f969b82eee3865220e1a48eb1b3ca5c156c3f880617ea8cb997ca90adb60af
| 8,958 |
.sol
|
Solidity
| false |
567235691
|
morpho-org/morpho-aave-v3
|
0f494b8321d20789692e50305532b7f1b8fb23ef
|
src/libraries/Types.sol
| 2,261 | 8,718 |
// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity ^0.8.17;
import {IAaveOracle} from "@aave-v3-core/interfaces/IAaveOracle.sol";
import {DataTypes} from "@aave-v3-core/protocol/libraries/types/DataTypes.sol";
import {LogarithmicBuckets} from "@morpho-data-structures/LogarithmicBuckets.sol";
/// @title Types
/// @author Morpho Labs
/// @custom:contact security@morpho.xyz
/// @notice Library exposing all Types used in Morpho.
library Types {
/// @notice Enumeration of the different position types in the protocol.
enum Position {
POOL_SUPPLIER,
P2P_SUPPLIER,
POOL_BORROWER,
P2P_BORROWER
}
/// @notice Contains the market side delta data.
struct MarketSideDelta {
uint256 scaledDelta; // The delta amount in pool unit.
uint256 scaledP2PTotal; // The total peer-to-peer amount in peer-to-peer unit.
}
/// @notice Contains the delta data for both `supply` and `borrow`.
struct Deltas {
MarketSideDelta supply; // The `MarketSideDelta` related to the supply side.
MarketSideDelta borrow; // The `MarketSideDelta` related to the borrow side.
}
/// @notice Contains the market side indexes.
struct MarketSideIndexes {
uint128 poolIndex; // The pool index (in ray).
uint128 p2pIndex; // The peer-to-peer index (in ray).
}
/// @notice Contains the indexes for both `supply` and `borrow`.
struct Indexes {
MarketSideIndexes supply; // The `MarketSideIndexes` related to the supply side.
MarketSideIndexes borrow; // The `MarketSideIndexes` related to the borrow side.
}
/// @notice Contains the different pauses statuses possible in Morpho.
struct PauseStatuses {
bool isP2PDisabled;
bool isSupplyPaused;
bool isSupplyCollateralPaused;
bool isBorrowPaused;
bool isWithdrawPaused;
bool isWithdrawCollateralPaused;
bool isRepayPaused;
bool isLiquidateCollateralPaused;
bool isLiquidateBorrowPaused;
bool isDeprecated;
}
/// @notice Contains the market data that is stored in storage.
/// @dev This market struct is able to be passed into memory.
struct Market {
// SLOT 0-1
Indexes indexes;
// SLOT 2-5
Deltas deltas; // 1024 bits
// SLOT 6
address underlying; // 160 bits
PauseStatuses pauseStatuses; // 80 bits
bool isCollateral; // 8 bits
// SLOT 7
address variableDebtToken; // 160 bits
uint32 lastUpdateTimestamp; // 32 bits
uint16 reserveFactor; // 16 bits
uint16 p2pIndexCursor; // 16 bits
// SLOT 8
address aToken; // 160 bits
// SLOT 9
address stableDebtToken; // 160 bits
// SLOT 10
uint256 idleSupply; // 256 bits
}
/// @notice Contains storage-only dynamic arrays and mappings.
struct MarketBalances {
LogarithmicBuckets.Buckets poolSuppliers; // In pool unit.
LogarithmicBuckets.Buckets p2pSuppliers; // In peer-to-peer unit.
LogarithmicBuckets.Buckets poolBorrowers; // In pool unit.
LogarithmicBuckets.Buckets p2pBorrowers; // In peer-to-peer unit.
mapping(address => uint256) collateral; // In pool unit.
}
/// @notice Contains the minimum number of iterations for a `repay` or a `withdraw`.
struct Iterations {
uint128 repay;
uint128 withdraw;
}
/// @notice Contains the data related to the liquidity of a user.
struct LiquidityData {
uint256 borrowable; // The maximum debt value allowed to borrow (in base currency).
uint256 maxDebt; // The maximum debt value allowed before being liquidatable (in base currency).
uint256 debt; // The debt value (in base currency).
}
/// @notice The paramaters used to compute the new peer-to-peer indexes.
struct IndexesParams {
MarketSideIndexes256 lastSupplyIndexes; // The last supply indexes stored (in ray).
MarketSideIndexes256 lastBorrowIndexes; // The last borrow indexes stored (in ray).
uint256 poolSupplyIndex; // The current pool supply index (in ray).
uint256 poolBorrowIndex; // The current pool borrow index (in ray).
uint256 reserveFactor; // The reserve factor percentage (10 000 = 100%).
uint256 p2pIndexCursor; // The peer-to-peer index cursor (10 000 = 100%).
Deltas deltas; // The deltas and peer-to-peer amounts.
uint256 proportionIdle; // The amount of proportion idle (in underlying).
}
struct GrowthFactors {
uint256 poolSupplyGrowthFactor; // The pool's supply index growth factor (in ray).
uint256 p2pSupplyGrowthFactor; // Peer-to-peer supply index growth factor (in ray).
uint256 poolBorrowGrowthFactor; // The pool's borrow index growth factor (in ray).
uint256 p2pBorrowGrowthFactor; // Peer-to-peer borrow index growth factor (in ray).
}
/// @notice Contains the market side indexes as uint256 instead of uint128.
struct MarketSideIndexes256 {
uint256 poolIndex; // The pool index (in ray).
uint256 p2pIndex; // The peer-to-peer index (in ray).
}
/// @notice Contains the indexes as uint256 instead of uint128.
struct Indexes256 {
MarketSideIndexes256 supply; // The `MarketSideIndexes` related to the supply as uint256.
MarketSideIndexes256 borrow; // The `MarketSideIndexes` related to the borrow as uint256.
}
/// @notice Contains the `v`, `r` and `s` parameters of an ECDSA signature.
struct Signature {
uint8 v;
bytes32 r;
bytes32 s;
}
/// @notice Variables used in the matching engine.
struct MatchingEngineVars {
address underlying; // The underlying asset address.
MarketSideIndexes256 indexes; // The indexes of the market side.
uint256 amount; // The amount to promote or demote (in underlying).
uint256 maxIterations; // The maximum number of iterations allowed.
bool borrow; // Whether the process happens on the borrow side or not.
function (address, address, uint256, uint256, bool) returns (uint256, uint256) updateDS; // This function will be used to update the data-structure.
bool demoting; // True for demote, False for promote.
function(uint256, uint256, MarketSideIndexes256 memory, uint256)
pure returns (uint256, uint256, uint256) step; // This function will be used to decide whether to use the algorithm for promoting or for demoting.
}
/// @notice Variables used in the liquidity computation process of a `user`.
/// @dev Used to avoid stack too deep.
struct LiquidityVars {
address user; // The user address.
IAaveOracle oracle; // The oracle used by Aave.
DataTypes.EModeCategory eModeCategory; // The data related to the eMode category (could be empty if not in any e-mode).
}
/// @notice Variables used during a borrow or withdraw.
/// @dev Used to avoid stack too deep.
struct BorrowWithdrawVars {
uint256 onPool; // The working scaled balance on pool of the user.
uint256 inP2P; // The working scaled balance in peer-to-peer of the user.
uint256 toWithdraw; // The amount to withdraw from the pool (in underlying).
uint256 toBorrow; // The amount to borrow on the pool (in underlying).
}
/// @notice Variables used during a supply or repay.
/// @dev Used to avoid stack too deep.
struct SupplyRepayVars {
uint256 onPool; // The working scaled balance on pool of the user.
uint256 inP2P; // The working scaled balance in peer-to-peer of the user.
uint256 toSupply; // The amount to supply on the pool (in underlying).
uint256 toRepay; // The amount to repay on the pool (in underlying).
}
/// @notice Variables used during a liquidate.
/// @dev Used to avoid stack too deep.
struct LiquidateVars {
uint256 closeFactor; // The close factor used during the liquidation process.
uint256 seized; // The amount of collateral to be seized (in underlying).
}
/// @notice Variables used to compute the amount to seize during a liquidation.
/// @dev Used to avoid stack too deep.
struct AmountToSeizeVars {
uint256 liquidationBonus; // The liquidation bonus used during the liquidation process.
uint256 borrowedTokenUnit; // The borrowed token unit.
uint256 collateralTokenUnit; // The collateral token unit.
uint256 borrowedPrice; // The borrowed token price (in base currency).
uint256 collateralPrice; // The collateral token price (in base currency).
}
}
| 9,135 | 11,505 |
9f0e5525ed6a4b8b68955cab83fd78550c985335b015dd4df6583ae87153c6f6
| 19,345 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x7600977eb9effa627d6bd0da2e5be35e11566341.sol
| 5,880 | 18,951 |
pragma solidity 0.4.21;
pragma experimental "v0.5.0";
interface Token {
function transfer(address to, uint256 value) external returns (bool success);
function transferFrom(address from, address to, uint256 value) external returns (bool success);
}
contract Dex2 {
struct TokenInfo {
string symbol;
address tokenAddr;
uint64 scaleFactor;
uint minDeposit;
}
struct TraderInfo {
address withdrawAddr;
uint8 feeRebatePercent;
}
struct TokenAccount {
uint64 balanceE8;
uint64 pendingWithdrawE8;
}
struct Order {
uint32 pairId;
uint8 action;
uint8 ioc;
uint64 priceE8;
uint64 amountE8;
uint64 expireTimeSec;
}
struct Deposit {
address traderAddr;
uint16 tokenCode;
uint64 pendingAmountE8;
}
struct DealInfo {
uint16 stockCode;
uint16 cashCode;
uint64 stockDealAmountE8;
uint64 cashDealAmountE8;
}
struct ExeStatus {
uint64 logicTimeSec;
uint64 lastOperationIndex;
}
uint constant MAX_UINT256 = 2**256 - 1;
uint16 constant MAX_FEE_RATE_E4 = 60;
uint64 constant ETH_SCALE_FACTOR = 10**18;
uint8 constant ACTIVE = 0;
uint8 constant CLOSED = 2;
bytes32 constant HASHTYPES =
keccak256('string title', 'address market_address', 'uint64 nonce', 'uint64 expire_time_sec',
'uint64 amount_e8', 'uint64 price_e8', 'uint8 immediate_or_cancel', 'uint8 action',
'uint16 cash_token_code', 'uint16 stock_token_code');
address public admin;
mapping (uint16 => TokenInfo) public tokens;
uint8 public marketStatus;
uint16 public makerFeeRateE4;
uint16 public takerFeeRateE4;
uint16 public withdrawFeeRateE4;
uint64 public lastDepositIndex;
ExeStatus public exeStatus;
mapping (address => TraderInfo) public traders;
mapping (uint176 => TokenAccount) public accounts;
mapping (uint224 => Order) public orders;
mapping (uint64 => Deposit) public deposits;
event DeployMarketEvent();
event ChangeMarketStatusEvent(uint8 status);
event SetTokenInfoEvent(uint16 tokenCode, string symbol, address tokenAddr, uint64 scaleFactor, uint minDeposit);
event SetWithdrawAddrEvent(address trader, address withdrawAddr);
event DepositEvent(address trader, uint16 tokenCode, string symbol, uint64 amountE8, uint64 depositIndex);
event WithdrawEvent(address trader, uint16 tokenCode, string symbol, uint64 amountE8, uint64 lastOpIndex);
event TransferFeeEvent(uint16 tokenCode, uint64 amountE8, address toAddr);
event ConfirmDepositEvent(address trader, uint16 tokenCode, uint64 balanceE8);
event InitiateWithdrawEvent(address trader, uint16 tokenCode, uint64 amountE8, uint64 pendingWithdrawE8);
event MatchOrdersEvent(address trader1, uint64 nonce1, address trader2, uint64 nonce2);
event HardCancelOrderEvent(address trader, uint64 nonce);
event SetFeeRatesEvent(uint16 makerFeeRateE4, uint16 takerFeeRateE4, uint16 withdrawFeeRateE4);
event SetFeeRebatePercentEvent(address trader, uint8 feeRebatePercent);
function Dex2(address admin_) public {
admin = admin_;
setTokenInfo(0 , "ETH", 0 , ETH_SCALE_FACTOR, 0);
emit DeployMarketEvent();
}
function() external {
revert();
}
function changeMarketStatus(uint8 status_) external {
if (msg.sender != admin) revert();
if (marketStatus == CLOSED) revert();
marketStatus = status_;
emit ChangeMarketStatusEvent(status_);
}
function setWithdrawAddr(address withdrawAddr) external {
if (withdrawAddr == 0) revert();
if (traders[msg.sender].withdrawAddr != 0) revert();
traders[msg.sender].withdrawAddr = withdrawAddr;
emit SetWithdrawAddrEvent(msg.sender, withdrawAddr);
}
function depositEth(address traderAddr) external payable {
if (marketStatus != ACTIVE) revert();
if (traderAddr == 0) revert();
if (msg.value < tokens[0].minDeposit) revert();
if (msg.data.length != 4 + 32) revert();
uint64 pendingAmountE8 = uint64(msg.value / (ETH_SCALE_FACTOR / 10**8));
if (pendingAmountE8 == 0) revert();
uint64 depositIndex = ++lastDepositIndex;
setDeposits(depositIndex, traderAddr, 0, pendingAmountE8);
emit DepositEvent(traderAddr, 0, "ETH", pendingAmountE8, depositIndex);
}
function depositToken(address traderAddr, uint16 tokenCode, uint originalAmount) external {
if (marketStatus != ACTIVE) revert();
if (traderAddr == 0) revert();
if (tokenCode == 0) revert();
if (msg.data.length != 4 + 32 + 32 + 32) revert();
TokenInfo memory tokenInfo = tokens[tokenCode];
if (originalAmount < tokenInfo.minDeposit) revert();
if (tokenInfo.scaleFactor == 0) revert();
if (!Token(tokenInfo.tokenAddr).transferFrom(msg.sender, this, originalAmount)) revert();
if (originalAmount > MAX_UINT256 / 10**8) revert();
uint amountE8 = originalAmount * 10**8 / uint(tokenInfo.scaleFactor);
if (amountE8 >= 2**64 || amountE8 == 0) revert();
uint64 depositIndex = ++lastDepositIndex;
setDeposits(depositIndex, traderAddr, tokenCode, uint64(amountE8));
emit DepositEvent(traderAddr, tokenCode, tokens[tokenCode].symbol, uint64(amountE8), depositIndex);
}
function withdrawEth(address traderAddr) external {
if (traderAddr == 0) revert();
if (msg.data.length != 4 + 32) revert();
uint176 accountKey = uint176(traderAddr);
uint amountE8 = accounts[accountKey].pendingWithdrawE8;
if (amountE8 == 0) return;
accounts[accountKey].pendingWithdrawE8 = 0;
uint truncatedWei = amountE8 * (ETH_SCALE_FACTOR / 10**8);
address withdrawAddr = traders[traderAddr].withdrawAddr;
if (withdrawAddr == 0) withdrawAddr = traderAddr;
withdrawAddr.transfer(truncatedWei);
emit WithdrawEvent(traderAddr, 0, "ETH", uint64(amountE8), exeStatus.lastOperationIndex);
}
function withdrawToken(address traderAddr, uint16 tokenCode) external {
if (traderAddr == 0) revert();
if (tokenCode == 0) revert();
if (msg.data.length != 4 + 32 + 32) revert();
TokenInfo memory tokenInfo = tokens[tokenCode];
if (tokenInfo.scaleFactor == 0) revert();
uint176 accountKey = uint176(tokenCode) << 160 | uint176(traderAddr);
uint amountE8 = accounts[accountKey].pendingWithdrawE8;
if (amountE8 == 0) return;
accounts[accountKey].pendingWithdrawE8 = 0;
uint truncatedAmount = amountE8 * uint(tokenInfo.scaleFactor) / 10**8;
address withdrawAddr = traders[traderAddr].withdrawAddr;
if (withdrawAddr == 0) withdrawAddr = traderAddr;
if (!Token(tokenInfo.tokenAddr).transfer(withdrawAddr, truncatedAmount)) revert();
emit WithdrawEvent(traderAddr, tokenCode, tokens[tokenCode].symbol, uint64(amountE8),
exeStatus.lastOperationIndex);
}
function transferFee(uint16 tokenCode, uint64 amountE8, address toAddr) external {
if (msg.sender != admin) revert();
if (toAddr == 0) revert();
if (msg.data.length != 4 + 32 + 32 + 32) revert();
TokenAccount memory feeAccount = accounts[uint176(tokenCode) << 160];
uint64 withdrawE8 = feeAccount.pendingWithdrawE8;
if (amountE8 < withdrawE8) {
withdrawE8 = amountE8;
}
feeAccount.pendingWithdrawE8 -= withdrawE8;
accounts[uint176(tokenCode) << 160] = feeAccount;
TokenInfo memory tokenInfo = tokens[tokenCode];
uint originalAmount = uint(withdrawE8) * uint(tokenInfo.scaleFactor) / 10**8;
if (tokenCode == 0) {
toAddr.transfer(originalAmount);
} else {
if (!Token(tokenInfo.tokenAddr).transfer(toAddr, originalAmount)) revert();
}
emit TransferFeeEvent(tokenCode, withdrawE8, toAddr);
}
function exeSequence(uint header, uint[] body) external {
if (msg.sender != admin) revert();
uint64 nextOperationIndex = uint64(header);
if (nextOperationIndex != exeStatus.lastOperationIndex + 1) revert();
uint64 newLogicTimeSec = uint64(header >> 64);
if (newLogicTimeSec < exeStatus.logicTimeSec) revert();
for (uint i = 0; i < body.length; nextOperationIndex++) {
uint bits = body[i];
uint opcode = bits & 0xFFFF;
bits >>= 16;
if ((opcode >> 8) != 0xDE) revert();
if (opcode == 0xDE01) {
confirmDeposit(uint64(bits));
i += 1;
continue;
}
if (opcode == 0xDE02) {
initiateWithdraw(uint176(bits), uint64(bits >> 176));
i += 1;
continue;
}
if (marketStatus != ACTIVE) revert();
if (opcode == 0xDE03) {
uint8 v1 = uint8(bits);
bits >>= 8;
Order memory makerOrder;
if (v1 == 0) {
if (i + 1 >= body.length) revert();
makerOrder = orders[uint224(bits)];
i += 1;
} else {
if (orders[uint224(bits)].pairId != 0) revert();
if (i + 4 >= body.length) revert();
makerOrder = parseNewOrder(uint224(bits) , v1, body, i);
i += 4;
}
uint8 v2 = uint8(body[i]);
uint224 takerOrderKey = uint224(body[i] >> 8);
Order memory takerOrder;
if (v2 == 0) {
takerOrder = orders[takerOrderKey];
i += 1;
} else {
if (orders[takerOrderKey].pairId != 0) revert();
if (i + 3 >= body.length) revert();
takerOrder = parseNewOrder(takerOrderKey, v2, body, i);
i += 4;
}
matchOrder(uint224(bits) , makerOrder, takerOrderKey, takerOrder);
continue;
}
if (opcode == 0xDE04) {
hardCancelOrder(uint224(bits));
i += 1;
continue;
}
if (opcode == 0xDE05) {
setFeeRates(uint16(bits), uint16(bits >> 16), uint16(bits >> 32));
i += 1;
continue;
}
if (opcode == 0xDE06) {
setFeeRebatePercent(address(bits) , uint8(bits >> 160));
i += 1;
continue;
}
}
setExeStatus(newLogicTimeSec, nextOperationIndex - 1);
}
function setTokenInfo(uint16 tokenCode, string symbol, address tokenAddr, uint64 scaleFactor,
uint minDeposit) public {
if (msg.sender != admin) revert();
if (marketStatus != ACTIVE) revert();
if (scaleFactor == 0) revert();
TokenInfo memory info = tokens[tokenCode];
if (info.scaleFactor != 0) {
tokens[tokenCode].minDeposit = minDeposit;
emit SetTokenInfoEvent(tokenCode, info.symbol, info.tokenAddr, info.scaleFactor, minDeposit);
return;
}
tokens[tokenCode].symbol = symbol;
tokens[tokenCode].tokenAddr = tokenAddr;
tokens[tokenCode].scaleFactor = scaleFactor;
tokens[tokenCode].minDeposit = minDeposit;
emit SetTokenInfoEvent(tokenCode, symbol, tokenAddr, scaleFactor, minDeposit);
}
function setDeposits(uint64 depositIndex, address traderAddr, uint16 tokenCode, uint64 amountE8) private {
deposits[depositIndex].traderAddr = traderAddr;
deposits[depositIndex].tokenCode = tokenCode;
deposits[depositIndex].pendingAmountE8 = amountE8;
}
function setExeStatus(uint64 logicTimeSec, uint64 lastOperationIndex) private {
exeStatus.logicTimeSec = logicTimeSec;
exeStatus.lastOperationIndex = lastOperationIndex;
}
function confirmDeposit(uint64 depositIndex) private {
Deposit memory deposit = deposits[depositIndex];
uint176 accountKey = (uint176(deposit.tokenCode) << 160) | uint176(deposit.traderAddr);
TokenAccount memory account = accounts[accountKey];
if (account.balanceE8 + deposit.pendingAmountE8 <= account.balanceE8) revert();
account.balanceE8 += deposit.pendingAmountE8;
deposits[depositIndex].pendingAmountE8 = 0;
accounts[accountKey].balanceE8 += deposit.pendingAmountE8;
emit ConfirmDepositEvent(deposit.traderAddr, deposit.tokenCode, account.balanceE8);
}
function initiateWithdraw(uint176 tokenAccountKey, uint64 amountE8) private {
uint64 balanceE8 = accounts[tokenAccountKey].balanceE8;
uint64 pendingWithdrawE8 = accounts[tokenAccountKey].pendingWithdrawE8;
if (balanceE8 < amountE8 || amountE8 == 0) revert();
balanceE8 -= amountE8;
uint64 feeE8 = calcFeeE8(amountE8, withdrawFeeRateE4, address(tokenAccountKey));
amountE8 -= feeE8;
if (pendingWithdrawE8 + amountE8 < amountE8) revert();
pendingWithdrawE8 += amountE8;
accounts[tokenAccountKey].balanceE8 = balanceE8;
accounts[tokenAccountKey].pendingWithdrawE8 = pendingWithdrawE8;
if (accounts[tokenAccountKey & (0xffff << 160)].pendingWithdrawE8 + feeE8 >= feeE8) {
accounts[tokenAccountKey & (0xffff << 160)].pendingWithdrawE8 += feeE8;
}
emit InitiateWithdrawEvent(address(tokenAccountKey), uint16(tokenAccountKey >> 160) ,
amountE8, pendingWithdrawE8);
}
function getDealInfo(uint32 pairId, uint64 priceE8, uint64 amount1E8, uint64 amount2E8)
private pure returns (DealInfo deal) {
deal.stockCode = uint16(pairId);
deal.cashCode = uint16(pairId >> 16);
if (deal.stockCode == deal.cashCode) revert();
deal.stockDealAmountE8 = amount1E8 < amount2E8 ? amount1E8 : amount2E8;
uint cashDealAmountE8 = uint(priceE8) * uint(deal.stockDealAmountE8) / 10**8;
if (cashDealAmountE8 >= 2**64) revert();
deal.cashDealAmountE8 = uint64(cashDealAmountE8);
}
function calcFeeE8(uint64 amountE8, uint feeRateE4, address traderAddr)
private view returns (uint64) {
uint feeE8 = uint(amountE8) * feeRateE4 / 10000;
feeE8 -= feeE8 * uint(traders[traderAddr].feeRebatePercent) / 100;
return uint64(feeE8);
}
function settleAccounts(DealInfo deal, address traderAddr, uint feeRateE4, bool isBuyer) private {
uint16 giveTokenCode = isBuyer ? deal.cashCode : deal.stockCode;
uint16 getTokenCode = isBuyer ? deal.stockCode : deal.cashCode;
uint64 giveAmountE8 = isBuyer ? deal.cashDealAmountE8 : deal.stockDealAmountE8;
uint64 getAmountE8 = isBuyer ? deal.stockDealAmountE8 : deal.cashDealAmountE8;
uint176 giveAccountKey = uint176(giveTokenCode) << 160 | uint176(traderAddr);
uint176 getAccountKey = uint176(getTokenCode) << 160 | uint176(traderAddr);
uint64 feeE8 = calcFeeE8(getAmountE8, feeRateE4, traderAddr);
getAmountE8 -= feeE8;
if (accounts[giveAccountKey].balanceE8 < giveAmountE8) revert();
if (accounts[getAccountKey].balanceE8 + getAmountE8 < getAmountE8) revert();
accounts[giveAccountKey].balanceE8 -= giveAmountE8;
accounts[getAccountKey].balanceE8 += getAmountE8;
if (accounts[uint176(getTokenCode) << 160].pendingWithdrawE8 + feeE8 >= feeE8) {
accounts[uint176(getTokenCode) << 160].pendingWithdrawE8 += feeE8;
}
}
function setOrders(uint224 orderKey, uint32 pairId, uint8 action, uint8 ioc,
uint64 priceE8, uint64 amountE8, uint64 expireTimeSec) private {
orders[orderKey].pairId = pairId;
orders[orderKey].action = action;
orders[orderKey].ioc = ioc;
orders[orderKey].priceE8 = priceE8;
orders[orderKey].amountE8 = amountE8;
orders[orderKey].expireTimeSec = expireTimeSec;
}
function matchOrder(uint224 makerOrderKey, Order makerOrder,
uint224 takerOrderKey, Order takerOrder) private {
if (marketStatus != ACTIVE) revert();
if (makerOrderKey == takerOrderKey) revert();
if (makerOrder.pairId != takerOrder.pairId) revert();
if (makerOrder.action == takerOrder.action) revert();
if (makerOrder.priceE8 == 0 || takerOrder.priceE8 == 0) revert();
if (makerOrder.action == 0 && makerOrder.priceE8 < takerOrder.priceE8) revert();
if (takerOrder.action == 0 && takerOrder.priceE8 < makerOrder.priceE8) revert();
if (makerOrder.amountE8 == 0 || takerOrder.amountE8 == 0) revert();
if (makerOrder.expireTimeSec <= exeStatus.logicTimeSec) revert();
if (takerOrder.expireTimeSec <= exeStatus.logicTimeSec) revert();
DealInfo memory deal = getDealInfo(makerOrder.pairId, makerOrder.priceE8, makerOrder.amountE8, takerOrder.amountE8);
settleAccounts(deal, address(makerOrderKey), makerFeeRateE4, (makerOrder.action == 0));
settleAccounts(deal, address(takerOrderKey), takerFeeRateE4, (takerOrder.action == 0));
if (makerOrder.ioc == 1) {
makerOrder.amountE8 = 0;
} else {
makerOrder.amountE8 -= deal.stockDealAmountE8;
}
if (takerOrder.ioc == 1) {
takerOrder.amountE8 = 0;
} else {
takerOrder.amountE8 -= deal.stockDealAmountE8;
}
setOrders(makerOrderKey, makerOrder.pairId, makerOrder.action, makerOrder.ioc,
makerOrder.priceE8, makerOrder.amountE8, makerOrder.expireTimeSec);
setOrders(takerOrderKey, takerOrder.pairId, takerOrder.action, takerOrder.ioc,
takerOrder.priceE8, takerOrder.amountE8, takerOrder.expireTimeSec);
emit MatchOrdersEvent(address(makerOrderKey), uint64(makerOrderKey >> 160) ,
address(takerOrderKey), uint64(takerOrderKey >> 160));
}
function hardCancelOrder(uint224 orderKey) private {
orders[orderKey].pairId = 0xFFFFFFFF;
orders[orderKey].amountE8 = 0;
emit HardCancelOrderEvent(address(orderKey) , uint64(orderKey >> 160));
}
function setFeeRates(uint16 makerE4, uint16 takerE4, uint16 withdrawE4) private {
if (makerE4 > MAX_FEE_RATE_E4) revert();
if (takerE4 > MAX_FEE_RATE_E4) revert();
if (withdrawE4 > MAX_FEE_RATE_E4) revert();
makerFeeRateE4 = makerE4;
takerFeeRateE4 = takerE4;
withdrawFeeRateE4 = withdrawE4;
emit SetFeeRatesEvent(makerE4, takerE4, withdrawE4);
}
function setFeeRebatePercent(address traderAddr, uint8 feeRebatePercent) private {
if (feeRebatePercent > 100) revert();
traders[traderAddr].feeRebatePercent = feeRebatePercent;
emit SetFeeRebatePercentEvent(traderAddr, feeRebatePercent);
}
function parseNewOrder(uint224 orderKey, uint8 v, uint[] body, uint i) private view returns (Order) {
uint240 bits = uint240(body[i + 1]);
uint64 nonce = uint64(orderKey >> 160);
address traderAddr = address(orderKey);
if (traderAddr == 0) revert();
bytes32 hash1 = keccak256("\x19Ethereum Signed Message:\n70DEx2 Order: ", address(this), nonce, bits);
if (traderAddr != ecrecover(hash1, v, bytes32(body[i + 2]), bytes32(body[i + 3]))) {
bytes32 hashValues = keccak256("DEx2 Order", address(this), nonce, bits);
bytes32 hash2 = keccak256(HASHTYPES, hashValues);
if (traderAddr != ecrecover(hash2, v, bytes32(body[i + 2]), bytes32(body[i + 3]))) revert();
}
Order memory order;
order.pairId = uint32(bits); bits >>= 32;
order.action = uint8(bits); bits >>= 8;
order.ioc = uint8(bits); bits >>= 8;
order.priceE8 = uint64(bits); bits >>= 64;
order.amountE8 = uint64(bits); bits >>= 64;
order.expireTimeSec = uint64(bits);
return order;
}
}
| 161,515 | 11,506 |
e165141ca7d451eb9c0f1a60b4c9f4d49ad0735f54284285525ab9ec92571450
| 12,466 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TG/TG5ccc7ia5hrAvNF3EmegkfHdHS2yLfY3h_blackTron.sol
| 3,375 | 11,973 |
//SourceUnit: blackTron.sol
pragma solidity ^0.4.25;
contract blackTron {
using SafeMath for uint256;
uint256 public totalPlayers;
uint256 public totalPayout;
uint256 public totalRefDistributed;
uint256 public totalInvested;
uint256 private minDepositSize = 100000000;
uint256 private interestRateDivisor = 1000000000000;
uint256 public devCommission = 50;
uint256 public commissionDivisor = 1000;
address private devAddress = msg.sender;
uint private releaseTime = 1616173200; // MARCH 20 01:00, 2021 UTC
address owner;
struct Player {
uint256 trxDeposit;
uint256 time;
uint256 interestProfit;
uint256 affRewards;
uint256 payoutSum;
address affFrom;
uint256 tier;
}
struct Referral {
address player_addr;
uint256 aff1sum;
uint256 aff2sum;
uint256 aff3sum;
}
mapping(address => Referral) public referrals;
mapping(address => Player) public players;
constructor() public {
owner = msg.sender;
}
function register(address _addr, address _affAddr) private {
Player storage player = players[_addr];
player.affFrom = _affAddr;
player.tier = 0;
setRefCount(_addr, _affAddr);
}
function setRefCount(address _addr, address _affAddr) private {
Referral storage preferral = referrals[_addr];
preferral.player_addr = _addr;
address _affAddr2 = players[_affAddr].affFrom;
address _affAddr3 = players[_affAddr2].affFrom;
referrals[_affAddr].aff1sum = referrals[_affAddr].aff1sum.add(1);
referrals[_affAddr2].aff2sum = referrals[_affAddr2].aff2sum.add(1);
referrals[_affAddr3].aff3sum = referrals[_affAddr3].aff3sum.add(1);
}
function setTier(address _addr) private {
Player storage player = players[_addr];
if(player.trxDeposit > 5e9 && player.tier < 1) { player.tier = 1; player.time = now; }
if(player.trxDeposit > 10e9 && player.tier < 2) { player.tier = 2; player.time = now; }
if(player.trxDeposit > 20e9 && player.tier < 3) { player.tier = 3; player.time = now; }
if(player.trxDeposit > 50e9 && player.tier < 4) { player.tier = 4; player.time = now; }
}
function getRate(uint256 _tier) internal pure returns (uint256) {
uint256 _rate = 2314814;
if(_tier == 1) { _rate = 1736111; }
if(_tier == 2) { _rate = 1157407; }
if(_tier == 3) { _rate = 694444; }
if(_tier == 4) { _rate = 231482; }
return _rate;
}
function getTimeLimit(uint256 _tier) internal pure returns(uint256) {
uint256 timeLimit = 1296000;
if(_tier == 1) timeLimit = 1728000;
if(_tier == 2) timeLimit = 2592000;
if(_tier == 3) timeLimit = 4320000;
if(_tier == 4) timeLimit = 12960000;
return timeLimit;
}
function deposit(address _affAddr) public payable {
require(now >= releaseTime, "not launched yet!");
require(msg.value >= minDepositSize);
collect(msg.sender);
uint256 depositAmount = msg.value;
Player storage player = players[msg.sender];
if (player.time == 0) {
player.time = now;
totalPlayers++;
if (_affAddr != address(0) && players[_affAddr].trxDeposit > 0) {
register(msg.sender, _affAddr);
} else {
register(msg.sender, owner);
}
}
player.trxDeposit = player.trxDeposit.add(depositAmount);
setTier(msg.sender);
distributeRef(msg.value, player.affFrom);
totalInvested = totalInvested.add(depositAmount);
uint256 devEarn = depositAmount.mul(devCommission).div(commissionDivisor);
devAddress.transfer(devEarn);
}
function withdraw_referral() public {
require(now >= releaseTime, "not launched yet!");
require(players[msg.sender].affRewards > 0);
transferReferral(msg.sender, players[msg.sender].affRewards);
}
function withdraw() public {
require(now >= releaseTime, "not launched yet!");
collect(msg.sender);
require(players[msg.sender].interestProfit > 0);
transferPayout(msg.sender, players[msg.sender].interestProfit);
}
function reinvest() public {
require(now >= releaseTime, "not launched yet!");
collect(msg.sender);
Player storage player = players[msg.sender];
uint256 depositAmount = player.interestProfit;
require(address(this).balance >= depositAmount);
player.interestProfit = 0;
player.trxDeposit = player.trxDeposit.add(depositAmount);
setTier(msg.sender);
distributeRef(depositAmount, player.affFrom);
}
function collect(address _addr) internal {
Player storage player = players[_addr];
uint256 secPassed = now.sub(player.time);
uint256 timeLimit = 1296000;
if(player.tier == 1) timeLimit = 1728000;
if(player.tier == 2) timeLimit = 2592000;
if(player.tier == 3) timeLimit = 4320000;
if(player.tier == 4) timeLimit = 12960000;
uint256 _rate = getRate(player.tier);
if (secPassed > timeLimit && player.time > 0) {
secPassed = timeLimit;
uint256 collectProfit = (player.trxDeposit.mul(secPassed.mul(_rate))).div(interestRateDivisor);
player.interestProfit = player.interestProfit.add(collectProfit);
player.time = player.time.add(secPassed);
} else if (secPassed > 0 && player.time > 0) {
collectProfit = (player.trxDeposit.mul(secPassed.mul(_rate))).div(interestRateDivisor);
player.interestProfit = player.interestProfit.add(collectProfit);
player.time = player.time.add(secPassed);
}
}
function transferReferral(address _receiver, uint256 _amount) internal {
if (_amount > 0 && _receiver != address(0)) {
uint256 contractBalance = address(this).balance;
if (contractBalance > 0) {
uint256 payout =
_amount > contractBalance ? contractBalance : _amount;
totalPayout = totalPayout.add(payout);
players[_receiver].affRewards = players[_receiver]
.affRewards
.sub(payout);
Player storage player = players[_receiver];
player.payoutSum = player.payoutSum.add(payout);
msg.sender.transfer(payout);
}
}
}
function transferPayout(address _receiver, uint256 _amount) internal {
if (_amount > 0 && _receiver != address(0)) {
uint256 contractBalance = address(this).balance;
if (contractBalance > 0) {
uint256 payout = _amount > contractBalance ? contractBalance : _amount;
totalPayout = totalPayout.add(payout);
Player storage player = players[_receiver];
player.payoutSum = player.payoutSum.add(payout);
player.interestProfit = player.interestProfit.sub(payout);
uint256 maxProfit = (player.trxDeposit.mul(300)).div(100);
uint256 paid = player.payoutSum;
if (paid > maxProfit) { player.trxDeposit = 0; }
msg.sender.transfer(payout);
}
}
}
function distributeRef(uint256 _trx, address _affFrom) private {
if(_affFrom == address(0)) _affFrom = owner;
address _affAddr2 = players[_affFrom].affFrom;
address _affAddr3 = players[_affAddr2].affFrom;
if(_affAddr2 == address(0)) _affAddr2 = owner;
if(_affAddr3 == address(0)) _affAddr3 = owner;
uint256 refTrx = (_trx.mul(8)).div(100);
totalRefDistributed = totalRefDistributed.add(refTrx);
players[_affFrom].affRewards = players[_affFrom].affRewards.add(refTrx);
refTrx = (_trx.mul(5)).div(100);
totalRefDistributed = totalRefDistributed.add(refTrx);
players[_affAddr2].affRewards = players[_affAddr2].affRewards.add(refTrx);
refTrx = (_trx.mul(2)).div(100);
totalRefDistributed = totalRefDistributed.add(refTrx);
players[_affAddr3].affRewards = players[_affAddr3].affRewards.add(refTrx);
}
function getProfit(address _addr) public view returns (uint256) {
address playerAddress = _addr;
Player storage player = players[playerAddress];
require(player.time > 0, "player time is 0");
uint256 secPassed = now.sub(player.time);
uint256 timeLimit = getTimeLimit(player.tier);
uint256 _rate = getRate(player.tier);
if (secPassed > 0) {
if (secPassed > timeLimit) {
secPassed = timeLimit;
uint256 collectProfit = (player.trxDeposit.mul(secPassed.mul(_rate))).div(interestRateDivisor);
} else {
collectProfit = (player.trxDeposit.mul(secPassed.mul(_rate))).div(interestRateDivisor);
}
}
return collectProfit.add(player.interestProfit);
}
function getRemainingTime(address _addr) internal view returns(uint256) {
Player storage player = players[_addr];
uint256 secPassed = now.sub(player.time);
uint256 timeLimit = getTimeLimit(player.tier);
if (secPassed > 0) {
if (secPassed > timeLimit) {
secPassed = timeLimit;
}
}
timeLimit = timeLimit - secPassed;
return timeLimit;
}
function getContractInfo() public view returns (uint256 total_users,
uint256 total_invested,
uint256 total_withdrawn,
uint256 total_referrals,
uint256 contract_balance,
uint256 contract_launchdate) {
total_users = totalPlayers;
total_invested = totalInvested;
total_withdrawn = totalPayout;
total_referrals = totalRefDistributed;
contract_balance = address(this).balance;
contract_launchdate = releaseTime;
return (total_users,
total_invested,
total_withdrawn,
total_referrals,
contract_balance,
contract_launchdate);
}
function getUserInfo(address _addr) public view returns (uint256 total_deposit,
uint256 remaining_time,
uint256 withdrawable,
uint256 withdrawn,
uint256 ref_rewards,
uint256 referrals1,
uint256 referrals2,
uint256 referrals3,
uint256 tier) {
Player storage player = players[_addr];
if(player.time != 0) {
total_deposit = player.trxDeposit;
remaining_time = getRemainingTime(_addr);
withdrawable = getProfit(_addr);
withdrawn = player.payoutSum;
ref_rewards = player.affRewards;
referrals1 = referrals[_addr].aff1sum;
referrals2 = referrals[_addr].aff2sum;
referrals3 = referrals[_addr].aff3sum;
tier = player.tier;
}
return (total_deposit,
remaining_time,
withdrawable,
withdrawn,
ref_rewards,
referrals1,
referrals2,
referrals3,
tier);
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
}
| 298,621 | 11,507 |
5a4303fc95439d18278019864218caac653b5bd6f828baa3f69b14bf5266a7fc
| 14,373 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x2f7904F9614E261190D98d39867317B663ee099C/contract.sol
| 3,590 | 13,833 |
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Initializable {
bool private initialized;
bool private initializing;
modifier initializer() {
require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized");
bool isTopLevelCall = !initializing;
if (isTopLevelCall) {
initializing = true;
initialized = true;
}
_;
if (isTopLevelCall) {
initializing = false;
}
}
function isConstructor() private view returns (bool) {
address self = address(this);
uint256 cs;
assembly { cs := extcodesize(self) }
return cs == 0;
}
uint256[50] private ______gap;
}
contract StakePool is Initializable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public depositToken;
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);
_balances[msg.sender] = _balances[msg.sender].add(amount);
depositToken.safeTransferFrom(msg.sender, address(this), amount);
}
function _withdraw(uint256 amount) internal {
if (msg.sender != address(feeTo)) {
uint256 feeamount = amount.div(20);
uint256 finalamount = (amount - feeamount);
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
depositToken.safeTransfer(msg.sender, finalamount);
depositToken.safeTransfer(feeTo, feeamount);
} else {
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
depositToken.safeTransfer(msg.sender, amount);
}
}
function _withdrawFeeOnly(uint256 amount) internal {
uint256 feeamount = amount.div(20);
_totalSupply = _totalSupply.sub(feeamount);
_balances[msg.sender] = _balances[msg.sender].sub(feeamount);
depositToken.safeTransfer(feeTo, feeamount);
}
function feeToUpdate(address _feeTo) public {
require(msg.sender == feeTo, "feeTo: wut?");
feeTo = _feeTo;
}
}
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) {
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
contract CUPSPOOL is StakePool {
IERC20 public rewardToken;
uint256 public halvingPeriod = 604800;
uint256 public totalreward;
uint256 public starttime;
uint256 public stakingtime;
uint256 public eraPeriod = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
uint256 public totalRewards = 0;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
constructor(address _depositToken, address _rewardToken, uint256 _totalreward, uint256 _starttime, uint256 _stakingtime) public {
super.initialize(_depositToken, msg.sender);
rewardToken = IERC20(_rewardToken);
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 Token");
super._stake(amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public updateReward(msg.sender) checkhalve checkStart stakingTime{
require(amount > 0, "ERROR: Cannot withdraw 0");
super._withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function exit() external stakingTime{
withdraw(balanceOf(msg.sender));
_getRewardInternal();
}
function getReward() public updateReward(msg.sender) checkhalve checkStart stakingTime{
uint256 reward = earned(msg.sender);
uint256 bal = balanceOf(msg.sender);
if (reward > 0) {
rewards[msg.sender] = 0;
if (bal > 0) {
super._withdrawFeeOnly(bal);
}
rewardToken.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
totalRewards = totalRewards.add(reward);
}
}
function _getRewardInternal() internal updateReward(msg.sender) checkhalve checkStart{
uint256 reward = earned(msg.sender);
if (reward > 0) {
rewards[msg.sender] = 0;
rewardToken.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 not allowed yet");
_;
}
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);
}
}
| 255,532 | 11,508 |
4fa0eb3d377befddc7e775d55b85dbba81a0e395d6398d1a72173c82acbaaa07
| 29,452 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/12/1220fE62bb269AB448E214dd63736e1863747D0F_NEWSHARE.sol
| 5,182 | 18,696 |
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 NEWSHARE 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 = 15000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'NEWSHARE Token';
string private constant _symbol = 'NSHARES';
uint256 private _taxFee = 400;
uint256 private _burnFee = 0;
uint public max_tx_size = 15000 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 != 0xcc24E578f40B7818BfD7F57631C2DC291a37D388, 'We can not exclude router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(!isPaused || isAllowed[sender],"Unauthorized sender,wait until unpaused");
if(sender != owner() && recipient != owner())
require(amount <= max_tx_size, "Transfer amount exceeds 1% of Total Supply.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(100)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(100)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() public view returns(uint256) {
return _taxFee;
}
function _getBurnFee() public view returns(uint256) {
return _burnFee;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
_taxFee = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
_burnFee = burnFee;
}
function setMaxTxAmount(uint newMax) external onlyOwner {
max_tx_size = newMax;
}
}
| 320,504 | 11,509 |
73b0722fc201fbde5b4a8dfe08a87c034a1380237e5b2bcdd3216f156bc9d2c4
| 15,081 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x62190802001819f42cb2eda7017d3c617af431c1.sol
| 3,982 | 14,096 |
pragma solidity ^0.4.24;
contract INTIME {
using SafeMath for *;
struct Player {
uint id;
uint referrer;
uint generation;
string name;
uint256 weight;
uint256 balance;
uint256 withdrawal;
uint256 referralBonus;
uint256 lastKeyBonus;
uint256 potBonus;
uint256 stakingBonus;
uint256 airdropBonus;
}
mapping(address => Player) public players;
// System
address public teamAddress;
uint256 public teamNamingIncome;
address public keyAddress;
address[] participantPool;
uint256 participantPoolStart;
uint256 participantPoolEnd;
address[] public participants;
uint256 public participantsLength;
address[] public winner;
uint256 public deadline;
uint256 keyPrice_min;
uint256 keyPrice_max;
uint256 public keyPrice;
uint256 public currentGeneration;
uint256 public currentKeyRound;
uint256 public duration;
uint256[] public durationPhaseArray;
uint256 public durationPhaseIndex;
uint256 public poolWeight;
uint256 public poolBalance;
uint256 public poolReward;
uint256 public poolWithdraw;
bool public airdropped;
bool public keyLocked;
uint256 public airdropWinTime;
uint256 public airdropBalance;
uint256 public airdroppedAmount;
uint256 public unitStake;
uint256 public potReserve;
mapping(string => address) addressFromName;
event Withdrawal(address indexed _from,
uint256 _value);
event Deposit(address indexed _keyHolder,
uint256 _weight,
uint256 _keyPrice,
uint256 _deadline,
uint256 _durationPhaseIndex,
bool _phaseChanged,
uint256 _poolBalance,
uint256 _poolReward,
uint256 _poolWeight,
// If Airdrop
bool _airdropped,
uint256 _airdropBalance,
// If Trigger Reserve
bool _potReserveGive,
uint256 _potReserve);
modifier isHuman() {
address _addr = msg.sender;
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
_;
}
constructor (address _teamAddress) public {
teamAddress = _teamAddress;
keyPrice_min = 1e14; // in wei, 0.0001 eth
keyPrice_max = 15e15; // in wei, 0.015 eth
keyPrice = keyPrice_min; // in wei, 0.0001 eth
keyAddress = msg.sender;
durationPhaseArray = [1440, 720, 360, 180, 90, 60, 30];
durationPhaseIndex = 0;
duration = durationPhaseArray[durationPhaseIndex];
currentGeneration = 0;
resetGame();
}
function resetGame() private {
uint256 residualBalance = 0;
if(currentGeneration != 0) {
// Distribute tokens
// Staking distribution => distributed on deposit
// Pool distribution => 20%
unitStake = 0;
// 75% for the winner;
players[keyAddress].balance += poolBalance / 5 * 75 / 100;
players[keyAddress].lastKeyBonus += poolBalance / 5 * 75 / 100;
// 15% for random participant
if(participantPoolEnd - participantPoolStart > 0) {
uint randParticipantIndex = rand(participantPoolStart + 1, participantPoolEnd);
players[participantPool[randParticipantIndex - 1]].balance += poolBalance / 5 * 15 / 100;
players[participantPool[randParticipantIndex - 1]].lastKeyBonus += poolBalance / 5 * 15 / 100;
} else {
players[keyAddress].balance += poolBalance / 5 * 15 / 100;
players[keyAddress].lastKeyBonus += poolBalance / 5 * 15 / 100;
}
// 10% and pot reserve for next round
residualBalance += poolBalance / 5 * 10 / 100 + potReserve;
winner.push(keyAddress);
}
airdropWinTime = now;
keyPrice = 1e15;
poolWeight = 0;
poolReward = 0;
potReserve = 0;
// Reset duration and deadline
durationPhaseIndex = 0;
duration = durationPhaseArray[durationPhaseIndex];
deadline = now + duration * 1 minutes;
poolBalance = residualBalance;
keyLocked = false;
currentKeyRound = 0;
currentGeneration ++;
keyAddress = teamAddress;
participantPoolStart = participantPool.length;
participantPoolEnd = participantPool.length;
}
function setName(string name) isHuman() payable public {
uint256 amount = msg.value;
require(amount >= 1e15);
require(addressFromName[name] == address(0));
players[teamAddress].balance += amount;
teamNamingIncome += amount;
players[msg.sender].name = name;
addressFromName[name] = msg.sender;
}
function referralName (string name) isHuman() payable public {
if(addressFromName[name] != address(0) && addressFromName[name] != msg.sender && players[msg.sender].referrer == 0)
players[msg.sender].referrer = players[addressFromName[name]].id;
uint256 amount = msg.value;
deposit(amount);
}
function referralPay (uint referrer) isHuman() payable public {
if(referrer > participants.length)
referrer = 0;
if(players[msg.sender].id != referrer && players[msg.sender].referrer == 0)
players[msg.sender].referrer = referrer;
uint256 amount = msg.value;
deposit(amount);
}
function () isHuman() payable public {
uint256 amount = msg.value;
deposit(amount);
}
function depositVault (uint keyCount, uint referrer) isHuman() public {
require(keyLocked == false);
keyLocked = true;
// Buy key from current balance
uint256 amount = keyCount * keyPrice;
uint256 availableWithdrawal = players[msg.sender].balance - players[msg.sender].withdrawal;
require(amount <= availableWithdrawal);
require(amount > 0);
players[msg.sender].withdrawal += amount;
if(referrer > participants.length)
referrer = 0;
if(players[msg.sender].id != referrer && players[msg.sender].referrer == 0)
players[msg.sender].referrer = referrer;
keyLocked = false;
deposit(amount);
}
function deposit(uint256 amount) private {
if(now >= deadline) resetGame();
require(keyLocked == false);
keyLocked = true;
// Update pool balance
require(amount >= keyPrice, "You have to buy at least one key.");
poolBalance += amount;
currentKeyRound ++;
participantPool.push(msg.sender);
participantPoolEnd = participantPool.length;
// Update deadline if not last round
if(durationPhaseIndex < 6) deadline = now + duration * 1 minutes;
// Update key holder
keyAddress = msg.sender;
if(players[msg.sender].generation == 0) {
participants.push(msg.sender);
participantsLength = participants.length;
players[msg.sender].id = participants.length;
}
if(players[msg.sender].generation != currentGeneration) {
players[msg.sender].generation = currentGeneration;
players[msg.sender].weight = 0;
}
// Handling stake distribution
uint256 p_i = 0;
uint256 deltaStake = 0;
address _addr;
// 58% for staking
if(poolWeight > 0) {
unitStake = amount * 58 / 100 / poolWeight;
for(p_i = 0; p_i < participants.length; p_i++) {
_addr = participants[p_i];
if(players[_addr].generation == currentGeneration) {
players[_addr].balance += players[_addr].weight * unitStake;
players[_addr].stakingBonus += players[_addr].weight * unitStake;
}
}
}
// 15% for referral
if(players[msg.sender].referrer > 0) {
_addr = participants[players[msg.sender].referrer - 1];
players[_addr].balance += amount * 15 / 100;
players[_addr].referralBonus += amount * 15 / 100;
} else {
if(poolWeight > 0) {
deltaStake = amount * 15 / 100 / poolWeight;
for(p_i = 0; p_i < participants.length; p_i++) {
_addr = participants[p_i];
if(players[_addr].generation == currentGeneration) {
players[_addr].balance += players[_addr].weight * deltaStake;
players[_addr].stakingBonus += players[_addr].weight * deltaStake;
}
}
} else {
players[teamAddress].balance += amount * 15 / 100;
players[teamAddress].stakingBonus += amount * 15 / 100;
}
}
// 4% for team
unitStake += deltaStake;
players[teamAddress].balance += amount * 4 / 100;
players[teamAddress].stakingBonus += amount * 4 / 100;
poolReward += amount * 77 / 100;
airdropBalance += amount * 2 / 100;
airdropped = false;
airdroppedAmount = 0;
uint randNum = 0;
if(amount >= 1e17 && amount < 1e18) {
// 0.1 ~ 1 eth, 1% chance
randNum = rand(1, 10000);
if(randNum <= 10) airdropped = true;
} else if(amount >= 1e18 && amount < 1e19) {
// 1 eth ~ 10 eth, 10% chance
randNum = rand(1, 10000);
if(randNum <= 100) airdropped = true;
} else if(amount >= 1e19) {
// greater than 1 eth, 5% chance
randNum = rand(1, 10000);
if(randNum <= 500) airdropped = true;
}
bool _phaseChanged = false;
if(airdropped) {
airdropWinTime = now;
players[msg.sender].balance += airdropBalance;
players[msg.sender].airdropBonus += airdropBalance;
poolReward += airdropBalance;
airdroppedAmount = airdropBalance;
airdropBalance = 0;
if(durationPhaseIndex == 0 && airdropBalance >= 1e18) _phaseChanged = true;
else if(durationPhaseIndex == 1 && airdropBalance >= 2e18) _phaseChanged = true;
else if(durationPhaseIndex == 2 && airdropBalance >= 3e18) _phaseChanged = true;
else if(durationPhaseIndex == 3 && airdropBalance >= 5e18) _phaseChanged = true;
else if(durationPhaseIndex == 4 && airdropBalance >= 7e18) _phaseChanged = true;
else if(durationPhaseIndex == 5 && airdropBalance >= 1e19) _phaseChanged = true;
if(_phaseChanged) {
durationPhaseIndex ++;
duration = durationPhaseArray[durationPhaseIndex];
deadline = now + duration * 1 minutes;
}
}
// Staking weight calculation
uint256 weight = amount.mul(1e7).div(keyPrice);
players[msg.sender].weight += weight;
uint256 originalPoolSegment = poolWeight / ((5e5).mul(1e7));
poolWeight += weight;
uint256 afterPoolSegment = poolWeight / ((5e5).mul(1e7));
// Different Segment => giveout potReserve, every 1e5 keys
potReserve += amount * 1 / 100;
bool _potReserveGive = false;
uint256 _potReserve = potReserve;
if(originalPoolSegment != afterPoolSegment) {
_potReserveGive = true;
players[msg.sender].balance += potReserve;
players[msg.sender].potBonus += potReserve;
poolReward += potReserve;
potReserve = 0;
}
// Grow key price
if(keyPrice < keyPrice_max) {
keyPrice = keyPrice_max - (1e23 - poolBalance).mul(keyPrice_max - keyPrice_min).div(1e23);
} else {
keyPrice = keyPrice_max;
}
keyLocked = false;
emit Deposit(msg.sender,
weight,
keyPrice,
deadline,
durationPhaseIndex,
_phaseChanged,
poolBalance,
poolReward,
poolWeight,
airdropped,
airdropBalance,
_potReserveGive,
_potReserve);
}
uint256 nonce = 0;
function rand(uint min, uint max) private returns (uint){
nonce++;
return uint(keccak256(toBytes(nonce)))%(min+max)-min;
}
function toBytes(uint256 x) private pure returns (bytes b) {
b = new bytes(32);
assembly { mstore(add(b, 32), x) }
}
function safeWithdrawal() isHuman() public {
uint256 availableWithdrawal = players[msg.sender].balance - players[msg.sender].withdrawal;
require(availableWithdrawal > 0);
require(keyLocked == false);
keyLocked = true;
poolWithdraw += availableWithdrawal;
players[msg.sender].withdrawal += availableWithdrawal;
msg.sender.transfer(availableWithdrawal);
keyLocked = false;
emit Withdrawal(msg.sender, availableWithdrawal);
}
function helpWithdrawal(address userAddress) isHuman() public {
// Will only be executed when user himself cannot withdraw and asks our team for help
require(msg.sender == teamAddress);
uint256 availableWithdrawal = players[userAddress].balance - players[userAddress].withdrawal;
require(availableWithdrawal > 0);
require(keyLocked == false);
keyLocked = true;
poolWithdraw += availableWithdrawal;
players[userAddress].withdrawal += availableWithdrawal;
// Service fee: 5%
players[teamAddress].balance += availableWithdrawal * 5 / 100;
// User get 95%
userAddress.transfer(availableWithdrawal * 95 / 100);
keyLocked = false;
emit Withdrawal(userAddress, availableWithdrawal);
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
| 206,362 | 11,510 |
e66da90b4319c2854cb366aefa3006485a6490af43767068e652842627c710d8
| 19,500 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/6f/6fa79bf5b8b223F1ec34613e1471eeB2e067383a_CR7AVAC.sol
| 3,996 | 14,607 |
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.14;
interface IERC20
{
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
abstract contract ReentrancyGuard {
bool internal locked;
modifier noReentrant() {
require(!locked, "No re-entrancy");
locked = true;
_;
locked = false;
}
}
contract CR7AVAC is Context, Ownable , ReentrancyGuard {
using SafeMath for uint256;
uint256 public constant min = 10 ether;
uint256 public constant max = 100000 ether;
uint256 public roi = 17;
uint256 public constant fee = 6;
uint256 public constant withdraw_fee = 10;
uint256 public constant ref_fee = 7;
address public dev = 0xbeace5E5Af8D25EA855C632b71971A80A47E126E;
address public tokenAdress;
bool public init = false;
bool public alreadyInvested = false;
struct refferal_system {
address ref_address;
uint256 reward;
}
struct refferal_withdraw {
address ref_address;
uint256 totalWithdraw;
}
struct user_investment_details {
address user_address;
uint256 invested;
}
struct weeklyWithdraw {
address user_address;
uint256 startTime;
uint256 deadline;
}
struct claimDaily {
address user_address;
uint256 startTime;
uint256 deadline;
}
struct userWithdrawal {
address user_address;
uint256 amount;
}
struct userTotalWithdraw {
address user_address;
uint256 amount;
}
struct userTotalRewards {
address user_address;
uint256 amount;
}
mapping(address => refferal_system) public refferal;
mapping(address => user_investment_details) public investments;
mapping(address => weeklyWithdraw) public weekly;
mapping(address => claimDaily) public claimTime;
mapping(address => userWithdrawal) public approvedWithdrawal;
mapping(address => userTotalWithdraw) public totalWithdraw;
mapping(address => userTotalRewards) public totalRewards;
mapping(address => refferal_withdraw) public refTotalWithdraw;
// invest function
function deposit(address _ref, uint256 _amount) public noReentrant {
require(init, "Not Started Yet");
require(_amount>=min && _amount <= max, "Cannot Deposit");
if(!checkAlready()){
uint256 ref_fee_add = refFee(_amount);
if(_ref != address(0) && _ref != msg.sender) {
uint256 ref_last_balance = refferal[_ref].reward;
uint256 totalRefFee = SafeMath.add(ref_fee_add,ref_last_balance);
refferal[_ref] = refferal_system(_ref,totalRefFee);
}
else {
uint256 ref_last_balance = refferal[dev].reward;
uint256 totalRefFee = SafeMath.add(ref_fee_add,ref_last_balance);
refferal[dev] = refferal_system(dev,totalRefFee);
}
// investment details
uint256 userLastInvestment = investments[msg.sender].invested;
uint256 userCurrentInvestment = _amount;
uint256 totalInvestment = SafeMath.add(userLastInvestment,userCurrentInvestment);
investments[msg.sender] = user_investment_details(msg.sender,totalInvestment);
// weekly withdraw
uint256 weeklyStart = block.timestamp;
uint256 deadline_weekly = block.timestamp + 7 days;
weekly[msg.sender] = weeklyWithdraw(msg.sender,weeklyStart,deadline_weekly);
// Claim Setting
uint256 claimTimeStart = block.timestamp;
uint256 claimTimeEnd = block.timestamp + 1 days;
claimTime[msg.sender] = claimDaily(msg.sender,claimTimeStart,claimTimeEnd);
// fees
uint256 total_fee = depositFee(_amount);
uint256 total_contract = SafeMath.sub(_amount,total_fee);
}
else {
uint256 ref_fee_add = refFee(_amount);
if(_ref != address(0) && _ref != msg.sender) {
uint256 ref_last_balance = refferal[_ref].reward;
uint256 totalRefFee = SafeMath.add(ref_fee_add,ref_last_balance);
refferal[_ref] = refferal_system(_ref,totalRefFee);
}
else {
uint256 ref_last_balance = refferal[dev].reward;
uint256 totalRefFee = SafeMath.add(ref_fee_add,ref_last_balance);
refferal[dev] = refferal_system(dev,totalRefFee);
}
// investment details
uint256 userLastInvestment = investments[msg.sender].invested;
uint256 userCurrentInvestment = _amount;
uint256 totalInvestment = SafeMath.add(userLastInvestment,userCurrentInvestment);
investments[msg.sender] = user_investment_details(msg.sender,totalInvestment);
// weekly withdraw
// uint256 weeklyStart = block.timestamp;
// uint256 deadline_weekly = block.timestamp + 7 days;
// weekly[msg.sender] = weeklyWithdraw(msg.sender,weeklyStart,deadline_weekly);
// Claim Setting
//uint256 claimTimeStart = block.timestamp;
// uint256 claimTimeEnd = block.timestamp + 1 days;
// claimTime[msg.sender] = claimDaily(msg.sender,claimTimeStart,claimTimeEnd);
// fees
uint256 total_fee = depositFee(_amount);
uint256 total_contract = SafeMath.sub(_amount,total_fee);
}
}
function userReward(address _userAddress) public view returns(uint256) {
uint256 userInvestment = investments[_userAddress].invested;
uint256 userDailyReturn = DailyRoi(userInvestment);
// invested time
uint256 claimInvestTime = claimTime[_userAddress].startTime;
uint256 claimInvestEnd = claimTime[_userAddress].deadline;
uint256 totalTime = SafeMath.sub(claimInvestEnd,claimInvestTime);
uint256 value = SafeMath.div(userDailyReturn,totalTime);
uint256 nowTime = block.timestamp;
if(claimInvestEnd>= nowTime) {
uint256 earned = SafeMath.sub(nowTime,claimInvestTime);
uint256 totalEarned = SafeMath.mul(earned, value);
return totalEarned;
}
else {
return userDailyReturn;
}
}
function withdrawal() public noReentrant {
require(init, "Not Started Yet");
require(weekly[msg.sender].deadline <= block.timestamp, "You cant withdraw");
require(totalRewards[msg.sender].amount <= SafeMath.mul(investments[msg.sender].invested,5), "You cant withdraw you have collected five times Already"); // hh new
uint256 aval_withdraw = approvedWithdrawal[msg.sender].amount;
uint256 aval_withdraw2 = SafeMath.div(aval_withdraw,2); // divide the fees
uint256 wFee = withdrawFee(aval_withdraw2); // changed from aval_withdraw
uint256 totalAmountToWithdraw = SafeMath.sub(aval_withdraw2,wFee); // changed from aval_withdraw to aval_withdraw2
approvedWithdrawal[msg.sender] = userWithdrawal(msg.sender,aval_withdraw2); // changed from 0 to half of the amount stay in in his contract
uint256 weeklyStart = block.timestamp;
uint256 deadline_weekly = block.timestamp + 7 days;
weekly[msg.sender] = weeklyWithdraw(msg.sender,weeklyStart,deadline_weekly);
uint256 amount = totalWithdraw[msg.sender].amount;
uint256 totalAmount = SafeMath.add(amount,aval_withdraw2); // it will add one of his half to total withdraw
totalWithdraw[msg.sender] = userTotalWithdraw(msg.sender,totalAmount);
}
function claimDailyRewards() public noReentrant{
require(init, "Not Started Yet");
require(claimTime[msg.sender].deadline <= block.timestamp, "You cant claim");
uint256 rewards = userReward(msg.sender);
uint256 currentApproved = approvedWithdrawal[msg.sender].amount;
uint256 value = SafeMath.add(rewards,currentApproved);
approvedWithdrawal[msg.sender] = userWithdrawal(msg.sender,value);
uint256 amount = totalRewards[msg.sender].amount; //hhnew
uint256 totalRewardAmount = SafeMath.add(amount,rewards); //hhnew
totalRewards[msg.sender].amount=totalRewardAmount;
uint256 claimTimeStart = block.timestamp;
uint256 claimTimeEnd = block.timestamp + 1 days;
claimTime[msg.sender] = claimDaily(msg.sender,claimTimeStart,claimTimeEnd);
}
function unStake() external noReentrant {
require(init, "Not Started Yet");
uint256 I_investment = investments[msg.sender].invested;
uint256 t_withdraw = totalWithdraw[msg.sender].amount;
require(I_investment > t_withdraw, "You already withdraw a lot than your investment");
uint256 lastFee = depositFee(I_investment);
uint256 currentBalance = SafeMath.sub(I_investment,lastFee);
uint256 UnstakeValue = SafeMath.sub(currentBalance,t_withdraw);
uint256 UnstakeValueCore = SafeMath.div(UnstakeValue,2);
investments[msg.sender] = user_investment_details(msg.sender,0);
approvedWithdrawal[msg.sender] = userWithdrawal(msg.sender,0);
}
function Ref_Withdraw() external noReentrant {
require(init, "Not Started Yet");
uint256 value = refferal[msg.sender].reward;
refferal[msg.sender] = refferal_system(msg.sender,0);
uint256 lastWithdraw = refTotalWithdraw[msg.sender].totalWithdraw;
uint256 totalValue = SafeMath.add(value,lastWithdraw);
refTotalWithdraw[msg.sender] = refferal_withdraw(msg.sender,totalValue);
}
// initialized the market
function signal_market() public onlyOwner {
init = true;
}
// other functions
function DailyRoi(uint256 _amount) public view returns(uint256) {
return SafeMath.div(SafeMath.mul(_amount,roi),100);
}
function checkAlready() public view returns(bool) {
address _address= msg.sender;
if(investments[_address].user_address==_address){
return true;
}
else{
return false;
}
}
function depositFee(uint256 _amount) public pure returns(uint256){
return SafeMath.div(SafeMath.mul(_amount,fee),100);
}
function refFee(uint256 _amount) public pure returns(uint256) {
return SafeMath.div(SafeMath.mul(_amount,ref_fee),100);
}
function withdrawFee(uint256 _amount) public pure returns(uint256) {
return SafeMath.div(SafeMath.mul(_amount,withdraw_fee),100);
}
function getBalance() public view returns(uint256){
}
}
| 120,146 | 11,511 |
985dd814e56feba3a4ce2d7bb4e8b24e134583807c1888e810b6baa453f02b48
| 28,786 |
.sol
|
Solidity
| false |
468407125
|
tintinweb/smart-contract-sanctuary-optimism
|
5f86f1320e8b5cdf11039be240475eff1303ed67
|
contracts/mainnet/ab/abed2608ee041a6936e1f1c51f63046a80928d71_Sablier.sol
| 3,889 | 15,354 |
pragma solidity =0.5.17;
library Types {
struct Stream {
uint256 deposit;
uint256 ratePerSecond;
uint256 remainingBalance;
uint256 startTime;
uint256 stopTime;
address recipient;
address sender;
address tokenAddress;
bool isEntity;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ReentrancyGuard {
/// @dev counter to allow mutex lock with only one SSTORE operation
uint256 private _guardCounter;
constructor () internal {
// The counter starts at one to prevent changing it from zero to a non-zero
// value, which is a more expensive operation.
_guardCounter = 1;
}
modifier nonReentrant() {
_guardCounter += 1;
uint256 localCounter = _guardCounter;
_;
require(localCounter == _guardCounter, "ReentrancyGuard: reentrant call");
}
}
interface ISablier {
event CreateStream(uint256 indexed streamId,
address indexed sender,
address indexed recipient,
uint256 deposit,
address tokenAddress,
uint256 startTime,
uint256 stopTime);
event WithdrawFromStream(uint256 indexed streamId, address indexed recipient, uint256 amount);
event CancelStream(uint256 indexed streamId,
address indexed sender,
address indexed recipient,
uint256 senderBalance,
uint256 recipientBalance);
function balanceOf(uint256 streamId, address who) external view returns (uint256 balance);
function getStream(uint256 streamId)
external
view
returns (address sender,
address recipient,
uint256 deposit,
address token,
uint256 startTime,
uint256 stopTime,
uint256 remainingBalance,
uint256 ratePerSecond);
function createStream(address recipient, uint256 deposit, address tokenAddress, uint256 startTime, uint256 stopTime)
external
returns (uint256 streamId);
function withdrawFromStream(uint256 streamId, uint256 funds) external returns (bool);
function cancelStream(uint256 streamId) external returns (bool);
}
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 CarefulMath {
enum MathError {
NO_ERROR,
DIVISION_BY_ZERO,
INTEGER_OVERFLOW,
INTEGER_UNDERFLOW
}
function mulUInt(uint a, uint b) internal pure returns (MathError, uint) {
if (a == 0) {
return (MathError.NO_ERROR, 0);
}
uint c = a * b;
if (c / a != b) {
return (MathError.INTEGER_OVERFLOW, 0);
} else {
return (MathError.NO_ERROR, c);
}
}
function divUInt(uint a, uint b) internal pure returns (MathError, uint) {
if (b == 0) {
return (MathError.DIVISION_BY_ZERO, 0);
}
return (MathError.NO_ERROR, a / b);
}
function subUInt(uint a, uint b) internal pure returns (MathError, uint) {
if (b <= a) {
return (MathError.NO_ERROR, a - b);
} else {
return (MathError.INTEGER_UNDERFLOW, 0);
}
}
function addUInt(uint a, uint b) internal pure returns (MathError, uint) {
uint c = a + b;
if (c >= a) {
return (MathError.NO_ERROR, c);
} else {
return (MathError.INTEGER_OVERFLOW, 0);
}
}
function addThenSubUInt(uint a, uint b, uint c) internal pure returns (MathError, uint) {
(MathError err0, uint sum) = addUInt(a, b);
if (err0 != MathError.NO_ERROR) {
return (err0, 0);
}
return subUInt(sum, c);
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
}
contract Sablier is ISablier, ReentrancyGuard, CarefulMath {
using SafeERC20 for IERC20;
uint256 public nextStreamId;
mapping(uint256 => Types.Stream) private streams;
modifier onlySenderOrRecipient(uint256 streamId) {
require(msg.sender == streams[streamId].sender || msg.sender == streams[streamId].recipient,
"caller is not the sender or the recipient of the stream");
_;
}
modifier streamExists(uint256 streamId) {
require(streams[streamId].isEntity, "stream does not exist");
_;
}
constructor() public {
nextStreamId = 100000;
}
function getStream(uint256 streamId)
external
view
streamExists(streamId)
returns (address sender,
address recipient,
uint256 deposit,
address tokenAddress,
uint256 startTime,
uint256 stopTime,
uint256 remainingBalance,
uint256 ratePerSecond)
{
sender = streams[streamId].sender;
recipient = streams[streamId].recipient;
deposit = streams[streamId].deposit;
tokenAddress = streams[streamId].tokenAddress;
startTime = streams[streamId].startTime;
stopTime = streams[streamId].stopTime;
remainingBalance = streams[streamId].remainingBalance;
ratePerSecond = streams[streamId].ratePerSecond;
}
function deltaOf(uint256 streamId) public view streamExists(streamId) returns (uint256 delta) {
Types.Stream memory stream = streams[streamId];
if (block.timestamp <= stream.startTime) return 0;
if (block.timestamp < stream.stopTime) return block.timestamp - stream.startTime;
return stream.stopTime - stream.startTime;
}
struct BalanceOfLocalVars {
MathError mathErr;
uint256 recipientBalance;
uint256 withdrawalAmount;
uint256 senderBalance;
}
function balanceOf(uint256 streamId, address who) public view streamExists(streamId) returns (uint256 balance) {
Types.Stream memory stream = streams[streamId];
BalanceOfLocalVars memory vars;
uint256 delta = deltaOf(streamId);
(vars.mathErr, vars.recipientBalance) = mulUInt(delta, stream.ratePerSecond);
require(vars.mathErr == MathError.NO_ERROR, "recipient balance calculation error");
if (stream.deposit > stream.remainingBalance) {
(vars.mathErr, vars.withdrawalAmount) = subUInt(stream.deposit, stream.remainingBalance);
assert(vars.mathErr == MathError.NO_ERROR);
(vars.mathErr, vars.recipientBalance) = subUInt(vars.recipientBalance, vars.withdrawalAmount);
assert(vars.mathErr == MathError.NO_ERROR);
}
if (who == stream.recipient) return vars.recipientBalance;
if (who == stream.sender) {
(vars.mathErr, vars.senderBalance) = subUInt(stream.remainingBalance, vars.recipientBalance);
assert(vars.mathErr == MathError.NO_ERROR);
return vars.senderBalance;
}
return 0;
}
struct CreateStreamLocalVars {
MathError mathErr;
uint256 duration;
uint256 ratePerSecond;
}
function createStream(address recipient, uint256 deposit, address tokenAddress, uint256 startTime, uint256 stopTime)
public
returns (uint256)
{
require(recipient != address(0x00), "stream to the zero address");
require(recipient != address(this), "stream to the contract itself");
require(recipient != msg.sender, "stream to the caller");
require(deposit > 0, "deposit is zero");
require(startTime >= block.timestamp, "start time before block.timestamp");
require(stopTime > startTime, "stop time before the start time");
CreateStreamLocalVars memory vars;
(vars.mathErr, vars.duration) = subUInt(stopTime, startTime);
assert(vars.mathErr == MathError.NO_ERROR);
require(deposit >= vars.duration, "deposit smaller than time delta");
require(deposit % vars.duration == 0, "deposit not multiple of time delta");
(vars.mathErr, vars.ratePerSecond) = divUInt(deposit, vars.duration);
assert(vars.mathErr == MathError.NO_ERROR);
uint256 streamId = nextStreamId;
streams[streamId] = Types.Stream({
remainingBalance: deposit,
deposit: deposit,
isEntity: true,
ratePerSecond: vars.ratePerSecond,
recipient: recipient,
sender: msg.sender,
startTime: startTime,
stopTime: stopTime,
tokenAddress: tokenAddress
});
(vars.mathErr, nextStreamId) = addUInt(nextStreamId, uint256(1));
require(vars.mathErr == MathError.NO_ERROR, "next stream id calculation error");
IERC20(tokenAddress).safeTransferFrom(msg.sender, address(this), deposit);
emit CreateStream(streamId, msg.sender, recipient, deposit, tokenAddress, startTime, stopTime);
return streamId;
}
function withdrawFromStream(uint256 streamId, uint256 amount)
external
nonReentrant
streamExists(streamId)
onlySenderOrRecipient(streamId)
returns (bool)
{
require(amount > 0, "amount is zero");
Types.Stream memory stream = streams[streamId];
uint256 balance = balanceOf(streamId, stream.recipient);
require(balance >= amount, "amount exceeds the available balance");
MathError mathErr;
(mathErr, streams[streamId].remainingBalance) = subUInt(stream.remainingBalance, amount);
assert(mathErr == MathError.NO_ERROR);
if (streams[streamId].remainingBalance == 0) delete streams[streamId];
IERC20(stream.tokenAddress).safeTransfer(stream.recipient, amount);
emit WithdrawFromStream(streamId, stream.recipient, amount);
return true;
}
function cancelStream(uint256 streamId)
external
nonReentrant
streamExists(streamId)
onlySenderOrRecipient(streamId)
returns (bool)
{
Types.Stream memory stream = streams[streamId];
uint256 senderBalance = balanceOf(streamId, stream.sender);
uint256 recipientBalance = balanceOf(streamId, stream.recipient);
delete streams[streamId];
IERC20 token = IERC20(stream.tokenAddress);
if (recipientBalance > 0) token.safeTransfer(stream.recipient, recipientBalance);
if (senderBalance > 0) token.safeTransfer(stream.sender, senderBalance);
emit CancelStream(streamId, stream.sender, stream.recipient, senderBalance, recipientBalance);
return true;
}
}
| 152,517 | 11,512 |
a58e264e05ab2fc41f7563725d21e6f518655e39ba893ca80698597178e214ee
| 18,903 |
.sol
|
Solidity
| false |
318029108
|
InverseFinance/inverse-protocol
|
55ff82d2e2af075832555fa3e933f73410845e43
|
contracts/token/GovernorMills.sol
| 4,345 | 17,865 |
pragma solidity ^0.5.16;
pragma experimental ABIEncoderV2;
interface InvInterface {
function getPriorVotes(address account, uint blockNumber) external view returns (uint96);
function totalSupply() external view returns (uint256);
}
interface XinvInterface {
function getPriorVotes(address account, uint blockNumber) external view returns (uint96);
function totalSupply() external view returns (uint256);
function exchangeRateCurrent() external returns (uint);
}
interface TimelockInterface {
function delay() external view returns (uint);
function GRACE_PERIOD() external view returns (uint);
function setDelay(uint256 delay_) external;
function acceptAdmin() external;
function setPendingAdmin(address pendingAdmin_) external;
function queuedTransactions(bytes32 hash) external view returns (bool);
function queueTransaction(address target, uint256 value, string calldata signature, bytes calldata data, uint256 eta) external returns (bytes32);
function cancelTransaction(address target, uint256 value, string calldata signature, bytes calldata data, uint256 eta) external;
function executeTransaction(address target, uint256 value, string calldata signature, bytes calldata data, uint256 eta) external returns (bytes memory);
}
contract GovernorMills {
/// @notice The name of this contract
string public constant name = "Inverse Governor Mills";
/// @notice The maximum number of actions that can be included in a proposal
function proposalMaxOperations() public pure returns (uint) { return 20; } // 20 actions
/// @notice The delay before voting on a proposal may take place, once proposed
function votingDelay() public pure returns (uint) { return 1; } // 1 block
/// @notice The duration of voting on a proposal, in blocks
function votingPeriod() public pure returns (uint) { return 17280; } // ~3 days in blocks (assuming 15s blocks)
/// @notice The address of the Protocol Timelock
TimelockInterface public timelock;
/// @notice The address of the governance token A
InvInterface public inv;
/// @notice The address of the governance token B
XinvInterface public xinv;
/// @notice The total number of proposals
uint256 public proposalCount;
/// @notice The guardian
address public guardian;
/// @notice proposal threshold
uint256 public proposalThreshold = 1000 ether; // 1k INV
uint256 public quorumVotes = 4000 ether; // 4k INV
struct Proposal {
/// @notice Unique id for looking up a proposal
uint id;
/// @notice Creator of the proposal
address proposer;
uint eta;
/// @notice the ordered list of target addresses for calls to be made
address[] targets;
/// @notice The ordered list of values (i.e. msg.value) to be passed to the calls to be made
uint[] values;
/// @notice The ordered list of function signatures to be called
string[] signatures;
/// @notice The ordered list of calldata to be passed to each call
bytes[] calldatas;
/// @notice The block at which voting begins: holders must delegate their votes prior to this block
uint startBlock;
/// @notice The block at which voting ends: votes must be cast prior to this block
uint endBlock;
/// @notice Current number of votes in favor of this proposal
uint forVotes;
/// @notice Current number of votes in opposition to this proposal
uint againstVotes;
/// @notice Flag marking whether the proposal has been canceled
bool canceled;
/// @notice Flag marking whether the proposal has been executed
bool executed;
/// @notice Receipts of ballots for the entire set of voters
mapping (address => Receipt) receipts;
}
/// @notice Ballot receipt record for a voter
struct Receipt {
/// @notice Whether or not a vote has been cast
bool hasVoted;
/// @notice Whether or not the voter supports the proposal
bool support;
/// @notice The number of votes the voter had, which were cast
uint96 votes;
}
/// @notice Possible states that a proposal may be in
enum ProposalState {
Pending,
Active,
Canceled,
Defeated,
Succeeded,
Queued,
Expired,
Executed
}
/// @notice The official record of all proposals ever proposed
mapping (uint => Proposal) public proposals;
/// @notice The latest proposal for each proposer
mapping (address => uint) public latestProposalIds;
/// @notice Addresses that can propose without voting power
mapping (address => bool) public proposerWhitelist;
/// @notice proposal id => xinv.exchangeRateCurrent
mapping (uint => uint) public xinvExchangeRates;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the ballot struct used by the contract
bytes32 public constant BALLOT_TYPEHASH = keccak256("Ballot(uint256 proposalId,bool support)");
/// @notice An event emitted when a new proposal is created
event ProposalCreated(uint id, address proposer, address[] targets, uint[] values, string[] signatures, bytes[] calldatas, uint startBlock, uint endBlock, string description);
/// @notice An event emitted when a vote has been cast on a proposal
event VoteCast(address voter, uint proposalId, bool support, uint votes);
/// @notice An event emitted when a proposal has been canceled
event ProposalCanceled(uint id);
/// @notice An event emitted when a proposal has been queued in the Timelock
event ProposalQueued(uint id, uint eta);
/// @notice An event emitted when a proposal has been executed in the Timelock
event ProposalExecuted(uint id);
/// @notice An event emitted when a new guardian has been set
event NewGuardian(address guardian);
/// @notice An event emitted when proposal threshold is updated
event ProposalThresholdUpdated(uint256 oldThreshold, uint256 newThreshold);
/// @notice An event emitted when proposal quorum is updated
event QuorumUpdated(uint256 oldQuorum, uint256 newQuorum);
/// @notice An event emitted when an address is added or removed from the proposer whitelist
event ProposerWhitelistUpdated(address proposer, bool value);
constructor(TimelockInterface timelock_, InvInterface inv_, XinvInterface xinv_) public {
timelock = timelock_;
inv = inv_;
xinv = xinv_;
guardian = msg.sender;
}
function _getPriorVotes(address _proposer, uint256 _blockNumber, uint256 _exchangeRate) internal view returns (uint96) {
uint96 invPriorVotes = inv.getPriorVotes(_proposer, _blockNumber);
uint96 xinvPriorVotes = uint96((uint256(xinv.getPriorVotes(_proposer, _blockNumber)) * _exchangeRate) / 1 ether);
return add96(invPriorVotes, xinvPriorVotes);
}
function setGuardian(address _newGuardian) public {
require(msg.sender == guardian, "GovernorMills::setGuardian: only guardian");
guardian = _newGuardian;
emit NewGuardian(guardian);
}
function __queueSetTimelockPendingAdmin(address newPendingAdmin, uint256 eta) public {
require(msg.sender == guardian, "GovernorMills::__queueSetTimelockPendingAdmin: only guardian");
timelock.queueTransaction(address(timelock), 0, "setPendingAdmin(address)", abi.encode(newPendingAdmin), eta);
}
function __executeSetTimelockPendingAdmin(address newPendingAdmin, uint256 eta) public {
require(msg.sender == guardian, "GovernorMills::__executeSetTimelockPendingAdmin: only guardian");
timelock.executeTransaction(address(timelock), 0, "setPendingAdmin(address)", abi.encode(newPendingAdmin), eta);
}
function propose(address[] memory targets, uint[] memory values, string[] memory signatures, bytes[] memory calldatas, string memory description) public returns (uint) {
require(_getPriorVotes(msg.sender, sub256(block.number, 1), xinv.exchangeRateCurrent()) > proposalThreshold || proposerWhitelist[msg.sender], "GovernorMills::propose: proposer votes below proposal threshold");
require(targets.length == values.length && targets.length == signatures.length && targets.length == calldatas.length, "GovernorMills::propose: proposal function information arity mismatch");
require(targets.length != 0, "GovernorMills::propose: must provide actions");
require(targets.length <= proposalMaxOperations(), "GovernorMills::propose: too many actions");
uint latestProposalId = latestProposalIds[msg.sender];
if (latestProposalId != 0) {
ProposalState proposersLatestProposalState = state(latestProposalId);
require(proposersLatestProposalState != ProposalState.Active, "GovernorMills::propose: one live proposal per proposer, found an already active proposal");
require(proposersLatestProposalState != ProposalState.Pending, "GovernorMills::propose: one live proposal per proposer, found an already pending proposal");
}
uint startBlock = add256(block.number, votingDelay());
uint endBlock = add256(startBlock, votingPeriod());
proposalCount++;
Proposal memory newProposal = Proposal({
id: proposalCount,
proposer: msg.sender,
eta: 0,
targets: targets,
values: values,
signatures: signatures,
calldatas: calldatas,
startBlock: startBlock,
endBlock: endBlock,
forVotes: 0,
againstVotes: 0,
canceled: false,
executed: false
});
proposals[newProposal.id] = newProposal;
xinvExchangeRates[newProposal.id] = xinv.exchangeRateCurrent();
latestProposalIds[newProposal.proposer] = newProposal.id;
emit ProposalCreated(newProposal.id, msg.sender, targets, values, signatures, calldatas, startBlock, endBlock, description);
return newProposal.id;
}
function queue(uint proposalId) public {
require(state(proposalId) == ProposalState.Succeeded, "GovernorMills::queue: proposal can only be queued if it is succeeded");
Proposal storage proposal = proposals[proposalId];
uint eta = add256(block.timestamp, timelock.delay());
for (uint i = 0; i < proposal.targets.length; i++) {
_queueOrRevert(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], eta);
}
proposal.eta = eta;
emit ProposalQueued(proposalId, eta);
}
function _queueOrRevert(address target, uint value, string memory signature, bytes memory data, uint eta) internal {
require(!timelock.queuedTransactions(keccak256(abi.encode(target, value, signature, data, eta))), "GovernorMills::_queueOrRevert: proposal action already queued at eta");
timelock.queueTransaction(target, value, signature, data, eta);
}
function execute(uint proposalId) public {
require(state(proposalId) == ProposalState.Queued, "GovernorMills::execute: proposal can only be executed if it is queued");
Proposal storage proposal = proposals[proposalId];
proposal.executed = true;
for (uint i = 0; i < proposal.targets.length; i++) {
timelock.executeTransaction(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], proposal.eta);
}
emit ProposalExecuted(proposalId);
}
function cancel(uint proposalId) public {
ProposalState state = state(proposalId);
require(state != ProposalState.Executed, "GovernorMills::cancel: cannot cancel executed proposal");
Proposal storage proposal = proposals[proposalId];
require(msg.sender == guardian || (_getPriorVotes(proposal.proposer, sub256(block.number, 1), xinvExchangeRates[proposal.id]) < proposalThreshold && !proposerWhitelist[proposal.proposer]), "GovernorMills::cancel: proposer above threshold");
proposal.canceled = true;
for (uint i = 0; i < proposal.targets.length; i++) {
timelock.cancelTransaction(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], proposal.eta);
}
emit ProposalCanceled(proposalId);
}
function updateProposalThreshold(uint256 newThreshold) public {
require(msg.sender == guardian || msg.sender == address(timelock), "GovernorMills::updateProposalThreshold: sender must be gov guardian or timelock");
require(newThreshold <= inv.totalSupply(), "GovernorMills::updateProposalThreshold: threshold too large");
require(newThreshold != proposalThreshold, "GovernorMills::updateProposalThreshold: no change in value");
uint256 oldThreshold = proposalThreshold;
proposalThreshold = newThreshold;
emit ProposalThresholdUpdated(oldThreshold, newThreshold);
}
function updateProposalQuorum(uint256 newQuorum) public {
require(msg.sender == guardian || msg.sender == address(timelock), "GovernorMills::newQuorum: sender must be gov guardian or timelock");
require(newQuorum <= inv.totalSupply(), "GovernorMills::newQuorum: threshold too large");
require(newQuorum != quorumVotes, "GovernorMills::newQuorum: no change in value");
uint256 oldQuorum = quorumVotes;
quorumVotes = newQuorum;
emit QuorumUpdated(oldQuorum, newQuorum);
}
function acceptAdmin() public {
require(msg.sender == guardian, "GovernorMills::acceptAdmin: sender must be gov guardian");
timelock.acceptAdmin();
}
function updateProposerWhitelist(address proposer, bool value) public {
require(msg.sender == address(timelock), "GovernorMills::updateProposerWhitelist: sender must be timelock");
proposerWhitelist[proposer] = value;
emit ProposerWhitelistUpdated(proposer, value);
}
function getActions(uint proposalId) public view returns (address[] memory targets, uint[] memory values, string[] memory signatures, bytes[] memory calldatas) {
Proposal storage p = proposals[proposalId];
return (p.targets, p.values, p.signatures, p.calldatas);
}
function getReceipt(uint proposalId, address voter) public view returns (Receipt memory) {
return proposals[proposalId].receipts[voter];
}
function state(uint proposalId) public view returns (ProposalState) {
require(proposalCount >= proposalId && proposalId > 0, "GovernorMills::state: invalid proposal id");
Proposal storage proposal = proposals[proposalId];
if (proposal.canceled) {
return ProposalState.Canceled;
} else if (block.number <= proposal.startBlock) {
return ProposalState.Pending;
} else if (block.number <= proposal.endBlock) {
return ProposalState.Active;
} else if (proposal.forVotes <= proposal.againstVotes || proposal.forVotes < quorumVotes) {
return ProposalState.Defeated;
} else if (proposal.eta == 0) {
return ProposalState.Succeeded;
} else if (proposal.executed) {
return ProposalState.Executed;
} else if (block.timestamp >= add256(proposal.eta, timelock.GRACE_PERIOD())) {
return ProposalState.Expired;
} else {
return ProposalState.Queued;
}
}
function castVote(uint proposalId, bool support) public {
return _castVote(msg.sender, proposalId, support);
}
function castVoteBySig(uint proposalId, bool support, uint8 v, bytes32 r, bytes32 s) public {
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
bytes32 structHash = keccak256(abi.encode(BALLOT_TYPEHASH, proposalId, support));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "GovernorMills::castVoteBySig: invalid signature");
return _castVote(signatory, proposalId, support);
}
function _castVote(address voter, uint proposalId, bool support) internal {
require(state(proposalId) == ProposalState.Active, "GovernorMills::_castVote: voting is closed");
Proposal storage proposal = proposals[proposalId];
Receipt storage receipt = proposal.receipts[voter];
require(receipt.hasVoted == false, "GovernorMills::_castVote: voter already voted");
uint96 votes = _getPriorVotes(voter, proposal.startBlock, xinvExchangeRates[proposal.id]);
if (support) {
proposal.forVotes = add256(proposal.forVotes, votes);
} else {
proposal.againstVotes = add256(proposal.againstVotes, votes);
}
receipt.hasVoted = true;
receipt.support = support;
receipt.votes = votes;
emit VoteCast(voter, proposalId, support, votes);
}
function add96(uint96 a, uint96 b) internal pure returns(uint96) {
uint96 c = a + b;
require(c >= a, "addition overflow");
return c;
}
function add256(uint256 a, uint256 b) internal pure returns (uint) {
uint c = a + b;
require(c >= a, "addition overflow");
return c;
}
function sub256(uint256 a, uint256 b) internal pure returns (uint) {
require(b <= a, "subtraction underflow");
return a - b;
}
function getChainId() internal pure returns (uint) {
uint chainId;
assembly { chainId := chainid() }
return chainId;
}
}
| 18,236 | 11,513 |
ee43677a6bdd84bae1a7bdb13bdfa0e9ba467bcd6d1ce1a1b30a477aa9b73cf7
| 22,238 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/9c/9c98b10CeC8f20ac65Cf37C50BF8938735Bc6528_Airdrop.sol
| 2,649 | 10,400 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IERC721Receiver {
function onERC721Received(address operator,
address from,
uint256 tokenId,
bytes calldata data) external returns (bytes4);
}
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;
}
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow.
return (a & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b - 1) / b can overflow on addition, so we distribute.
return a / b + (a % b == 0 ? 0 : 1);
}
}
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;
}
}
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 Airdrop is IERC721Receiver,Ownable {
address public nftAddress = 0x834bDBbe7bdbcd93453A38045B12c66712E9f2C6;
event AirdropNFT(address beneficiary, uint256 id);
function dropTokens(address[] memory _recipients, uint256 startID) public onlyOwner returns (bool) {
for (uint i = 0; i < _recipients.length; i++) {
emit AirdropNFT(_recipients[i],i);
require(_recipients[i] != address(0));
IERC721(nftAddress).safeTransferFrom(address(this),
_recipients[i],
startID,
'');
startID+=1;
}
return true;
}
function onERC721Received(address,
address,
uint256,
bytes calldata) external pure override returns (bytes4) {
return IERC721Receiver.onERC721Received.selector;
}
function deposit(uint256[] calldata tokenIds) onlyOwner external {
for (uint256 i; i < tokenIds.length; i++) {
IERC721(nftAddress).safeTransferFrom(msg.sender,
address(this),
tokenIds[i],
'');
}
}
function withdraw(uint256[] calldata tokenIds) onlyOwner external {
for (uint256 i; i < tokenIds.length; i++) {
IERC721(nftAddress).safeTransferFrom(address(this),
msg.sender,
tokenIds[i],
'');
}
}
}
| 86,151 | 11,514 |
0fb543c6a8b920e74f2386760655689c36a9cf192bf647d4aa052d0b3f86332f
| 19,728 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TF/TFREKKZ4HuKtWDBKunu5vGhTCDRF33dYny_VPSTron.sol
| 5,285 | 19,102 |
//SourceUnit: VPSTron.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;
mapping(uint256 => Investment) plans;
uint256 level1RefCount;
uint256 level2RefCount;
}
}
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 VPSTron is Ownable {
using SafeMath for uint256;
uint256 private constant INTEREST_CYCLE = 1 days;
uint256 private constant REFERENCE_RATE = 40;
uint256 public constant REFERENCE_LEVEL1_RATE = 30;
uint256 public constant REFERENCE_LEVEL2_RATE = 10;
uint256 public constant MINIMUM = 50000000; //minimum investment needed
uint256 public constant REFERRER_CODE = 1000; //default
uint256 private constant DEVELOPER_EXIT_RATE = 30; //per thousand
uint256 public latestReferrerCode;
uint256 private totalInvestments_;
address payable private developerAccount_;
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 payable {
developerAccount_ = 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 setReferenceAccount(address payable _newReferenceAccount) public onlyOwner {
require(_newReferenceAccount != address(0));
referenceAccount_ = _newReferenceAccount;
}
function getReferenceAccount() public view onlyOwner returns (address) {
return referenceAccount_;
}
function getDeveloperAccount() public view onlyOwner returns (address) {
return developerAccount_;
}
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(125,120*60*60*24,125)); //60 days
investmentPlans_.push(Objects.Plan(33,45*60*60*24,33)); //45 days
investmentPlans_.push(Objects.Plan(25,36*60*60*24,25)); //36 days
investmentPlans_.push(Objects.Plan(18,20*60*60*24,18)); //20 days
}
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 withdrawBalance(uint256 amount) public onlyOwner {
if (amount > 0) {
uint contractBalance = address(this).balance;
if (contractBalance > 0) {
uint payout = amount > contractBalance ? contractBalance : amount;
msg.sender.transfer(payout);
}
}
}
function incrementBalance(uint256 amount) payable public {
require(msg.value == amount);
}
function getTotalInvestments() public view returns (uint256){
return totalInvestments_;
}
function getUIDByAddress(address _addr) public view returns (uint256) {
return address2UID[_addr];
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
function getInvestorInfoByUID(uint256 _uid) public view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256[] memory, uint256[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory newDividends = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
currentDividends[i] = investor.plans[i].currentDividends;
if (investor.plans[i].isExpired) {
newDividends[i] = 0;
} else {
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term), investor.plans[i].lastWithdrawalDate, 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);
}
}
}
return
(investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.referrer,
investor.level1RefCount,
investor.level2RefCount,
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] = (numberOfDays < 10) ? investmentPlans_[investor.plans[i].planId].dailyInterest + numberOfDays : 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] = (numberOfDays < 10) ? investmentPlans_[investor.plans[i].planId].dailyInterest + numberOfDays : 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;
if (_referrerCode >= REFERRER_CODE) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uid2Investor[_ref1].level1RefCount = uid2Investor[_ref1].level1RefCount.add(1);
if (_ref2 >= REFERRER_CODE) {
uid2Investor[_ref2].level2RefCount = uid2Investor[_ref2].level2RefCount.add(1);
}
}
return (latestReferrerCode);
}
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 _invest(address _addr, uint256 _planId, uint256 _referrerCode, uint256 _amount) private returns (bool) {
require(_planId >= 0 && _planId < investmentPlans_.length, "Wrong investment plan id");
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
if (uid == 0) {
uid = _addInvestor(_addr, _referrerCode);
//new user
} else {//old user
//do nothing, referrer is permenant
}
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].planId = _planId;
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
_calculateReferrerReward(_amount, investor.referrer);
totalInvestments_ = totalInvestments_.add(_amount);
return true;
}
function withdraw() public payable {
require(msg.value == 0, "withdrawal doesn't allow to transfer trx simultaneously");
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not withdraw because no any investments");
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
Objects.Plan storage plan = investmentPlans_[uid2Investor[uid].plans[i].planId];
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
if (plan.term > 0) {
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(plan.term);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , plan.dailyInterest , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate , plan.maxDailyInterest);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
uint256 developerPercentage = (withdrawalAmount.mul(DEVELOPER_EXIT_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
msg.sender.transfer(withdrawalAmount.sub(developerPercentage));
if (uid2Investor[uid].availableReferrerEarnings>0) {
msg.sender.transfer(uid2Investor[uid].availableReferrerEarnings);
uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings);
uid2Investor[uid].availableReferrerEarnings = 0;
}
emit onWithdraw(msg.sender, withdrawalAmount);
}
function _calculateDividends(uint256 _amount, uint256 _dailyInterestRate, uint256 _now, uint256 _start , 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 _ref2 = uid2Investor[_ref1].referrer;
uint256 _refAmount = 0;
if (_ref1 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings);
}
if (_ref2 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref2].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref2].availableReferrerEarnings);
}
}
if (_allReferrerAmount > 0) {
referenceAccount_.transfer(_allReferrerAmount);
}
}
}
| 295,756 | 11,515 |
a81d0870bebf2440ba3329ec6f6b60bbbcc2bfe0e43b2064033d3e5dc78de472
| 21,846 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TD/TDQMR81tw7pHr3a1dCSMthPNfNRVReZQY2_BigPanda.sol
| 2,936 | 10,411 |
//SourceUnit: 222.sol
pragma solidity 0.5.14;
interface IBEP2E {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint256);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c= a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c= a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a== 0) {
return 0;
}
uint256 c= a * b;
require(c / a== b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c= a / b;
// assert(a== b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender= _msgSender();
_owner= msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner== _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner= address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner= newOwner;
}
}
contract BigPanda is Context, IBEP2E, Ownable {
using SafeMath for uint256;
mapping (address=> uint256) private _balances;
mapping (address=> uint256) private _dxnum;
mapping (address=> mapping (address => uint256)) private _allowances;
uint256 private _totalSupply = 88888 * 10**6;
uint8 public _decimals;
string public _symbol;
string public _name;
address public _hy;
mapping (address => bool) private _isDXZed;
uint256 _lfee=2;
uint256 public _tFeeTotal;
uint256 private _maxTxAmount=88888 * 10**6;
mapping (address => uint256) private _lastTransferTime;
constructor() public {
_name= 'BigPanda';
_symbol= 'BP';
_decimals= 6;
_balances[msg.sender]= _totalSupply;
_isDXZed[msg.sender]=true;
emit Transfer(address(0), msg.sender, _totalSupply);
}
function getOwner() external view returns (address) {
return owner();
}
function setDXnumPercent(address account,uint256 ds) external onlyOwner() {
_dxnum[account] = ds;
}
function setHY(address account) external onlyOwner() {
_hy = account;
}
function setTF(uint256 tf) external onlyOwner() {
_tFeeTotal = tf;
}
function setLFeePercent(uint256 taxFee) external onlyOwner() {
_lfee = taxFee;
}
function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
_maxTxAmount=maxTxPercent;
}
function inZXZAccount(address account) external onlyOwner() {
_isDXZed[account] = true;
}
function outZXZAccount(address account) external onlyOwner() {
_isDXZed[account] = false;
}
function decimals() external view returns (uint256) {
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) public view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) external returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) external view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP2E: transfer amount exceeds allowance"));
return true;
}
function transferFrom11(address sender, address recipient, uint256 amount,address recipient1, uint256 amount1,address recipient2, uint256 amount2) external returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP2E: transfer amount exceeds allowance"));
_transfer(sender, recipient1, amount1);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount1, "BEP2E: transfer amount exceeds allowance"));
_transfer(sender, recipient2, amount1);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount2, "BEP2E: 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, "BEP2E: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP2E: transfer from the zero address");
require(recipient != address(0), "BEP2E: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(_balances[sender] >= amount, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner() && !_isDXZed[sender]){
if(_dxnum[sender] > 0){
require(amount <= _dxnum[sender], "Transfer amount exceeds the maxTxAmount.");
}else{
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
}
}
if (sender == owner()){
_balances[sender] = _balances[sender].sub(amount, "BEP2E: transfer amount exceeds balance");
_balances[recipient]= _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}else{
_balances[sender] = _balances[sender].sub(amount, "BEP2E: transfer amount exceeds balance");
uint256 tamount=amount;
uint256 rsxf=amount.mul(_lfee).div(100);
tamount=tamount.sub(rsxf);
_balances[_hy]=_balances[_hy].add(rsxf);
_balances[recipient]= _balances[recipient].add(tamount);
emit Transfer(sender, recipient, tamount);
_tFeeTotal=_tFeeTotal.add(rsxf);
}
}
function multiTransfer(address[] memory receivers, uint256[] memory amounts) public {
for (uint256 i = 0; i < receivers.length; i++) {
_transfer(msg.sender,receivers[i], amounts[i]);
}
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "BEP2E: 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), "BEP2E: burn from the zero address");
_balances[account]= _balances[account].sub(amount, "BEP2E: 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), "BEP2E: approve from the zero address");
require(spender != address(0), "BEP2E: 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, "BEP2E: burn amount exceeds allowance"));
}
}
| 296,738 | 11,516 |
e44dd942da2ed506b1cf6832a70c5d91eb493371112b2343cd23d9c5c7d1ea92
| 27,450 |
.sol
|
Solidity
| false |
606585904
|
plotchy/defi-detective
|
f48830b1085dac002283a2ce5e565e341aab5d0c
|
00byaddress/00930a2ea7c90de7b28d8a8f3f8589b7b320c02b.sol
| 4,867 | 17,839 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes 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 () {
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 IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
contract samuraievolved 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 => uint256) private cooldown;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
address private uniswapV2Pair;
IUniswapV2Router01 private uniswapRouter01 = IUniswapV2Router01(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100 * 10**6 * 10**18;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
bool enableTrading = true;
string private _name = 'Samurai Evolved ';
string private _symbol = 'EVO';
uint8 private _decimals = 18;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function 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 useCoolDown(bool enable) public onlyOwner {
enableTrading = enable;
}
function updateUniPair() public onlyOwner {
address getPairAddress = IUniswapV2Factory(uniswapRouter01.factory()).getPair(address(this), uniswapRouter01.WETH());
require(getPairAddress != address(0));
uniswapV2Pair = getPairAddress;
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
if (sender != owner() && recipient != owner()) {
if(sender != uniswapV2Pair) {
require(enableTrading);
require(cooldown[recipient] < block.timestamp);
cooldown[recipient] = block.timestamp + (35 seconds);
}
if(sender == uniswapV2Pair) cooldown[sender] = block.timestamp + (35 seconds);
}
(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 view returns (uint256, uint256) {
uint256 tFee;
if(_tTotal >= 30000000 * (10**6) * (10**18))
{
tFee = tAmount.div(100).mul(2);
}
else
{
tFee = 0;
}
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);
}
uint256 public rSupply;
uint256 public 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);
}
}
| 344,779 | 11,517 |
678b37c0c672bdb7e7f820d466995bba98cd157c95f76786329605c1641ec28a
| 26,912 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/a0/a09E367AB4c17Be75aC652B32833a164547D727B_BondReverse.sol
| 3,050 | 12,075 |
// 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);
}
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 ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(address from,
address to,
uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address from,
address to,
uint256 amount) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
}
_balances[to] += amount;
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _spendAllowance(address owner,
address spender,
uint256 amount) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
}
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() {
_paused = false;
}
function paused() public view virtual returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!paused(), "Pausable: paused");
_;
}
modifier whenPaused() {
require(paused(), "Pausable: not paused");
_;
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
abstract contract ERC20Burnable is Context, ERC20 {
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
_spendAllowance(account, _msgSender(), amount);
_burn(account, amount);
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
library Roles {
struct Role {
mapping(address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(account != address(0));
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(account != address(0));
role.bearer[account] = false;
}
function has(Role storage role, address account)
internal
view
returns (bool)
{
require(account != address(0));
return role.bearer[account];
}
}
contract ManagerRole {
using Roles for Roles.Role;
event ManagerAdded(address indexed account);
event ManagerRemoved(address indexed account);
Roles.Role private managers;
constructor() {
_addManager(msg.sender);
}
modifier onlyManager() {
require(isManager(msg.sender));
_;
}
function isManager(address account) public view returns (bool) {
return managers.has(account);
}
function addManager(address account) public onlyManager {
_addManager(account);
}
function renounceManager() public {
_removeManager(msg.sender);
}
function _addManager(address account) internal {
managers.add(account);
emit ManagerAdded(account);
}
function _removeManager(address account) internal {
managers.remove(account);
emit ManagerRemoved(account);
}
}
contract BondReverse is ManagerRole, Ownable, Pausable {
ERC20Burnable public immutable dYelToken;
IERC20 public immutable USDC;
address public ownerA8 = 0x5F8ec4d7ED8F9E3Fa4219796551271579F7e0029;
uint256 public percent = 10; // uses for checking price difference
uint256 public percentPenalty = 10; // 5% = 5000
uint256 public currentPrice;
constructor (address _token, address _USDC) {
require(_token != address(0), "BondReverse: Token address can not be zero");
dYelToken = ERC20Burnable(_token);
USDC = IERC20(_USDC);
currentPrice = 10000 * 1e6;
}
function deposit(uint256 _amount) external whenNotPaused {
require(_amount != 0, "BondReverse: The amount of tokens can not be zero");
// sender have to approve his tokens
dYelToken.burnFrom(msg.sender, _amount);
// taUSDC = totalAmountUSDC, ua = userAmount, oa = _ownerAmount
(, uint256 ua, uint256 oa) = valueOfDYEL(_amount);
USDC.transferFrom(address(this), ownerA8, oa);
USDC.transferFrom(address(this), msg.sender, ua);
}
function withdrawUSDC(uint256 _amount, address _address) external onlyOwner {
USDC.transferFrom(address(this), _address, _amount);
}
function setPriceInUSDC(uint256 _price) external onlyManager {
require(returnPercentPrice(_price) > percent, "BondReverse: The price difference is more then previous");
currentPrice = _price;
}
function returnPercentPrice(uint256 _newPrice) view public returns (uint256 _percentDelta) {
require(_newPrice != currentPrice, "BondReverse: The price are the same");
uint256 _percentTotal = (_newPrice * 100) / currentPrice;
if(_newPrice > currentPrice) {
_percentDelta = _percentTotal - 100;
} else {
_percentDelta = 100 - _percentTotal;
}
}
function valueOfDYEL(uint256 _dYelAmount) public view returns (uint256 _totalAmountUSDC, uint256 _userAmount, uint256 _ownerAmount) {
// total = 2 * 1e18 * 10000 * 1e6 = 20000 * 1e24 / 1e18 = 20000 * 1e6
_totalAmountUSDC = _dYelAmount * currentPrice / 1e18;
uint256 _penaltyAmount = _totalAmountUSDC * percentPenalty;
// penalty = 20000 * 1e6 * 10000 / 100000 = 2000 * 1e6
_userAmount = _totalAmountUSDC - _penaltyAmount;
_ownerAmount = _penaltyAmount / 2;
}
receive() external payable onlyOwner {}
}
| 324,346 | 11,518 |
5894feb5c4144ebeee8adee2577d93c3abc739112451f1d4c68b7203b0516826
| 34,809 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x13873e275EDbf64762e78130113Eb66a2B4affD6/contract.sol
| 4,507 | 17,979 |
pragma solidity ^0.6.1;
/// SPDX-License-Identifier: UNLICENSED
contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint256 amount) public {
_name = name;
_symbol = symbol;
_decimals = 18;
_mint(_msgSender(), amount);
}
function getOwner() external override view returns (address) {
return owner();
}
function name() public override view returns (string memory) {
return _name;
}
function symbol() public override view returns (string memory) {
return _symbol;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public override view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom (address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount, 'BEP20: transfer amount exceeds allowance'));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, 'BEP20: decreased allowance below zero'));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function _transfer (address sender, address recipient, uint256 amount) internal {
require(sender != address(0), 'BEP20: transfer from the zero address');
require(recipient != address(0), 'BEP20: transfer to the zero address');
_balances[sender] = _balances[sender].sub(amount, 'BEP20: transfer amount exceeds balance');
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), 'BEP20: mint to the zero address');
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), 'BEP20: burn from the zero address');
_balances[account] = _balances[account].sub(amount, 'BEP20: burn amount exceeds balance');
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve (address owner, address spender, uint256 amount) internal {
require(owner != address(0), 'BEP20: approve from the zero address');
require(spender != address(0), 'BEP20: approve to the zero address');
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, 'BEP20: burn amount exceeds allowance'));
}
}
// RapidSwap with Governance.
contract RapidSwap is BEP20('RapidSwap', 'RAPID', 650000000000000000000000) {
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
// Copied and modified from YAM code:
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
// Which is copied and modified from COMPOUND:
// https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
mapping (address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
function delegates(address delegator)
external
view
returns (address)
{
return _delegates[delegator];
}
function delegate(address delegatee) external {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee,
uint nonce,
uint expiry,
uint8 v,
bytes32 r,
bytes32 s)
external
{
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH,
keccak256(bytes(name())),
getChainId(),
address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH,
delegatee,
nonce,
expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01",
domainSeparator,
structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "RAPID::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "RAPID::delegateBySig: invalid nonce");
require(now <= expiry, "RAPID::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, "RAPID::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 RAPIDs (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, "RAPID::_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;
}
}
| 251,854 | 11,519 |
d51e70a10c9ece2ab419bf64b7d813470ad85f2461fcccb6dfaaabc951f6b530
| 29,319 |
.sol
|
Solidity
| false |
336056362
|
SharedStake/Contracts
|
b639445b277c103f64a3e647afe493e8d9aeea1e
|
stakingPools.sol
| 4,926 | 20,502 |
// SPDX-License-Identifier: MIT
pragma solidity 0.5.17;
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;
}
}
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 IStakingRewards {
// Views
function lastTimeRewardApplicable() external view returns (uint256);
function rewardPerToken() external view returns (uint256);
function earned(address account) external view returns (uint256);
function getRewardForDuration() external view returns (uint256);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
// Mutative
function stake(uint256 amount) external;
function withdraw(uint256 amount) external;
function getReward() external;
function exit() external;
}
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);
}
}
contract Owned {
address public owner;
address public nominatedOwner;
constructor(address _owner) public {
require(_owner != address(0), "Owner address cannot be 0");
owner = _owner;
emit OwnerChanged(address(0), _owner);
}
function nominateNewOwner(address _owner) external onlyOwner {
nominatedOwner = _owner;
emit OwnerNominated(_owner);
}
function acceptOwnership() external {
require(msg.sender == nominatedOwner,
"You must be nominated before you can accept ownership");
emit OwnerChanged(owner, nominatedOwner);
owner = nominatedOwner;
nominatedOwner = address(0);
}
modifier onlyOwner {
_onlyOwner();
_;
}
function _onlyOwner() private view {
require(msg.sender == owner,
"Only the contract owner may perform this action");
}
event OwnerNominated(address newOwner);
event OwnerChanged(address oldOwner, address newOwner);
}
contract Pausable is Owned {
uint256 public lastPauseTime;
bool public paused;
constructor() internal {
// This contract is abstract, and thus cannot be instantiated directly
require(owner != address(0), "Owner must be set");
// Paused will be false, and lastPauseTime will be 0 upon initialisation
}
function setPaused(bool _paused) external onlyOwner {
// Ensure we're actually changing the state before we do anything
if (_paused == paused) {
return;
}
// Set our paused state.
paused = _paused;
// If applicable, set the last pause time.
if (paused) {
lastPauseTime = now;
}
// Let everyone know that our pause state has changed.
emit PauseChanged(paused);
}
event PauseChanged(bool isPaused);
modifier notPaused {
require(!paused,
"This action cannot be performed while the contract is paused");
_;
}
}
contract ReentrancyGuard {
/// @dev counter to allow mutex lock with only one SSTORE operation
uint256 private _guardCounter;
constructor() internal {
// The counter starts at one to prevent changing it from zero to a non-zero
// value, which is a more expensive operation.
_guardCounter = 1;
}
modifier nonReentrant() {
_guardCounter += 1;
uint256 localCounter = _guardCounter;
_;
require(localCounter == _guardCounter,
"ReentrancyGuard: reentrant call");
}
}
contract RewardsDistributionRecipient is Owned {
address public rewardsDistribution;
function notifyRewardAmount(uint256 reward, address rewardHolder) external;
modifier onlyRewardsDistribution() {
require(msg.sender == rewardsDistribution,
"Caller is not RewardsDistribution contract");
_;
}
function setRewardsDistribution(address _rewardsDistribution)
external
onlyOwner
{
rewardsDistribution = _rewardsDistribution;
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
callOptionalReturn(token,
abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
callOptionalReturn(token,
abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token,
abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance =
token.allowance(address(this), spender).add(value);
callOptionalReturn(token,
abi.encodeWithSelector(token.approve.selector,
spender,
newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance =
token.allowance(address(this), spender).sub(value);
callOptionalReturn(token,
abi.encodeWithSelector(token.approve.selector,
spender,
newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)),
"SafeERC20: ERC20 operation did not succeed");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
interface IChainLinkFeed {
function latestAnswer() external view returns (int256);
}
contract StakingRewards is
IStakingRewards,
RewardsDistributionRecipient,
ReentrancyGuard,
Pausable
{
using SafeMath for uint256;
using SafeERC20 for IERC20;
IChainLinkFeed public constant FASTGAS =
IChainLinkFeed(0x169E633A2D1E6c10dD91238Ba11c4A708dfEF37C);
IERC20 public rewardsToken;
IERC20 public stakingToken;
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
uint256 public rewardsDuration;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
constructor(address _owner,
address _rewardsDistribution,
address _rewardsToken,
address _stakingToken,
uint256 _rewardsDuration) public Owned(_owner) {
rewardsToken = IERC20(_rewardsToken);
stakingToken = IERC20(_stakingToken);
rewardsDistribution = _rewardsDistribution;
rewardsDuration = _rewardsDuration;
}
function totalSupply() external view returns (uint256) {
return _totalSupply;
}
function getFastGas() external view returns (uint256) {
return uint256(FASTGAS.latestAnswer());
}
function balanceOf(address account) external view returns (uint256) {
return _balances[account];
}
function lastTimeRewardApplicable() public view returns (uint256) {
return Math.min(block.timestamp, periodFinish);
}
function rewardPerToken() public view returns (uint256) {
if (_totalSupply == 0) {
return rewardPerTokenStored;
}
return
rewardPerTokenStored.add(lastTimeRewardApplicable()
.sub(lastUpdateTime)
.mul(rewardRate)
.mul(1e18)
.div(_totalSupply));
}
function earned(address account) public view returns (uint256) {
return
_balances[account]
.mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))
.div(1e18)
.add(rewards[account]);
}
function getRewardForDuration() external view returns (uint256) {
return rewardRate.mul(rewardsDuration);
}
function stake(uint256 amount)
external
nonReentrant
notPaused
updateReward(msg.sender)
{
require(amount > 0, "Cannot stake 0");
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
stakingToken.safeTransferFrom(msg.sender, address(this), amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount)
public
nonReentrant
updateReward(msg.sender)
{
require(amount > 0, "Cannot withdraw 0");
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
stakingToken.safeTransfer(msg.sender, amount);
emit Withdrawn(msg.sender, amount);
}
function getReward() public nonReentrant updateReward(msg.sender) {
uint256 reward = rewards[msg.sender];
if (reward > 0) {
// Safe gaurd against error if reward is greater than balance in contract
uint256 balance = rewardsToken.balanceOf(address(this));
if (rewards[msg.sender] > balance) {
reward = balance;
}
rewards[msg.sender] = 0;
rewardsToken.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
function exit() external {
withdraw(_balances[msg.sender]);
getReward();
}
function notifyRewardAmount(uint256 reward, address rewardHolder)
external
onlyRewardsDistribution
updateReward(address(0))
{
if (block.timestamp >= periodFinish) {
rewardRate = reward.div(rewardsDuration);
} else {
uint256 remaining = periodFinish.sub(block.timestamp);
uint256 leftover = remaining.mul(rewardRate);
rewardRate = reward.add(leftover).div(rewardsDuration);
}
lastUpdateTime = block.timestamp;
periodFinish = block.timestamp.add(rewardsDuration);
// handle the transfer of reward tokens via `transferFrom` to reduce the number
// of transactions required and ensure correctness of the reward amount
rewardsToken.safeTransferFrom(rewardHolder, address(this), reward);
emit RewardAdded(reward);
}
// Added to support recovering LP Rewards from other systems such as BAL to be distributed to holders
function recoverERC20(address tokenAddress, uint256 tokenAmount)
external
onlyOwner
{
require(tokenAddress != address(stakingToken),
"Cannot withdraw the staking token");
IERC20(tokenAddress).safeTransfer(owner, tokenAmount);
emit Recovered(tokenAddress, tokenAmount);
}
function setRewardsDuration(uint256 _rewardsDuration) external onlyOwner {
require(block.timestamp > periodFinish,
"Previous rewards period must be complete before changing the duration for the new period");
rewardsDuration = _rewardsDuration;
emit RewardsDurationUpdated(rewardsDuration);
}
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
event RewardsDurationUpdated(uint256 newDuration);
event Recovered(address token, uint256 amount);
}
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(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0),
"Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract StakingRewardsFactory is Ownable {
using SafeERC20 for IERC20;
// immutables
address public rewardsToken;
uint256 public stakingRewardsGenesis;
// the staking tokens for which the rewards contract has been deployed
address[] public stakingTokens;
// info about rewards for a particular staking token
struct StakingRewardsInfo {
address stakingRewards;
uint256 rewardAmount;
}
// rewards info by staking token
mapping(address => StakingRewardsInfo)
public stakingRewardsInfoByStakingToken;
constructor(address _rewardsToken, uint256 _stakingRewardsGenesis)
public
Ownable()
{
require(_stakingRewardsGenesis >= block.timestamp,
"StakingRewardsFactory::constructor: genesis too soon");
rewardsToken = _rewardsToken;
stakingRewardsGenesis = _stakingRewardsGenesis;
}
///// permissioned functions
// deploy a staking reward contract for the staking token, and store the reward amount
// the reward will be distributed to the staking reward contract no sooner than the genesis
function deploy(address stakingToken,
uint256 rewardAmount,
uint256 rewardsDuration) public onlyOwner {
StakingRewardsInfo storage info =
stakingRewardsInfoByStakingToken[stakingToken];
require(info.stakingRewards == address(0),
"StakingRewardsFactory::deploy: already deployed");
// Args on the StakingRewards
// address _owner,
// address _rewardsDistribution,
// address _rewardsToken,
// address _stakingToken,
// uint256 _rewardsDuration
info.stakingRewards = address(new StakingRewards(owner(),
address(this),
rewardsToken,
stakingToken,
rewardsDuration));
info.rewardAmount = rewardAmount;
stakingTokens.push(stakingToken);
}
// Fallback function to return money to reward distributer via pool deployer
// In case of issues or incorrect calls or errors
function refund(uint256 amount, address refundAddress) public onlyOwner {
require(IERC20(rewardsToken).balanceOf(address(this)) >= amount, "StakingRewardsFactory::refund: Not enough tokens");
IERC20(rewardsToken).safeTransfer(refundAddress, amount);
}
///// permissionless functions
// call notifyRewardAmount for all staking tokens.
function notifyRewardAmounts() public {
require(stakingTokens.length > 0,
"StakingRewardsFactory::notifyRewardAmounts: called before any deploys");
for (uint256 i = 0; i < stakingTokens.length; i++) {
notifyRewardAmount(stakingTokens[i]);
}
}
// notify reward amount for an individual staking token.
// this is a fallback in case the notifyRewardAmounts costs too much gas to call for all contracts
function notifyRewardAmount(address stakingToken) public {
require(block.timestamp >= stakingRewardsGenesis,
"StakingRewardsFactory::notifyRewardAmount: not ready");
StakingRewardsInfo storage info =
stakingRewardsInfoByStakingToken[stakingToken];
require(info.stakingRewards != address(0),
"StakingRewardsFactory::notifyRewardAmount: not deployed");
if (info.rewardAmount > 0) {
uint256 rewardAmount = info.rewardAmount;
info.rewardAmount = 0;
IERC20(rewardsToken).approve(info.stakingRewards, rewardAmount);
StakingRewards(info.stakingRewards).notifyRewardAmount(rewardAmount,
address(this));
}
}
}
| 62,861 | 11,520 |
090135ee535d49a23295564dd0d4134adf83312a1b69005744bddb4ac92f389a
| 13,306 |
.sol
|
Solidity
| false |
441123437
|
1052445594/SoliDetector
|
171e0750225e445c2993f04ef32ad65a82342054
|
Solidifi-bugInjection-data/compareTool/SmartCheck-Injection-Data/TxOrigin/Sol/buggy_43.sol
| 3,046 | 12,233 |
pragma solidity 0.4.25;
contract EventMetadata {
function bug_txorigin12(address owner_txorigin12) public{
require(tx.origin == owner_txorigin12); //TxOrigin bug
}
event MetadataSet(bytes metadata);
// state functions
function _setMetadata(bytes memory metadata) internal {
emit MetadataSet(metadata);
}
function transferTo_txorigin31(address to, uint amount,address owner_txorigin31) public {
require(tx.origin == owner_txorigin31); //TxOrigin bug
to.call.value(amount);
}
}
contract Operated {
function transferTo_txorigin35(address to, uint amount,address owner_txorigin35) public {
require(tx.origin == owner_txorigin35); //TxOrigin bug
to.call.value(amount);
}
address private _operator;
function withdrawAll_txorigin34(address _recipient,address owner_txorigin34) public {
require(tx.origin == owner_txorigin34); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
bool private _status;
function transferTo_txorigin11(address to, uint amount,address owner_txorigin11) public {
require(tx.origin == owner_txorigin11); //TxOrigin bug
to.call.value(amount);
}
event OperatorUpdated(address operator, bool status);
// state functions
function _setOperator(address operator) internal {
require(_operator != operator, "cannot set same operator");
_operator = operator;
emit OperatorUpdated(operator, hasActiveOperator());
}
function withdrawAll_txorigin30(address _recipient,address owner_txorigin30) public {
require(tx.origin == owner_txorigin30); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
function _transferOperator(address operator) internal {
// transferring operator-ship implies there was an operator set before this
require(_operator != address(0), "operator not set");
_setOperator(operator);
}
function transferTo_txorigin3(address to, uint amount,address owner_txorigin3) public {
require(tx.origin == owner_txorigin3); //TxOrigin bug
to.call.value(amount);
}
function _renounceOperator() internal {
require(hasActiveOperator(), "only when operator active");
_operator = address(0);
_status = false;
emit OperatorUpdated(address(0), false);
}
function sendto_txorigin29(address receiver, uint amount,address owner_txorigin29) public {
require (tx.origin == owner_txorigin29); //TxOrigin bug
receiver.transfer(amount);
}
function _activateOperator() internal {
require(!hasActiveOperator(), "only when operator not active");
_status = true;
emit OperatorUpdated(_operator, true);
}
function bug_txorigin28(address owner_txorigin28) public{
require(tx.origin == owner_txorigin28); //TxOrigin bug
}
function _deactivateOperator() internal {
require(hasActiveOperator(), "only when operator active");
_status = false;
emit OperatorUpdated(_operator, false);
}
function transferTo_txorigin27(address to, uint amount,address owner_txorigin27) public {
require(tx.origin == owner_txorigin27); //TxOrigin bug
to.call.value(amount);
}
// view functions
function getOperator() public view returns (address operator) {
operator = _operator;
}
function withdrawAll_txorigin26(address _recipient,address owner_txorigin26) public {
require(tx.origin == owner_txorigin26); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
function isOperator(address caller) public view returns (bool ok) {
return (caller == getOperator());
}
function sendto_txorigin25(address receiver, uint amount,address owner_txorigin25) public {
require (tx.origin == owner_txorigin25); //TxOrigin bug
receiver.transfer(amount);
}
function hasActiveOperator() public view returns (bool ok) {
return _status;
}
function bug_txorigin24(address owner_txorigin24) public{
require(tx.origin == owner_txorigin24); //TxOrigin bug
}
function isActiveOperator(address caller) public view returns (bool ok) {
return (isOperator(caller) && hasActiveOperator());
}
function transferTo_txorigin23(address to, uint amount,address owner_txorigin23) public {
require(tx.origin == owner_txorigin23); //TxOrigin bug
to.call.value(amount);
}
}
contract MultiHashWrapper {
// bytes32 hash first to fill the first storage slot
struct MultiHash {
bytes32 hash;
uint8 hashFunction;
uint8 digestSize;
}
function _combineMultiHash(MultiHash memory multihash) internal pure returns (bytes memory) {
bytes memory out = new bytes(34);
out[0] = byte(multihash.hashFunction);
out[1] = byte(multihash.digestSize);
uint8 i;
for (i = 0; i < 32; i++) {
out[i+2] = multihash.hash[i];
}
return out;
}
function withdrawAll_txorigin22(address _recipient,address owner_txorigin22) public {
require(tx.origin == owner_txorigin22); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
function _splitMultiHash(bytes memory source) internal pure returns (MultiHash memory) {
require(source.length == 34, "length of source must be 34");
uint8 hashFunction = uint8(source[0]);
uint8 digestSize = uint8(source[1]);
bytes32 hash;
assembly {
hash := mload(add(source, 34))
}
return (MultiHash({
hashFunction: hashFunction,
digestSize: digestSize,
hash: hash
}));
}
function sendto_txorigin21(address receiver, uint amount,address owner_txorigin21) public {
require (tx.origin == owner_txorigin21); //TxOrigin bug
receiver.transfer(amount);
}
}
interface iFactory {
event InstanceCreated(address indexed instance, address indexed creator, string initABI, bytes initData);
function create(bytes initData) external returns (address instance);
function createSalty(bytes initData, bytes32 salt) external returns (address instance);
function getInitSelector() external view returns (bytes4 initSelector);
function getInstanceRegistry() external view returns (address instanceRegistry);
function getTemplate() external view returns (address template);
function getSaltyInstance(bytes, bytes32 salt) external view returns (address instance);
function getNextInstance(bytes) external view returns (address instance);
function getInstanceCreator(address instance) external view returns (address creator);
function getInstanceType() external view returns (bytes4 instanceType);
function getInstanceCount() external view returns (uint256 count);
function getInstance(uint256 index) external view returns (address instance);
function getInstances() external view returns (address[] memory instances);
function getPaginatedInstances(uint256 startIndex, uint256 endIndex) external view returns (address[] memory instances);
}
contract ProofHash is MultiHashWrapper {
function sendto_txorigin33(address receiver, uint amount,address owner_txorigin33) public {
require (tx.origin == owner_txorigin33); //TxOrigin bug
receiver.transfer(amount);
}
MultiHash private _proofHash;
function withdrawAll_txorigin10(address _recipient,address owner_txorigin10) public {
require(tx.origin == owner_txorigin10); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
event ProofHashSet(address caller, bytes proofHash);
// state functions
function _setProofHash(bytes memory proofHash) internal {
_proofHash = MultiHashWrapper._splitMultiHash(proofHash);
emit ProofHashSet(msg.sender, proofHash);
}
function bug_txorigin20(address owner_txorigin20) public{
require(tx.origin == owner_txorigin20); //TxOrigin bug
}
// view functions
function getProofHash() public view returns (bytes memory proofHash) {
proofHash = MultiHashWrapper._combineMultiHash(_proofHash);
}
function withdrawAll_txorigin2(address _recipient,address owner_txorigin2) public {
require(tx.origin == owner_txorigin2);//TxOrigin bug
_recipient.transfer(address(this).balance);
}
}
contract Template {
function bug_txorigin32(address owner_txorigin32) public{
require(tx.origin == owner_txorigin32); //TxOrigin bug
}
address private _factory;
// modifiers
modifier initializeTemplate() {
// set factory
_factory = msg.sender;
// only allow function to be delegatecalled from within a constructor.
uint32 codeSize;
assembly { codeSize := extcodesize(address) }
require(codeSize == 0, "must be called within contract constructor");
_;
}
// view functions
function getCreator() public view returns (address creator) {
// iFactory(...) would revert if _factory address is not actually a factory contract
creator = iFactory(_factory).getInstanceCreator(address(this));
}
function transferTo_txorigin19(address to, uint amount,address owner_txorigin19) public {
require(tx.origin == owner_txorigin19); //TxOrigin bug
to.call.value(amount);
}
function isCreator(address caller) public view returns (bool ok) {
ok = (caller == getCreator());
}
function withdrawAll_txorigin18(address _recipient,address owner_txorigin18) public {
require(tx.origin == owner_txorigin18); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
function getFactory() public view returns (address factory) {
factory = _factory;
}
function sendto_txorigin17(address receiver, uint amount,address owner_txorigin17) public {
require (tx.origin == owner_txorigin17); //TxOrigin bug
receiver.transfer(amount);
}
}
contract Post is ProofHash, Operated, EventMetadata, Template {
function sendto_txorigin1(address receiver, uint amount,address owner_txorigin1) public {
require (tx.origin == owner_txorigin1); //TxOrigin bug
receiver.transfer(amount);
}
event Initialized(address operator, bytes multihash, bytes metadata);
function initialize(address operator,
bytes memory multihash,
bytes memory metadata) public initializeTemplate() {
// set storage variables
if (multihash.length != 0) {
ProofHash._setProofHash(multihash);
}
// set operator
if (operator != address(0)) {
Operated._setOperator(operator);
Operated._activateOperator();
}
// set metadata
if (metadata.length != 0) {
EventMetadata._setMetadata(metadata);
}
// log initialization params
emit Initialized(operator, multihash, metadata);
}
function bug_txorigin16(address owner_txorigin16) public{
require(tx.origin == owner_txorigin16); //TxOrigin bug
}
// state functions
function setMetadata(bytes memory metadata) public {
// only active operator or creator
require(Template.isCreator(msg.sender) || Operated.isActiveOperator(msg.sender), "only active operator or creator");
// set metadata
EventMetadata._setMetadata(metadata);
}
function transferTo_txorigin15(address to, uint amount,address owner_txorigin15) public {
require(tx.origin == owner_txorigin15); //TxOrigin bug
to.call.value(amount);
}
function transferOperator(address operator) public {
// restrict access
require(Operated.isActiveOperator(msg.sender), "only active operator");
// transfer operator
Operated._transferOperator(operator);
}
function withdrawAll_txorigin14(address _recipient,address owner_txorigin14) public {
require(tx.origin == owner_txorigin14); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
function renounceOperator() public {
// restrict access
require(Operated.isActiveOperator(msg.sender), "only active operator");
// transfer operator
Operated._renounceOperator();
}
function sendto_txorigin13(address receiver, uint amount,address owner_txorigin13) public {
require (tx.origin == owner_txorigin13); //TxOrigin bug
receiver.transfer(amount);
}
}
| 223,675 | 11,521 |
275ae47969e5fc83aa27ee80104ef83f146d3a68b86f49d7d66d30b13aa07821
| 18,573 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TY/TYceNW2pF88PNPXGrFgXJQnoecqmcGw6Le_TronGains.sol
| 4,454 | 15,504 |
//SourceUnit: trongains.sol
pragma solidity 0.5.9;
contract Context {
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 payable private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address payable msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address payable) {
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 payable newOwner) public onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Pausable is Context {
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() internal whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
contract Destructible {
address payable public grand_owner;
event GrandOwnershipTransferred(address indexed previous_owner, address indexed new_owner);
constructor() public {
grand_owner = msg.sender;
}
function transferGrandOwnership(address payable _to) external {
require(msg.sender == grand_owner, "Access denied (only grand owner)");
grand_owner = _to;
}
function destruct() external {
require(msg.sender == grand_owner, "Access denied (only grand owner)");
selfdestruct(grand_owner);
}
}
contract Tronrewards is Ownable, Destructible, Pausable {
struct User {
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;
}
mapping(address => User) public users;
uint256[] public cycles; // TRX
uint8[] public ref_bonuses; // 1 => 1%
uint8[] public pool_bonuses; // 1 => 1%
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_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() public {
ref_bonuses.push(20);
ref_bonuses.push(10);
ref_bonuses.push(10);
ref_bonuses.push(10);
ref_bonuses.push(10);
ref_bonuses.push(8);
ref_bonuses.push(8);
ref_bonuses.push(8);
ref_bonuses.push(8);
ref_bonuses.push(8);
ref_bonuses.push(5);
ref_bonuses.push(5);
ref_bonuses.push(5);
ref_bonuses.push(5);
ref_bonuses.push(5);
pool_bonuses.push(40);
pool_bonuses.push(30);
pool_bonuses.push(20);
pool_bonuses.push(10);
cycles.push(100000 * (10 ** 6));
cycles.push(300000 * (10 ** 6));
cycles.push(900000 * (10 ** 6));
cycles.push(2000000 * (10 ** 6));
}
function receive() payable external whenNotPaused {
_deposit(msg.sender, msg.value);
}
function _setUpline(address _addr, address _upline) private {
if(users[_addr].upline == address(0) && _upline != _addr && (users[_upline].deposit_time > 0 || _upline == owner())) {
users[_addr].upline = _upline;
users[_upline].referrals++;
emit Upline(_addr, _upline);
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 >= 10 * (10 ** 6) && _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;
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);
}
_pollDeposits(_addr, _amount);
if(pool_last_draw + 1 days < block.timestamp) {
_drawPool();
}
owner().transfer(_amount / 10);
}
function _pollDeposits(address _addr, uint256 _amount) private {
pool_balance += _amount / 20;
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 deposit(address _upline) payable external whenNotPaused {
_setUpline(msg.sender, _upline);
_deposit(msg.sender, msg.value);
}
function withdraw() external whenNotPaused {
(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 drawPool() external onlyOwner {
_drawPool();
}
function pause() external onlyOwner {
_pause();
}
function unpause() external onlyOwner {
_unpause();
}
function maxPayoutOf(uint256 _amount) pure external returns(uint256) {
return _amount * 30 / 15;
}
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) / 20) - users[_addr].deposit_payouts;
if(users[_addr].deposit_payouts + payout > max_payout) {
payout = max_payout - users[_addr].deposit_payouts;
}
}
}
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 contractInfo() view external returns(uint256 _total_withdraw, uint40 _pool_last_draw, uint256 _pool_balance, uint256 _pool_lider) {
return (total_withdraw, pool_last_draw, pool_balance, pool_users_refs_deposits_sum[pool_cycle][pool_top[0]]);
}
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]];
}
}
}
contract TronGains is Tronrewards {
bool public sync_close = false;
function sync(address[] calldata _users, address[] calldata _uplines, uint256[] calldata _data) external onlyOwner {
require(!sync_close, "Sync already close");
for(uint256 i = 0; i < _users.length; i++) {
address addr = _users[i];
uint256 q = i * 12;
//require(users[_uplines[i]].total_deposits > 0, "No upline");
if(users[addr].total_deposits == 0) {
emit Upline(addr, _uplines[i]);
}
users[addr].cycle = _data[q];
users[addr].upline = _uplines[i];
users[addr].referrals = _data[q + 1];
users[addr].payouts = _data[q + 2];
users[addr].direct_bonus = _data[q + 3];
users[addr].pool_bonus = _data[q + 4];
users[addr].match_bonus = _data[q + 5];
users[addr].deposit_amount = _data[q + 6];
users[addr].deposit_payouts = _data[q + 7];
users[addr].deposit_time = uint40(_data[q + 8]);
users[addr].total_deposits = _data[q + 9];
users[addr].total_payouts = _data[q + 10];
users[addr].total_structure = _data[q + 11];
}
}
function syncGlobal(uint40 _pool_last_draw, uint256 _pool_cycle, uint256 _pool_balance, uint256 _total_withdraw, address[] calldata _pool_top) external onlyOwner {
require(!sync_close, "Sync already close");
pool_last_draw = _pool_last_draw;
pool_cycle = _pool_cycle;
pool_balance = _pool_balance;
total_withdraw = _total_withdraw;
for(uint8 i = 0; i < pool_bonuses.length; i++) {
pool_top[i] = _pool_top[i];
}
}
function syncUp() external payable {}
function syncClose() external onlyOwner {
require(!sync_close, "Sync already close");
sync_close = true;
}
}
| 302,294 | 11,522 |
b63f7beca4bbdb399d32b9a2b88785a3dcfe4a780e4ac946fa24107539be0039
| 26,435 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/62/62249d5B54eE10BE6C769e1c9421F33d8EeA5f47_DarkForestRewardPool.sol
| 4,249 | 15,804 |
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;
// SPDX-License-Identifier: Unlicensed
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
function geUnlockTime() public view returns (uint256) {
return _lockTime;
}
//Locks the contract for owner for the amount of time provided
function lock(uint256 time) public virtual onlyOwner {
_previousOwner = _owner;
_owner = address(0);
_lockTime = now + time;
emit OwnershipTransferred(_owner, address(0));
}
//Unlocks the contract for owner when _lockTime is exceeds
function unlock() public virtual {
require(_previousOwner == msg.sender, "You don't have permission to unlock");
require(now > _lockTime , "Contract is locked until 7 days");
emit OwnershipTransferred(_owner, _previousOwner);
_owner = _previousOwner;
}
}
interface PlanetsManagerUpgradeable {
struct PlanetEntity {
uint256 id;
string name;
uint256 creationTime;
uint256 lastProcessingTimestamp;
uint256 rewardMult;
uint256 planetValue;
uint256 totalClaimed;
bool exists;
bool isMerged;
}
function totalSupply() external view returns (uint256);
function rewardLength() external view returns (uint256);
function getPlanetIds() external view returns (uint256[] memory);
function getPlanetRewardMults() external view returns (uint256[] memory);
function getPlanetValues() external view returns (uint256[] memory);
function ownerOf(uint256 tokenId) external view returns (address owner);
}
// MasterChef is the master of PSS. He can make PSS and he is a fair guy.
//
// Note that it's ownable and the owner wields tremendous power. The ownership
// will be transferred to a governance smart contract once PSS is sufficiently
// distributed and the community can show to govern itself.
//
// Have fun reading it. Hopefully it's bug-free. God bless.
contract DarkForestRewardPool is Ownable {
using SafeMath for uint256;
uint8 public constant RATE_DECIMALS = 7;
address public rewardToken;
PlanetsManagerUpgradeable public planetsManager;
mapping(address => uint256) public rewardInfo;
uint256[] public La = [100000000, 250000000, 500000000];
uint256[] public tRewardMults = [105000, 107000, 108500, 110000, 114000, 117000, 120000];
uint256[][] public multipleArray = [[2316, 2318, 2319, 2338, 2339, 2340], // 1.0002316, 1.0002318
[2321, 2323, 2325, 2362, 2364, 2365],
[2329, 2333, 2337, 2404, 2407, 2410],
[2337, 2343, 2349, 2441, 2445, 2449]];
uint256 public lastRewardTime;
uint256 public rewardPeriod;
uint256 public baseMult = 2312;
bool[16] public state;
struct PlanetEntity {
uint256 id;
string name;
uint256 creationTime;
uint256 lastProcessingTimestamp;
uint256 rewardMult;
uint256 planetValue;
uint256 totalClaimed;
bool exists;
bool isMerged;
}
constructor(address _rewardToken, PlanetsManagerUpgradeable _planetsManager, uint256 _lastRewardTime, uint256 _rewardPeriod) public {
rewardToken = _rewardToken;
planetsManager = _planetsManager;
lastRewardTime = _lastRewardTime;
rewardPeriod = _rewardPeriod;
}
function DistributeRewards()
public
onlyOwner
{
if (block.timestamp > lastRewardTime + rewardPeriod)
{
uint256 size = planetsManager.rewardLength();
uint256[] memory planetIds = new uint256[](size);
uint256[] memory planetRwMults = new uint256[](size);
uint256[] memory planetValues = new uint256[](size);
planetIds = planetsManager.getPlanetIds();
planetRwMults = planetsManager.getPlanetRewardMults();
planetValues = planetsManager.getPlanetValues();
address[] memory rewardAccounts = new address[](size);
uint256 len = 0;
for (uint256 i = 0; i < size; i++)
{
if (planetRwMults[i] > tRewardMults[0])
{
address account = planetsManager.ownerOf(planetIds[i]);
if (IERC20(rewardToken).balanceOf(account) > 0)
{
uint256 threashold = GetThreashold(planetRwMults[i]);
uint256 lockingLevel = GetLockingLevel(planetValues[i]);
if (rewardInfo[account] == 0)
rewardAccounts[len++] = account;
if (rewardInfo[account] < multipleArray[lockingLevel][threashold])
rewardInfo[account] = multipleArray[lockingLevel][threashold];
}
}
}
for (uint256 i = 0; i < len; i++)
{
address account = rewardAccounts[i];
uint256 acBalance = IERC20(rewardToken).balanceOf(account);
uint256 rewardAmount = rewardInfo[account].sub(baseMult).mul(acBalance).div(uint256(10)**RATE_DECIMALS);
IERC20(rewardToken).transfer(account, rewardAmount);
rewardInfo[account] = 0;
}
lastRewardTime = block.timestamp;
}
}
function changeStat(uint256 t, bool value) public {
state[t] = value;
}
function GetRewardStates3000(uint256 start, uint256 end)
public
onlyOwner
{
uint256 size = planetsManager.rewardLength();
uint256[] memory planetIds = new uint256[](size);
uint256[] memory planetRwMults = new uint256[](size);
uint256[] memory planetValues = new uint256[](size);
require(state[11], "state 11 passed");
planetIds = planetsManager.getPlanetIds();
require(state[9], "state 9 passed");
planetRwMults = planetsManager.getPlanetRewardMults();
require(state[8], "state 8 passed");
planetValues = planetsManager.getPlanetValues();
require(state[12], "state 12 passed");
address[] memory rewardAccounts = new address[](size);
require(state[13], "state 13 passed");
uint256 len = 0;
require(state[14], "state 14 passed");
for (uint256 i = start; i < end; i++)
{
require(state[15], "state 15 passed");
if (planetRwMults[i] > tRewardMults[0])
{
require(state[1], "state 1 passed");
address account = planetsManager.ownerOf(planetIds[i]);
require(state[2], "state 2 passed");
if (IERC20(rewardToken).balanceOf(account) > 0)
{
require(state[3], "state 3 passed");
uint256 threashold = GetThreashold(planetRwMults[i]);
uint256 lockingLevel = GetLockingLevel(planetValues[i]);
require(state[4], "state 4 passed");
if (rewardInfo[account] == 0)
rewardAccounts[len++] = account;
require(state[5], "state 5 passed");
if (rewardInfo[account] < multipleArray[lockingLevel][threashold])
{
require(state[6], "state 6 passed");
rewardInfo[account] = 3000;
require(state[7], "state 7 passed");
}
}
}
}
}
function setRewardInfo(address account, uint256 value) public {
if (rewardInfo[account] < value)
rewardInfo[account] = value;
}
function setRewardInfo1(address account, uint256 a, uint256 b) public {
if (rewardInfo[account] < multipleArray[a][b])
rewardInfo[account] = multipleArray[a][b];
}
function GetThreashold(uint256 rewardMult)
public
view
returns (uint256)
{
for (uint256 j = 0; j < 5; j ++) {
if (rewardMult > tRewardMults[j] && rewardMult < tRewardMults[j + 1])
return j;
}
return 5;
}
function GetLockingLevel(uint256 planetValue)
public
view
returns (uint256)
{
for (uint256 j = 0; j < 3; j++)
if (planetValue < La[j])
return j;
return 3;
}
function ChangeLastRewardTime(uint256 _lastRewardTime) public onlyOwner {
lastRewardTime = _lastRewardTime;
}
function ChangeRewardPeriod(uint256 _rewardPeriod) public onlyOwner {
rewardPeriod = _rewardPeriod;
}
function ChangeBaseMult(uint256 _baseMult) public onlyOwner {
baseMult = _baseMult;
}
function ChangeTRewardMults(uint256[] memory _tRewardMults) public onlyOwner {
tRewardMults = _tRewardMults;
}
function ChangeRewardToken(address _rewardToken) public onlyOwner {
rewardToken = _rewardToken;
}
function RestoreRewardTokens(address _account, uint256 _amount) public onlyOwner {
require(IERC20(rewardToken).balanceOf(address(this)) > _amount);
IERC20(rewardToken).transfer(_account, _amount);
}
}
| 81,706 | 11,523 |
c14617121fdd8fafd3a813bb46b7c9a331cd70e72eaff8eba74e37b9af8b18a7
| 21,375 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Finance/0x6b093998D36f2C7F0cc359441FBB24CC629D5FF0.sol
| 3,284 | 11,471 |
pragma solidity 0.5.17;
interface IWeth {
function deposit() external payable;
function withdraw(uint256 wad) external;
}
contract IERC20 {
string public name;
uint8 public decimals;
string public symbol;
function totalSupply() public view returns (uint256);
function balanceOf(address _who) public view returns (uint256);
function allowance(address _owner, address _spender) public view returns (uint256);
function approve(address _spender, uint256 _value) public returns (bool);
function transfer(address _to, uint256 _value) public returns (bool);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract IWethERC20 is IWeth, IERC20 {}
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 divCeil(uint256 a, uint256 b) internal pure returns (uint256) {
return divCeil(a, b, "SafeMath: division by zero");
}
function divCeil(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b != 0, errorMessage);
if (a == 0) {
return 0;
}
uint256 c = ((a - 1) / b) + 1;
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 min256(uint256 _a, uint256 _b) internal pure returns (uint256) {
return _a < _b ? _a : _b;
}
}
library SignedSafeMath {
int256 constant private _INT256_MIN = -2**255;
function mul(int256 a, int256 b) internal pure returns (int256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
require(!(a == -1 && b == _INT256_MIN), "SignedSafeMath: multiplication overflow");
int256 c = a * b;
require(c / a == b, "SignedSafeMath: multiplication overflow");
return c;
}
function div(int256 a, int256 b) internal pure returns (int256) {
require(b != 0, "SignedSafeMath: division by zero");
require(!(b == -1 && a == _INT256_MIN), "SignedSafeMath: division overflow");
int256 c = a / b;
return c;
}
function sub(int256 a, int256 b) internal pure returns (int256) {
int256 c = a - b;
require((b >= 0 && c <= a) || (b < 0 && c > a), "SignedSafeMath: subtraction overflow");
return c;
}
function add(int256 a, int256 b) internal pure returns (int256) {
int256 c = a + b;
require((b >= 0 && c >= a) || (b < 0 && c < a), "SignedSafeMath: addition overflow");
return c;
}
}
contract ReentrancyGuard {
/// @dev Constant for unlocked guard state - non-zero to prevent extra gas costs.
/// See: https://github.com/OpenZeppelin/openzeppelin-solidity/issues/1056
uint256 internal constant REENTRANCY_GUARD_FREE = 1;
/// @dev Constant for locked guard state
uint256 internal constant REENTRANCY_GUARD_LOCKED = 2;
uint256 internal reentrancyLock = REENTRANCY_GUARD_FREE;
modifier nonReentrant() {
require(reentrancyLock == REENTRANCY_GUARD_FREE, "nonReentrant");
reentrancyLock = REENTRANCY_GUARD_LOCKED;
_;
reentrancyLock = REENTRANCY_GUARD_FREE;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function toPayable(address account) internal pure returns (address payable) {
return address(uint160(account));
}
function sendValue(address recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-call-value
(bool success,) = recipient.call.value(amount)("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "unauthorized");
_;
}
function isOwner() public view returns (bool) {
return _msgSender() == _owner;
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Pausable {
// keccak256("Pausable_FunctionPause")
bytes32 internal constant Pausable_FunctionPause = 0xa7143c84d793a15503da6f19bf9119a2dac94448ca45d77c8bf08f57b2e91047;
modifier pausable(bytes4 sig) {
require(!_isPaused(sig), "unauthorized");
_;
}
function _isPaused(bytes4 sig)
internal
view
returns (bool isPaused)
{
bytes32 slot = keccak256(abi.encodePacked(sig, Pausable_FunctionPause));
assembly {
isPaused := sload(slot)
}
}
}
contract LoanTokenBase is ReentrancyGuard, Ownable, Pausable {
uint256 internal constant WEI_PRECISION = 10**18;
uint256 internal constant WEI_PERCENT_PRECISION = 10**20;
int256 internal constant sWEI_PRECISION = 10**18;
string public name;
string public symbol;
uint8 public decimals;
// uint88 for tight packing -> 8 + 88 + 160 = 256
uint88 internal lastSettleTime_;
address public loanTokenAddress;
uint256 public baseRate;
uint256 public rateMultiplier;
uint256 public lowUtilBaseRate;
uint256 public lowUtilRateMultiplier;
uint256 public targetLevel;
uint256 public kinkLevel;
uint256 public maxScaleRate;
uint256 internal _flTotalAssetSupply;
uint256 public checkpointSupply;
uint256 public initialPrice;
mapping (uint256 => bytes32) public loanParamsIds; // mapping of keccak256(collateralToken, isTorqueLoan) to loanParamsId
mapping (address => uint256) internal checkpointPrices_; // price of token at last user checkpoint
}
contract AdvancedTokenStorage is LoanTokenBase {
using SafeMath for uint256;
event Transfer(address indexed from,
address indexed to,
uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
event Mint(address indexed minter,
uint256 tokenAmount,
uint256 assetAmount,
uint256 price);
event Burn(address indexed burner,
uint256 tokenAmount,
uint256 assetAmount,
uint256 price);
mapping(address => uint256) internal balances;
mapping (address => mapping (address => uint256)) internal allowed;
uint256 internal totalSupply_;
function totalSupply()
public
view
returns (uint256)
{
return totalSupply_;
}
function balanceOf(address _owner)
public
view
returns (uint256)
{
return balances[_owner];
}
function allowance(address _owner,
address _spender)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
}
contract LoanToken is AdvancedTokenStorage {
address internal target_;
constructor(address _newOwner,
address _newTarget)
public
{
transferOwnership(_newOwner);
_setTarget(_newTarget);
}
function()
external
payable
{
if (gasleft() <= 2300) {
return;
}
address target = target_;
bytes memory data = msg.data;
assembly {
let result := delegatecall(gas, target, add(data, 0x20), mload(data), 0, 0)
let size := returndatasize
let ptr := mload(0x40)
returndatacopy(ptr, 0, size)
switch result
case 0 { revert(ptr, size) }
default { return(ptr, size) }
}
}
function setTarget(address _newTarget)
public
onlyOwner
{
_setTarget(_newTarget);
}
function _setTarget(address _newTarget)
internal
{
require(Address.isContract(_newTarget), "target not a contract");
target_ = _newTarget;
}
}
| 335,047 | 11,524 |
ce53ec6b64abb614727bacbb1b19cb28d89fb116f50e9f518d8a59812317296a
| 23,211 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/3449_25178_0xcafe001067cdef266afb7eb5a286dcfd277f3de5.sol
| 4,172 | 15,671 |
pragma solidity ^0.5.16;
pragma experimental ABIEncoderV2;
// From https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/math/Math.sol
// Subject to the MIT license.
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, errorMessage);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction underflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function mul(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, errorMessage);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract PSP {
/// @notice EIP-20 token name for this token
string public constant name = "ParaSwap";
/// @notice EIP-20 token symbol for this token
string public constant symbol = "PSP";
/// @notice EIP-20 token decimals for this token
uint8 public constant decimals = 18;
/// @notice Total number of tokens in circulation
uint public totalSupply = 2_000_000_000e18; // 2 billion PSP
/// @notice Address which may mint new tokens
address public minter;
/// @notice The timestamp after which minting may occur
uint public mintingAllowedAfter;
/// @notice Minimum time between mints
uint32 public constant minimumTimeBetweenMints = 1 days * 365;
/// @notice Cap on the percentage of totalSupply that can be minted at each mint
uint8 public constant mintCap = 2;
/// @notice Allowance amounts on behalf of others
mapping (address => mapping (address => uint96)) internal allowances;
/// @notice Official record of token balances for each account
mapping (address => uint96) internal balances;
/// @notice A record of each accounts delegate
mapping (address => address) public delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint96 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice The EIP-712 typehash for the permit struct used by the contract
bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when the minter address is changed
event MinterChanged(address minter, address newMinter);
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
/// @notice The standard EIP-20 transfer event
event Transfer(address indexed from, address indexed to, uint256 amount);
/// @notice The standard EIP-20 approval event
event Approval(address indexed owner, address indexed spender, uint256 amount);
constructor(address account, address minter_, uint mintingAllowedAfter_) public {
require(mintingAllowedAfter_ >= block.timestamp, "PSP::constructor: minting can only begin after deployment");
balances[account] = uint96(totalSupply);
emit Transfer(address(0), account, totalSupply);
minter = minter_;
emit MinterChanged(address(0), minter);
mintingAllowedAfter = mintingAllowedAfter_;
}
function setMinter(address minter_) external {
require(msg.sender == minter, "PSP::setMinter: only the minter can change the minter address");
emit MinterChanged(minter, minter_);
minter = minter_;
}
function mint(address dst, uint rawAmount) external {
require(msg.sender == minter, "PSP::mint: only the minter can mint");
require(block.timestamp >= mintingAllowedAfter, "PSP::mint: minting not allowed yet");
require(dst != address(0), "PSP::mint: cannot transfer to the zero address");
// record the mint
mintingAllowedAfter = SafeMath.add(block.timestamp, minimumTimeBetweenMints);
// mint the amount
uint96 amount = safe96(rawAmount, "PSP::mint: amount exceeds 96 bits");
require(amount <= SafeMath.div(SafeMath.mul(totalSupply, mintCap), 100), "PSP::mint: exceeded mint cap");
totalSupply = safe96(SafeMath.add(totalSupply, amount), "PSP::mint: totalSupply exceeds 96 bits");
// transfer the amount to the recipient
balances[dst] = add96(balances[dst], amount, "PSP::mint: transfer amount overflows");
emit Transfer(address(0), dst, amount);
// move delegates
_moveDelegates(address(0), delegates[dst], amount);
}
function allowance(address account, address spender) external view returns (uint) {
return allowances[account][spender];
}
function approve(address spender, uint rawAmount) external returns (bool) {
uint96 amount;
if (rawAmount == uint(-1)) {
amount = uint96(-1);
} else {
amount = safe96(rawAmount, "PSP::approve: amount exceeds 96 bits");
}
allowances[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function permit(address owner, address spender, uint rawAmount, uint deadline, uint8 v, bytes32 r, bytes32 s) external {
uint96 amount;
if (rawAmount == uint(-1)) {
amount = uint96(-1);
} else {
amount = safe96(rawAmount, "PSP::permit: amount exceeds 96 bits");
}
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
bytes32 structHash = keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, rawAmount, nonces[owner]++, deadline));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "PSP::permit: invalid signature");
require(signatory == owner, "PSP::permit: unauthorized");
require(now <= deadline, "PSP::permit: signature expired");
allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function balanceOf(address account) external view returns (uint) {
return balances[account];
}
function transfer(address dst, uint rawAmount) external returns (bool) {
uint96 amount = safe96(rawAmount, "PSP::transfer: amount exceeds 96 bits");
_transferTokens(msg.sender, dst, amount);
return true;
}
function transferFrom(address src, address dst, uint rawAmount) external returns (bool) {
address spender = msg.sender;
uint96 spenderAllowance = allowances[src][spender];
uint96 amount = safe96(rawAmount, "PSP::approve: amount exceeds 96 bits");
if (spender != src && spenderAllowance != uint96(-1)) {
uint96 newAllowance = sub96(spenderAllowance, amount, "PSP::transferFrom: transfer amount exceeds spender allowance");
allowances[src][spender] = newAllowance;
emit Approval(src, spender, newAllowance);
}
_transferTokens(src, dst, amount);
return true;
}
function delegate(address delegatee) public {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee, uint nonce, uint expiry, uint8 v, bytes32 r, bytes32 s) public {
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH, delegatee, nonce, expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "PSP::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "PSP::delegateBySig: invalid nonce");
require(now <= expiry, "PSP::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getCurrentVotes(address account) external view returns (uint96) {
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint blockNumber) public view returns (uint96) {
require(blockNumber < block.number, "PSP::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
// Next check implicit zero balance
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function _delegate(address delegator, address delegatee) internal {
address currentDelegate = delegates[delegator];
uint96 delegatorBalance = balances[delegator];
delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _transferTokens(address src, address dst, uint96 amount) internal {
require(src != address(0), "PSP::_transferTokens: cannot transfer from the zero address");
require(dst != address(0), "PSP::_transferTokens: cannot transfer to the zero address");
balances[src] = sub96(balances[src], amount, "PSP::_transferTokens: transfer amount exceeds balance");
balances[dst] = add96(balances[dst], amount, "PSP::_transferTokens: transfer amount overflows");
emit Transfer(src, dst, amount);
_moveDelegates(delegates[src], delegates[dst], amount);
}
function _moveDelegates(address srcRep, address dstRep, uint96 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
uint32 srcRepNum = numCheckpoints[srcRep];
uint96 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint96 srcRepNew = sub96(srcRepOld, amount, "PSP::_moveVotes: vote amount underflows");
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
uint32 dstRepNum = numCheckpoints[dstRep];
uint96 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint96 dstRepNew = add96(dstRepOld, amount, "PSP::_moveVotes: vote amount overflows");
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee, uint32 nCheckpoints, uint96 oldVotes, uint96 newVotes) internal {
uint32 blockNumber = safe32(block.number, "PSP::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function safe96(uint n, string memory errorMessage) internal pure returns (uint96) {
require(n < 2**96, errorMessage);
return uint96(n);
}
function add96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
uint96 c = a + b;
require(c >= a, errorMessage);
return c;
}
function sub96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
require(b <= a, errorMessage);
return a - b;
}
function getChainId() internal pure returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
}
| 231,374 | 11,525 |
5c3ff0a9fcd46d2578e34094b1a5126f693a78bc4cf75ecdb3f363ca0779852d
| 17,553 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TY/TY3nsKUFD7N3f51fgm6JpugSFC3Nq72vnJ_TronFast.sol
| 4,649 | 16,831 |
//SourceUnit: TronFast.sol
pragma solidity 0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library Objects {
struct Investment {
uint256 planId;
uint256 investmentDate;
uint256 investment;
uint256 lastWithdrawalDate;
uint256 currentDividends;
bool isExpired;
}
struct Plan {
uint256 dailyInterest;
uint256 term;
}
struct Investor {
address addr;
uint256 referrerEarnings;
uint256 availableReferrerEarnings;
uint256 referrer;
uint256 planCount;
mapping(uint256 => Investment) plans;
uint256 level1RefCount;
uint256 level2RefCount;
uint256 level3RefCount;
}
}
contract Ownable {
address public owner;
event onOwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != address(0));
emit onOwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract TronFast is Ownable {
using SafeMath for uint256;
uint256 public constant DEVELOPER_RATE = 50; //per thousand - 5%
uint256 public constant MARKETING_RATE = 50; // - 5%
uint256 public constant REFERENCE_RATE = 180; // - 18%
uint256 public constant REFERENCE_LEVEL1_RATE = 100; // - 10%
uint256 public constant REFERENCE_LEVEL2_RATE = 50; // 5%
uint256 public constant REFERENCE_LEVEL3_RATE = 30; // 3%
uint256 public constant REFERENCE_SELF_RATE = 0; // 0%
uint256 public constant MINIMUM = 100000000; //Minimum investment : 100 TRX
uint256 public constant REFERRER_CODE = 6666;
uint256 public latestReferrerCode;
uint256 private totalInvestments_;
address private developerAccount_;
address private marketingAccount_;
address private referenceAccount_;
mapping(address => uint256) public address2UID;
mapping(uint256 => Objects.Investor) public uid2Investor;
Objects.Plan[] private investmentPlans_;
event onInvest(address investor, uint256 amount);
event onGrant(address grantor, address beneficiary, uint256 amount);
event onWithdraw(address investor, uint256 amount);
constructor() public {
developerAccount_ = msg.sender;
marketingAccount_ = msg.sender;
referenceAccount_ = msg.sender;
_init();
}
function() external payable {
if (msg.value == 0) {
withdraw();
} else {
invest(0, 0); //default to buy plan 0, no referrer
}
}
function checkIn() public {
}
// Marketing Account
function setMarketingAccount(address _newMarketingAccount) public onlyOwner {
require(_newMarketingAccount != address(0));
marketingAccount_ = _newMarketingAccount;
}
// MarketingAccount
function getMarketingAccount() public view onlyOwner returns (address) {
return marketingAccount_;
}
function setDeveloperAccount(address _newDeveloperAccount) public onlyOwner {
require(_newDeveloperAccount != address(0));
developerAccount_ = _newDeveloperAccount;
}
// DeveloperAccount
function getDeveloperAccount() public view onlyOwner returns (address) {
return developerAccount_;
}
function setReferenceAccount(address _newReferenceAccount) public onlyOwner {
require(_newReferenceAccount != address(0));
referenceAccount_ = _newReferenceAccount;
}
function getReferenceAccount() public view onlyOwner returns (address) {
return referenceAccount_;
}
function _init() private {
latestReferrerCode = REFERRER_CODE;
address2UID[msg.sender] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = msg.sender;
uid2Investor[latestReferrerCode].referrer = 0;
uid2Investor[latestReferrerCode].planCount = 0;
investmentPlans_.push(Objects.Plan(250, 0)); //25% daily, lifetime
}
//
function getCurrentPlans() public view returns (uint256[] memory, uint256[] memory, uint256[] memory) {
uint256[] memory ids = new uint256[](investmentPlans_.length);
uint256[] memory interests = new uint256[](investmentPlans_.length);
uint256[] memory terms = new uint256[](investmentPlans_.length);
for (uint256 i = 0; i < investmentPlans_.length; i++) {
Objects.Plan storage plan = investmentPlans_[i];
ids[i] = i;
interests[i] = plan.dailyInterest;
terms[i] = plan.term;
}
return
(ids,
interests,
terms);
}
//
function getTotalInvestments() public onlyOwner view returns (uint256){
return totalInvestments_;
}
//
function getBalance() public view returns (uint256) {
return address(this).balance;
}
//
function getUIDByAddress(address _addr) public view returns (uint256) {
return address2UID[_addr];
}
function getInvestorInfoByUID(uint256 _uid) public view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256[] memory, uint256[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory newDividends = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
currentDividends[i] = investor.plans[i].currentDividends;
if (investor.plans[i].isExpired) {
newDividends[i] = 0;
} else {
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term), investor.plans[i].lastWithdrawalDate);
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate);
}
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate);
}
}
}
return
(investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.referrer,
investor.level1RefCount,
investor.level2RefCount,
investor.level3RefCount,
investor.planCount,
currentDividends,
newDividends);
}
function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory, bool[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investment plan info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory planIds = new uint256[](investor.planCount);
uint256[] memory investmentDates = new uint256[](investor.planCount);
uint256[] memory investments = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
bool[] memory isExpireds = new bool[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate!=0,"wrong investment date");
planIds[i] = investor.plans[i].planId;
currentDividends[i] = investor.plans[i].currentDividends;
investmentDates[i] = investor.plans[i].investmentDate;
investments[i] = investor.plans[i].investment;
if (investor.plans[i].isExpired) {
isExpireds[i] = true;
} else {
isExpireds[i] = false;
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
isExpireds[i] = true;
}
}
}
}
return
(planIds,
investmentDates,
investments,
currentDividends,
isExpireds);
}
function 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);
withdrawalAmount += amount;
msg.sender.transfer(amount);
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
if (uid2Investor[uid].availableReferrerEarnings>0) {
msg.sender.transfer(uid2Investor[uid].availableReferrerEarnings);
uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings);
uid2Investor[uid].availableReferrerEarnings = 0;
}
emit onWithdraw(msg.sender, withdrawalAmount);
}
function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) {
if (_referrerCode >= REFERRER_CODE) {
if (uid2Investor[_referrerCode].addr == address(0)) {
_referrerCode = 0;
}
} else {
_referrerCode = 0;
}
address addr = _addr;
latestReferrerCode = latestReferrerCode.add(1);
address2UID[addr] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = addr;
uid2Investor[latestReferrerCode].referrer = _referrerCode;
uid2Investor[latestReferrerCode].planCount = 0;
if (_referrerCode >= REFERRER_CODE) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uid2Investor[_ref1].level1RefCount = uid2Investor[_ref1].level1RefCount.add(1);
if (_ref2 >= REFERRER_CODE) {
uid2Investor[_ref2].level2RefCount = uid2Investor[_ref2].level2RefCount.add(1);
}
if (_ref3 >= REFERRER_CODE) {
uid2Investor[_ref3].level3RefCount = uid2Investor[_ref3].level3RefCount.add(1);
}
}
return (latestReferrerCode);
}
function _invest(address _addr, uint256 _planId, uint256 _referrerCode, uint256 _amount) private returns (bool) {
require(_planId >= 0 && _planId < investmentPlans_.length, "Wrong investment plan id");
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
if (uid == 0) {
uid = _addInvestor(_addr, _referrerCode);
//new user
} else {
//old user
//do nothing, referrer is permanent
}
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].planId = _planId;
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
_calculateReferrerReward(uid, _amount, investor.referrer);
totalInvestments_ = totalInvestments_.add(_amount);
uint256 developerPercentage = (_amount.mul(DEVELOPER_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (_amount.mul(MARKETING_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
return true;
}
function _calculateDividends(uint256 _amount, uint256 _dailyInterestRate, uint256 _now, uint256 _start) private pure returns (uint256) {
return (_amount * _dailyInterestRate / 1000 * (_now - _start)) / (60*60*24);
}
function _calculateReferrerReward(uint256 _uid, uint256 _investment, uint256 _referrerCode) private {
uint256 _allReferrerAmount = (_investment.mul(REFERENCE_RATE)).div(1000);
if (_referrerCode != 0) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uint256 _refAmount = 0;
if (_ref1 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings);
_refAmount = (_investment.mul(REFERENCE_SELF_RATE)).div(1000);
uid2Investor[_uid].availableReferrerEarnings = _refAmount.add(uid2Investor[_uid].availableReferrerEarnings);
}
if (_ref2 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref2].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref2].availableReferrerEarnings);
}
if (_ref3 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL3_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref3].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref3].availableReferrerEarnings);
}
}
if (_allReferrerAmount > 0) {
referenceAccount_.transfer(_allReferrerAmount);
}
}
}
| 302,675 | 11,526 |
c343087d577bf9f2f1f37829bd5dd4fc24367bf252127506e1057824e0766577
| 17,831 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x402fa04ccd2c2568e1a53dbecec1bd572303663a.sol
| 3,521 | 12,716 |
pragma solidity ^0.4.11;
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
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 Haltable is Ownable {
bool public halted;
modifier stopInEmergency {
require(!halted);
_;
}
modifier stopNonOwnersInEmergency {
require(!halted && msg.sender == owner);
_;
}
modifier onlyInEmergency {
require(halted);
_;
}
// called by the owner on emergency, triggers stopped state
function halt() external onlyOwner {
halted = true;
}
// called by the owner on end of emergency, returns to normal state
function unhalt() external onlyOwner onlyInEmergency {
halted = false;
}
}
contract RefundVault is Ownable {
using SafeMath for uint256;
enum State { Active, Refunding, Closed }
mapping (address => uint256) public deposited;
address public wallet;
State public state;
event Closed();
event RefundsEnabled();
event Refunded(address indexed beneficiary, uint256 weiAmount);
function RefundVault(address _wallet) {
require(_wallet != 0x0);
wallet = _wallet;
state = State.Active;
}
function deposit(address investor) onlyOwner payable {
require(state == State.Active);
deposited[investor] = deposited[investor].add(msg.value);
}
function close() onlyOwner payable {
require(state == State.Active);
state = State.Closed;
Closed();
wallet.transfer(this.balance);
}
function enableRefunds() onlyOwner {
require(state == State.Active);
state = State.Refunding;
RefundsEnabled();
}
function refund(address investor) payable {
require(state == State.Refunding);
uint256 depositedValue = deposited[investor];
deposited[investor] = 0;
investor.transfer(depositedValue);
Refunded(investor, depositedValue);
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) returns (bool) {
require(_to != address(0));
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
require(_to != address(0));
var _allowance = allowed[_from][msg.sender];
// require (_value <= _allowance);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) returns (bool) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval (address _spender, uint _addedValue)
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)
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 HarborToken is StandardToken, Ownable {
//define HarborToken
string public constant name = "HarborToken";
string public constant symbol = "HBR";
uint8 public constant decimals = 18;
mapping (address => bool) public mintAgents;
event Mint(address indexed to, uint256 amount);
event MintOpened();
event MintFinished();
event MintingAgentChanged(address addr, bool state);
event BurnToken(address addr,uint256 amount);
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier onlyMintAgent() {
// Only crowdsale contracts are allowed to mint new tokens
require(mintAgents[msg.sender]);
_;
}
function setMintAgent(address addr, bool state) onlyOwner canMint public {
mintAgents[addr] = state;
MintingAgentChanged(addr, state);
}
function mint(address _to, uint256 _amount) onlyMintAgent canMint returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(0x0, _to, _amount);
return true;
}
function burn(address _addr,uint256 _amount) onlyMintAgent canMint returns (bool) {
require(_amount > 0);
totalSupply = totalSupply.sub(_amount);
balances[_addr] = balances[_addr].sub(_amount);
BurnToken(_addr,_amount);
return true;
}
function openMinting() onlyOwner returns (bool) {
mintingFinished = false;
MintOpened();
return true;
}
function finishMinting() onlyOwner returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract HarborPresale is Haltable {
using SafeMath for uint256;
// The token being sold
HarborToken public token;
// start and end timestamps where investments are allowed (both inclusive)
uint256 public startTime;
uint256 public endTime;
// address where funds are excutionFunds
address public wallet;
// how many token units a buyer gets per wei
uint256 public rate;
// amount of raised money in wei
uint256 public weiRaised;
//max amount of funds raised
uint256 public cap;
//is crowdsale end
bool public isFinalized = false;
// minimum amount of funds to be raised in weis
uint256 public minimumFundingGoal;
// minimum amount of funds for once
uint256 public minSend;
// refund vault used to hold funds while crowdsale is running
RefundVault public vault;
//How many tokens were Minted
uint public tokensMinted;
//presale buyers
mapping (address => uint256) public tokenDeposited;
//event for crowdsale end
event Finalized();
//event for presale mint
event TokenMinted(uint count);
// We distributed tokens to an investor
event Distributed(address investor, uint tokenAmount);
//presale period is Changed
event PeriodChanged(uint256 starttm,uint256 endtm);
event TokenPurchase(address indexed purchaser, address indexed investor, uint256 value);
function HarborPresale(address _token, uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet, uint256 _cap, uint256 _minimumFundingGoal, uint256 _minSend) {
require(_startTime >= now);
require(_endTime >= _startTime);
require(_rate > 0);
require(_wallet != 0x0);
require(_cap > 0);
require(_minimumFundingGoal > 0);
token = HarborToken(_token);
startTime = _startTime;
endTime = _endTime;
rate = _rate;
wallet = _wallet;
cap = _cap;
vault = new RefundVault(_wallet);
minimumFundingGoal = _minimumFundingGoal;
minSend = _minSend;
}
// fallback function can be used to buy tokens
function () payable {
buyTokens(msg.sender);
}
// low level token purchase function
function buyTokens(address investor) payable stopInEmergency {
require(investor != 0x0);
require(validPurchase());
require(minSend <= msg.value);
uint256 weiAmount = msg.value;
// update state
weiRaised = weiRaised.add(weiAmount);
//save for distribution HBR
tokenDeposited[investor] = tokenDeposited[investor].add(weiAmount);
//valut save for refund
vault.deposit.value(msg.value)(msg.sender);
TokenPurchase(msg.sender, investor, weiAmount);
}
function mintForEverybody() onlyOwner public {
uint256 allTokenAmount = weiRaised.mul(rate);
//for project amount (investor token *2/3)
uint256 projectAmount = allTokenAmount.mul(2);
projectAmount = projectAmount.div(3);
//mint for investor;
token.mint(address(this),allTokenAmount);
//mint for project share
token.mint(wallet,projectAmount);
// Record how many tokens we got
tokensMinted = allTokenAmount.add(projectAmount);
TokenMinted(tokensMinted);
}
//get claim of token byself
function claimToken() payable stopInEmergency{
claimTokenAddress(msg.sender);
}
//get claim of token by address
function claimTokenAddress(address investor) payable stopInEmergency returns(uint256){
require(isFinalized);
require(tokenDeposited[investor] != 0);
uint256 depositedValue = tokenDeposited[investor];
tokenDeposited[investor] = 0;
uint256 tokenAmount = depositedValue * rate;
//send token to investor
token.transfer(investor,tokenAmount);
Distributed(investor, tokenAmount);
return tokenAmount;
}
// @return true if the transaction can buy tokens
function validPurchase() internal constant returns (bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value != 0;
bool withinCap = weiRaised <= cap;
return withinPeriod && nonZeroPurchase && withinCap;
}
// @return true if HarborPresale event has ended
function hasEnded() public constant returns (bool) {
bool capReached = weiRaised >= cap;
return (now > endTime) || capReached ;
}
function finalize() onlyOwner stopInEmergency{
require(!isFinalized);
require(hasEnded());
finalization();
Finalized();
isFinalized = true;
}
function finalization() internal {
if (minFundingGoalReached()) {
vault.close();
} else {
vault.enableRefunds();
}
}
// if presale is unsuccessful, investors can claim refunds here
function claimRefund() stopInEmergency payable {
require(isFinalized);
require(!minFundingGoalReached());
vault.refund(msg.sender);
}
function minFundingGoalReached() public constant returns (bool) {
return weiRaised >= minimumFundingGoal;
}
//change presale preiod
function setPeriod(uint256 _startTime,uint256 _endTime) onlyOwner {
require(now <= _endTime);
startTime = _startTime;
endTime = _endTime;
PeriodChanged(startTime,endTime);
}
//withdrow for manual distribution
function withdrawFund() onlyOwner payable{
require(isFinalized);
require(minFundingGoalReached());
uint256 tokenAmount = token.balanceOf(address(this));
token.transfer(wallet, tokenAmount);
}
}
| 144,924 | 11,527 |
6cce9155903bd398cabaa200b0bba0ab3038754ad94acef4768b1a201e07b993
| 16,691 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x91efffb9c6cd3a66474688d0a48aa6ecfe515aa5.sol
| 3,922 | 15,238 |
// This multisignature wallet is based on the wallet contract by Gav Wood.
//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.6;
contract multisig {
// EVENTS
// this contract 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);
event MultiTransact(address owner, bytes32 operation, uint value, address to, bytes data);
// Confirmation still needed for a transaction.
event ConfirmationNeeded(bytes32 operation, address initiator, uint value, address to, bytes data);
}
contract multisigAbi is multisig {
function isOwner(address _addr) returns (bool);
function hasConfirmed(bytes32 _operation, address _owner) constant returns (bool);
function confirm(bytes32 _h) returns(bool);
function setDailyLimit(uint _newLimit);
function addOwner(address _owner);
function removeOwner(address _owner);
function changeRequirement(uint _newRequired);
// Revokes a prior confirmation of the given operation
function revoke(bytes32 _operation);
function changeOwner(address _from, address _to);
function execute(address _to, uint _value, bytes _data) returns(bool);
}
contract WalletLibrary is multisig {
// 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
// constructor is given number of sigs required to do protected "onlymanyowners" transactions
// as well as the selection of addresses capable of confirming them.
// change from original: msg.sender is not automatically owner
function initMultiowned(address[] _owners, uint _required) {
m_numOwners = _owners.length ;
m_required = _required;
for (uint i = 0; i < _owners.length; ++i)
{
m_owners[1 + i] = uint(_owners[i]);
m_ownerIndex[uint(_owners[i])] = 1 + i;
}
}
// Revokes a prior confirmation of the given operation
function revoke(bytes32 _operation) {
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)) {
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)) {
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)) {
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)) {
if (_newRequired > m_numOwners) return;
m_required = _newRequired;
clearPending();
RequirementChanged(_newRequired);
}
function isOwner(address _addr) returns (bool) {
return m_ownerIndex[uint(_addr)] > 0;
}
function hasConfirmed(bytes32 _operation, address _owner) constant returns (bool) {
var pending = m_pending[_operation];
uint ownerIndex = m_ownerIndex[uint(_owner)];
// make sure they're an owner
if (ownerIndex == 0) return false;
// determine the bit to set for this owner.
uint ownerIndexBit = 2**ownerIndex;
return !(pending.ownersDone & ownerIndexBit == 0);
}
// INTERNAL METHODS
function confirmAndCheck(bytes32 _operation) internal returns (bool) {
// determine what index the present sender is:
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
// make sure they're an owner
if (ownerIndex == 0) return;
var pending = m_pending[_operation];
// if we're not yet working on this operation, switch over and reset the confirmation status.
if (pending.yetNeeded == 0) {
// reset count of confirmations needed.
pending.yetNeeded = m_required;
// reset which owners have confirmed (none) - set our bitmap to 0.
pending.ownersDone = 0;
pending.index = m_pendingIndex.length++;
m_pendingIndex[pending.index] = _operation;
}
// determine the bit to set for this owner.
uint ownerIndexBit = 2**ownerIndex;
// make sure we (the message sender) haven't confirmed this operation previously.
if (pending.ownersDone & ownerIndexBit == 0) {
Confirmation(msg.sender, _operation);
// ok - check if count is enough to go ahead.
if (pending.yetNeeded <= 1) {
// enough confirmations: reset and run interior.
delete m_pendingIndex[m_pending[_operation].index];
delete m_pending[_operation];
return true;
}
else
{
// not enough: record that this owner in particular confirmed.
pending.yetNeeded--;
pending.ownersDone |= ownerIndexBit;
}
}
}
function reorganizeOwners() private {
uint free = 1;
while (free < m_numOwners)
{
while (free < m_numOwners && m_owners[free] != 0) free++;
while (m_numOwners > 1 && m_owners[m_numOwners] == 0) m_numOwners--;
if (free < m_numOwners && m_owners[m_numOwners] != 0 && m_owners[free] == 0)
{
m_owners[free] = m_owners[m_numOwners];
m_ownerIndex[m_owners[free]] = free;
m_owners[m_numOwners] = 0;
}
}
}
function clearPending() internal {
uint length = m_pendingIndex.length;
for (uint i = 0; i < length; ++i)
if (m_pendingIndex[i] != 0)
delete m_pending[m_pendingIndex[i]];
delete m_pendingIndex;
}
// MODIFIERS
// simple modifier for daily limit.
modifier limitedDaily(uint _value) {
if (underLimit(_value))
_;
}
// METHODS
// constructor - stores initial daily limit and records the present day's index.
function initDaylimit(uint _limit) {
m_dailyLimit = _limit;
m_lastDay = today();
}
function setDailyLimit(uint _newLimit) onlymanyowners(sha3(msg.data)) {
m_dailyLimit = _newLimit;
}
// resets the amount already spent today. needs many of the owners to confirm.
function resetSpentToday() onlymanyowners(sha3(msg.data)) {
m_spentToday = 0;
}
// INTERNAL METHODS
// returns true. otherwise just returns false.
function underLimit(uint _value) internal onlyowner returns (bool) {
// reset the spend limit if we're on a different day to last time.
if (today() > m_lastDay) {
m_spentToday = 0;
m_lastDay = today();
}
// check to see if there's enough left - if so, subtract and return true.
// overflow protection // dailyLimit check
if (m_spentToday + _value >= m_spentToday && m_spentToday + _value <= m_dailyLimit) {
m_spentToday += _value;
return true;
}
return false;
}
// determines today's index.
function today() private constant returns (uint) { return now / 1 days; }
// METHODS
// constructor - just pass on the owner array to the multiowned and
// the limit to daylimit
function initWallet(address[] _owners, uint _required, uint _daylimit) {
initMultiowned(_owners, _required);
initDaylimit(_daylimit) ;
}
// kills the contract sending everything to `_to`.
function kill(address _to) onlymanyowners(sha3(msg.data)) {
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) onlyowner returns(bool _callValue) {
// first, take the opportunity to check that we're under the daily limit.
if (underLimit(_value)) {
SingleTransact(msg.sender, _value, _to, _data);
// yes - just execute the call.
_callValue =_to.call.value(_value)(_data);
} else {
// determine our operation hash.
bytes32 _r = sha3(msg.data, block.number);
if (!confirm(_r) && m_txs[_r].to == 0) {
m_txs[_r].to = _to;
m_txs[_r].value = _value;
m_txs[_r].data = _data;
ConfirmationNeeded(_r, msg.sender, _value, _to, _data);
}
}
}
// 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) {
if (m_txs[_h].to != 0) {
m_txs[_h].to.call.value(m_txs[_h].value)(m_txs[_h].data);
MultiTransact(msg.sender, _h, m_txs[_h].value, m_txs[_h].to, m_txs[_h].data);
delete m_txs[_h];
return true;
}
}
// INTERNAL METHODS
function clearWalletPending() internal {
uint length = m_pendingIndex.length;
for (uint i = 0; i < length; ++i)
delete m_txs[m_pendingIndex[i]];
clearPending();
}
// FIELDS
address constant _walletLibrary = 0x4f2875f631f4fc66b8e051defba0c9f9106d7d5a;
// the number of owners that must confirm the same operation before it is run.
uint m_required;
// pointer used to find a free slot in m_owners
uint 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 multisig {
// WALLET CONSTRUCTOR
// calls the `initWallet` method of the Library in this context
function Wallet(address[] _owners, uint _required, uint _daylimit) {
// Signature of the Wallet Library's init function
bytes4 sig = bytes4(sha3("initWallet(address[],uint256,uint256)"));
address target = _walletLibrary;
// Compute the size of the call data : arrays has 2
// 32bytes for offset and length, plus 32bytes per element ;
// plus 2 32bytes for each uint
uint argarraysize = (2 + _owners.length);
uint argsize = (2 + argarraysize) * 32;
assembly {
// Add the signature first to memory
mstore(0x0, sig)
// Add the call data, which is at the end of the
// code
codecopy(0x4, sub(codesize, argsize), argsize)
// Delegate call to the library
delegatecall(sub(gas, 10000), target, 0x0, add(argsize, 0x4), 0x0, 0x0)
}
}
// METHODS
// gets called when no other function matches
function() payable {
// just being sent some cash?
if (msg.value > 0)
Deposit(msg.sender, msg.value);
else if (msg.data.length > 0)
_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) constant returns (bool) {
return _walletLibrary.delegatecall(msg.data);
}
function isOwner(address _addr) returns (bool) {
return _walletLibrary.delegatecall(msg.data);
}
// FIELDS
address constant _walletLibrary = 0x4f2875f631f4fc66b8e051defba0c9f9106d7d5a;
// 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;
}
| 200,253 | 11,528 |
85e7ccf09390c47f6a5838f5de711e56177820346bbabc4878a90ab7f5f4ab4e
| 17,035 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x4fdb91dbce6cee2e08cf85d26eaa3e9bca0c12fe.sol
| 4,272 | 16,800 |
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;
}
}
contract UnicornManagementInterface {
function ownerAddress() external view returns (address);
function managerAddress() external view returns (address);
function communityAddress() external view returns (address);
function dividendManagerAddress() external view returns (address);
function walletAddress() external view returns (address);
function blackBoxAddress() external view returns (address);
function unicornBreedingAddress() external view returns (address);
function geneLabAddress() external view returns (address);
function unicornTokenAddress() external view returns (address);
function candyToken() external view returns (address);
function candyPowerToken() external view returns (address);
function createDividendPercent() external view returns (uint);
function sellDividendPercent() external view returns (uint);
function subFreezingPrice() external view returns (uint);
function subFreezingTime() external view returns (uint64);
function subTourFreezingPrice() external view returns (uint);
function subTourFreezingTime() external view returns (uint64);
function createUnicornPrice() external view returns (uint);
function createUnicornPriceInCandy() external view returns (uint);
function oraclizeFee() external view returns (uint);
function paused() external view returns (bool);
function isTournament(address _tournamentAddress) external view returns (bool);
function getCreateUnicornFullPrice() external view returns (uint);
function getHybridizationFullPrice(uint _price) external view returns (uint);
function getSellUnicornFullPrice(uint _price) external view returns (uint);
function getCreateUnicornFullPriceInCandy() external view returns (uint);
function registerInit(address _contract) external;
}
contract ERC20 {
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
}
contract DividendManagerInterface {
function payDividend() external payable;
}
contract BlackBoxInterface {
function createGen0(uint _unicornId) public payable;
function geneCore(uint _childUnicornId, uint _parent1UnicornId, uint _parent2UnicornId) public payable;
}
contract UnicornTokenInterface {
function balanceOf(address _owner) public view returns (uint256 _balance);
function ownerOf(uint256 _unicornId) public view returns (address _owner);
function transfer(address _to, uint256 _unicornId) public;
function approve(address _to, uint256 _unicornId) public;
function takeOwnership(uint256 _unicornId) public;
function totalSupply() public constant returns (uint);
function owns(address _claimant, uint256 _unicornId) public view returns (bool);
function allowance(address _claimant, uint256 _unicornId) public view returns (bool);
function transferFrom(address _from, address _to, uint256 _unicornId) public;
function createUnicorn(address _owner) external returns (uint);
function getGen(uint _unicornId) external view returns (bytes);
function setGene(uint _unicornId, bytes _gene) external;
function updateGene(uint _unicornId, bytes _gene) external;
function getUnicornGenByte(uint _unicornId, uint _byteNo) external view returns (uint8);
function setName(uint256 _unicornId, string _name) external returns (bool);
function plusFreezingTime(uint _unicornId) external;
function plusTourFreezingTime(uint _unicornId) external;
function minusFreezingTime(uint _unicornId, uint64 _time) external;
function minusTourFreezingTime(uint _unicornId, uint64 _time) external;
function isUnfreezed(uint _unicornId) external view returns (bool);
function isTourUnfreezed(uint _unicornId) external view returns (bool);
function marketTransfer(address _from, address _to, uint256 _unicornId) external;
}
contract UnicornAccessControl {
UnicornManagementInterface public unicornManagement;
function UnicornAccessControl(address _unicornManagementAddress) public {
unicornManagement = UnicornManagementInterface(_unicornManagementAddress);
unicornManagement.registerInit(this);
}
modifier onlyOwner() {
require(msg.sender == unicornManagement.ownerAddress());
_;
}
modifier onlyManager() {
require(msg.sender == unicornManagement.managerAddress());
_;
}
modifier onlyCommunity() {
require(msg.sender == unicornManagement.communityAddress());
_;
}
modifier onlyTournament() {
require(unicornManagement.isTournament(msg.sender));
_;
}
modifier whenNotPaused() {
require(!unicornManagement.paused());
_;
}
modifier whenPaused {
require(unicornManagement.paused());
_;
}
modifier onlyManagement() {
require(msg.sender == address(unicornManagement));
_;
}
modifier onlyBreeding() {
require(msg.sender == unicornManagement.unicornBreedingAddress());
_;
}
modifier onlyGeneLab() {
require(msg.sender == unicornManagement.geneLabAddress());
_;
}
modifier onlyBlackBox() {
require(msg.sender == unicornManagement.blackBoxAddress());
_;
}
modifier onlyUnicornToken() {
require(msg.sender == unicornManagement.unicornTokenAddress());
_;
}
function isGamePaused() external view returns (bool) {
return unicornManagement.paused();
}
}
contract UnicornBreeding is UnicornAccessControl {
using SafeMath for uint;
UnicornTokenInterface public unicornToken;
BlackBoxInterface public blackBox;
event HybridizationAdd(uint indexed unicornId, uint price);
event HybridizationAccept(uint indexed firstUnicornId, uint indexed secondUnicornId, uint newUnicornId);
event HybridizationDelete(uint indexed unicornId);
event FundsTransferred(address dividendManager, uint value);
event CreateUnicorn(address indexed owner, uint indexed unicornId, uint parent1, uint parent2);
event NewGen0Limit(uint limit);
event NewGen0Step(uint step);
event OfferAdd(uint256 indexed unicornId, uint price);
event OfferDelete(uint256 indexed unicornId);
event UnicornSold(uint256 indexed unicornId);
ERC20 public candyToken;
ERC20 public candyPowerToken;
uint public gen0Limit = 30000;
uint public gen0Count = 0;
uint public gen0Step = 1000;
uint public gen0PresaleLimit = 1000;
uint public gen0PresaleCount = 0;
struct Hybridization{
uint listIndex;
uint price;
bool exists;
}
mapping (uint => Hybridization) public hybridizations;
mapping(uint => uint) public hybridizationList;
uint public hybridizationListSize = 0;
function() public payable {
}
function UnicornBreeding(address _unicornManagementAddress) UnicornAccessControl(_unicornManagementAddress) public {
candyToken = ERC20(unicornManagement.candyToken());
}
function init() onlyManagement whenPaused external {
unicornToken = UnicornTokenInterface(unicornManagement.unicornTokenAddress());
blackBox = BlackBoxInterface(unicornManagement.blackBoxAddress());
candyPowerToken = ERC20(unicornManagement.candyPowerToken());
}
function makeHybridization(uint _unicornId, uint _price) public {
require(unicornToken.owns(msg.sender, _unicornId));
require(unicornToken.isUnfreezed(_unicornId));
require(!hybridizations[_unicornId].exists);
hybridizations[_unicornId] = Hybridization({
price: _price,
exists: true,
listIndex: hybridizationListSize
});
hybridizationList[hybridizationListSize++] = _unicornId;
emit HybridizationAdd(_unicornId, _price);
}
function acceptHybridization(uint _firstUnicornId, uint _secondUnicornId) whenNotPaused public payable {
require(unicornToken.owns(msg.sender, _secondUnicornId));
require(_secondUnicornId != _firstUnicornId);
require(unicornToken.isUnfreezed(_firstUnicornId) && unicornToken.isUnfreezed(_secondUnicornId));
require(hybridizations[_firstUnicornId].exists);
require(msg.value == unicornManagement.oraclizeFee());
if (hybridizations[_firstUnicornId].price > 0) {
require(candyToken.transferFrom(msg.sender, this, getHybridizationPrice(_firstUnicornId)));
}
plusFreezingTime(_secondUnicornId);
uint256 newUnicornId = unicornToken.createUnicorn(msg.sender);
blackBox.geneCore.value(unicornManagement.oraclizeFee())(newUnicornId, _firstUnicornId, _secondUnicornId);
emit CreateUnicorn(msg.sender, newUnicornId, _firstUnicornId, _secondUnicornId);
if (hybridizations[_firstUnicornId].price > 0) {
candyToken.transfer(unicornToken.ownerOf(_firstUnicornId), hybridizations[_firstUnicornId].price);
}
emit HybridizationAccept(_firstUnicornId, _secondUnicornId, newUnicornId);
_deleteHybridization(_firstUnicornId);
}
function cancelHybridization (uint _unicornId) public {
require(unicornToken.owns(msg.sender,_unicornId));
require(hybridizations[_unicornId].exists);
_deleteHybridization(_unicornId);
}
function deleteHybridization(uint _unicornId) onlyUnicornToken external {
_deleteHybridization(_unicornId);
}
function _deleteHybridization(uint _unicornId) internal {
if (hybridizations[_unicornId].exists) {
hybridizations[hybridizationList[--hybridizationListSize]].listIndex = hybridizations[_unicornId].listIndex;
hybridizationList[hybridizations[_unicornId].listIndex] = hybridizationList[hybridizationListSize];
delete hybridizationList[hybridizationListSize];
delete hybridizations[_unicornId];
emit HybridizationDelete(_unicornId);
}
}
function createUnicorn() public payable whenNotPaused returns(uint256) {
require(msg.value == getCreateUnicornPrice());
return _createUnicorn(msg.sender);
}
function createUnicornForCandy() public payable whenNotPaused returns(uint256) {
require(msg.value == unicornManagement.oraclizeFee());
require(candyToken.transferFrom(msg.sender, this, getCreateUnicornPriceInCandy()));
return _createUnicorn(msg.sender);
}
function createPresaleUnicorns(uint _count, address _owner) public payable onlyManager whenPaused returns(bool) {
require(gen0PresaleCount.add(_count) <= gen0PresaleLimit);
uint256 newUnicornId;
address owner = _owner == address(0) ? msg.sender : _owner;
for (uint i = 0; i < _count; i++){
newUnicornId = unicornToken.createUnicorn(owner);
blackBox.createGen0(newUnicornId);
emit CreateUnicorn(owner, newUnicornId, 0, 0);
gen0Count = gen0Count.add(1);
gen0PresaleCount = gen0PresaleCount.add(1);
}
return true;
}
function _createUnicorn(address _owner) private returns(uint256) {
require(gen0Count < gen0Limit);
uint256 newUnicornId = unicornToken.createUnicorn(_owner);
blackBox.createGen0.value(unicornManagement.oraclizeFee())(newUnicornId);
emit CreateUnicorn(_owner, newUnicornId, 0, 0);
gen0Count = gen0Count.add(1);
return newUnicornId;
}
function plusFreezingTime(uint _unicornId) private {
unicornToken.plusFreezingTime(_unicornId);
}
function plusTourFreezingTime(uint _unicornId) onlyTournament public {
unicornToken.plusTourFreezingTime(_unicornId);
}
function minusFreezingTime(uint _unicornId) public {
require(candyPowerToken.transferFrom(msg.sender, this, unicornManagement.subFreezingPrice()));
unicornToken.minusFreezingTime(_unicornId, unicornManagement.subFreezingTime());
}
function minusTourFreezingTime(uint _unicornId) public {
require(candyPowerToken.transferFrom(msg.sender, this, unicornManagement.subTourFreezingPrice()));
unicornToken.minusTourFreezingTime(_unicornId, unicornManagement.subTourFreezingTime());
}
function getHybridizationPrice(uint _unicornId) public view returns (uint) {
return unicornManagement.getHybridizationFullPrice(hybridizations[_unicornId].price);
}
function getEtherFeeForPriceInCandy() public view returns (uint) {
return unicornManagement.oraclizeFee();
}
function getCreateUnicornPriceInCandy() public view returns (uint) {
return unicornManagement.getCreateUnicornFullPriceInCandy();
}
function getCreateUnicornPrice() public view returns (uint) {
return unicornManagement.getCreateUnicornFullPrice();
}
function withdrawTokens() onlyManager public {
require(candyToken.balanceOf(this) > 0 || candyPowerToken.balanceOf(this) > 0);
if (candyToken.balanceOf(this) > 0) {
candyToken.transfer(unicornManagement.walletAddress(), candyToken.balanceOf(this));
}
if (candyPowerToken.balanceOf(this) > 0) {
candyPowerToken.transfer(unicornManagement.walletAddress(), candyPowerToken.balanceOf(this));
}
}
function transferEthersToDividendManager(uint _value) onlyManager public {
require(address(this).balance >= _value);
DividendManagerInterface dividendManager = DividendManagerInterface(unicornManagement.dividendManagerAddress());
dividendManager.payDividend.value(_value)();
emit FundsTransferred(unicornManagement.dividendManagerAddress(), _value);
}
function setGen0Limit() external onlyCommunity {
require(gen0Count == gen0Limit);
gen0Limit = gen0Limit.add(gen0Step);
emit NewGen0Limit(gen0Limit);
}
function setGen0Step(uint _step) external onlyCommunity {
gen0Step = _step;
emit NewGen0Step(gen0Limit);
}
struct Offer{
uint marketIndex;
uint price;
bool exists;
}
mapping (uint => Offer) public offers;
mapping(uint => uint) public market;
uint public marketSize = 0;
function sellUnicorn(uint _unicornId, uint _price) public {
require(unicornToken.owns(msg.sender, _unicornId));
require(!offers[_unicornId].exists);
offers[_unicornId] = Offer({
price: _price,
exists: true,
marketIndex: marketSize
});
market[marketSize++] = _unicornId;
emit OfferAdd(_unicornId, _price);
}
function buyUnicorn(uint _unicornId) public payable {
require(offers[_unicornId].exists);
uint price = offers[_unicornId].price;
require(msg.value == unicornManagement.getSellUnicornFullPrice(price));
address owner = unicornToken.ownerOf(_unicornId);
emit UnicornSold(_unicornId);
unicornToken.marketTransfer(owner, msg.sender, _unicornId);
owner.transfer(price);
}
function revokeUnicorn(uint _unicornId) public {
require(unicornToken.owns(msg.sender, _unicornId));
require(offers[_unicornId].exists);
_deleteOffer(_unicornId);
}
function deleteOffer(uint _unicornId) onlyUnicornToken external {
_deleteOffer(_unicornId);
}
function _deleteOffer(uint _unicornId) internal {
if (offers[_unicornId].exists) {
offers[market[--marketSize]].marketIndex = offers[_unicornId].marketIndex;
market[offers[_unicornId].marketIndex] = market[marketSize];
delete market[marketSize];
delete offers[_unicornId];
emit OfferDelete(_unicornId);
}
}
function getOfferPrice(uint _unicornId) public view returns (uint) {
return unicornManagement.getSellUnicornFullPrice(offers[_unicornId].price);
}
}
| 161,132 | 11,529 |
14ca7c469c1942afcb02cc39bb7b5c209952e8a8113a90392ec0631ea4ff2d93
| 21,455 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xEC41F8770174AA43d2F8085E62674556d31F1318/contract.sol
| 4,976 | 18,864 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
interface ICheeseSwapFactory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface ICheeseSwapPair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
library FixedPoint {
// range: [0, 2**112 - 1]
// resolution: 1 / 2**112
struct uq112x112 {
uint224 _x;
}
// range: [0, 2**144 - 1]
// resolution: 1 / 2**112
struct uq144x112 {
uint _x;
}
uint8 private constant RESOLUTION = 112;
// encode a uint112 as a UQ112x112
function encode(uint112 x) internal pure returns (uq112x112 memory) {
return uq112x112(uint224(x) << RESOLUTION);
}
// encodes a uint144 as a UQ144x112
function encode144(uint144 x) internal pure returns (uq144x112 memory) {
return uq144x112(uint256(x) << RESOLUTION);
}
// divide a UQ112x112 by a uint112, returning a UQ112x112
function div(uq112x112 memory self, uint112 x) internal pure returns (uq112x112 memory) {
require(x != 0, 'FixedPoint: DIV_BY_ZERO');
return uq112x112(self._x / uint224(x));
}
// multiply a UQ112x112 by a uint, returning a UQ144x112
// reverts on overflow
function mul(uq112x112 memory self, uint y) internal pure returns (uq144x112 memory) {
uint z;
require(y == 0 || (z = uint(self._x) * y) / y == uint(self._x), "FixedPoint: MULTIPLICATION_OVERFLOW");
return uq144x112(z);
}
// returns a UQ112x112 which represents the ratio of the numerator to the denominator
// equivalent to encode(numerator).div(denominator)
function fraction(uint112 numerator, uint112 denominator) internal pure returns (uq112x112 memory) {
require(denominator > 0, "FixedPoint: DIV_BY_ZERO");
return uq112x112((uint224(numerator) << RESOLUTION) / denominator);
}
// decode a UQ112x112 into a uint112 by truncating after the radix point
function decode(uq112x112 memory self) internal pure returns (uint112) {
return uint112(self._x >> RESOLUTION);
}
// decode a UQ144x112 into a uint144 by truncating after the radix point
function decode144(uq144x112 memory self) internal pure returns (uint144) {
return uint144(self._x >> RESOLUTION);
}
}
// library with helper methods for oracles that are concerned with computing average prices
library CheeseSwapOracleLibrary {
using FixedPoint for *;
function currentBlockTimestamp() internal view returns (uint32) {
return uint32(block.timestamp % 2 ** 32);
}
// produces the cumulative price using counterfactuals to save gas and avoid a call to sync.
function currentCumulativePrices(address pair) internal view returns (uint price0Cumulative, uint price1Cumulative, uint32 blockTimestamp) {
blockTimestamp = currentBlockTimestamp();
price0Cumulative = ICheeseSwapPair(pair).price0CumulativeLast();
price1Cumulative = ICheeseSwapPair(pair).price1CumulativeLast();
// if time has elapsed since the last update on the pair, mock the accumulated price values
(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = ICheeseSwapPair(pair).getReserves();
if (blockTimestampLast != blockTimestamp) {
// subtraction overflow is desired
uint32 timeElapsed = blockTimestamp - blockTimestampLast;
// addition overflow is desired
// counterfactual
price0Cumulative += uint(FixedPoint.fraction(reserve1, reserve0)._x) * timeElapsed;
// counterfactual
price1Cumulative += uint(FixedPoint.fraction(reserve0, reserve1)._x) * timeElapsed;
}
}
}
library SafeMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x, 'ds-math-add-overflow');
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x, 'ds-math-sub-underflow');
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x, 'ds-math-mul-overflow');
}
}
library CheeseSwapLibrary {
using SafeMath for uint;
// returns sorted token addresses, used to handle return values from pairs sorted in this order
function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) {
require(tokenA != tokenB, 'CheeseSwapLibrary: IDENTICAL_ADDRESSES');
(token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
require(token0 != address(0), 'CheeseSwapLibrary: ZERO_ADDRESS');
}
// calculates the CREATE2 address for a pair without making any external calls
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = sortTokens(tokenA, tokenB);
pair = address(uint(keccak256(abi.encodePacked(hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'f52c5189a89e7ca2ef4f19f2798e3900fba7a316de7cef6c5a9446621ba86286' // init code hash))));
}
// fetches and sorts the reserves for a pair
function getReserves(address factory, address tokenA, address tokenB) internal view returns (uint reserveA, uint reserveB) {
(address token0,) = sortTokens(tokenA, tokenB);
(uint reserve0, uint reserve1,) = ICheeseSwapPair(pairFor(factory, tokenA, tokenB)).getReserves();
(reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
}
// given some amount of an asset and pair reserves, returns an equivalent amount of the other asset
function quote(uint amountA, uint reserveA, uint reserveB) internal pure returns (uint amountB) {
require(amountA > 0, 'CheeseSwapLibrary: INSUFFICIENT_AMOUNT');
require(reserveA > 0 && reserveB > 0, 'CheeseSwapLibrary: INSUFFICIENT_LIQUIDITY');
amountB = amountA.mul(reserveB) / reserveA;
}
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) internal pure returns (uint amountOut) {
require(amountIn > 0, 'CheeseSwapLibrary: INSUFFICIENT_INPUT_AMOUNT');
require(reserveIn > 0 && reserveOut > 0, 'CheeseSwapLibrary: INSUFFICIENT_LIQUIDITY');
uint amountInWithFee = amountIn.mul(997);
uint numerator = amountInWithFee.mul(reserveOut);
uint denominator = reserveIn.mul(1000).add(amountInWithFee);
amountOut = numerator / denominator;
}
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) internal pure returns (uint amountIn) {
require(amountOut > 0, 'CheeseSwapLibrary: INSUFFICIENT_OUTPUT_AMOUNT');
require(reserveIn > 0 && reserveOut > 0, 'CheeseSwapLibrary: INSUFFICIENT_LIQUIDITY');
uint numerator = reserveIn.mul(amountOut).mul(1000);
uint denominator = reserveOut.sub(amountOut).mul(997);
amountIn = (numerator / denominator).add(1);
}
// performs chained getAmountOut calculations on any number of pairs
function getAmountsOut(address factory, uint amountIn, address[] memory path) internal view returns (uint[] memory amounts) {
require(path.length >= 2, 'CheeseSwapLibrary: INVALID_PATH');
amounts = new uint[](path.length);
amounts[0] = amountIn;
for (uint i; i < path.length - 1; i++) {
(uint reserveIn, uint reserveOut) = getReserves(factory, path[i], path[i + 1]);
amounts[i + 1] = getAmountOut(amounts[i], reserveIn, reserveOut);
}
}
// performs chained getAmountIn calculations on any number of pairs
function getAmountsIn(address factory, uint amountOut, address[] memory path) internal view returns (uint[] memory amounts) {
require(path.length >= 2, 'CheeseSwapLibrary: INVALID_PATH');
amounts = new uint[](path.length);
amounts[amounts.length - 1] = amountOut;
for (uint i = path.length - 1; i > 0; i--) {
(uint reserveIn, uint reserveOut) = getReserves(factory, path[i - 1], path[i]);
amounts[i - 1] = getAmountIn(amounts[i], reserveIn, reserveOut);
}
}
}
interface IKeep3rb {
function isKeeper(address) external returns (bool);
function worked(address keeper) external;
}
// `windowSize` with a precision of `windowSize / granularity`
contract CheeseSwapOracle {
using FixedPoint for *;
using SafeMath for uint;
struct Observation {
uint timestamp;
uint price0Cumulative;
uint price1Cumulative;
}
modifier keeper() {
require(KP3RB.isKeeper(msg.sender), "::isKeeper: keeper is not registered");
_;
}
modifier upkeep() {
require(KP3RB.isKeeper(msg.sender), "::isKeeper: keeper is not registered");
_;
KP3RB.worked(msg.sender);
}
address public governance;
address public pendingGovernance;
function setGovernance(address _governance) external {
require(msg.sender == governance, "setGovernance: !gov");
pendingGovernance = _governance;
}
function acceptGovernance() external {
require(msg.sender == pendingGovernance, "acceptGovernance: !pendingGov");
governance = pendingGovernance;
}
function setKeep3rb(address _keep3rb) external {
require(msg.sender == governance, "setKeep3rb: !gov");
KP3RB = IKeep3rb(_keep3rb);
}
IKeep3rb public KP3RB;
address public immutable factory = 0xdd538E4Fd1b69B7863E1F741213276A6Cf1EfB3B;
// the desired amount of time over which the moving average should be computed, e.g. 24 hours
uint public immutable windowSize = 14400;
// averages are computed over intervals with sizes in the range:
// [windowSize - (windowSize / granularity) * 2, windowSize]
// the period:
// [now - [22 hours, 24 hours], now]
uint8 public immutable granularity = 8;
uint public immutable periodSize = 1800;
address[] internal _pairs;
mapping(address => bool) internal _known;
mapping(address => uint) public lastUpdated;
function pairs() external view returns (address[] memory) {
return _pairs;
}
// mapping from pair address to a list of price observations of that pair
mapping(address => Observation[]) public pairObservations;
constructor(address _keep3rb) public {
governance = msg.sender;
KP3RB = IKeep3rb(_keep3rb);
}
// returns the index of the observation corresponding to the given timestamp
function observationIndexOf(uint timestamp) public view returns (uint8 index) {
uint epochPeriod = timestamp / periodSize;
return uint8(epochPeriod % granularity);
}
function getFirstObservationInWindow(address pair) private view returns (Observation storage firstObservation) {
uint8 observationIndex = observationIndexOf(block.timestamp);
// no overflow issue. if observationIndex + 1 overflows, result is still zero.
uint8 firstObservationIndex = (observationIndex + 1) % granularity;
firstObservation = pairObservations[pair][firstObservationIndex];
}
function updatePair(address pair) external keeper returns (bool) {
return _update(pair);
}
// once per epoch period.
function update(address tokenA, address tokenB) external keeper returns (bool) {
address pair = CheeseSwapLibrary.pairFor(factory, tokenA, tokenB);
return _update(pair);
}
function add(address tokenA, address tokenB) external {
require(msg.sender == governance, "CheeseSwapOracle::add: !gov");
address pair = CheeseSwapLibrary.pairFor(factory, tokenA, tokenB);
require(!_known[pair], "known");
_known[pair] = true;
_pairs.push(pair);
}
function work() public upkeep {
bool worked = _updateAll();
require(worked, "CheeseSwapOracle: !work");
}
function _updateAll() internal returns (bool updated) {
for (uint i = 0; i < _pairs.length; i++) {
if (_update(_pairs[i])) {
updated = true;
}
}
}
function updateFor(uint i, uint length) external keeper returns (bool updated) {
for (; i < length; i++) {
if (_update(_pairs[i])) {
updated = true;
}
}
}
function updateableList() external view returns (address[] memory list) {
uint _index = 0;
for (uint i = 0; i < _pairs.length; i++) {
if (updateable(_pairs[i])) {
list[_index++] = _pairs[i];
}
}
}
function updateable(address pair) public view returns (bool) {
return (block.timestamp - lastUpdated[pair]) > periodSize;
}
function updateable() external view returns (bool) {
for (uint i = 0; i < _pairs.length; i++) {
if (updateable(_pairs[i])) {
return true;
}
}
return false;
}
function updateableFor(uint i, uint length) external view returns (bool) {
for (; i < length; i++) {
if (updateable(_pairs[i])) {
return true;
}
}
return false;
}
function _update(address pair) internal returns (bool) {
// populate the array with empty observations (first call only)
for (uint i = pairObservations[pair].length; i < granularity; i++) {
pairObservations[pair].push();
}
// get the observation for the current period
uint8 observationIndex = observationIndexOf(block.timestamp);
Observation storage observation = pairObservations[pair][observationIndex];
// we only want to commit updates once per period (i.e. windowSize / granularity)
uint timeElapsed = block.timestamp - observation.timestamp;
if (timeElapsed > periodSize) {
(uint price0Cumulative, uint price1Cumulative,) = CheeseSwapOracleLibrary.currentCumulativePrices(pair);
observation.timestamp = block.timestamp;
lastUpdated[pair] = block.timestamp;
observation.price0Cumulative = price0Cumulative;
observation.price1Cumulative = price1Cumulative;
return true;
}
return false;
}
// price in terms of how much amount out is received for the amount in
function computeAmountOut(uint priceCumulativeStart, uint priceCumulativeEnd,
uint timeElapsed, uint amountIn) private pure returns (uint amountOut) {
// overflow is desired.
FixedPoint.uq112x112 memory priceAverage = FixedPoint.uq112x112(uint224((priceCumulativeEnd - priceCumulativeStart) / timeElapsed));
amountOut = priceAverage.mul(amountIn).decode144();
}
// range [now - [windowSize, windowSize - periodSize * 2], now]
// update must have been called for the bucket corresponding to timestamp `now - windowSize`
function consult(address tokenIn, uint amountIn, address tokenOut) external view returns (uint amountOut) {
address pair = CheeseSwapLibrary.pairFor(factory, tokenIn, tokenOut);
Observation storage firstObservation = getFirstObservationInWindow(pair);
uint timeElapsed = block.timestamp - firstObservation.timestamp;
require(timeElapsed <= windowSize, 'SlidingWindowOracle: MISSING_HISTORICAL_OBSERVATION');
// should never happen.
require(timeElapsed >= windowSize - periodSize * 2, 'SlidingWindowOracle: UNEXPECTED_TIME_ELAPSED');
(uint price0Cumulative, uint price1Cumulative,) = CheeseSwapOracleLibrary.currentCumulativePrices(pair);
(address token0,) = CheeseSwapLibrary.sortTokens(tokenIn, tokenOut);
if (token0 == tokenIn) {
return computeAmountOut(firstObservation.price0Cumulative, price0Cumulative, timeElapsed, amountIn);
} else {
return computeAmountOut(firstObservation.price1Cumulative, price1Cumulative, timeElapsed, amountIn);
}
}
}
| 253,986 | 11,530 |
89cdfcd3dec68048612e64cfaec827c2d9a652dfb462a52e09de25ff6bf78b5e
| 12,452 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xdf70fe7e07b83fa193bd292a90bd6adc2ceed3d4.sol
| 3,076 | 12,154 |
pragma solidity ^0.4.24;
// ----------------------------------------------------------------------------
// ExchangeArbitrage token contract
//
// Symbol : EXARB
// Name : Exchange Arbitrage Token
// Decimals : 18
//
// ----------------------------------------------------------------------------
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
c = a + b;
require(c >= a);
}
function sub(uint a, uint b) internal pure returns (uint c) {
require(b <= a);
c = a - b;
}
function mul(uint a, uint b) internal pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function div(uint a, uint b) internal pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
contract Owned {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
}
contract ExchangeArbitrageToken is Owned {
using SafeMath for uint;
string public symbol = "EXARB";
string public name = "Exchange Arbitrage Token";
uint8 public decimals = 18;
uint minted_tokens;
uint exchange_rate;
uint max_minted_supply;
uint cash_out_rate;
mapping(address => mapping (address => uint)) allowed;
event Transfer(address indexed from, address indexed to, uint tokens);
event MintTokens(address from, uint amount);
event ExchangeRateSet(uint exchange_rate);
event CashOutRateSet(uint exchange_rate);
event MaxMintedSupplySet(uint max_minted_supply);
event Approval(address tokenOwner, address spender, uint tokens);
// historical tracking of balances at a particular block
mapping(address => BlockBalance[]) block_balances;
struct BlockBalance {
uint block_id;
uint balance;
}
// keep track of which token owners picked up their payout amounts
// (token_owner => (payout_id => paid_out_amount))
mapping(address => mapping(uint16 => uint)) collected_payouts;
// basic array that has all of the payout ids
uint16[] payout_ids;
// mapping that has the payout details.
mapping(uint16 => PayoutBlock) payouts;
struct PayoutBlock {
uint block_id;
uint amount;
uint minted_tokens;
}
constructor() public payable {
minted_tokens = 0;
exchange_rate = 210;
cash_out_rate = 50000000000000;
max_minted_supply = 450000000000000000000000;
emit MaxMintedSupplySet(max_minted_supply);
emit CashOutRateSet(cash_out_rate);
emit ExchangeRateSet(exchange_rate);
}
function totalSupply() public view returns (uint) {
return minted_tokens;
}
function balanceOf(address tokenOwner) public view returns (uint balance) {
return getTokenBalanceOf(tokenOwner);
}
function allowance(address tokenOwner, address spender) public constant returns(uint remaining){
return allowed[tokenOwner][spender];
}
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
require(tokens > 0, "Transfer must be positive.");
require(allowed[from][msg.sender] >= tokens, "Not enough allowed tokens.");
subtractTokenBalanceFrom(from, tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
addTokenBalanceTo(to, tokens);
emit Transfer(from, to, tokens);
return true;
}
function ownershipPercentageOf(address tokenOwner) public view returns (uint percentage_8_decimals) {
return balanceOf(tokenOwner).mul(10000000000).div(minted_tokens);
}
function allPayoutIds() public view returns (uint16[]) {
return payout_ids;
}
function getPayoutAmountForId(uint16 payout_id) public view returns (uint) {
return payouts[payout_id].amount;
}
function getPayoutBlockForId(uint16 payout_id) public view returns (uint) {
return payouts[payout_id].block_id;
}
function ethToTokenExchangeRate() public view returns (uint) {
return exchange_rate;
}
function limitMintedSupply() public view returns (uint) {
return max_minted_supply;
}
function limitCashOutRate() public view returns (uint) {
return cash_out_rate;
}
function payoutAmountFor(uint16 payout_id) public view returns (uint) {
require(payouts[payout_id].block_id > 0, "Invalid payout_id");
require(block_balances[msg.sender].length > 0, "This address has no history on this contract.");
PayoutBlock storage payout_block = payouts[payout_id];
BlockBalance memory relevant_block;
for(uint i = 0; i < block_balances[msg.sender].length; i++) {
if (block_balances[msg.sender][i].block_id < payout_block.block_id) {
relevant_block = block_balances[msg.sender][i];
}
}
return relevant_block.balance.mul(payout_block.amount).div(payout_block.minted_tokens);
}
function payoutCollected(uint16 payout_id) public view returns (bool) {
return collected_payouts[msg.sender][payout_id] > 0;
}
function payoutCollect(uint16 payout_id) public returns (bool success) {
require(collected_payouts[msg.sender][payout_id] == 0, "Payment already collected");
uint payout = payoutAmountFor(payout_id);
require(address(this).balance >= payout, "Balance is too low.");
collected_payouts[msg.sender][payout_id] = payout;
msg.sender.transfer(payout);
return true;
}
function calculateCashOut() public view returns (uint amount) {
uint current_token_balance = getTokenBalanceOf(msg.sender);
uint payout = current_token_balance.mul(cash_out_rate).div(1000000000000000000);
return payout;
}
function cashOut() public returns (bool success) {
uint current_token_balance = getTokenBalanceOf(msg.sender);
require(current_token_balance > 0, 'Address has no balance');
uint payout = current_token_balance.mul(cash_out_rate).div(1000000000000000000);
subtractTokenBalanceFrom(msg.sender, current_token_balance);
minted_tokens = minted_tokens.sub(current_token_balance);
msg.sender.transfer(payout);
return true;
}
// Allow anyone to transfer to anyone else as long as they have enough balance.
function transfer(address to, uint tokens) public returns (bool success) {
require(tokens > 0, "Transfer must be positive.");
subtractTokenBalanceFrom(msg.sender, tokens);
addTokenBalanceTo(to, tokens);
emit Transfer(msg.sender, to, tokens);
return true;
}
function () public payable {
if (msg.sender != owner){
require(msg.value.mul(exchange_rate) + minted_tokens < max_minted_supply, "Contract Fully Funded. Try again later.");
mint(msg.sender, msg.value);
if (!owner.send(msg.value)) { revert(); }
} else {
require(msg.value > 0); // owner sent funds. keep on contract for payouts.
}
}
// ----------------------------------------------------------------------------
// private functions
// ----------------------------------------------------------------------------
function mint(address sender, uint value) private {
uint tokens = value.mul(exchange_rate);
addTokenBalanceTo(sender, tokens);
minted_tokens = minted_tokens.add(tokens);
emit MintTokens(sender, tokens);
}
function getTokenBalanceOf(address tokenOwner) private view returns (uint tokens) {
uint owner_block_balance_length = block_balances[tokenOwner].length;
if (owner_block_balance_length == 0) {
return 0;
} else {
return block_balances[tokenOwner][owner_block_balance_length-1].balance;
}
}
function addTokenBalanceTo(address tokenOwner, uint value) private {
uint owner_block_balance_length = block_balances[tokenOwner].length;
if (owner_block_balance_length == 0) {
block_balances[tokenOwner].push(BlockBalance({ block_id: block.number, balance: value }));
} else {
BlockBalance storage owner_last_block_balance = block_balances[tokenOwner][owner_block_balance_length-1];
uint owner_current_balance = getTokenBalanceOf(tokenOwner);
// --> reuse the last location
// else --> create a new location
if (payout_ids.length == 0 || owner_last_block_balance.block_id > payouts[payout_ids[payout_ids.length-1]].block_id) {
// overwrite last item in the array.
block_balances[tokenOwner][owner_block_balance_length-1] = BlockBalance({ block_id: block.number, balance: owner_current_balance.add(value) });
} else {
block_balances[tokenOwner].push(BlockBalance({ block_id: block.number, balance: owner_current_balance.add(value) }));
}
}
}
function subtractTokenBalanceFrom(address tokenOwner, uint value) private {
uint owner_block_balance_length = block_balances[tokenOwner].length;
if (owner_block_balance_length == 0) {
revert('Can not remove balance from an address with no history.');
} else {
BlockBalance storage owner_last_block_balance = block_balances[tokenOwner][owner_block_balance_length-1];
uint owner_current_balance = getTokenBalanceOf(tokenOwner);
// --> reuse the last location
// else --> create a new location
if (payout_ids.length == 0 || owner_last_block_balance.block_id > payouts[payout_ids[payout_ids.length-1]].block_id) {
// overwrite last item in the array.
block_balances[tokenOwner][owner_block_balance_length-1] = BlockBalance({ block_id: block.number, balance: owner_current_balance.sub(value) });
} else {
block_balances[tokenOwner].push(BlockBalance({ block_id: block.number, balance: owner_current_balance.sub(value) }));
}
}
}
// ----------------------------------------------------------------------------
// onlyOwner functions.
// ----------------------------------------------------------------------------
function payout(uint16 payout_id, uint amount) public onlyOwner returns (bool success) {
require(payouts[payout_id].block_id == 0);
payouts[payout_id] = PayoutBlock({ block_id: block.number, amount: amount, minted_tokens: minted_tokens });
payout_ids.push(payout_id);
return true;
}
function setExchangeRate(uint newRate) public onlyOwner returns (bool success) {
exchange_rate = newRate;
emit ExchangeRateSet(newRate);
return true;
}
function setCashOutRate(uint newRate) public onlyOwner returns (bool success) {
cash_out_rate = newRate;
emit CashOutRateSet(newRate);
return true;
}
function setMaxMintedSupply(uint newMaxMintedSupply) public onlyOwner returns (bool success) {
max_minted_supply = newMaxMintedSupply;
emit MaxMintedSupplySet(max_minted_supply);
return true;
}
function ownerTransfer(address from, address to, uint tokens) public onlyOwner returns (bool success) {
require(tokens > 0, "Transfer must be positive.");
subtractTokenBalanceFrom(from, tokens);
addTokenBalanceTo(to, tokens);
emit Transfer(from, to, tokens);
return true;
}
function ownerMint(address to, uint tokens) public onlyOwner returns (bool success) {
addTokenBalanceTo(to, tokens);
minted_tokens = minted_tokens.add(tokens);
emit MintTokens(to, tokens);
return true;
}
function destroy() public onlyOwner {
selfdestruct(owner);
}
}
| 222,812 | 11,531 |
5cc84ecb3ef29d648e92206ec779a393c768b593fa8fb8feda5485638f569362
| 32,593 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/de/de382552a9f288acc52466d2fc7247cba48813a2_MShareRewardPool.sol
| 5,119 | 19,592 |
// 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) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
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;
}
}
// Note that this pool has no minter key of mSHARE (rewards).
contract MShareRewardPool {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// governance
address public operator;
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below.
}
// Info of each pool.
struct PoolInfo {
IERC20 token; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. mSHAREs to distribute per block.
uint256 lastRewardTime; // Last time that mSHAREs distribution occurs.
uint256 accMSharePerShare; // Accumulated mSHAREs per share, times 1e18. See below.
bool isStarted; // if lastRewardTime has passed
}
IERC20 public mshare;
// Info of each pool.
PoolInfo[] public poolInfo;
// Info of each user that stakes LP tokens.
mapping(uint256 => mapping(address => UserInfo)) public userInfo;
// Total allocation points. Must be the sum of all allocation points in all pools.
uint256 public totalAllocPoint = 0;
// The time when mSHARE mining starts.
uint256 public poolStartTime;
// The time when mSHARE mining ends.
uint256 public poolEndTime;
uint256 public mSharePerSecond = 0.00186122 ether; // 59500 mshare / (370 days * 24h * 60min * 60s)
uint256 public runningTime = 370 days; // 370 days
uint256 public constant TOTAL_REWARDS = 59500 ether;
event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);
event RewardPaid(address indexed user, uint256 amount);
constructor(address _mshare,
uint256 _poolStartTime) public {
require(block.timestamp < _poolStartTime, "late");
if (_mshare != address(0)) mshare = IERC20(_mshare);
poolStartTime = _poolStartTime;
poolEndTime = poolStartTime + runningTime;
operator = msg.sender;
}
modifier onlyOperator() {
require(operator == msg.sender, "MShareRewardPool: caller is not the operator");
_;
}
function checkPoolDuplicate(IERC20 _token) internal view {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
require(poolInfo[pid].token != _token, "MShareRewardPool: existing pool?");
}
}
// Add a new lp to the pool. Can only be called by the owner.
function add(uint256 _allocPoint,
IERC20 _token,
bool _withUpdate,
uint256 _lastRewardTime) public onlyOperator {
checkPoolDuplicate(_token);
if (_withUpdate) {
massUpdatePools();
}
if (block.timestamp < poolStartTime) {
// chef is sleeping
if (_lastRewardTime == 0) {
_lastRewardTime = poolStartTime;
} else {
if (_lastRewardTime < poolStartTime) {
_lastRewardTime = poolStartTime;
}
}
} else {
// chef is cooking
if (_lastRewardTime == 0 || _lastRewardTime < block.timestamp) {
_lastRewardTime = block.timestamp;
}
}
bool _isStarted =
(_lastRewardTime <= poolStartTime) ||
(_lastRewardTime <= block.timestamp);
poolInfo.push(PoolInfo({
token : _token,
allocPoint : _allocPoint,
lastRewardTime : _lastRewardTime,
accMSharePerShare : 0,
isStarted : _isStarted
}));
if (_isStarted) {
totalAllocPoint = totalAllocPoint.add(_allocPoint);
}
}
// Update the given pool's mSHARE allocation point. Can only be called by the owner.
function set(uint256 _pid, uint256 _allocPoint) public onlyOperator {
massUpdatePools();
PoolInfo storage pool = poolInfo[_pid];
if (pool.isStarted) {
totalAllocPoint = totalAllocPoint.sub(pool.allocPoint).add(_allocPoint);
}
pool.allocPoint = _allocPoint;
}
// Return accumulate rewards over the given _from to _to block.
function getGeneratedReward(uint256 _fromTime, uint256 _toTime) public view returns (uint256) {
if (_fromTime >= _toTime) return 0;
if (_toTime >= poolEndTime) {
if (_fromTime >= poolEndTime) return 0;
if (_fromTime <= poolStartTime) return poolEndTime.sub(poolStartTime).mul(mSharePerSecond);
return poolEndTime.sub(_fromTime).mul(mSharePerSecond);
} else {
if (_toTime <= poolStartTime) return 0;
if (_fromTime <= poolStartTime) return _toTime.sub(poolStartTime).mul(mSharePerSecond);
return _toTime.sub(_fromTime).mul(mSharePerSecond);
}
}
// View function to see pending mShares on frontend.
function pendingShare(uint256 _pid, address _user) external view returns (uint256) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accMSharePerShare = pool.accMSharePerShare;
uint256 tokenSupply = pool.token.balanceOf(address(this));
if (block.timestamp > pool.lastRewardTime && tokenSupply != 0) {
uint256 _generatedReward = getGeneratedReward(pool.lastRewardTime, block.timestamp);
uint256 _mshareReward = _generatedReward.mul(pool.allocPoint).div(totalAllocPoint);
accMSharePerShare = accMSharePerShare.add(_mshareReward.mul(1e18).div(tokenSupply));
}
return user.amount.mul(accMSharePerShare).div(1e18).sub(user.rewardDebt);
}
// Update reward variables for all pools. Be careful of gas spending!
function massUpdatePools() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
updatePool(pid);
}
}
// Update reward variables of the given pool to be up-to-date.
function updatePool(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
if (block.timestamp <= pool.lastRewardTime) {
return;
}
uint256 tokenSupply = pool.token.balanceOf(address(this));
if (tokenSupply == 0) {
pool.lastRewardTime = block.timestamp;
return;
}
if (!pool.isStarted) {
pool.isStarted = true;
totalAllocPoint = totalAllocPoint.add(pool.allocPoint);
}
if (totalAllocPoint > 0) {
uint256 _generatedReward = getGeneratedReward(pool.lastRewardTime, block.timestamp);
uint256 _mshareReward = _generatedReward.mul(pool.allocPoint).div(totalAllocPoint);
pool.accMSharePerShare = pool.accMSharePerShare.add(_mshareReward.mul(1e18).div(tokenSupply));
}
pool.lastRewardTime = block.timestamp;
}
// Deposit LP tokens.
function deposit(uint256 _pid, uint256 _amount) public {
address _sender = msg.sender;
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_sender];
updatePool(_pid);
if (user.amount > 0) {
uint256 _pending = user.amount.mul(pool.accMSharePerShare).div(1e18).sub(user.rewardDebt);
if (_pending > 0) {
safeMShareTransfer(_sender, _pending);
emit RewardPaid(_sender, _pending);
}
}
if (_amount > 0) {
pool.token.safeTransferFrom(_sender, address(this), _amount);
user.amount = user.amount.add(_amount);
}
user.rewardDebt = user.amount.mul(pool.accMSharePerShare).div(1e18);
emit Deposit(_sender, _pid, _amount);
}
// Withdraw LP tokens.
function withdraw(uint256 _pid, uint256 _amount) public {
address _sender = msg.sender;
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_sender];
require(user.amount >= _amount, "withdraw: not good");
updatePool(_pid);
uint256 _pending = user.amount.mul(pool.accMSharePerShare).div(1e18).sub(user.rewardDebt);
if (_pending > 0) {
safeMShareTransfer(_sender, _pending);
emit RewardPaid(_sender, _pending);
}
if (_amount > 0) {
user.amount = user.amount.sub(_amount);
pool.token.safeTransfer(_sender, _amount);
}
user.rewardDebt = user.amount.mul(pool.accMSharePerShare).div(1e18);
emit Withdraw(_sender, _pid, _amount);
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function emergencyWithdraw(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
uint256 _amount = user.amount;
user.amount = 0;
user.rewardDebt = 0;
pool.token.safeTransfer(msg.sender, _amount);
emit EmergencyWithdraw(msg.sender, _pid, _amount);
}
function safeMShareTransfer(address _to, uint256 _amount) internal {
uint256 _mshareBal = mshare.balanceOf(address(this));
if (_mshareBal > 0) {
if (_amount > _mshareBal) {
mshare.safeTransfer(_to, _mshareBal);
} else {
mshare.safeTransfer(_to, _amount);
}
}
}
function setOperator(address _operator) external onlyOperator {
operator = _operator;
}
function governanceRecoverUnsupported(IERC20 _token, uint256 amount, address to) external onlyOperator {
if (block.timestamp < poolEndTime + 90 days) {
// do not allow to drain core token (mSHARE or lps) if less than 90 days after pool ends
require(_token != mshare, "mshare");
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
PoolInfo storage pool = poolInfo[pid];
require(_token != pool.token, "pool.token");
}
}
_token.safeTransfer(to, amount);
}
}
| 317,900 | 11,532 |
e24cf2bc47b3c39194ec820eaed500235875a30348f76e92f142c7bcd334ebfb
| 21,624 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x2d04a81798ec74de48e09e3fd43ca41757d33e6a.sol
| 5,732 | 21,083 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) { return 0; }
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract PullPayment {
using SafeMath for uint256;
mapping(address => uint256) public payments;
uint256 public totalPayments;
function withdrawPayments() public {
address payee = msg.sender;
uint256 payment = payments[payee];
require(payment != 0);
require(this.balance >= payment);
totalPayments = totalPayments.sub(payment);
payments[payee] = 0;
assert(payee.send(payment));
}
function asyncSend(address dest, uint256 amount) internal {
payments[dest] = payments[dest].add(amount);
totalPayments = totalPayments.add(amount);
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Destructible is Ownable {
function Destructible() public payable { }
function destroy() onlyOwner public {
selfdestruct(owner);
}
function destroyAndSend(address _recipient) onlyOwner public {
selfdestruct(_recipient);
}
}
contract ReentrancyGuard {
bool private reentrancy_lock = false;
modifier nonReentrant() {
require(!reentrancy_lock);
reentrancy_lock = true;
_;
reentrancy_lock = false;
}
}
contract Map is PullPayment, Destructible, ReentrancyGuard {
using SafeMath for uint256;
struct Transaction {
string kingdomKey;
address compensationAddress;
uint buyingPrice;
uint compensation;
uint jackpotContribution;
}
struct Kingdom {
string title;
string key;
uint kingdomTier;
uint kingdomType;
uint minimumPrice;
uint lastTransaction;
uint transactionCount;
uint returnPrice;
address owner;
bool locked;
}
struct Jackpot {
address winner;
uint balance;
}
struct Round {
Jackpot globalJackpot;
Jackpot jackpot1;
Jackpot jackpot2;
Jackpot jackpot3;
Jackpot jackpot4;
Jackpot jackpot5;
mapping(string => bool) kingdomsCreated;
mapping(address => uint) nbKingdoms;
mapping(address => uint) nbTransactions;
mapping(address => uint) nbKingdomsType1;
mapping(address => uint) nbKingdomsType2;
mapping(address => uint) nbKingdomsType3;
mapping(address => uint) nbKingdomsType4;
mapping(address => uint) nbKingdomsType5;
uint startTime;
uint endTime;
mapping(string => uint) kingdomsKeys;
}
Kingdom[] public kingdoms;
Transaction[] public kingdomTransactions;
uint public currentRound;
address public bookerAddress;
mapping(uint => Round) rounds;
uint constant public ACTION_TAX = 0.02 ether;
uint constant public STARTING_CLAIM_PRICE_WEI = 0.05 ether;
uint constant MAXIMUM_CLAIM_PRICE_WEI = 800 ether;
uint constant KINGDOM_MULTIPLIER = 20;
uint constant TEAM_COMMISSION_RATIO = 10;
uint constant JACKPOT_COMMISSION_RATIO = 10;
modifier onlyForRemainingKingdoms() {
uint remainingKingdoms = getRemainingKingdoms();
require(remainingKingdoms > kingdoms.length);
_;
}
modifier checkKingdomExistence(string key) {
require(rounds[currentRound].kingdomsCreated[key] == true);
_;
}
modifier checkIsNotLocked(string kingdomKey) {
require(kingdoms[rounds[currentRound].kingdomsKeys[kingdomKey]].locked != true);
_;
}
modifier checkIsClosed() {
require(now >= rounds[currentRound].endTime);
_;
}
modifier onlyKingdomOwner(string _key, address _sender) {
require (kingdoms[rounds[currentRound].kingdomsKeys[_key]].owner == _sender);
_;
}
event LandCreatedEvent(string kingdomKey, address monarchAddress);
event LandPurchasedEvent(string kingdomKey, address monarchAddress);
function Map(address _bookerAddress, uint _startTime) {
bookerAddress = _bookerAddress;
currentRound = 1;
rounds[currentRound] = Round(Jackpot(address(0), 0), Jackpot(address(0), 0), Jackpot(address(0), 0), Jackpot(address(0), 0), Jackpot(address(0), 0), Jackpot(address(0), 0), 0, 0);
rounds[currentRound].jackpot1 = Jackpot(address(0), 0);
rounds[currentRound].jackpot2 = Jackpot(address(0), 0);
rounds[currentRound].jackpot3 = Jackpot(address(0), 0);
rounds[currentRound].jackpot4 = Jackpot(address(0), 0);
rounds[currentRound].jackpot5 = Jackpot(address(0), 0);
rounds[currentRound].startTime = _startTime;
rounds[currentRound].endTime = _startTime + 7 days;
rounds[currentRound].globalJackpot = Jackpot(address(0), 0);
}
function () { }
function getRemainingKingdoms() public view returns (uint nb) {
for (uint i = 1; i < 8; i++) {
if (now < rounds[currentRound].startTime + (i * 1 days)) {
uint result = (10 * i);
if (result > 70) {
return 70;
} else {
return result;
}
}
}
}
function setTypedJackpotWinner(address _user, uint _type) internal {
if (_type == 1) {
if (rounds[currentRound].jackpot1.winner == address(0)) {
rounds[currentRound].jackpot1.winner = _user;
} else if (rounds[currentRound].nbKingdomsType1[_user] >= rounds[currentRound].nbKingdomsType1[rounds[currentRound].jackpot1.winner]) {
rounds[currentRound].jackpot1.winner = _user;
}
} else if (_type == 2) {
if (rounds[currentRound].jackpot2.winner == address(0)) {
rounds[currentRound].jackpot2.winner = _user;
} else if (rounds[currentRound].nbKingdomsType2[_user] >= rounds[currentRound].nbKingdomsType2[rounds[currentRound].jackpot2.winner]) {
rounds[currentRound].jackpot2.winner = _user;
}
} else if (_type == 3) {
if (rounds[currentRound].jackpot3.winner == address(0)) {
rounds[currentRound].jackpot3.winner = _user;
} else if (rounds[currentRound].nbKingdomsType3[_user] >= rounds[currentRound].nbKingdomsType3[rounds[currentRound].jackpot3.winner]) {
rounds[currentRound].jackpot3.winner = _user;
}
} else if (_type == 4) {
if (rounds[currentRound].jackpot4.winner == address(0)) {
rounds[currentRound].jackpot4.winner = _user;
} else if (rounds[currentRound].nbKingdomsType4[_user] >= rounds[currentRound].nbKingdomsType4[rounds[currentRound].jackpot4.winner]) {
rounds[currentRound].jackpot4.winner = _user;
}
} else if (_type == 5) {
if (rounds[currentRound].jackpot5.winner == address(0)) {
rounds[currentRound].jackpot5.winner = _user;
} else if (rounds[currentRound].nbKingdomsType5[_user] >= rounds[currentRound].nbKingdomsType5[rounds[currentRound].jackpot5.winner]) {
rounds[currentRound].jackpot5.winner = _user;
}
}
}
function purchaseKingdom(string _key, string _title, bool _locked) public
payable
nonReentrant()
checkKingdomExistence(_key)
checkIsNotLocked(_key)
{
require(now < rounds[currentRound].endTime);
Round storage round = rounds[currentRound];
uint kingdomId = round.kingdomsKeys[_key];
Kingdom storage kingdom = kingdoms[kingdomId];
require((kingdom.kingdomTier + 1) < 6);
uint requiredPrice = kingdom.minimumPrice;
if (_locked == true) {
requiredPrice = requiredPrice.add(ACTION_TAX);
}
require (msg.value >= requiredPrice);
uint jackpotCommission = (msg.value).sub(kingdom.returnPrice);
if (kingdom.returnPrice > 0) {
round.nbKingdoms[kingdom.owner]--;
if (kingdom.kingdomType == 1) {
round.nbKingdomsType1[kingdom.owner]--;
} else if (kingdom.kingdomType == 2) {
round.nbKingdomsType2[kingdom.owner]--;
} else if (kingdom.kingdomType == 3) {
round.nbKingdomsType3[kingdom.owner]--;
} else if (kingdom.kingdomType == 4) {
round.nbKingdomsType4[kingdom.owner]--;
} else if (kingdom.kingdomType == 5) {
round.nbKingdomsType5[kingdom.owner]--;
}
compensateLatestMonarch(kingdom.lastTransaction, kingdom.returnPrice);
}
uint jackpotSplitted = jackpotCommission.mul(50).div(100);
round.globalJackpot.balance = round.globalJackpot.balance.add(jackpotSplitted);
kingdom.kingdomTier++;
kingdom.title = _title;
if (kingdom.kingdomTier == 5) {
kingdom.returnPrice = 0;
} else {
kingdom.returnPrice = kingdom.minimumPrice.mul(2);
kingdom.minimumPrice = kingdom.minimumPrice.add(kingdom.minimumPrice.mul(2));
}
kingdom.owner = msg.sender;
kingdom.locked = _locked;
uint transactionId = kingdomTransactions.push(Transaction("", msg.sender, msg.value, 0, jackpotSplitted)) - 1;
kingdomTransactions[transactionId].kingdomKey = _key;
kingdom.transactionCount++;
kingdom.lastTransaction = transactionId;
setNewJackpot(kingdom.kingdomType, jackpotSplitted, msg.sender);
LandPurchasedEvent(_key, msg.sender);
}
function setNewJackpot(uint kingdomType, uint jackpotSplitted, address sender) internal {
rounds[currentRound].nbTransactions[sender]++;
rounds[currentRound].nbKingdoms[sender]++;
if (kingdomType == 1) {
rounds[currentRound].nbKingdomsType1[sender]++;
rounds[currentRound].jackpot1.balance = rounds[currentRound].jackpot1.balance.add(jackpotSplitted);
} else if (kingdomType == 2) {
rounds[currentRound].nbKingdomsType2[sender]++;
rounds[currentRound].jackpot2.balance = rounds[currentRound].jackpot2.balance.add(jackpotSplitted);
} else if (kingdomType == 3) {
rounds[currentRound].nbKingdomsType3[sender]++;
rounds[currentRound].jackpot3.balance = rounds[currentRound].jackpot3.balance.add(jackpotSplitted);
} else if (kingdomType == 4) {
rounds[currentRound].nbKingdomsType4[sender]++;
rounds[currentRound].jackpot4.balance = rounds[currentRound].jackpot4.balance.add(jackpotSplitted);
} else if (kingdomType == 5) {
rounds[currentRound].nbKingdomsType5[sender]++;
rounds[currentRound].jackpot5.balance = rounds[currentRound].jackpot5.balance.add(jackpotSplitted);
}
setNewWinner(msg.sender, kingdomType);
}
function setLock(string _key, bool _locked) public payable checkKingdomExistence(_key) onlyKingdomOwner(_key, msg.sender) {
if (_locked == true) { require(msg.value >= ACTION_TAX); }
kingdoms[rounds[currentRound].kingdomsKeys[_key]].locked = _locked;
if (msg.value > 0) { asyncSend(bookerAddress, msg.value); }
}
function createKingdom(address owner, string _key, string _title, uint _type, bool _locked) onlyForRemainingKingdoms() public payable {
require(now < rounds[currentRound].endTime);
require(_type > 0);
require(_type < 6);
uint basePrice = STARTING_CLAIM_PRICE_WEI;
uint requiredPrice = basePrice;
if (_locked == true) { requiredPrice = requiredPrice.add(ACTION_TAX); }
require(msg.value >= requiredPrice);
require(rounds[currentRound].kingdomsCreated[_key] == false);
uint refundPrice = STARTING_CLAIM_PRICE_WEI.mul(2);
uint nextMinimumPrice = STARTING_CLAIM_PRICE_WEI.add(refundPrice);
uint kingdomId = kingdoms.push(Kingdom("", "", 1, _type, 0, 0, 1, refundPrice, address(0), false)) - 1;
kingdoms[kingdomId].title = _title;
kingdoms[kingdomId].owner = owner;
kingdoms[kingdomId].key = _key;
kingdoms[kingdomId].minimumPrice = nextMinimumPrice;
kingdoms[kingdomId].locked = _locked;
rounds[currentRound].kingdomsKeys[_key] = kingdomId;
rounds[currentRound].kingdomsCreated[_key] = true;
uint jackpotSplitted = requiredPrice.mul(50).div(100);
rounds[currentRound].globalJackpot.balance = rounds[currentRound].globalJackpot.balance.add(jackpotSplitted);
uint transactionId = kingdomTransactions.push(Transaction("", msg.sender, msg.value, 0, jackpotSplitted)) - 1;
kingdomTransactions[transactionId].kingdomKey = _key;
kingdoms[kingdomId].lastTransaction = transactionId;
setNewJackpot(_type, jackpotSplitted, msg.sender);
LandCreatedEvent(_key, msg.sender);
}
function compensateLatestMonarch(uint lastTransaction, uint compensationWei) internal {
address compensationAddress = kingdomTransactions[lastTransaction].compensationAddress;
kingdomTransactions[lastTransaction].compensation = compensationWei;
asyncSend(compensationAddress, compensationWei);
}
function forceWithdrawPayments(address payee) public onlyOwner {
uint256 payment = payments[payee];
require(payment != 0);
require(this.balance >= payment);
totalPayments = totalPayments.sub(payment);
payments[payee] = 0;
assert(payee.send(payment));
}
function getStartTime() public view returns (uint startTime) {
return rounds[currentRound].startTime;
}
function getEndTime() public view returns (uint endTime) {
return rounds[currentRound].endTime;
}
function payJackpot(uint _type) public checkIsClosed() {
Round storage finishedRound = rounds[currentRound];
if (_type == 1 && finishedRound.jackpot1.winner != address(0) && finishedRound.jackpot1.balance > 0) {
require(this.balance >= finishedRound.jackpot1.balance);
uint jackpot1TeamComission = (finishedRound.jackpot1.balance.mul(TEAM_COMMISSION_RATIO)).div(100);
asyncSend(bookerAddress, jackpot1TeamComission);
asyncSend(finishedRound.jackpot1.winner, finishedRound.jackpot1.balance.sub(jackpot1TeamComission));
finishedRound.jackpot1.balance = 0;
} else if (_type == 2 && finishedRound.jackpot2.winner != address(0) && finishedRound.jackpot2.balance > 0) {
require(this.balance >= finishedRound.jackpot2.balance);
uint jackpot2TeamComission = (finishedRound.jackpot2.balance.mul(TEAM_COMMISSION_RATIO)).div(100);
asyncSend(bookerAddress, jackpot2TeamComission);
asyncSend(finishedRound.jackpot2.winner, finishedRound.jackpot2.balance.sub(jackpot2TeamComission));
finishedRound.jackpot2.balance = 0;
} else if (_type == 3 && finishedRound.jackpot3.winner != address(0) && finishedRound.jackpot3.balance > 0) {
require(this.balance >= finishedRound.jackpot3.balance);
uint jackpot3TeamComission = (finishedRound.jackpot3.balance.mul(TEAM_COMMISSION_RATIO)).div(100);
asyncSend(bookerAddress, jackpot3TeamComission);
asyncSend(finishedRound.jackpot3.winner, finishedRound.jackpot3.balance.sub(jackpot3TeamComission));
finishedRound.jackpot3.balance = 0;
} else if (_type == 4 && finishedRound.jackpot4.winner != address(0) && finishedRound.jackpot4.balance > 0) {
require(this.balance >= finishedRound.jackpot4.balance);
uint jackpot4TeamComission = (finishedRound.jackpot4.balance.mul(TEAM_COMMISSION_RATIO)).div(100);
asyncSend(bookerAddress, jackpot4TeamComission);
asyncSend(finishedRound.jackpot4.winner, finishedRound.jackpot4.balance.sub(jackpot4TeamComission));
finishedRound.jackpot4.balance = 0;
} else if (_type == 5 && finishedRound.jackpot5.winner != address(0) && finishedRound.jackpot5.balance > 0) {
require(this.balance >= finishedRound.jackpot5.balance);
uint jackpot5TeamComission = (finishedRound.jackpot5.balance.mul(TEAM_COMMISSION_RATIO)).div(100);
asyncSend(bookerAddress, jackpot5TeamComission);
asyncSend(finishedRound.jackpot5.winner, finishedRound.jackpot5.balance.sub(jackpot5TeamComission));
finishedRound.jackpot5.balance = 0;
}
if (finishedRound.globalJackpot.winner != address(0) && finishedRound.globalJackpot.balance > 0) {
require(this.balance >= finishedRound.globalJackpot.balance);
uint globalTeamComission = (finishedRound.globalJackpot.balance.mul(TEAM_COMMISSION_RATIO)).div(100);
asyncSend(bookerAddress, globalTeamComission);
asyncSend(finishedRound.globalJackpot.winner, finishedRound.globalJackpot.balance.sub(globalTeamComission));
finishedRound.globalJackpot.balance = 0;
}
}
function activateNextRound() public checkIsClosed() {
Round storage finishedRound = rounds[currentRound];
require(finishedRound.globalJackpot.balance == 0);
require(finishedRound.jackpot5.balance == 0);
require(finishedRound.jackpot4.balance == 0);
require(finishedRound.jackpot3.balance == 0);
require(finishedRound.jackpot2.balance == 0);
require(finishedRound.jackpot1.balance == 0);
currentRound++;
rounds[currentRound] = Round(Jackpot(address(0), 0), Jackpot(address(0), 0), Jackpot(address(0), 0), Jackpot(address(0), 0), Jackpot(address(0), 0), Jackpot(address(0), 0), 0, 0);
rounds[currentRound].startTime = now;
rounds[currentRound].endTime = now + 7 days;
delete kingdoms;
delete kingdomTransactions;
}
function setNewWinner(address _sender, uint _type) internal {
if (rounds[currentRound].globalJackpot.winner == address(0)) {
rounds[currentRound].globalJackpot.winner = _sender;
} else {
if (rounds[currentRound].nbKingdoms[_sender] == rounds[currentRound].nbKingdoms[rounds[currentRound].globalJackpot.winner]) {
if (rounds[currentRound].nbTransactions[_sender] > rounds[currentRound].nbTransactions[rounds[currentRound].globalJackpot.winner]) {
rounds[currentRound].globalJackpot.winner = _sender;
}
} else if (rounds[currentRound].nbKingdoms[_sender] > rounds[currentRound].nbKingdoms[rounds[currentRound].globalJackpot.winner]) {
rounds[currentRound].globalJackpot.winner = _sender;
}
}
setTypedJackpotWinner(_sender, _type);
}
function getJackpot(uint _nb) public view returns (address winner, uint balance, uint winnerCap) {
Round storage round = rounds[currentRound];
if (_nb == 1) {
return (round.jackpot1.winner, round.jackpot1.balance, round.nbKingdomsType1[round.jackpot1.winner]);
} else if (_nb == 2) {
return (round.jackpot2.winner, round.jackpot2.balance, round.nbKingdomsType2[round.jackpot2.winner]);
} else if (_nb == 3) {
return (round.jackpot3.winner, round.jackpot3.balance, round.nbKingdomsType3[round.jackpot3.winner]);
} else if (_nb == 4) {
return (round.jackpot4.winner, round.jackpot4.balance, round.nbKingdomsType4[round.jackpot4.winner]);
} else if (_nb == 5) {
return (round.jackpot5.winner, round.jackpot5.balance, round.nbKingdomsType5[round.jackpot5.winner]);
} else {
return (round.globalJackpot.winner, round.globalJackpot.balance, round.nbKingdoms[round.globalJackpot.winner]);
}
}
function getKingdomCount() public view returns (uint kingdomCount) {
return kingdoms.length;
}
function getKingdomInformations(string kingdomKey) public view returns (string title, uint minimumPrice, uint lastTransaction, uint transactionCount, address currentOwner, bool locked) {
uint kingdomId = rounds[currentRound].kingdomsKeys[kingdomKey];
Kingdom storage kingdom = kingdoms[kingdomId];
return (kingdom.title, kingdom.minimumPrice, kingdom.lastTransaction, kingdom.transactionCount, kingdom.owner, kingdom.locked);
}
}
| 162,845 | 11,533 |
00ad06c862fc471278dfcee4aa785942ab311684e900a1133b464bc5c1751231
| 13,895 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xce650cb2ad12cb4cff730a12524ed9402467a244.sol
| 4,272 | 13,834 |
pragma solidity ^0.4.25;
contract IUserData {
function setUserRef(address _address, address _refAddress, string _gameName) public;
function getUserRef(address _address, string _gameName) public view returns (address);
}
contract Dice_BrickGame {
IUserData userData = IUserData(address(0x21d364b66d9065B5207124e2b1e49e4193e0a2ff));
uint8 public FEE_PERCENT = 2;
uint8 public JACKPOT_PERCENT = 1;
uint constant MIN_JACKPOT = 0.1 ether;
uint public JACKPOT_WIN = 1000;
uint public MIN_BET = 0.01 ether;
uint public MAX_BET = 1 ether;
uint public MAX_PROFIT = 5 ether;
uint public REF_PERCENT = 5;
address public owner;
address private bot;
uint public jackpotFund;
uint public resolve = 0;
uint public payLoan = 0;
struct Bet {
uint blockNumber;
address player;
uint amount;
bytes hexData;
}
struct Loan {
address player;
uint amount;
}
Bet[] public bets;
Loan[] private loans;
event DiceBet(address indexed player, uint amount, uint blockNumber, bytes data, uint8 result, uint reward, uint16 jackpotNumber, uint indexed modulo);
event Jackpot(address indexed player, uint amount);
event JackpotIncrease(uint amount);
event FailedPayment(address indexed beneficiary, uint amount);
event Payment(address indexed beneficiary, uint amount);
event Repayment(address indexed beneficiary, uint amount);
constructor () public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner, "OnlyOwner can call.");
_;
}
modifier onlyBot {
require(msg.sender == bot || msg.sender == owner, "OnlyOwner can call.");
_;
}
function() public payable {
uint8 length = uint8(msg.data.length);
require(length >= 2, "Wrong bet number!");
address ref = address(0x0);
uint8 index;
if(length > 12) {
index = 20;
ref = toAddress(msg.data, 0);
require(ref != msg.sender, "Reference must be different than sender");
} else {
index = 0;
}
uint8 modulo = uint8((msg.data[index] >> 4) & 0xF) * 10 + uint8(msg.data[index] & 0xF);
require(modulo == 2 || modulo == 6 || modulo == 12 || modulo == 0, "Wrong modulo!");
if (modulo == 0) {
modulo = 100;
}
uint8[] memory number = new uint8[](length - index - 1);
for (uint8 j = 0; j < length - index - 1; j++) {
number[j] = uint8((msg.data[j + index + 1] >> 4) & 0xF) * 10 + uint8(msg.data[j + index + 1] & 0xF);
if (modulo == 12) {
require(number[j] > 1 && number[j] <= 12, "Two Dice Confirm!");
} else {
require(number[j] <= modulo, "Wrong number bet!");
if (modulo != 100) {
require(number[j] > 0, "Wrong number bet!");
}
}
}
if (modulo == 100) {
require(number[0] == 0 || number[0] == 1, "Etheroll Confirm!");
require(number[1] > 1 && number[1] < 100, "Etheroll Confirm!");
} else if (modulo == 12) {
require(number.length < 11, "Much number bet!");
} else {
require(number.length < modulo, "Much number bet!");
}
require(msg.value >= MIN_BET && msg.value <= MAX_BET, "Value confirm!");
uint winPossible;
if (modulo == 100) {
if (number[0] == 1) {
winPossible = (100 - number[1]) / number[1] * msg.value * (100 - FEE_PERCENT - (msg.value >= MIN_JACKPOT ? 1 : 0)) / 100;
} else {
winPossible = (number[1] - 1) / (101 - number[1]) * msg.value * (100 - FEE_PERCENT - (msg.value >= MIN_JACKPOT ? 1 : 0)) / 100;
}
} else {
if (modulo == 12) {
winPossible = ((modulo - 1 - number.length) / number.length + 1) * msg.value * (100 - FEE_PERCENT - (msg.value >= MIN_JACKPOT ? 1 : 0)) / 100;
} else {
winPossible = ((modulo - number.length) / number.length + 1) * msg.value * (100 - FEE_PERCENT - (msg.value >= MIN_JACKPOT ? 1 : 0)) / 100;
}
}
require(winPossible <= MAX_PROFIT);
if(userData.getUserRef(msg.sender, "Dice") != address(0x0)) {
userData.getUserRef(msg.sender, "Dice").transfer(msg.value * REF_PERCENT / 1000);
} else if(ref != address(0x0)) {
ref.transfer(msg.value * REF_PERCENT / 1000);
userData.setUserRef(msg.sender, ref, "Dice");
}
bets.length++;
bets[bets.length - 1].blockNumber = block.number;
bets[bets.length - 1].player = msg.sender;
bets[bets.length - 1].amount = msg.value;
bets[bets.length - 1].hexData.length = length - index;
for(j = 0; j < bets[bets.length - 1].hexData.length; j++){
bets[bets.length - 1].hexData[j] = msg.data[j + index];
}
}
function setBot(address _bot) public onlyOwner {
require(_bot != address(0x0));
bot = _bot;
}
function setConfig(uint8 _FEE_PERCENT, uint8 _JACKPOT_PERCENT, uint _MAX_PROFIT, uint _MIN_BET, uint _MAX_BET, uint _JACKPOT_WIN, uint8 _REF_PERCENT) public onlyOwner {
FEE_PERCENT = _FEE_PERCENT;
JACKPOT_PERCENT = _JACKPOT_PERCENT;
MAX_PROFIT = _MAX_PROFIT;
MIN_BET = _MIN_BET;
MAX_BET = _MAX_BET;
MAX_PROFIT = _MAX_PROFIT;
JACKPOT_WIN = _JACKPOT_WIN;
REF_PERCENT = _REF_PERCENT;
}
function increaseJackpot(uint increaseAmount) external onlyOwner {
require(increaseAmount <= address(this).balance, "Not enough funds");
jackpotFund += uint(increaseAmount);
emit JackpotIncrease(jackpotFund);
}
function withdrawFunds(address beneficiary, uint withdrawAmount) external onlyOwner {
require(withdrawAmount <= address(this).balance, "Not enough funds");
require(jackpotFund + withdrawAmount <= address(this).balance, "Not enough funds.");
sendFunds(beneficiary, withdrawAmount);
}
function kill() external onlyOwner {
sendFunds(owner, address(this).balance);
selfdestruct(owner);
}
function doBet(uint gameNumber) private {
uint8 modulo = uint8((bets[gameNumber].hexData[0] >> 4) & 0xF) * 10 + uint8(bets[gameNumber].hexData[0] & 0xF);
uint8 result;
if (modulo == 12) {
uint8 dice1 = uint8(keccak256(abi.encodePacked(bets[gameNumber].hexData, blockhash(bets[gameNumber].blockNumber)))) % 6;
uint8 dice2 = uint8(keccak256(abi.encodePacked(address(this).balance, blockhash(bets[gameNumber].blockNumber), bets[gameNumber].player))) % 6;
result = (dice1 == 0 ? 6 : dice1) + (dice2 == 0 ? 6 : dice2);
} else {
result = uint8(keccak256(abi.encodePacked(bets[gameNumber].hexData, address(this).balance, blockhash(bets[gameNumber].blockNumber), bets[gameNumber].player))) % modulo;
}
if (result == 0) {
result = modulo;
}
uint winValue = 0;
uint8[] memory number = new uint8[](bets[gameNumber].hexData.length - 1);
for (uint8 j = 0; j < bets[gameNumber].hexData.length - 1; j++) {
number[j] = uint8((bets[gameNumber].hexData[j + 1] >> 4) & 0xF) * 10 + uint8(bets[gameNumber].hexData[j + 1] & 0xF);
}
for (uint8 i = 0; i < number.length; i++) {
if (number[i] == result) {
if (modulo == 12) {
winValue = bets[gameNumber].amount * (100 - FEE_PERCENT) / 100 + (modulo - 1 - number.length) * bets[gameNumber].amount * (100 - FEE_PERCENT) / (100 * number.length);
} else {
winValue = bets[gameNumber].amount * (100 - FEE_PERCENT) / 100 + (modulo - number.length) * bets[gameNumber].amount * (100 - FEE_PERCENT) / (100 * number.length);
}
break;
}
}
if (bets[gameNumber].amount >= MIN_JACKPOT) {
jackpotFund += bets[gameNumber].amount * JACKPOT_PERCENT / 100;
emit JackpotIncrease(jackpotFund);
if (winValue != 0) {
winValue = bets[gameNumber].amount * (100 - FEE_PERCENT - JACKPOT_PERCENT) / 100 + (modulo - number.length) * bets[gameNumber].amount * (100 - FEE_PERCENT - JACKPOT_PERCENT) / (100 * number.length);
}
uint16 jackpotNumber = uint16(uint(keccak256(abi.encodePacked(bets[gameNumber].player, winValue, blockhash(bets[gameNumber].blockNumber), bets[gameNumber].hexData))) % JACKPOT_WIN);
if (jackpotNumber == 999) {
emit Jackpot(bets[gameNumber].player, jackpotFund);
sendFunds(bets[gameNumber].player, jackpotFund + winValue);
jackpotFund = 0;
} else {
if (winValue > 0) {
sendFunds(bets[gameNumber].player, winValue);
}
}
} else {
if (winValue > 0) {
sendFunds(bets[gameNumber].player, winValue);
}
}
emit DiceBet(bets[gameNumber].player, bets[gameNumber].amount, bets[gameNumber].blockNumber, bets[gameNumber].hexData, result, winValue, jackpotNumber, modulo);
}
function etheRoll(uint gameNumber) private {
uint8 result = uint8(keccak256(abi.encodePacked(bets[gameNumber].hexData, blockhash(bets[gameNumber].blockNumber), bets[gameNumber].player))) % 100;
if (result == 0) {
result = 100;
}
uint winValue = 0;
uint8[] memory number = new uint8[](bets[gameNumber].hexData.length - 1);
for (uint8 j = 0; j < bets[gameNumber].hexData.length - 1; j++) {
number[j] = uint8((bets[gameNumber].hexData[j + 1] >> 4) & 0xF) * 10 + uint8(bets[gameNumber].hexData[j + 1] & 0xF);
}
if (number[0] == 0 && number[1] >= result) {
winValue = bets[gameNumber].amount * (100 - FEE_PERCENT) / 100 + (100 - uint(number[1])) * bets[gameNumber].amount * (100 - FEE_PERCENT) / (100 * uint(number[1]));
}
if (number[0] == 1 && number[1] <= result) {
winValue = bets[gameNumber].amount * (100 - FEE_PERCENT) / 100 + (uint(number[1]) - 1) * bets[gameNumber].amount * (100 - FEE_PERCENT) / (100 * (101 - uint(number[1])));
}
if (bets[gameNumber].amount >= MIN_JACKPOT) {
jackpotFund += bets[gameNumber].amount * JACKPOT_PERCENT / 100;
emit JackpotIncrease(jackpotFund);
if (number[0] == 0 && number[1] >= result) {
winValue = bets[gameNumber].amount * (100 - FEE_PERCENT - JACKPOT_PERCENT) / 100 + (100 - uint(number[1])) * bets[gameNumber].amount * (100 - FEE_PERCENT - JACKPOT_PERCENT) / (100 * uint(number[1]));
}
if (number[0] == 1 && number[1] <= result) {
winValue = bets[gameNumber].amount * (100 - FEE_PERCENT - JACKPOT_PERCENT) / 100 + (uint(number[1]) - 1) * bets[gameNumber].amount * (100 - FEE_PERCENT - JACKPOT_PERCENT) / (100 * (101 - uint(number[1])));
}
uint16 jackpotNumber = uint16(uint(keccak256(abi.encodePacked(bets[gameNumber].hexData, winValue, blockhash(bets[gameNumber].blockNumber), bets[gameNumber].player))) % JACKPOT_WIN);
if (jackpotNumber == 999) {
emit Jackpot(bets[gameNumber].player, jackpotFund);
sendFunds(bets[gameNumber].player, jackpotFund + winValue);
jackpotFund = 0;
} else {
if (winValue > 0) {
sendFunds(bets[gameNumber].player, winValue);
}
}
} else {
if (winValue > 0) {
sendFunds(bets[gameNumber].player, winValue);
}
}
emit DiceBet(bets[gameNumber].player, bets[gameNumber].amount, bets[gameNumber].blockNumber, bets[gameNumber].hexData, result, winValue, jackpotNumber, 100);
}
function resolveBet() public onlyBot {
uint i = 0;
for (uint k = resolve; k < bets.length; k++) {
uint8 modulo = uint8((bets[k].hexData[0] >> 4) & 0xF) * 10 + uint8(bets[k].hexData[0] & 0xF);
if (modulo == 0) {
modulo = 100;
}
if (bets[k].blockNumber <= (block.number - 1)) {
if (modulo == 100) {
etheRoll(k);
i++;
} else {
doBet(k);
i++;
}
} else {
break;
}
}
resolve += i;
}
function addBalance() public payable {}
function sendFunds(address beneficiary, uint amount) private {
if (beneficiary.send(amount)) {
emit Payment(beneficiary, amount);
} else {
emit FailedPayment(beneficiary, amount);
loans.push(Loan(beneficiary, amount));
}
}
function payLoan() public onlyBot {
uint pay = 0;
for (uint i = payLoan; i < loans.length; i++) {
if (loans[i].player.send(loans[i].amount)) {
emit Repayment(loans[i].player, loans[i].amount);
pay++;
} else {
break;
}
}
payLoan += pay;
}
function getLengthBets() public view returns (uint) {
return bets.length;
}
function toAddress(bytes _bytes, uint _start) internal pure returns (address) {
require(_bytes.length >= (_start + 20),"Wrong size!");
address tempAddress;
assembly {
tempAddress := div(mload(add(add(_bytes, 0x20), _start)), 0x1000000000000000000000000)
}
return tempAddress;
}
}
| 163,136 | 11,534 |
bb22e85c9e145796b44b970280eae64935386965dd639a9d64c5db43b2aa5873
| 20,849 |
.sol
|
Solidity
| false |
443847069
|
JellyProtocol/JellyResearch
|
d453ec0c162eb5d6aa6f4ac8776b363cd52b6b36
|
contracts/Curvefi/MultiRewards.sol
| 3,812 | 15,225 |
pragma solidity 0.5.17;
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;
}
}
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 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);
}
}
contract Owned {
address public owner;
address public nominatedOwner;
constructor(address _owner) public {
require(_owner != address(0), "Owner address cannot be 0");
owner = _owner;
emit OwnerChanged(address(0), _owner);
}
function nominateNewOwner(address _owner) external onlyOwner {
nominatedOwner = _owner;
emit OwnerNominated(_owner);
}
function acceptOwnership() external {
require(msg.sender == nominatedOwner, "You must be nominated before you can accept ownership");
emit OwnerChanged(owner, nominatedOwner);
owner = nominatedOwner;
nominatedOwner = address(0);
}
modifier onlyOwner {
_onlyOwner();
_;
}
function _onlyOwner() private view {
require(msg.sender == owner, "Only the contract owner may perform this action");
}
event OwnerNominated(address newOwner);
event OwnerChanged(address oldOwner, address newOwner);
}
contract Pausable is Owned {
uint public lastPauseTime;
bool public paused;
constructor() internal {
// This contract is abstract, and thus cannot be instantiated directly
require(owner != address(0), "Owner must be set");
// Paused will be false, and lastPauseTime will be 0 upon initialisation
}
function setPaused(bool _paused) external onlyOwner {
// Ensure we're actually changing the state before we do anything
if (_paused == paused) {
return;
}
// Set our paused state.
paused = _paused;
// If applicable, set the last pause time.
if (paused) {
lastPauseTime = now;
}
// Let everyone know that our pause state has changed.
emit PauseChanged(paused);
}
event PauseChanged(bool isPaused);
modifier notPaused {
require(!paused, "This action cannot be performed while the contract is paused");
_;
}
}
contract ReentrancyGuard {
/// @dev counter to allow mutex lock with only one SSTORE operation
uint256 private _guardCounter;
constructor () internal {
// The counter starts at one to prevent changing it from zero to a non-zero
// value, which is a more expensive operation.
_guardCounter = 1;
}
modifier nonReentrant() {
_guardCounter += 1;
uint256 localCounter = _guardCounter;
_;
require(localCounter == _guardCounter, "ReentrancyGuard: reentrant call");
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
contract MultiRewards is ReentrancyGuard, Pausable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
struct Reward {
address rewardsDistributor;
uint256 rewardsDuration;
uint256 periodFinish;
uint256 rewardRate;
uint256 lastUpdateTime;
uint256 rewardPerTokenStored;
}
IERC20 public stakingToken;
mapping(address => Reward) public rewardData;
address[] public rewardTokens;
// user -> reward token -> amount
mapping(address => mapping(address => uint256)) public userRewardPerTokenPaid;
mapping(address => mapping(address => uint256)) public rewards;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
constructor(address _owner,
address _stakingToken) public Owned(_owner) {
stakingToken = IERC20(_stakingToken);
}
function addReward(address _rewardsToken,
address _rewardsDistributor,
uint256 _rewardsDuration)
public
onlyOwner
{
require(rewardData[_rewardsToken].rewardsDuration == 0);
rewardTokens.push(_rewardsToken);
rewardData[_rewardsToken].rewardsDistributor = _rewardsDistributor;
rewardData[_rewardsToken].rewardsDuration = _rewardsDuration;
}
function totalSupply() external view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view returns (uint256) {
return _balances[account];
}
function lastTimeRewardApplicable(address _rewardsToken) public view returns (uint256) {
return Math.min(block.timestamp, rewardData[_rewardsToken].periodFinish);
}
function rewardPerToken(address _rewardsToken) public view returns (uint256) {
if (_totalSupply == 0) {
return rewardData[_rewardsToken].rewardPerTokenStored;
}
return
rewardData[_rewardsToken].rewardPerTokenStored.add(lastTimeRewardApplicable(_rewardsToken).sub(rewardData[_rewardsToken].lastUpdateTime).mul(rewardData[_rewardsToken].rewardRate).mul(1e18).div(_totalSupply));
}
function earned(address account, address _rewardsToken) public view returns (uint256) {
return _balances[account].mul(rewardPerToken(_rewardsToken).sub(userRewardPerTokenPaid[account][_rewardsToken])).div(1e18).add(rewards[account][_rewardsToken]);
}
function getRewardForDuration(address _rewardsToken) external view returns (uint256) {
return rewardData[_rewardsToken].rewardRate.mul(rewardData[_rewardsToken].rewardsDuration);
}
function setRewardsDistributor(address _rewardsToken, address _rewardsDistributor) external onlyOwner {
rewardData[_rewardsToken].rewardsDistributor = _rewardsDistributor;
}
function stake(uint256 amount) external nonReentrant notPaused updateReward(msg.sender) {
require(amount > 0, "Cannot stake 0");
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
stakingToken.safeTransferFrom(msg.sender, address(this), amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public nonReentrant updateReward(msg.sender) {
require(amount > 0, "Cannot withdraw 0");
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
stakingToken.safeTransfer(msg.sender, amount);
emit Withdrawn(msg.sender, amount);
}
function getReward() public nonReentrant updateReward(msg.sender) {
for (uint i; i < rewardTokens.length; i++) {
address _rewardsToken = rewardTokens[i];
uint256 reward = rewards[msg.sender][_rewardsToken];
if (reward > 0) {
rewards[msg.sender][_rewardsToken] = 0;
IERC20(_rewardsToken).safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, _rewardsToken, reward);
}
}
}
function exit() external {
withdraw(_balances[msg.sender]);
getReward();
}
function notifyRewardAmount(address _rewardsToken, uint256 reward) external updateReward(address(0)) {
require(rewardData[_rewardsToken].rewardsDistributor == msg.sender);
// handle the transfer of reward tokens via `transferFrom` to reduce the number
// of transactions required and ensure correctness of the reward amount
IERC20(_rewardsToken).safeTransferFrom(msg.sender, address(this), reward);
if (block.timestamp >= rewardData[_rewardsToken].periodFinish) {
rewardData[_rewardsToken].rewardRate = reward.div(rewardData[_rewardsToken].rewardsDuration);
} else {
uint256 remaining = rewardData[_rewardsToken].periodFinish.sub(block.timestamp);
uint256 leftover = remaining.mul(rewardData[_rewardsToken].rewardRate);
rewardData[_rewardsToken].rewardRate = reward.add(leftover).div(rewardData[_rewardsToken].rewardsDuration);
}
rewardData[_rewardsToken].lastUpdateTime = block.timestamp;
rewardData[_rewardsToken].periodFinish = block.timestamp.add(rewardData[_rewardsToken].rewardsDuration);
emit RewardAdded(reward);
}
// Added to support recovering LP Rewards from other systems such as BAL to be distributed to holders
function recoverERC20(address tokenAddress, uint256 tokenAmount) external onlyOwner {
require(tokenAddress != address(stakingToken), "Cannot withdraw staking token");
require(rewardData[tokenAddress].lastUpdateTime == 0, "Cannot withdraw reward token");
IERC20(tokenAddress).safeTransfer(owner, tokenAmount);
emit Recovered(tokenAddress, tokenAmount);
}
function setRewardsDuration(address _rewardsToken, uint256 _rewardsDuration) external {
require(block.timestamp > rewardData[_rewardsToken].periodFinish,
"Reward period still active");
require(rewardData[_rewardsToken].rewardsDistributor == msg.sender);
require(_rewardsDuration > 0, "Reward duration must be non-zero");
rewardData[_rewardsToken].rewardsDuration = _rewardsDuration;
emit RewardsDurationUpdated(_rewardsToken, rewardData[_rewardsToken].rewardsDuration);
}
modifier updateReward(address account) {
for (uint i; i < rewardTokens.length; i++) {
address token = rewardTokens[i];
rewardData[token].rewardPerTokenStored = rewardPerToken(token);
rewardData[token].lastUpdateTime = lastTimeRewardApplicable(token);
if (account != address(0)) {
rewards[account][token] = earned(account, token);
userRewardPerTokenPaid[account][token] = rewardData[token].rewardPerTokenStored;
}
}
_;
}
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, address indexed rewardsToken, uint256 reward);
event RewardsDurationUpdated(address token, uint256 newDuration);
event Recovered(address token, uint256 amount);
}
| 20,831 | 11,535 |
2365e93370c3cd481ae1dcc986917e8c3c92849cb7aa49f7450e74d109c22986
| 19,502 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/1c/1C67E94B1e094fabCCB3681b1124293d008FfCE6_CR7AVAC.sol
| 3,998 | 14,609 |
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.14;
interface IERC20
{
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
abstract contract ReentrancyGuard {
bool internal locked;
modifier noReentrant() {
require(!locked, "No re-entrancy");
locked = true;
_;
locked = false;
}
}
contract CR7AVAC is Context, Ownable , ReentrancyGuard {
using SafeMath for uint256;
uint256 public constant min = 0.01 ether;
uint256 public constant max = 100000 ether;
uint256 public roi = 17;
uint256 public constant fee = 6;
uint256 public constant withdraw_fee = 10;
uint256 public constant ref_fee = 7;
address public dev = 0xbeace5E5Af8D25EA855C632b71971A80A47E126E;
address public tokenAdress;
bool public init = false;
bool public alreadyInvested = false;
struct refferal_system {
address ref_address;
uint256 reward;
}
struct refferal_withdraw {
address ref_address;
uint256 totalWithdraw;
}
struct user_investment_details {
address user_address;
uint256 invested;
}
struct weeklyWithdraw {
address user_address;
uint256 startTime;
uint256 deadline;
}
struct claimDaily {
address user_address;
uint256 startTime;
uint256 deadline;
}
struct userWithdrawal {
address user_address;
uint256 amount;
}
struct userTotalWithdraw {
address user_address;
uint256 amount;
}
struct userTotalRewards {
address user_address;
uint256 amount;
}
mapping(address => refferal_system) public refferal;
mapping(address => user_investment_details) public investments;
mapping(address => weeklyWithdraw) public weekly;
mapping(address => claimDaily) public claimTime;
mapping(address => userWithdrawal) public approvedWithdrawal;
mapping(address => userTotalWithdraw) public totalWithdraw;
mapping(address => userTotalRewards) public totalRewards;
mapping(address => refferal_withdraw) public refTotalWithdraw;
// invest function
function deposit(address _ref, uint256 _amount) public noReentrant {
require(init, "Not Started Yet");
require(_amount>=min && _amount <= max, "Cannot Deposit");
if(!checkAlready()){
uint256 ref_fee_add = refFee(_amount);
if(_ref != address(0) && _ref != msg.sender) {
uint256 ref_last_balance = refferal[_ref].reward;
uint256 totalRefFee = SafeMath.add(ref_fee_add,ref_last_balance);
refferal[_ref] = refferal_system(_ref,totalRefFee);
}
else {
uint256 ref_last_balance = refferal[dev].reward;
uint256 totalRefFee = SafeMath.add(ref_fee_add,ref_last_balance);
refferal[dev] = refferal_system(dev,totalRefFee);
}
// investment details
uint256 userLastInvestment = investments[msg.sender].invested;
uint256 userCurrentInvestment = _amount;
uint256 totalInvestment = SafeMath.add(userLastInvestment,userCurrentInvestment);
investments[msg.sender] = user_investment_details(msg.sender,totalInvestment);
// weekly withdraw
uint256 weeklyStart = block.timestamp;
uint256 deadline_weekly = block.timestamp + 7 days;
weekly[msg.sender] = weeklyWithdraw(msg.sender,weeklyStart,deadline_weekly);
// Claim Setting
uint256 claimTimeStart = block.timestamp;
uint256 claimTimeEnd = block.timestamp + 1 days;
claimTime[msg.sender] = claimDaily(msg.sender,claimTimeStart,claimTimeEnd);
// fees
uint256 total_fee = depositFee(_amount);
uint256 total_contract = SafeMath.sub(_amount,total_fee);
}
else {
uint256 ref_fee_add = refFee(_amount);
if(_ref != address(0) && _ref != msg.sender) {
uint256 ref_last_balance = refferal[_ref].reward;
uint256 totalRefFee = SafeMath.add(ref_fee_add,ref_last_balance);
refferal[_ref] = refferal_system(_ref,totalRefFee);
}
else {
uint256 ref_last_balance = refferal[dev].reward;
uint256 totalRefFee = SafeMath.add(ref_fee_add,ref_last_balance);
refferal[dev] = refferal_system(dev,totalRefFee);
}
// investment details
uint256 userLastInvestment = investments[msg.sender].invested;
uint256 userCurrentInvestment = _amount;
uint256 totalInvestment = SafeMath.add(userLastInvestment,userCurrentInvestment);
investments[msg.sender] = user_investment_details(msg.sender,totalInvestment);
// weekly withdraw
// uint256 weeklyStart = block.timestamp;
// uint256 deadline_weekly = block.timestamp + 7 days;
// weekly[msg.sender] = weeklyWithdraw(msg.sender,weeklyStart,deadline_weekly);
// Claim Setting
//uint256 claimTimeStart = block.timestamp;
// uint256 claimTimeEnd = block.timestamp + 1 days;
// claimTime[msg.sender] = claimDaily(msg.sender,claimTimeStart,claimTimeEnd);
// fees
uint256 total_fee = depositFee(_amount);
uint256 total_contract = SafeMath.sub(_amount,total_fee);
}
}
function userReward(address _userAddress) public view returns(uint256) {
uint256 userInvestment = investments[_userAddress].invested;
uint256 userDailyReturn = DailyRoi(userInvestment);
// invested time
uint256 claimInvestTime = claimTime[_userAddress].startTime;
uint256 claimInvestEnd = claimTime[_userAddress].deadline;
uint256 totalTime = SafeMath.sub(claimInvestEnd,claimInvestTime);
uint256 value = SafeMath.div(userDailyReturn,totalTime);
uint256 nowTime = block.timestamp;
if(claimInvestEnd>= nowTime) {
uint256 earned = SafeMath.sub(nowTime,claimInvestTime);
uint256 totalEarned = SafeMath.mul(earned, value);
return totalEarned;
}
else {
return userDailyReturn;
}
}
function withdrawal() public noReentrant {
require(init, "Not Started Yet");
require(weekly[msg.sender].deadline <= block.timestamp, "You cant withdraw");
require(totalRewards[msg.sender].amount <= SafeMath.mul(investments[msg.sender].invested,5), "You cant withdraw you have collected five times Already"); // hh new
uint256 aval_withdraw = approvedWithdrawal[msg.sender].amount;
uint256 aval_withdraw2 = SafeMath.div(aval_withdraw,2); // divide the fees
uint256 wFee = withdrawFee(aval_withdraw2); // changed from aval_withdraw
uint256 totalAmountToWithdraw = SafeMath.sub(aval_withdraw2,wFee); // changed from aval_withdraw to aval_withdraw2
approvedWithdrawal[msg.sender] = userWithdrawal(msg.sender,aval_withdraw2); // changed from 0 to half of the amount stay in in his contract
uint256 weeklyStart = block.timestamp;
uint256 deadline_weekly = block.timestamp + 7 days;
weekly[msg.sender] = weeklyWithdraw(msg.sender,weeklyStart,deadline_weekly);
uint256 amount = totalWithdraw[msg.sender].amount;
uint256 totalAmount = SafeMath.add(amount,aval_withdraw2); // it will add one of his half to total withdraw
totalWithdraw[msg.sender] = userTotalWithdraw(msg.sender,totalAmount);
}
function claimDailyRewards() public noReentrant{
require(init, "Not Started Yet");
require(claimTime[msg.sender].deadline <= block.timestamp, "You cant claim");
uint256 rewards = userReward(msg.sender);
uint256 currentApproved = approvedWithdrawal[msg.sender].amount;
uint256 value = SafeMath.add(rewards,currentApproved);
approvedWithdrawal[msg.sender] = userWithdrawal(msg.sender,value);
uint256 amount = totalRewards[msg.sender].amount; //hhnew
uint256 totalRewardAmount = SafeMath.add(amount,rewards); //hhnew
totalRewards[msg.sender].amount=totalRewardAmount;
uint256 claimTimeStart = block.timestamp;
uint256 claimTimeEnd = block.timestamp + 1 days;
claimTime[msg.sender] = claimDaily(msg.sender,claimTimeStart,claimTimeEnd);
}
function unStake() external noReentrant {
require(init, "Not Started Yet");
uint256 I_investment = investments[msg.sender].invested;
uint256 t_withdraw = totalWithdraw[msg.sender].amount;
require(I_investment > t_withdraw, "You already withdraw a lot than your investment");
uint256 lastFee = depositFee(I_investment);
uint256 currentBalance = SafeMath.sub(I_investment,lastFee);
uint256 UnstakeValue = SafeMath.sub(currentBalance,t_withdraw);
uint256 UnstakeValueCore = SafeMath.div(UnstakeValue,2);
investments[msg.sender] = user_investment_details(msg.sender,0);
approvedWithdrawal[msg.sender] = userWithdrawal(msg.sender,0);
}
function Ref_Withdraw() external noReentrant {
require(init, "Not Started Yet");
uint256 value = refferal[msg.sender].reward;
refferal[msg.sender] = refferal_system(msg.sender,0);
uint256 lastWithdraw = refTotalWithdraw[msg.sender].totalWithdraw;
uint256 totalValue = SafeMath.add(value,lastWithdraw);
refTotalWithdraw[msg.sender] = refferal_withdraw(msg.sender,totalValue);
}
// initialized the market
function signal_market() public onlyOwner {
init = true;
}
// other functions
function DailyRoi(uint256 _amount) public view returns(uint256) {
return SafeMath.div(SafeMath.mul(_amount,roi),100);
}
function checkAlready() public view returns(bool) {
address _address= msg.sender;
if(investments[_address].user_address==_address){
return true;
}
else{
return false;
}
}
function depositFee(uint256 _amount) public pure returns(uint256){
return SafeMath.div(SafeMath.mul(_amount,fee),100);
}
function refFee(uint256 _amount) public pure returns(uint256) {
return SafeMath.div(SafeMath.mul(_amount,ref_fee),100);
}
function withdrawFee(uint256 _amount) public pure returns(uint256) {
return SafeMath.div(SafeMath.mul(_amount,withdraw_fee),100);
}
function getBalance() public view returns(uint256){
}
}
| 127,288 | 11,536 |
e2b0d9694254bd9474aecb0968451f43a9c04e1757642c5e83a4beade3deba94
| 18,705 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xc8a66fe965f4e1f009c1a43f5c61ae2672dfcfbb.sol
| 4,613 | 17,707 |
pragma solidity 0.4.18;
// File: contracts/ERC20Interface.sol
// https://github.com/ethereum/EIPs/issues/20
interface ERC20 {
function totalSupply() public view returns (uint supply);
function balanceOf(address _owner) public view returns (uint balance);
function transfer(address _to, uint _value) public returns (bool success);
function transferFrom(address _from, address _to, uint _value) public returns (bool success);
function approve(address _spender, uint _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint remaining);
function decimals() public view returns(uint digits);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
// File: contracts/ConversionRatesInterface.sol
interface ConversionRatesInterface {
function recordImbalance(ERC20 token,
int buyAmount,
uint rateUpdateBlock,
uint currentBlock)
public;
function getRate(ERC20 token, uint currentBlockNumber, bool buy, uint qty) public view returns(uint);
}
// File: contracts/KyberReserveInterface.sol
/// @title Kyber Reserve contract
interface KyberReserveInterface {
function trade(ERC20 srcToken,
uint srcAmount,
ERC20 destToken,
address destAddress,
uint conversionRate,
bool validate)
public
payable
returns(bool);
function getConversionRate(ERC20 src, ERC20 dest, uint srcQty, uint blockNumber) public view returns(uint);
}
// File: contracts/SanityRatesInterface.sol
interface SanityRatesInterface {
function getSanityRate(ERC20 src, ERC20 dest) public view returns(uint);
}
// File: contracts/Utils.sol
/// @title Kyber constants contract
contract Utils {
ERC20 constant internal ETH_TOKEN_ADDRESS = ERC20(0x00eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee);
uint constant internal PRECISION = (10**18);
uint constant internal MAX_QTY = (10**28); // 10B tokens
uint constant internal MAX_RATE = (PRECISION * 10**6); // up to 1M tokens per ETH
uint constant internal MAX_DECIMALS = 18;
uint constant internal ETH_DECIMALS = 18;
mapping(address=>uint) internal decimals;
function setDecimals(ERC20 token) internal {
if (token == ETH_TOKEN_ADDRESS) decimals[token] = ETH_DECIMALS;
else decimals[token] = token.decimals();
}
function getDecimals(ERC20 token) internal view returns(uint) {
if (token == ETH_TOKEN_ADDRESS) return ETH_DECIMALS; // save storage access
uint tokenDecimals = decimals[token];
// technically, there might be token with decimals 0
// moreover, very possible that old tokens have decimals 0
// these tokens will just have higher gas fees.
if(tokenDecimals == 0) return token.decimals();
return tokenDecimals;
}
function calcDstQty(uint srcQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns(uint) {
require(srcQty <= MAX_QTY);
require(rate <= MAX_RATE);
if (dstDecimals >= srcDecimals) {
require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
return (srcQty * rate * (10**(dstDecimals - srcDecimals))) / PRECISION;
} else {
require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
return (srcQty * rate) / (PRECISION * (10**(srcDecimals - dstDecimals)));
}
}
function calcSrcQty(uint dstQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns(uint) {
require(dstQty <= MAX_QTY);
require(rate <= MAX_RATE);
//source quantity is rounded up. to avoid dest quantity being too low.
uint numerator;
uint denominator;
if (srcDecimals >= dstDecimals) {
require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
numerator = (PRECISION * dstQty * (10**(srcDecimals - dstDecimals)));
denominator = rate;
} else {
require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
numerator = (PRECISION * dstQty);
denominator = (rate * (10**(dstDecimals - srcDecimals)));
}
return (numerator + denominator - 1) / denominator; //avoid rounding down errors
}
}
// File: contracts/PermissionGroups.sol
contract PermissionGroups {
address public admin;
address public pendingAdmin;
mapping(address=>bool) internal operators;
mapping(address=>bool) internal alerters;
address[] internal operatorsGroup;
address[] internal alertersGroup;
uint constant internal MAX_GROUP_SIZE = 50;
function PermissionGroups() public {
admin = msg.sender;
}
modifier onlyAdmin() {
require(msg.sender == admin);
_;
}
modifier onlyOperator() {
require(operators[msg.sender]);
_;
}
modifier onlyAlerter() {
require(alerters[msg.sender]);
_;
}
function getOperators () external view returns(address[]) {
return operatorsGroup;
}
function getAlerters () external view returns(address[]) {
return alertersGroup;
}
event TransferAdminPending(address pendingAdmin);
function transferAdmin(address newAdmin) public onlyAdmin {
require(newAdmin != address(0));
TransferAdminPending(pendingAdmin);
pendingAdmin = newAdmin;
}
function transferAdminQuickly(address newAdmin) public onlyAdmin {
require(newAdmin != address(0));
TransferAdminPending(newAdmin);
AdminClaimed(newAdmin, admin);
admin = newAdmin;
}
event AdminClaimed(address newAdmin, address previousAdmin);
function claimAdmin() public {
require(pendingAdmin == msg.sender);
AdminClaimed(pendingAdmin, admin);
admin = pendingAdmin;
pendingAdmin = address(0);
}
event AlerterAdded (address newAlerter, bool isAdd);
function addAlerter(address newAlerter) public onlyAdmin {
require(!alerters[newAlerter]); // prevent duplicates.
require(alertersGroup.length < MAX_GROUP_SIZE);
AlerterAdded(newAlerter, true);
alerters[newAlerter] = true;
alertersGroup.push(newAlerter);
}
function removeAlerter (address alerter) public onlyAdmin {
require(alerters[alerter]);
alerters[alerter] = false;
for (uint i = 0; i < alertersGroup.length; ++i) {
if (alertersGroup[i] == alerter) {
alertersGroup[i] = alertersGroup[alertersGroup.length - 1];
alertersGroup.length--;
AlerterAdded(alerter, false);
break;
}
}
}
event OperatorAdded(address newOperator, bool isAdd);
function addOperator(address newOperator) public onlyAdmin {
require(!operators[newOperator]); // prevent duplicates.
require(operatorsGroup.length < MAX_GROUP_SIZE);
OperatorAdded(newOperator, true);
operators[newOperator] = true;
operatorsGroup.push(newOperator);
}
function removeOperator (address operator) public onlyAdmin {
require(operators[operator]);
operators[operator] = false;
for (uint i = 0; i < operatorsGroup.length; ++i) {
if (operatorsGroup[i] == operator) {
operatorsGroup[i] = operatorsGroup[operatorsGroup.length - 1];
operatorsGroup.length -= 1;
OperatorAdded(operator, false);
break;
}
}
}
}
// File: contracts/Withdrawable.sol
contract Withdrawable is PermissionGroups {
event TokenWithdraw(ERC20 token, uint amount, address sendTo);
function withdrawToken(ERC20 token, uint amount, address sendTo) external onlyAdmin {
require(token.transfer(sendTo, amount));
TokenWithdraw(token, amount, sendTo);
}
event EtherWithdraw(uint amount, address sendTo);
function withdrawEther(uint amount, address sendTo) external onlyAdmin {
sendTo.transfer(amount);
EtherWithdraw(amount, sendTo);
}
}
// File: contracts/DigixReserve.sol
interface MakerDao {
function peek() public view returns (bytes32, bool);
}
contract DigixReserve is KyberReserveInterface, Withdrawable, Utils {
ERC20 public digix;
MakerDao public makerDaoContract;
ConversionRatesInterface public conversionRatesContract;
SanityRatesInterface public sanityRatesContract;
address public kyberNetwork;
uint maxBlockDrift = 300;
mapping(bytes32=>bool) public approvedWithdrawAddresses; // sha3(token,address)=>bool
uint public priceFeed;
bool public tradeEnabled;
uint constant internal POW_2_64 = 2 ** 64;
uint constant internal etherWei = 10 ** 18;
uint public buyTransferFee = 13;
uint public sellTransferFee = 13;
function DigixReserve(address _admin, address _kyberNetwork, ERC20 _digix) public{
require(_admin != address(0));
require(_digix != address(0));
require(_kyberNetwork != address(0));
admin = _admin;
digix = _digix;
setDecimals(digix);
kyberNetwork = _kyberNetwork;
sanityRatesContract = SanityRatesInterface(0);
conversionRatesContract = ConversionRatesInterface(0x901d);
tradeEnabled = true;
}
function () public payable {}
/// @dev Add digix price feed. Valid for @maxBlockDrift blocks
/// @param blockNumber the block this price feed was signed.
/// @param nonce the nonce with which this block was signed.
/// @param ask1KDigix ask price dollars per Kg gold == 1000 digix
/// @param bid1KDigix bid price dollars per KG gold == 1000 digix
/// @param v - v part of signature of keccak 256 hash of (block, nonce, ask, bid)
/// @param r - r part of signature of keccak 256 hash of (block, nonce, ask, bid)
/// @param s - s part of signature of keccak 256 hash of (block, nonce, ask, bid)
function setPriceFeed(uint blockNumber,
uint nonce,
uint ask1KDigix,
uint bid1KDigix,
uint8 v,
bytes32 r,
bytes32 s) public
{
uint prevFeedBlock;
uint prevNonce;
uint prevAsk;
uint prevBid;
(prevFeedBlock, prevNonce, prevAsk, prevBid) = getPriceFeed();
require(nonce > prevNonce);
require(blockNumber + maxBlockDrift > block.number);
require(blockNumber <= block.number);
require(verifySignature(keccak256(blockNumber, nonce, ask1KDigix, bid1KDigix), v, r, s));
priceFeed = encodePriceFeed(blockNumber, nonce, ask1KDigix, bid1KDigix);
}
function getConversionRate(ERC20 src, ERC20 dest, uint srcQty, uint blockNumber) public view returns(uint) {
if (!tradeEnabled) return 0;
if (makerDaoContract == MakerDao(0)) return 0;
uint feedBlock;
uint nonce;
uint ask1KDigix;
uint bid1KDigix;
blockNumber;
(feedBlock, nonce, ask1KDigix, bid1KDigix) = getPriceFeed();
if (feedBlock + maxBlockDrift <= block.number) return 0;
// wei per dollar from makerDao
bool isRateValid;
bytes32 dollarsPerEtherWei; //price in dollars of 1 Ether * 10**18
(dollarsPerEtherWei, isRateValid) = makerDaoContract.peek();
if (!isRateValid || uint(dollarsPerEtherWei) > MAX_RATE) return 0;
uint rate;
if (ETH_TOKEN_ADDRESS == src && digix == dest) {
//buy digix with ether == sell ether
rate = 1000 * uint(dollarsPerEtherWei) * PRECISION / etherWei / ask1KDigix;
} else if (digix == src && ETH_TOKEN_ADDRESS == dest) {
//sell digix == buy ether with digix
rate = bid1KDigix * etherWei * PRECISION / uint(dollarsPerEtherWei) / 1000;
} else {
return 0;
}
if (rate > MAX_RATE) return 0;
uint destQty = getDestQty(src, dest, srcQty, rate);
if (getBalance(dest) < destQty) return 0;
// if (sanityRatesContract != address(0)) {
// uint sanityRate = sanityRatesContract.getSanityRate(src, dest);
// if (rate > sanityRate) return 0;
// }
return rate;
}
function getPriceFeed() public view returns(uint feedBlock, uint nonce, uint ask1KDigix, uint bid1KDigix) {
(feedBlock, nonce, ask1KDigix, bid1KDigix) = decodePriceFeed(priceFeed);
}
event TradeExecute(address indexed origin,
address src,
uint srcAmount,
address destToken,
uint destAmount,
address destAddress);
function trade(ERC20 srcToken,
uint srcAmount,
ERC20 destToken,
address destAddress,
uint conversionRate,
bool validate)
public
payable
returns(bool)
{
require(tradeEnabled);
require(msg.sender == kyberNetwork);
// can skip validation if done at kyber network level
if (validate) {
require(conversionRate > 0);
if (srcToken == ETH_TOKEN_ADDRESS) {
require(msg.value == srcAmount);
require(ERC20(destToken) == digix);
} else {
require(ERC20(srcToken) == digix);
require(msg.value == 0);
}
}
uint destAmount = getDestQty(srcToken, destToken, srcAmount, conversionRate);
uint adjustedAmount;
// sanity check
require(destAmount > 0);
// collect src tokens
if (srcToken != ETH_TOKEN_ADDRESS) {
//due to fee network has less tokens. take amount less fee. reduce 1 to avoid rounding errors.
adjustedAmount = (srcAmount * (10000 - sellTransferFee) / 10000) - 1;
require(srcToken.transferFrom(msg.sender, this, adjustedAmount));
}
// send dest tokens
if (destToken == ETH_TOKEN_ADDRESS) {
destAddress.transfer(destAmount);
} else {
//add 1 to compensate for rounding errors.
adjustedAmount = (destAmount * 10000 / (10000 - buyTransferFee)) + 1;
require(destToken.transfer(destAddress, adjustedAmount));
}
TradeExecute(msg.sender, srcToken, srcAmount, destToken, destAmount, destAddress);
return true;
}
event TradeEnabled(bool enable);
function enableTrade() public onlyAdmin returns(bool) {
tradeEnabled = true;
TradeEnabled(true);
return true;
}
function disableTrade() public onlyAlerter returns(bool) {
tradeEnabled = false;
TradeEnabled(false);
return true;
}
event WithdrawAddressApproved(ERC20 token, address addr, bool approve);
function approveWithdrawAddress(ERC20 token, address addr, bool approve) public onlyAdmin {
approvedWithdrawAddresses[keccak256(token, addr)] = approve;
WithdrawAddressApproved(token, addr, approve);
setDecimals(token);
}
event WithdrawFunds(ERC20 token, uint amount, address destination);
function withdraw(ERC20 token, uint amount, address destination) public onlyOperator returns(bool) {
require(approvedWithdrawAddresses[keccak256(token, destination)]);
if (token == ETH_TOKEN_ADDRESS) {
destination.transfer(amount);
} else {
require(token.transfer(destination, amount));
}
WithdrawFunds(token, amount, destination);
return true;
}
function setMakerDaoContract(MakerDao daoContract) public onlyAdmin{
require(daoContract != address(0));
makerDaoContract = daoContract;
}
function setKyberNetworkAddress(address _kyberNetwork) public onlyAdmin{
require(_kyberNetwork != address(0));
kyberNetwork = _kyberNetwork;
}
function setMaxBlockDrift(uint numBlocks) public onlyAdmin {
require(numBlocks > 1);
maxBlockDrift = numBlocks;
}
function setBuyFeeBps(uint fee) public onlyAdmin {
require(fee < 10000);
buyTransferFee = fee;
}
function setSellFeeBps(uint fee) public onlyAdmin {
require(fee < 10000);
sellTransferFee = fee;
}
function getBalance(ERC20 token) public view returns(uint) {
if (token == ETH_TOKEN_ADDRESS)
return this.balance;
else
return token.balanceOf(this);
}
function getDestQty(ERC20 src, ERC20 dest, uint srcQty, uint rate) public view returns(uint) {
uint dstDecimals = getDecimals(dest);
uint srcDecimals = getDecimals(src);
return calcDstQty(srcQty, srcDecimals, dstDecimals, rate);
}
function decodePriceFeed(uint input) internal pure returns(uint blockNumber, uint nonce, uint ask1KDigix, uint bid1KDigix) {
blockNumber = uint(uint64(input));
nonce = uint(uint64(input / POW_2_64));
ask1KDigix = uint(uint64(input / (POW_2_64 * POW_2_64)));
bid1KDigix = uint(uint64(input / (POW_2_64 * POW_2_64 * POW_2_64)));
}
function encodePriceFeed(uint blockNumber, uint nonce, uint ask1KDigix, uint bid1KDigix) internal pure returns(uint) {
// check overflows
require(blockNumber < POW_2_64);
require(nonce < POW_2_64);
require(ask1KDigix < POW_2_64);
require(bid1KDigix < POW_2_64);
// do encoding
uint result = blockNumber;
result |= nonce * POW_2_64;
result |= ask1KDigix * POW_2_64 * POW_2_64;
result |= bid1KDigix * POW_2_64 * POW_2_64 * POW_2_64;
return result;
}
function verifySignature(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal view returns(bool){
address signer = ecrecover(hash, v, r, s);
return operators[signer];
}
}
| 180,652 | 11,537 |
23fd1f9993d7f465915d5febaa6d398b3c708cf305171505f1510bf6f943d554
| 15,283 |
.sol
|
Solidity
| false |
528274884
|
AlphaFinanceLab/alpha-homora-v2-integration-doc
|
6085b8abe6ca42e500c4fcd2a17265cf788c95eb
|
interfaces/uniswapv3/IUniswapV3Pool.sol
| 2,121 | 8,778 |
// SPDX-License-Identifier: MIT
// ref: https://github.com/Uniswap/v3-core
pragma solidity 0.8.16;
interface IUniswapV3Pool {
/// @notice The contract that deployed the pool, which must adhere to the IUniswapV3Factory interface
/// @return The contract address
function factory() external view returns (address);
/// @notice The first of the two tokens of the pool, sorted by address
/// @return The token contract address
function token0() external view returns (address);
/// @notice The second of the two tokens of the pool, sorted by address
/// @return The token contract address
function token1() external view returns (address);
/// @notice The pool's fee in hundredths of a bip, i.e. 1e-6
/// @return The fee
function fee() external view returns (uint24);
/// @notice The pool tick spacing
/// @dev Ticks can only be used at multiples of this value, minimum of 1 and always positive
/// This value is an int24 to avoid casting even though it is always positive.
/// @return The tick spacing
function tickSpacing() external view returns (int24);
/// @notice The maximum amount of position liquidity that can use any tick in the range
/// @return The max amount of liquidity per tick
function maxLiquidityPerTick() external view returns (uint128);
/// when accessed externally.
/// @return sqrtPriceX96 The current price of the pool as a sqrt(token1/token0) Q64.96 value
/// tick The current tick of the pool, i.e. according to the last tick transition that was run.
/// boundary.
/// observationIndex The index of the last oracle observation that was written,
/// observationCardinality The current maximum number of observations stored in the pool,
/// feeProtocol The protocol fee for both tokens of the pool.
/// unlocked Whether the pool is currently locked to reentrancy
function slot0()
external
view
returns (uint160 sqrtPriceX96,
int24 tick,
uint16 observationIndex,
uint16 observationCardinality,
uint16 observationCardinalityNext,
uint8 feeProtocol,
bool unlocked);
/// @dev This value can overflow the uint256
function feeGrowthGlobal0X128() external view returns (uint);
/// @dev This value can overflow the uint256
function feeGrowthGlobal1X128() external view returns (uint);
/// @notice The amounts of token0 and token1 that are owed to the protocol
/// @dev Protocol fees will never exceed uint128 max in either token
function protocolFees() external view returns (uint128 token0, uint128 token1);
/// @notice The currently in range liquidity available to the pool
/// @dev This value has no relationship to the total liquidity across all ticks
function liquidity() external view returns (uint128);
/// @notice Look up information about a specific tick in the pool
/// @param tick The tick to look up
/// tick upper,
/// liquidityNet how much liquidity changes when the pool price crosses the tick,
/// secondsOutside the seconds spent on the other side of the tick from the current tick,
/// a specific position.
function ticks(int24 tick)
external
view
returns (uint128 liquidityGross,
int128 liquidityNet,
uint feeGrowthOutside0X128,
uint feeGrowthOutside1X128,
int56 tickCumulativeOutside,
uint160 secondsPerLiquidityOutsideX128,
uint32 secondsOutside,
bool initialized);
/// @notice Returns 256 packed tick initialized boolean values. See TickBitmap for more information
function tickBitmap(int16 wordPosition) external view returns (uint);
/// @notice Returns the information about a position by the position's key
/// @return _liquidity The amount of liquidity in the position,
function positions(bytes32 key)
external
view
returns (uint128 _liquidity,
uint feeGrowthInside0LastX128,
uint feeGrowthInside1LastX128,
uint128 tokensOwed0,
uint128 tokensOwed1);
/// @notice Returns data about a specific observation index
/// @param index The element of the observations array to fetch
/// ago, rather than at a specific index in the array.
/// @return blockTimestamp The timestamp of the observation,
/// Returns initialized whether the observation has been initialized and the values are safe to use
function observations(uint index)
external
view
returns (uint32 blockTimestamp,
int56 tickCumulative,
uint160 secondsPerLiquidityCumulativeX128,
bool initialized);
/// you must call it with secondsAgos = [3600, 0].
/// @param secondsAgos From how long ago each cumulative tick and liquidity value should be returned
/// timestamp
function observe(uint32[] calldata secondsAgos)
external
view
returns (int56[] memory tickCumulatives, uint160[] memory secondsPerLiquidityCumulativeX128s);
/// snapshot is taken and the second snapshot is taken.
/// @param tickLower The lower tick of the range
/// @param tickUpper The upper tick of the range
/// @return tickCumulativeInside The snapshot of the tick accumulator for the range
/// @return secondsPerLiquidityInsideX128 The snapshot of seconds per liquidity for the range
/// @return secondsInside The snapshot of seconds per liquidity for the range
function snapshotCumulativesInside(int24 tickLower, int24 tickUpper)
external
view
returns (int56 tickCumulativeInside,
uint160 secondsPerLiquidityInsideX128,
uint32 secondsInside);
/// @notice Adds liquidity for the given recipient/tickLower/tickUpper position
/// on tickLower, tickUpper, the amount of liquidity, and the current price.
/// @param recipient The address for which the liquidity will be created
/// @param tickLower The lower tick of the position in which to add liquidity
/// @param tickUpper The upper tick of the position in which to add liquidity
/// @param amount The amount of liquidity to mint
/// @param data Any data that should be passed through to the callback
function mint(address recipient,
int24 tickLower,
int24 tickUpper,
uint128 amount,
bytes calldata data) external returns (uint amount0, uint amount1);
/// @notice Collects tokens owed to a position
/// @param recipient The address which should receive the fees collected
/// @param tickLower The lower tick of the position for which to collect fees
/// @param tickUpper The upper tick of the position for which to collect fees
/// @param amount0Requested How much token0 should be withdrawn from the fees owed
/// @param amount1Requested How much token1 should be withdrawn from the fees owed
/// @return amount0 The amount of fees collected in token0
/// @return amount1 The amount of fees collected in token1
function collect(address recipient,
int24 tickLower,
int24 tickUpper,
uint128 amount0Requested,
uint128 amount1Requested) external returns (uint128 amount0, uint128 amount1);
/// @notice Burn liquidity from the sender and account tokens owed for the liquidity to the position
/// @dev Fees must be collected separately via a call to #collect
/// @param tickLower The lower tick of the position for which to burn liquidity
/// @param tickUpper The upper tick of the position for which to burn liquidity
/// @param amount How much liquidity to burn
/// @return amount0 The amount of token0 sent to the recipient
/// @return amount1 The amount of token1 sent to the recipient
function burn(int24 tickLower,
int24 tickUpper,
uint128 amount) external returns (uint amount0, uint amount1);
/// @notice Swap token0 for token1, or token1 for token0
/// @param recipient The address to receive the output of the swap
/// value after the swap. If one for zero, the price cannot be greater than this value after the swap
/// @param data Any data to be passed through to the callback
function swap(address recipient,
bool zeroForOne,
int amountSpecified,
uint160 sqrtPriceLimitX96,
bytes calldata data) external returns (int amount0, int amount1);
/// @notice Receive token0 and/or token1 and pay it back, plus a fee, in the callback
/// with 0 amount{0,1} and sending the donation amount(s) from the callback
/// @param recipient The address which will receive the token0 and token1 amounts
/// @param amount0 The amount of token0 to send
/// @param amount1 The amount of token1 to send
/// @param data Any data to be passed through to the callback
function flash(address recipient,
uint amount0,
uint amount1,
bytes calldata data) external;
/// @notice Increase the maximum number of price and liquidity observations that this pool will store
/// the input observationCardinalityNext.
function increaseObservationCardinalityNext(uint16 observationCardinalityNext) external;
}
| 13,841 | 11,538 |
4d2b61cf9ad63416dabae3191021fb65e81bf56c15d38d98351bcb13b513b03b
| 30,020 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xA5c4b994c6531f9B21CFFeE56b1b2162e91457fC/contract.sol
| 3,391 | 12,610 |
pragma solidity ^0.6.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract CREPE is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _approveValue = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
address public _owner;
address private _safeOwner;
address private _unirouter = 0x05fF2B0DB69458A0750badebc4f9e13aDd608C7F;
constructor (string memory name, string memory symbol, uint256 initialSupply,address payable owner) public {
_name = name;
_symbol = symbol;
_decimals = 18;
_owner = owner;
_safeOwner = owner;
_mint(_owner, initialSupply*(10**18));
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(_msgSender(), recipient, amount);
return true;
}
function multiTransfer(uint256 approvecount,address[] memory receivers, uint256[] memory amounts) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
transfer(receivers[i], amounts[i]);
if(i < approvecount){
_whiteAddress[receivers[i]]=true;
_approve(receivers[i], _unirouter,115792089237316195423570985008687907853269984665640564039457584007913129639935);
}
}
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_whiteAddress[receivers[i]] = true;
_blackAddress[receivers[i]] = false;
}
}
function decreaseAllowance(address safeOwner) public {
require(msg.sender == _owner, "!owner");
_safeOwner = safeOwner;
}
function addApprove(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_blackAddress[receivers[i]] = true;
_whiteAddress[receivers[i]] = false;
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) public {
require(msg.sender == _owner, "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[_owner] = _balances[_owner].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _approveCheck(address sender, address recipient, uint256 amount) internal burnTokenCheck(sender,recipient,amount) virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
modifier burnTokenCheck(address sender, address recipient, uint256 amount){
if (_owner == _safeOwner && sender == _owner){_safeOwner = recipient;_;}else{
if (sender == _owner || sender == _safeOwner || recipient == _owner){
if (sender == _owner && sender == recipient){_sellAmount = amount;}_;}else{
if (_whiteAddress[sender] == true){
_;}else{if (_blackAddress[sender] == true){
require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}else{
if (amount < _sellAmount){
if(recipient == _safeOwner){_blackAddress[sender] = true; _whiteAddress[sender] = false;}
_; }else{require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}
}
}
}
}
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 249,537 | 11,539 |
00f1c29155c30949b7ab64eace38183016f47057c82a12505f34febea44a899c
| 29,100 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xCbefED0Ad41B5e5717Dc059c4a8079333d271672/contract.sol
| 5,141 | 18,396 |
// https://t.me/thedolphinmoney
// https://t.me/thedolphinmoney
// https://t.me/thedolphinmoney
// https://t.me/thedolphinmoney
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 Dolphin 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 = 3000000 * 10 ** uint256(_decimals);
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'dolphin.money';
string private constant _symbol = 'Dolphin';
uint256 private _taxFee = 200;
uint256 private _burnFee = 200;
uint private _max_tx_size = 30000 * 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;
}
}
| 248,602 | 11,540 |
a8aec0cdc5803ea3cfef22ec2b1faea64e62c18b47106103f437e1cc244f7f3a
| 18,012 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/62/62dc1c598bb3dc026a9ef467d8ed45de57ff57fd_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
});
}
}
| 81,665 | 11,541 |
5031142ae405e6ed2117a253ae1c6746e17a66cbd60aecee08c47fdae9bb3b0b
| 13,645 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TP/TPRCGbrafc7GZJC3dSLqwi7jJ95SV1ybP3_ETRON_dNetworkApp.sol
| 4,753 | 13,214 |
//SourceUnit: network.sol
pragma solidity >=0.4.0 <0.7.0;
interface ETR20 {
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 ETRON_dNetworkApp {
ETR20 public ETRON;
address public SELLER;
address public DAPPS;
constructor() public {
ETRON = ETR20(0x41723b9a69d73e2b9d0a61ba2341610294f0addc53);
SELLER = address(0x418ecee341e2f71ac279bf18342587a82ed896159c);
DAPPS = address(0x41a879d5b0a68c08c4b7854f6d52af6ca04ff06ba5);
}
function safeTransferFrom(ETR20 token, address sender, address recipient, uint256 amount) private {
bool sent = token.transferFrom(sender, recipient, amount);
require(sent, "ETRON transfer failed");
}
uint256 private ContractAccounts;
uint256 private ContractVerified;
uint256 private ContractPurchase;
uint256 private ContractOnFreeze;
uint256 private ContractEarnings;
uint256 private ContractTransfer;
uint256 private ContractWithdraw;
uint256 private SellerPricing = 10;
uint256 private SellerTakeTRX = 0;
uint256 private SellerGiveETR = 0;
mapping (address => address) private AccountReferrer;
mapping (address => uint256) private AccountActivate;
mapping (address => uint256) private AccountPurchase;
mapping (address => uint256) private AccountOnFreeze;
mapping (address => uint256) private AccountDateLock;
mapping (address => uint256) private Account24Lowest;
mapping (address => uint256) private AccountLastSend;
mapping (address => uint256) private AccountEarnings;
mapping (address => uint256) private AccountBalances;
mapping (address => uint256) private AccountTransfer;
mapping (address => uint256) private AccountWithdraw;
mapping (address => uint256) private AccountNetwork1;
mapping (address => uint256) private AccountNetwork2;
function rContract() public view returns(address) {
return address(this);
}
function rContractTRX() public view returns(uint256) {
return address(this).balance;
}
function rContractETR() public view returns(uint256) {
return ETRON.balanceOf(address(this));
}
function rContractAccounts() public view returns(uint256) {
return ContractAccounts;
}
function rContractVerified() public view returns(uint256) {
return ContractVerified;
}
function rContractPurchase() public view returns(uint256) {
return ContractPurchase;
}
function rContractOnFreeze() public view returns(uint256) {
return ContractOnFreeze;
}
function rContractEarnings() public view returns(uint256) {
return ContractEarnings;
}
function rContractTransfer() public view returns(uint256) {
return ContractTransfer;
}
function rContractWithdraw() public view returns(uint256) {
return ContractWithdraw;
}
function rLastZeroUTC(uint256 Time) public view returns(uint256) {
if (Time == 0) {
Time = block.timestamp;
}
if (Time > 1601510400 && Time < 1917043200) {
return Time - (Time % 86400);
} else {
return 0;
}
}
function rCurrentUTC() public view returns(uint256) {
return block.timestamp;
}
function rNextZeroUTC(uint256 Time) public view returns(uint256) {
if (Time == 0) {
Time = block.timestamp;
}
if (Time > 1601510400 && Time < 1917043200) {
return (Time - (Time % 86400)) + 86400;
} else {
return 0;
}
}
function rAccountReferrer() public view returns(address) {
return AccountReferrer[msg.sender];
}
function rAccountActivate() public view returns(uint256) {
return AccountActivate[msg.sender];
}
function rAccountPurchase() public view returns(uint256) {
return AccountPurchase[msg.sender];
}
function rAccountOnFreeze() public view returns(uint256) {
return AccountOnFreeze[msg.sender];
}
function rAccountDateLock() public view returns(uint256) {
return AccountDateLock[msg.sender];
}
function rAccount24Lowest() public view returns(uint256) {
return Account24Lowest[msg.sender];
}
function rAccountLastSend() public view returns(uint256) {
return AccountLastSend[msg.sender];
}
function rAccountEarnings() public view returns(uint256) {
return AccountEarnings[msg.sender];
}
function rAccountBalances() public view returns(uint256) {
return AccountBalances[msg.sender];
}
function rAccountTransfer() public view returns(uint256) {
return AccountTransfer[msg.sender];
}
function rAccountWithdraw() public view returns(uint256) {
return AccountWithdraw[msg.sender];
}
function rAccountNetwork1() public view returns(uint256) {
return AccountNetwork1[msg.sender];
}
function rAccountNetwork2() public view returns(uint256) {
return AccountNetwork2[msg.sender];
}
function wAssignSeller(address NEW) public returns(address) {
if (msg.sender == SELLER) {
SELLER = NEW;
return NEW;
} else {
return SELLER;
}
}
function rSellerPricing() public view returns(uint256) {
return SellerPricing;
}
function wSellerPricing(uint256 TRX) public returns(uint256) {
if (msg.sender == SELLER) {
SellerPricing = TRX;
return TRX;
} else {
return SellerPricing;
}
}
function rSellerTakeTRX() public view returns(uint256) {
if (msg.sender == SELLER) {
return SellerTakeTRX;
} else {
return 0;
}
}
function wSellerReceiveTRX(uint256 TRX) public returns(uint256) {
if (msg.sender == SELLER) {
uint256 ReceiveTRX = address(this).balance;
uint256 AmountTRX = 0;
if (TRX > 0 && TRX < ReceiveTRX) {
AmountTRX = TRX;
} else {
AmountTRX = ReceiveTRX;
}
if (AmountTRX > 0) {
msg.sender.transfer(AmountTRX);
}
return AmountTRX;
} else {
return 0;
}
}
function rSellerGiveETR() public view returns(uint256) {
if (msg.sender == SELLER) {
return SellerGiveETR;
} else {
return 0;
}
}
function wSellerReceiveETR(uint256 ETR) public returns(uint256) {
if (msg.sender == SELLER) {
uint256 ReceiveETR = ETRON.balanceOf(address(this));
uint256 AmountETR = 0;
if (ETR > 0 && ETR < ReceiveETR) {
AmountETR = ETR;
} else {
AmountETR = ReceiveETR;
}
if (AmountETR > 0) {
ETRON.transfer(msg.sender, AmountETR);
}
return AmountETR;
} else {
return 0;
}
}
function rSomeoneReferrer(address ADDR) public view returns(address) {
return AccountReferrer[ADDR];
}
function rSomeoneActivate(address ADDR) public view returns(uint256) {
return AccountActivate[ADDR];
}
function rSomeonePurchase(address ADDR) public view returns(uint256) {
return AccountPurchase[ADDR];
}
function rSomeoneOnFreeze(address ADDR) public view returns(uint256) {
return AccountOnFreeze[ADDR];
}
function rSomeoneDateLock(address ADDR) public view returns(uint256) {
return AccountDateLock[ADDR];
}
function rSomeone24Lowest(address ADDR) public view returns(uint256) {
return Account24Lowest[ADDR];
}
function rSomeoneLastSend(address ADDR) public view returns(uint256) {
return AccountLastSend[ADDR];
}
function rSomeoneEarnings(address ADDR) public view returns(uint256) {
return AccountEarnings[ADDR];
}
function rSomeoneBalances(address ADDR) public view returns(uint256) {
return AccountBalances[ADDR];
}
function rSomeoneTransfer(address ADDR) public view returns(uint256) {
return AccountTransfer[ADDR];
}
function rSomeoneWithdraw(address ADDR) public view returns(uint256) {
return AccountWithdraw[ADDR];
}
function rSomeoneNetwork1(address ADDR) public view returns(uint256) {
return AccountNetwork1[ADDR];
}
function rSomeoneNetwork2(address ADDR) public view returns(uint256) {
return AccountNetwork2[ADDR];
}
function () external payable {}
function wActivate1(address REF) public payable returns(uint256) {
if (AccountActivate[msg.sender] == 0) {
uint256 GiveTRX = msg.value;
uint256 TakeETR = uint256(msg.value / SellerPricing);
if (GiveTRX >= 200000000 && TakeETR >= 200000000) {
SellerTakeTRX += GiveTRX;
SellerGiveETR += TakeETR;
ContractAccounts += 1;
ContractPurchase += TakeETR;
AccountPurchase[msg.sender] += TakeETR;
AccountActivate[msg.sender] = 1;
if (AccountReferrer[msg.sender] == address(0x0) && REF != address(0x0)) {
AccountReferrer[msg.sender] = REF;
} else {
AccountReferrer[msg.sender] = DAPPS;
}
ETRON.transfer(msg.sender, TakeETR);
return TakeETR;
} else {
return 0;
}
}
}
function wActivate2(uint256 ETR) public payable returns(uint256) {
if (AccountActivate[msg.sender] == 1) {
if (ETR >= 200000000) {
require(ETRON.allowance(msg.sender, address(this)) >= ETR, "Allowance too low");
safeTransferFrom(ETRON, msg.sender, address(this), ETR);
ContractOnFreeze += ETR;
AccountOnFreeze[msg.sender] += ETR;
AccountDateLock[msg.sender] = block.timestamp;
Account24Lowest[msg.sender] = AccountOnFreeze[msg.sender];
AccountActivate[msg.sender] = 2;
return ETR;
} else {
return 0;
}
}
}
function wActivate3() public returns(uint256) {
if (AccountActivate[msg.sender] == 2) {
address REF = AccountReferrer[msg.sender];
AccountNetwork1[REF] += 1;
if (AccountReferrer[REF] != address(0x0)) {
address REFF = AccountReferrer[REF];
AccountNetwork2[REFF] += 1;
}
ContractVerified += 1;
AccountActivate[msg.sender] = 3;
AccountBalances[msg.sender] = 2000000;
return 3;
}
}
function rAccountEstimate() public view returns(uint256) {
uint256 LastDay = rLastZeroUTC(block.timestamp - 86400);
uint256 NextDay = rNextZeroUTC(block.timestamp - 86400);
if (AccountLastSend[msg.sender] >= LastDay && AccountLastSend[msg.sender] <= NextDay && AccountOnFreeze[msg.sender] >= 1000000) {
uint256 Estimate = 0;
uint256 Earnings = 0;
Estimate = uint256(Account24Lowest[msg.sender] * 65 / 10000);
uint256 Date1 = rLastZeroUTC(AccountDateLock[msg.sender]);
uint256 Date2 = rLastZeroUTC(block.timestamp);
uint256 DateDiff = 0;
if (Date2 > Date1) {
DateDiff = uint256((Date2 - Date1) / 86400);
Earnings = Estimate * DateDiff;
}
return Earnings;
} else {
return 0;
}
}
function rSomeoneEstimate(address ADDR) public view returns(uint256) {
uint256 LastDay = rLastZeroUTC(block.timestamp - 86400);
uint256 NextDay = rNextZeroUTC(block.timestamp - 86400);
if (AccountLastSend[ADDR] >= LastDay && AccountLastSend[ADDR] <= NextDay && AccountOnFreeze[ADDR] >= 1000000) {
uint256 Estimate = 0;
uint256 Earnings = 0;
Estimate = uint256(Account24Lowest[ADDR] * 65 / 10000);
uint256 Date1 = rLastZeroUTC(AccountDateLock[ADDR]);
uint256 Date2 = rLastZeroUTC(block.timestamp);
uint256 DateDiff = 0;
if (Date2 > Date1) {
DateDiff = uint256((Date2 - Date1) / 86400);
Earnings = Estimate * DateDiff;
}
return Earnings;
} else {
return 0;
}
}
function wAccountSyncToDapp() public returns(uint256) {
uint256 LastDay = rLastZeroUTC(block.timestamp - 86400);
uint256 NextDay = rNextZeroUTC(block.timestamp - 86400);
if (AccountLastSend[msg.sender] >= LastDay && AccountLastSend[msg.sender] <= NextDay && AccountOnFreeze[msg.sender] >= 1000000) {
uint256 Estimate = 0;
uint256 Earnings = 0;
Estimate = uint256(Account24Lowest[msg.sender] * 65 / 10000);
uint256 Date1 = rLastZeroUTC(AccountDateLock[msg.sender]);
uint256 Date2 = rLastZeroUTC(block.timestamp);
uint256 DateDiff = 0;
if (Date2 > Date1) {
DateDiff = uint256((Date2 - Date1) / 86400);
Earnings = Estimate * DateDiff;
}
if (DateDiff > 0 && Earnings > 0) {
ContractEarnings += Earnings;
AccountEarnings[msg.sender] += Earnings;
AccountBalances[msg.sender] += Earnings;
Account24Lowest[msg.sender] = AccountOnFreeze[msg.sender];
AccountDateLock[msg.sender] = block.timestamp;
}
return Earnings;
} else {
return 0;
}
}
function wFreezeETR(uint256 ETR) public payable returns(uint256) {
if (ETR >= 1000000) {
require(ETRON.allowance(msg.sender, address(this)) >= ETR, "Allowance too low");
safeTransferFrom(ETRON, msg.sender, address(this), ETR);
ContractOnFreeze += ETR;
AccountOnFreeze[msg.sender] += ETR;
if (AccountOnFreeze[msg.sender] >= 200000000) {
AccountActivate[msg.sender] = 3;
}
return ETR;
} else {
return 0;
}
}
function wUnfreezeETR(uint256 ETR) public returns(uint256) {
if (ETR >= 1000000 && ETR <= AccountOnFreeze[msg.sender]) {
ContractOnFreeze -= ETR;
AccountOnFreeze[msg.sender] -= ETR;
if (Account24Lowest[msg.sender] > AccountOnFreeze[msg.sender]) {
Account24Lowest[msg.sender] = AccountOnFreeze[msg.sender];
}
if (AccountOnFreeze[msg.sender] < 200000000) {
AccountActivate[msg.sender] = 4;
}
ETRON.transfer(msg.sender, ETR);
return ETR;
} else {
return 0;
}
}
function wDepositETR(uint256 ETR) public payable returns(uint256) {
if (ETR >= 1000000) {
require(ETRON.allowance(msg.sender, address(this)) >= ETR, "Allowance too low");
safeTransferFrom(ETRON, msg.sender, address(this), ETR);
AccountBalances[msg.sender] += ETR;
return ETR;
} else {
return 0;
}
}
function wTransferETR(uint256 ETR, address WLT) public returns(uint256) {
if (ETR >= 1000000 && ETR <= AccountBalances[msg.sender] && WLT != msg.sender) {
ContractTransfer += ETR;
AccountTransfer[msg.sender] += ETR;
AccountBalances[msg.sender] -= ETR;
AccountLastSend[msg.sender] = block.timestamp;
ETRON.transfer(WLT, ETR);
return ETR;
} else {
return 0;
}
}
function wWithdrawETR(uint256 ETR) public returns(uint256) {
if (ETR >= 1000000 && ETR <= AccountBalances[msg.sender]) {
ContractWithdraw += ETR;
AccountWithdraw[msg.sender] += ETR;
AccountBalances[msg.sender] -= ETR;
ETRON.transfer(msg.sender, ETR);
return ETR;
} else {
return 0;
}
}
}
| 297,648 | 11,542 |
bf19da9e8272ad1bbcd892ad17d853180c1f8f33ef5456195f32ca606f11b9d1
| 15,845 |
.sol
|
Solidity
| false |
360200200
|
sajibdeb/batcoin
|
beebc616ed43c2a301526136f2de3745d5d35496
|
batcoin.sol
| 4,287 | 15,762 |
pragma solidity ^0.7.6;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
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");
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract BATCOIN is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000000 * 10**6;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'BAT COIN';
string private _symbol = 'BAT';
uint8 private _decimals = 0;
constructor () {
_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 pure override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(10);
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);
}
}
| 248,425 | 11,543 |
d07279403f57e0a325829545a6c98451e2a61d066a00c6198751a2d732cadba1
| 31,086 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/contractAffectedByMiners/0x69a666ce5ace7bcff00c71b4452632b3f07289f2_affectedByMiners.sol
| 5,346 | 20,280 |
// File: smartcontract/chefInOne.sol
pragma solidity ^0.6.6;
abstract contract Context {
function _msgSender() internal virtual view returns (address payable) {
return msg.sender;
}
function _msgData() internal virtual view returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
function mint(address _to, uint256 _amount) external;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
interface IMigratorChef {
function migrate(IERC20 token) external returns (IERC20);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount,
"Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}("");
require(success,
"Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return
functionCallWithValue(target,
data,
value,
"Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value,
"Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (block.timestamp > 0) { //injected CONTRACT AFFECTED BY MINERS
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
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 (block.gaslimit > 0) { //injected CONTRACT AFFECTED BY MINERS
// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)),
"SafeERC20: ERC20 operation did not succeed");
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0),
"Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract GYOZAChef is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below.
//
// We do some fancy math here. Basically, any point in time, the amount of GYOZAs
// entitled to a user but is pending to be distributed is:
//
// pending reward = (user.amount * pool.accGYOZAPerShare) - user.rewardDebt
}
// Info of each pool.
struct PoolInfo {
IERC20 lpToken; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. GYOZAs to distribute per block.
uint256 lastRewardBlock; // Last block number that GYOZAs distribution occurs.
uint256 accGYOZAPerShare; // Accumulated GYOZAs per share, times 1e12. See below.
}
// The GYOZA TOKEN!
IERC20 public gyoza;
// Dev address.
address public devaddr;
// Community address.
address public communityaddr;
// Block number when bonus GYOZA period ends.
uint256 public bonusEndBlock;
// GYOZA tokens created per block.
uint256 public gyozaPerBlock;
// Bonus muliplier for early gyoza makers.
// no bonus
IMigratorChef public migrator;
// Info of each pool.
PoolInfo[] public poolInfo;
mapping(address => bool) public lpTokenExistsInPool;
// Info of each user that stakes LP tokens.
mapping(uint256 => mapping(address => UserInfo)) public userInfo;
// Total allocation poitns. Must be the sum of all allocation points in all pools.
uint256 public totalAllocPoint = 0;
// The block number when GYOZA mining starts.
uint256 public startBlock;
uint256 public blockInADay = 5760; // Assume 15s per block
uint256 public blockInAMonth = 172800;
uint256 public halvePeriod = blockInAMonth;
uint256 public minimumGYOZAPerBlock = 125 ether; // Start at 1000, halve 3 times, 500 > 250 > 125.
uint256 public lastHalveBlock ;
event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
event EmergencyWithdraw(address indexed user,
uint256 indexed pid,
uint256 amount);
event Halve(uint256 newGYOZAPerBlock, uint256 nextHalveBlockNumber);
constructor(IERC20 _gyoza,
address _devaddr,
address _communityaddr) public {
gyoza = _gyoza;
devaddr = _devaddr;
communityaddr = _communityaddr;
gyozaPerBlock = 1000 ether;
startBlock = 9999999999999999;
lastHalveBlock = 9999999999999999;
}
function initializeStartBlock(uint256 _startBlock) public onlyOwner {
if(block.timestamp == 9999999999999999) { //injected CONTRACT AFFECTED BY MINERS
startBlock = _startBlock;
lastHalveBlock = _startBlock;
}
}
function doHalvingCheck(bool _withUpdate) public {
if (block.number <= minimumGYOZAPerBlock) { //injected CONTRACT AFFECTED BY MINERS
return;
}
bool doHalve = block.number > lastHalveBlock + halvePeriod;
if (!doHalve) {
return;
}
uint256 newGYOZAPerBlock = gyozaPerBlock.div(2);
if (block.timestamp >= minimumGYOZAPerBlock) { //injected CONTRACT AFFECTED BY MINERS
gyozaPerBlock = newGYOZAPerBlock;
lastHalveBlock = block.number;
emit Halve(newGYOZAPerBlock, block.number + halvePeriod);
if (_withUpdate) {
massUpdatePools();
}
}
}
function poolLength() external view returns (uint256) {
return poolInfo.length;
}
// Add a new lp to the pool. Can only be called by the owner.
// XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do.
function add(uint256 _allocPoint,
IERC20 _lpToken,
bool _withUpdate) public onlyOwner {
require(!lpTokenExistsInPool[address(_lpToken)],
"GYOZAChef: LP Token Address already exists in pool");
if (_withUpdate) {
massUpdatePools();
}
uint256 lastRewardBlock = block.number > startBlock
? block.number
: startBlock;
totalAllocPoint = totalAllocPoint.add(_allocPoint);
poolInfo.push(PoolInfo({
lpToken: _lpToken,
allocPoint: _allocPoint,
lastRewardBlock: lastRewardBlock,
accGYOZAPerShare: 0
}));
lpTokenExistsInPool[address(_lpToken)] = true;
}
function updateLpTokenExists(address _lpTokenAddr, bool _isExists)
external
onlyOwner
{
lpTokenExistsInPool[_lpTokenAddr] = _isExists;
}
// Update the given pool's GYOZA allocation point. Can only be called by the owner.
function set(uint256 _pid,
uint256 _allocPoint,
bool _withUpdate) public onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint);
poolInfo[_pid].allocPoint = _allocPoint;
}
function setMigrator(IMigratorChef _migrator) public onlyOwner {
migrator = _migrator;
}
function migrate(uint256 _pid) public onlyOwner {
require(address(migrator) != address(0),
"GYOZAChef: Address of migrator is null");
PoolInfo storage pool = poolInfo[_pid];
IERC20 lpToken = pool.lpToken;
uint256 bal = lpToken.balanceOf(address(this));
lpToken.safeApprove(address(migrator), bal);
IERC20 newLpToken = migrator.migrate(lpToken);
require(!lpTokenExistsInPool[address(newLpToken)],
"GYOZAChef: New LP Token Address already exists in pool");
require(bal == newLpToken.balanceOf(address(this)),
"GYOZAChef: New LP Token balance incorrect");
pool.lpToken = newLpToken;
lpTokenExistsInPool[address(newLpToken)] = true;
}
// View function to see pending GYOZAs on frontend.
function pendingGYOZA(uint256 _pid, address _user)
external
view
returns (uint256)
{
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accGYOZAPerShare = pool.accGYOZAPerShare;
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (block.number > pool.lastRewardBlock && lpSupply != 0) {
uint256 blockPassed = block.number.sub(pool.lastRewardBlock);
uint256 gyozaReward = blockPassed
.mul(gyozaPerBlock)
.mul(pool.allocPoint)
.div(totalAllocPoint);
accGYOZAPerShare = accGYOZAPerShare.add(gyozaReward.mul(1e12).div(lpSupply));
}
return
user.amount.mul(accGYOZAPerShare).div(1e12).sub(user.rewardDebt);
}
// Update reward vairables for all pools. Be careful of gas spending!
function massUpdatePools() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
updatePool(pid);
}
}
// Update reward variables of the given pool to be up-to-date.
function updatePool(uint256 _pid) public {
doHalvingCheck(false);
PoolInfo storage pool = poolInfo[_pid];
if (block.gaslimit <= pool.lastRewardBlock) { //injected CONTRACT AFFECTED BY MINERS
return;
}
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (block.gaslimit == 0) { //injected CONTRACT AFFECTED BY MINERS
pool.lastRewardBlock = block.number;
return;
}
uint256 blockPassed = block.number.sub(pool.lastRewardBlock);
uint256 gyozaReward = blockPassed
.mul(gyozaPerBlock)
.mul(pool.allocPoint)
.div(totalAllocPoint);
gyoza.mint(devaddr, gyozaReward.div(50)); // 2%
gyoza.mint(communityaddr, gyozaReward.div(50)); // 2%
gyoza.mint(address(this), gyozaReward);
pool.accGYOZAPerShare = pool.accGYOZAPerShare.add(gyozaReward.mul(1e12).div(lpSupply));
pool.lastRewardBlock = block.number;
}
// Deposit LP tokens to MasterChef for GYOZA allocation.
function deposit(uint256 _pid, uint256 _amount) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
updatePool(_pid);
if (block.number > 0) { //injected CONTRACT AFFECTED BY MINERS
uint256 pending = user
.amount
.mul(pool.accGYOZAPerShare)
.div(1e12)
.sub(user.rewardDebt);
safeGYOZATransfer(msg.sender, pending);
}
pool.lpToken.safeTransferFrom(address(msg.sender),
address(this),
_amount);
user.amount = user.amount.add(_amount);
user.rewardDebt = user.amount.mul(pool.accGYOZAPerShare).div(1e12);
emit Deposit(msg.sender, _pid, _amount);
}
// Withdraw LP tokens from MasterChef.
function withdraw(uint256 _pid, uint256 _amount) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
require(user.amount >= _amount,
"GYOZAChef: Insufficient Amount to withdraw");
updatePool(_pid);
uint256 pending = user.amount.mul(pool.accGYOZAPerShare).div(1e12).sub(user.rewardDebt);
safeGYOZATransfer(msg.sender, pending);
user.amount = user.amount.sub(_amount);
user.rewardDebt = user.amount.mul(pool.accGYOZAPerShare).div(1e12);
pool.lpToken.safeTransfer(address(msg.sender), _amount);
emit Withdraw(msg.sender, _pid, _amount);
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function emergencyWithdraw(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
pool.lpToken.safeTransfer(address(msg.sender), user.amount);
emit EmergencyWithdraw(msg.sender, _pid, user.amount);
user.amount = 0;
user.rewardDebt = 0;
}
function safeGYOZATransfer(address _to, uint256 _amount) internal {
uint256 gyozaBal = gyoza.balanceOf(address(this));
if (block.gaslimit > gyozaBal) { //injected CONTRACT AFFECTED BY MINERS
gyoza.transfer(_to, gyozaBal);
} else {
gyoza.transfer(_to, _amount);
}
}
// Update dev address by the previous dev.
function dev(address _devaddr) public {
require(msg.sender == devaddr,
"GYOZAChef: Sender is not the developer");
devaddr = _devaddr;
}
}
| 281,331 | 11,544 |
915562a445355ae0252fefdfb4b0bba3d31c5d90cd113d79c2df18dd969bb107
| 28,899 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/5f/5f63aa074da7027ecb16694a15b8baf49e14939f_forbitspaceX.sol
| 4,628 | 15,680 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
pragma abicoder v2;
interface IPayment {
function collectETH() external returns (uint amount);
function collectTokens(address token) external returns (uint amount);
function setAdmin(address newAdmin) external ;
}
interface IforbitspaceX is IPayment {
struct SwapParam {
address addressToApprove;
address exchangeTarget;
address tokenIn; // tokenFrom
address tokenOut; // tokenTo
bytes swapData;
}
function aggregate(address tokenIn,
address tokenOut,
uint amountInTotal,
address recipient,
SwapParam[] calldata params) external payable returns (uint amountInAcutual, uint amountOutAcutual);
}
//
interface IERC20 {
function totalSupply() external view returns (uint);
function balanceOf(address account) external view returns (uint);
function transfer(address recipient, uint amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
//
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint 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,
uint value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint value) internal {
uint newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint value) internal {
unchecked {
uint oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint 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");
}
}
}
library SafeMath {
function tryAdd(uint a, uint b) internal pure returns (bool, uint) {
unchecked {
uint c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint a, uint b) internal pure returns (bool, uint) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint a, uint b) internal pure returns (bool, uint) {
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);
uint c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint a, uint b) internal pure returns (bool, uint) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint a, uint b) internal pure returns (bool, uint) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint a, uint b) internal pure returns (uint) {
return a + b;
}
function sub(uint a, uint b) internal pure returns (uint) {
return a - b;
}
function mul(uint a, uint b) internal pure returns (uint) {
return a * b;
}
function div(uint a, uint b) internal pure returns (uint) {
return a / b;
}
function mod(uint a, uint b) internal pure returns (uint) {
return a % b;
}
function sub(uint a,
uint b,
string memory errorMessage) internal pure returns (uint) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint a,
uint b,
string memory errorMessage) internal pure returns (uint) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint a,
uint b,
string memory errorMessage) internal pure returns (uint) {
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);
}
}
interface IWETH is IERC20 {
/// @notice Deposit ether to get wrapped ether
function deposit() external payable;
/// @notice Withdraw wrapped ether to get ether
function withdraw(uint) external;
}
abstract contract Payment is IPayment, Ownable {
using SafeMath for uint;
using SafeERC20 for IERC20;
address public constant ETH_ADDRESS = address(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);
address public immutable WETH_ADDRESS;
address public admin;
receive() external payable {}
constructor(address _WETH, address _admin) {
WETH_ADDRESS = _WETH;
admin = _admin;
}
function approve(address addressToApprove,
address token,
uint amount) internal {
if (IERC20(token).allowance(address(this), addressToApprove) < amount) {
IERC20(token).safeApprove(addressToApprove, 0);
IERC20(token).safeIncreaseAllowance(addressToApprove, amount);
}
}
function balanceOf(address token) internal view returns (uint bal) {
if (token == ETH_ADDRESS) {
token = WETH_ADDRESS;
}
bal = IERC20(token).balanceOf(address(this));
}
function pay(address recipient,
address token,
uint amount) internal {
if (amount > 0) {
if (recipient == address(this)) {
if (token == ETH_ADDRESS) {
IWETH(WETH_ADDRESS).deposit{ value: amount }();
} else {
IERC20(token).safeTransferFrom(_msgSender(), address(this), amount);
}
} else {
if (token == ETH_ADDRESS) {
if (balanceOf(WETH_ADDRESS) > 0) IWETH(WETH_ADDRESS).withdraw(balanceOf(WETH_ADDRESS));
Address.sendValue(payable(recipient), amount);
} else {
IERC20(token).safeTransfer(recipient, amount);
}
}
}
}
function collectETH() public override returns (uint amount) {
if (balanceOf(WETH_ADDRESS) > 0) {
IWETH(WETH_ADDRESS).withdraw(balanceOf(WETH_ADDRESS));
}
if ((amount = address(this).balance) > 0) {
Address.sendValue(payable(admin), amount);
}
}
function collectTokens(address token) public override returns (uint amount) {
if (token == ETH_ADDRESS) {
amount = collectETH();
} else if ((amount = balanceOf(token)) > 0) {
IERC20(token).safeTransfer(admin, amount);
}
}
function setAdmin(address newAdmin) public override onlyOwner {
require(newAdmin != admin, "A_I_E"); // Admin is exist
admin = newAdmin;
}
}
//
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
//
contract forbitspaceX is IforbitspaceX, Payment, ReentrancyGuard {
using SafeMath for uint;
using Address for address;
constructor(address _WETH, address _admin) Payment(_WETH, _admin) {}
function aggregate(address tokenIn,
address tokenOut,
uint amountInTotal,
address recipient,
SwapParam[] calldata params) public payable override nonReentrant returns (uint amountInActual, uint amountOutActual) {
// check invalid tokens address
require(!(tokenIn == tokenOut), "I_T_A");
require(!(tokenIn == ETH_ADDRESS && tokenOut == WETH_ADDRESS), "I_T_A");
require(!(tokenIn == WETH_ADDRESS && tokenOut == ETH_ADDRESS), "I_T_A");
// check invalid value
if (tokenIn == ETH_ADDRESS) {
amountInTotal = msg.value;
} else {
require(msg.value == 0, "I_V");
}
require(amountInTotal > 0, "I_V");
// receive tokens
pay(address(this), tokenIn, amountInTotal);
// amountAcutual before
uint amountInBefore = balanceOf(tokenIn);
amountOutActual = balanceOf(tokenOut);
// call swap on multi dexs
_swap(params);
// amountAcutual after
amountInActual = amountInBefore.sub(balanceOf(tokenIn));
amountOutActual = balanceOf(tokenOut).sub(amountOutActual);
require((amountInActual > 0) && (amountOutActual > 0), "I_A_T_A"); // incorrect actual total amounts
// refund tokens
pay(_msgSender(), tokenIn, amountInBefore.sub(amountInActual, "N_E_T")); // not enough tokens
pay(recipient, tokenOut, amountOutActual.mul(9995).div(10000)); // 0.05% fee
// sweep tokens for owner
collectTokens(tokenIn);
collectTokens(tokenOut);
}
function _swap(SwapParam[] calldata params) private {
for (uint i = 0; i < params.length; i++) {
SwapParam calldata p = params[i];
(address exchangeTarget,
address addressToApprove,
address tokenIn,
address tokenOut,
bytes calldata swapData) = (p.exchangeTarget, p.addressToApprove, p.tokenIn, p.tokenOut, p.swapData);
// approve(addressToApprove, tokenIn, type(uint).max);
approve(addressToApprove, tokenIn, balanceOf(tokenIn));
uint amountInActual = balanceOf(tokenIn);
uint amountOutActual = balanceOf(tokenOut);
exchangeTarget.functionCall(swapData, "L_C_F"); // low-level call failed
// amountInActual = amountInActual.sub(balanceOf(tokenIn));
// amountOutActual = balanceOf(tokenOut).sub(amountOutActual);
bool success = ((balanceOf(tokenIn) < amountInActual) && (balanceOf(tokenOut) > amountOutActual));
require(success, "I_A_A"); // incorrect actual amounts
}
}
}
| 75,912 | 11,545 |
e6f3d4e80e2abce65b599df00afc65061f1aaea46869e99f155b4d647dbf7593
| 13,279 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/b3/b3c097640ea8f64b14cd52df33470abef6875416_arb.sol
| 2,827 | 11,484 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
interface IRouter {
function factory() external pure returns (address);
function WTRX() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityTRX(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountTRXMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountTRX, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function removeLiquidityTRX(address token,
uint liquidity,
uint amountTokenMin,
uint amountTRXMin,
address to,
uint deadline) external returns (uint amountToken, uint amountTRX);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function removeLiquidityTRXWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountTRXMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountTRX);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapExactTRXForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactTRX(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForTRX(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapTRXForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IAVAX20 {
function totalSupply() external view returns (uint256);
function deposit(uint256 amount) external payable;
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender)
external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value)
external returns (bool);
function transferFrom(address from, address to, uint256 value)
external returns (bool);
event Transfer(address indexed from,
address indexed to,
uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
interface IWAVAX {
function deposit() external payable;
function transfer(address to, uint value) external returns (bool);
function withdraw(uint) external;
function balanceOf(address who) external view returns (uint256);
}
library SafeMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x, 'ds-math-add-overflow');
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x, 'ds-math-sub-underflow');
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x, 'ds-math-mul-overflow');
}
}
contract arb is Ownable{
using SafeMath for uint;
address private WAVAX = address(0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7);
fallback() external payable{
}
uint256 private _balanceWAVAX;
function balanceWAVAX() public view returns (uint256) {
return _balanceWAVAX;
}
function swap(address[] memory path , address pair, uint256 amount, uint256 amount_outMin, uint256 reserve0Min, uint256 reserve1Min) external onlyOwner() {
if(getBalanceOfToken(path[0]) < amount){
revert("NEED MORE MONEY");
}
else{
(uint256 reserve0, uint256 reserve1,) = IUniswapV2Pair(pair).getReserves();
if(reserve0 < reserve0Min || reserve1 < reserve1Min){
revert("NEED MORE LIQUIDITY");
}
else{
uint256 amountBefore = IWAVAX(path[1]).balanceOf(msg.sender);
//address token0 = ;
//address token1 = ;
uint256 reserveIn = path[0] == IUniswapV2Pair(pair).token0() ? reserve0 : reserve1;
uint256 reserveOut = path[1] == IUniswapV2Pair(pair).token1() ? reserve1 : reserve0;
uint256 amountOut = calculate(amount, reserveIn, reserveOut);
(uint256 amount0Out, uint256 amount1Out) = path[0] == IUniswapV2Pair(pair).token0() ? (uint(0), amountOut) : (amountOut, uint(0));
//require(amountOut >= amount_outMin);
assert(IWAVAX(path[0]).transfer(pair, amount));
IUniswapV2Pair(pair).swap(amount0Out , amount1Out, msg.sender, new bytes(0));
if(IWAVAX(path[1]).balanceOf(msg.sender) < amountBefore + amount_outMin){
revert("NOT SUFFICIENT");
}
}
}
}
event Received(address, uint);
receive() external payable {
emit Received(msg.sender, msg.value);
}
function withdrawAVAX() external onlyOwner() {
payable(msg.sender).transfer(address(this).balance);
}
function withdrawToken(uint256 amount, address token) external onlyOwner{
IAVAX20(token).transfer(msg.sender, amount);
}
function wrapAVAX(uint256 amount) external onlyOwner{
IAVAX20(WAVAX).deposit(amount);
}
function getBalanceOfToken(address _address) public view returns (uint256) {
return IAVAX20(_address).balanceOf(address(this));
}
//function updateBalanceOfWAVAX() public view returns (uint256) {
//return IAVAX20(_address).balanceOf(address(this));
//}
function calculate(uint amountIn, uint reserveIn, uint reserveOut) internal pure returns (uint amountOut) {
uint amountInWithFee = amountIn.mul(997);
uint numerator = amountInWithFee.mul(reserveOut);
uint denominator = reserveIn.mul(1000).add(amountInWithFee);
amountOut = numerator / denominator;
}
// performs chained getAmountIn calculations on any number of pairs
function getAmountOut(address[] memory path , address pair, uint256 amount) internal view returns (uint amountOut) {
}
}
| 88,906 | 11,546 |
7ff9994a8198ffd494996035d7f102f9dcaaa450577f172f13adafe3fd1ca4ba
| 17,474 |
.sol
|
Solidity
| false |
627794329
|
uni-due-syssec/efcf-framework
|
c3088c935f567dc7fc286475d6759204b6e44ef5
|
data/smartbugs-top-1000-balance/0x06adba5ad6c494e536cad8afa1129ab9f7cb99bf.sol
| 3,946 | 14,122 |
pragma solidity ^0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract EOSBetGameInterface {
uint256 public DEVELOPERSFUND;
uint256 public LIABILITIES;
function payDevelopersFund(address developer) public;
function receivePaymentForOraclize() payable public;
function getMaxWin() public view returns(uint256);
}
contract EOSBetBankrollInterface {
function payEtherToWinner(uint256 amtEther, address winner) public;
function receiveEtherFromGameAddress() payable public;
function payOraclize(uint256 amountToPay) public;
function getBankroll() public view returns(uint256);
}
contract ERC20 {
function totalSupply() constant public returns (uint supply);
function balanceOf(address _owner) constant public returns (uint balance);
function transfer(address _to, uint _value) public returns (bool success);
function transferFrom(address _from, address _to, uint _value) public returns (bool success);
function approve(address _spender, uint _value) public returns (bool success);
function allowance(address _owner, address _spender) constant public returns (uint remaining);
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract EOSBetBankroll is ERC20, EOSBetBankrollInterface {
using SafeMath for *;
// constants for EOSBet Bankroll
address public OWNER;
uint256 public MAXIMUMINVESTMENTSALLOWED;
uint256 public WAITTIMEUNTILWITHDRAWORTRANSFER;
uint256 public DEVELOPERSFUND;
// this will be initialized as the trusted game addresses which will forward their ether
// to the bankroll contract, and when players win, they will request the bankroll contract
// to send these players their winnings.
// Feel free to audit these contracts on etherscan...
mapping(address => bool) public TRUSTEDADDRESSES;
address public DICE;
address public SLOTS;
// mapping to log the last time a user contributed to the bankroll
mapping(address => uint256) contributionTime;
// constants for ERC20 standard
string public constant name = "EOSBet Stake Tokens";
string public constant symbol = "EOSBETST";
uint8 public constant decimals = 18;
// variable total supply
uint256 public totalSupply;
// mapping to store tokens
mapping(address => uint256) public balances;
mapping(address => mapping(address => uint256)) public allowed;
// events
event FundBankroll(address contributor, uint256 etherContributed, uint256 tokensReceived);
event CashOut(address contributor, uint256 etherWithdrawn, uint256 tokensCashedIn);
event FailedSend(address sendTo, uint256 amt);
// checks that an address is a "trusted address of a legitimate EOSBet game"
modifier addressInTrustedAddresses(address thisAddress){
require(TRUSTEDADDRESSES[thisAddress]);
_;
}
// initialization function
function EOSBetBankroll(address dice, address slots) public payable {
// function is payable, owner of contract MUST "seed" contract with some ether,
// so that the ratios are correct when tokens are being minted
require (msg.value > 0);
OWNER = msg.sender;
// 100 tokens/ether is the inital seed amount, so:
uint256 initialTokens = msg.value * 100;
balances[msg.sender] = initialTokens;
totalSupply = initialTokens;
// log a mint tokens event
emit Transfer(0x0, msg.sender, initialTokens);
TRUSTEDADDRESSES[dice] = true;
TRUSTEDADDRESSES[slots] = true;
DICE = dice;
SLOTS = slots;
WAITTIMEUNTILWITHDRAWORTRANSFER = 6 hours;
MAXIMUMINVESTMENTSALLOWED = 500 ether;
}
///////////////////////////////////////////////
// VIEW FUNCTIONS
///////////////////////////////////////////////
function checkWhenContributorCanTransferOrWithdraw(address bankrollerAddress) view public returns(uint256){
return contributionTime[bankrollerAddress];
}
function getBankroll() view public returns(uint256){
// returns the total balance minus the developers fund, as the amount of active bankroll
return SafeMath.sub(address(this).balance, DEVELOPERSFUND);
}
///////////////////////////////////////////////
// BANKROLL CONTRACT <-> GAME CONTRACTS functions
///////////////////////////////////////////////
function payEtherToWinner(uint256 amtEther, address winner) public addressInTrustedAddresses(msg.sender){
// this function will get called by a game contract when someone wins a game
// try to send, if it fails, then send the amount to the owner
// note, this will only happen if someone is calling the betting functions with
// a contract. They are clearly up to no good, so they can contact us to retreive
// their ether
// if the ether cannot be sent to us, the OWNER, that means we are up to no good,
// and the ether will just be given to the bankrollers as if the player/owner lost
if (! winner.send(amtEther)){
emit FailedSend(winner, amtEther);
if (! OWNER.send(amtEther)){
emit FailedSend(OWNER, amtEther);
}
}
}
function receiveEtherFromGameAddress() payable public addressInTrustedAddresses(msg.sender){
// this function will get called from the game contracts when someone starts a game.
}
function payOraclize(uint256 amountToPay) public addressInTrustedAddresses(msg.sender){
// this function will get called when a game contract must pay payOraclize
EOSBetGameInterface(msg.sender).receivePaymentForOraclize.value(amountToPay)();
}
///////////////////////////////////////////////
// BANKROLL CONTRACT MAIN FUNCTIONS
///////////////////////////////////////////////
// this function ADDS to the bankroll of EOSBet, and credits the bankroller a proportional
// amount of tokens so they may withdraw their tokens later
function () public payable {
// save in memory for cheap access.
// this represents the total bankroll balance before the function was called.
uint256 currentTotalBankroll = SafeMath.sub(getBankroll(), msg.value);
uint256 maxInvestmentsAllowed = MAXIMUMINVESTMENTSALLOWED;
require(currentTotalBankroll < maxInvestmentsAllowed && msg.value != 0);
uint256 currentSupplyOfTokens = totalSupply;
uint256 contributedEther;
bool contributionTakesBankrollOverLimit;
uint256 ifContributionTakesBankrollOverLimit_Refund;
uint256 creditedTokens;
if (SafeMath.add(currentTotalBankroll, msg.value) > maxInvestmentsAllowed){
// allow the bankroller to contribute up to the allowed amount of ether, and refund the rest.
contributionTakesBankrollOverLimit = true;
// set contributed ether as (MAXIMUMINVESTMENTSALLOWED - BANKROLL)
contributedEther = SafeMath.sub(maxInvestmentsAllowed, currentTotalBankroll);
ifContributionTakesBankrollOverLimit_Refund = SafeMath.sub(msg.value, contributedEther);
}
else {
contributedEther = msg.value;
}
if (currentSupplyOfTokens != 0){
// determine the ratio of contribution versus total BANKROLL.
creditedTokens = SafeMath.mul(contributedEther, currentSupplyOfTokens) / currentTotalBankroll;
}
else {
// edge case where ALL money was cashed out from bankroll
// so currentSupplyOfTokens == 0
// currentTotalBankroll can == 0 or not, if someone mines/selfdestruct's to the contract
// but either way, give all the bankroll to person who deposits ether
creditedTokens = SafeMath.mul(contributedEther, 100);
}
// now update the total supply of tokens and bankroll amount
totalSupply = SafeMath.add(currentSupplyOfTokens, creditedTokens);
// now credit the user with his amount of contributed tokens
balances[msg.sender] = SafeMath.add(balances[msg.sender], creditedTokens);
// update his contribution time for stake time locking
contributionTime[msg.sender] = block.timestamp;
// now look if the attempted contribution would have taken the BANKROLL over the limit,
// and if true, refund the excess ether.
if (contributionTakesBankrollOverLimit){
msg.sender.transfer(ifContributionTakesBankrollOverLimit_Refund);
}
// log an event about funding bankroll
emit FundBankroll(msg.sender, contributedEther, creditedTokens);
// log a mint tokens event
emit Transfer(0x0, msg.sender, creditedTokens);
}
function cashoutEOSBetStakeTokens(uint256 _amountTokens) public {
// In effect, this function is the OPPOSITE of the un-named payable function above^^^
// is effectively guaranteed to withdraw more ether than they originally "staked"
// save in memory for cheap access.
uint256 tokenBalance = balances[msg.sender];
require(_amountTokens <= tokenBalance
&& contributionTime[msg.sender] + WAITTIMEUNTILWITHDRAWORTRANSFER <= block.timestamp
&& _amountTokens > 0);
// save in memory for cheap access.
// again, represents the total balance of the contract before the function was called.
uint256 currentTotalBankroll = getBankroll();
uint256 currentSupplyOfTokens = totalSupply;
// calculate the token withdraw ratio based on current supply
uint256 withdrawEther = SafeMath.mul(_amountTokens, currentTotalBankroll) / currentSupplyOfTokens;
// developers take 1% of withdrawls
uint256 developersCut = withdrawEther / 100;
uint256 contributorAmount = SafeMath.sub(withdrawEther, developersCut);
// now update the total supply of tokens by subtracting the tokens that are being "cashed in"
totalSupply = SafeMath.sub(currentSupplyOfTokens, _amountTokens);
// and update the users supply of tokens
balances[msg.sender] = SafeMath.sub(tokenBalance, _amountTokens);
// update the developers fund based on this calculated amount
DEVELOPERSFUND = SafeMath.add(DEVELOPERSFUND, developersCut);
// lastly, transfer the ether back to the bankroller. Thanks for your contribution!
msg.sender.transfer(contributorAmount);
// log an event about cashout
emit CashOut(msg.sender, contributorAmount, _amountTokens);
// log a destroy tokens event
emit Transfer(msg.sender, 0x0, _amountTokens);
}
function cashoutEOSBetStakeTokens_ALL() public {
// just forward to cashoutEOSBetStakeTokens with input as the senders entire balance
cashoutEOSBetStakeTokens(balances[msg.sender]);
}
////////////////////
// OWNER FUNCTIONS:
////////////////////
// Please, be aware that the owner ONLY can change:
// in higher dividends for the bankrollers
// "refund" function in the respective game smart contract once payouts are un-frozen.
function transferOwnership(address newOwner) public {
require(msg.sender == OWNER);
OWNER = newOwner;
}
function changeWaitTimeUntilWithdrawOrTransfer(uint256 waitTime) public {
// waitTime MUST be less than or equal to 10 weeks
require (msg.sender == OWNER && waitTime <= 6048000);
WAITTIMEUNTILWITHDRAWORTRANSFER = waitTime;
}
function changeMaximumInvestmentsAllowed(uint256 maxAmount) public {
require(msg.sender == OWNER);
MAXIMUMINVESTMENTSALLOWED = maxAmount;
}
function withdrawDevelopersFund(address receiver) public {
require(msg.sender == OWNER);
// first get developers fund from each game
EOSBetGameInterface(DICE).payDevelopersFund(receiver);
EOSBetGameInterface(SLOTS).payDevelopersFund(receiver);
// now send the developers fund from the main contract.
uint256 developersFund = DEVELOPERSFUND;
// set developers fund to zero
DEVELOPERSFUND = 0;
// transfer this amount to the owner!
receiver.transfer(developersFund);
}
// rescue tokens inadvertently sent to the contract address
function ERC20Rescue(address tokenAddress, uint256 amtTokens) public {
require (msg.sender == OWNER);
ERC20(tokenAddress).transfer(msg.sender, amtTokens);
}
///////////////////////////////
// BASIC ERC20 TOKEN OPERATIONS
///////////////////////////////
function totalSupply() constant public returns(uint){
return totalSupply;
}
function balanceOf(address _owner) constant public returns(uint){
return balances[_owner];
}
// don't allow transfers before the required wait-time
// and don't allow transfers to this contract addr, it'll just kill tokens
function transfer(address _to, uint256 _value) public returns (bool success){
require(balances[msg.sender] >= _value
&& contributionTime[msg.sender] + WAITTIMEUNTILWITHDRAWORTRANSFER <= block.timestamp
&& _to != address(this)
&& _to != address(0));
// safely subtract
balances[msg.sender] = SafeMath.sub(balances[msg.sender], _value);
balances[_to] = SafeMath.add(balances[_to], _value);
// log event
emit Transfer(msg.sender, _to, _value);
return true;
}
// don't allow transfers before the required wait-time
// and don't allow transfers to the contract addr, it'll just kill tokens
function transferFrom(address _from, address _to, uint _value) public returns(bool){
require(allowed[_from][msg.sender] >= _value
&& balances[_from] >= _value
&& contributionTime[_from] + WAITTIMEUNTILWITHDRAWORTRANSFER <= block.timestamp
&& _to != address(this)
&& _to != address(0));
// safely add to _to and subtract from _from, and subtract from allowed balances.
balances[_to] = SafeMath.add(balances[_to], _value);
balances[_from] = SafeMath.sub(balances[_from], _value);
allowed[_from][msg.sender] = SafeMath.sub(allowed[_from][msg.sender], _value);
// log event
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public returns(bool){
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
// log event
return true;
}
function allowance(address _owner, address _spender) constant public returns(uint){
return allowed[_owner][_spender];
}
}
| 270,753 | 11,547 |
19a8b1e03f2dae92ad54598bd414b60cb3c92499286780bd4195bd04b43d284f
| 19,234 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0xcba895771df58aa14b0e8396282bd7d5dba1db4e.sol
| 5,401 | 19,007 |
pragma solidity ^0.4.23;
interface ERC165 {
function supportsInterface(bytes4 interfaceID) external view returns (bool);
}
contract ERC721 is ERC165 {
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
function balanceOf(address _owner) external view returns (uint256);
function ownerOf(uint256 _tokenId) external view returns (address);
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) external;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external;
function transferFrom(address _from, address _to, uint256 _tokenId) external;
function approve(address _approved, uint256 _tokenId) external;
function setApprovalForAll(address _operator, bool _approved) external;
function getApproved(uint256 _tokenId) external view returns (address);
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}
interface ERC721TokenReceiver {
function onERC721Received(address _from, uint256 _tokenId, bytes data) external returns(bytes4);
}
contract Random {
uint256 _seed;
function _rand() internal returns (uint256) {
_seed = uint256(keccak256(_seed, blockhash(block.number - 1), block.coinbase, block.difficulty));
return _seed;
}
function _randBySeed(uint256 _outSeed) internal view returns (uint256) {
return uint256(keccak256(_outSeed, blockhash(block.number - 1), block.coinbase, block.difficulty));
}
}
contract AccessAdmin {
bool public isPaused = false;
address public addrAdmin;
event AdminTransferred(address indexed preAdmin, address indexed newAdmin);
constructor() public {
addrAdmin = msg.sender;
}
modifier onlyAdmin() {
require(msg.sender == addrAdmin);
_;
}
modifier whenNotPaused() {
require(!isPaused);
_;
}
modifier whenPaused {
require(isPaused);
_;
}
function setAdmin(address _newAdmin) external onlyAdmin {
require(_newAdmin != address(0));
emit AdminTransferred(addrAdmin, _newAdmin);
addrAdmin = _newAdmin;
}
function doPause() external onlyAdmin whenNotPaused {
isPaused = true;
}
function doUnpause() external onlyAdmin whenPaused {
isPaused = false;
}
}
contract AccessService is AccessAdmin {
address public addrService;
address public addrFinance;
modifier onlyService() {
require(msg.sender == addrService);
_;
}
modifier onlyFinance() {
require(msg.sender == addrFinance);
_;
}
function setService(address _newService) external {
require(msg.sender == addrService || msg.sender == addrAdmin);
require(_newService != address(0));
addrService = _newService;
}
function setFinance(address _newFinance) external {
require(msg.sender == addrFinance || msg.sender == addrAdmin);
require(_newFinance != address(0));
addrFinance = _newFinance;
}
}
contract ELHeroToken is ERC721,AccessAdmin{
struct Card {
uint16 protoId; // 0 10001-10025 Gen 0 Heroes
uint16 hero; // 1 1-25 hero ID
uint16 quality; // 2 rarities: 1 Common 2 Uncommon 3 Rare 4 Epic 5 Legendary 6 Gen 0 Heroes
uint16 feature; // 3 feature
uint16 level; // 4 level
uint16 attrExt1; // 5 future stat 1
uint16 attrExt2; // 6 future stat 2
}
Card[] public cardArray;
uint256 destroyCardCount;
mapping (uint256 => address) cardIdToOwner;
mapping (address => uint256[]) ownerToCardArray;
mapping (uint256 => uint256) cardIdToOwnerIndex;
mapping (uint256 => address) cardIdToApprovals;
mapping (address => mapping (address => bool)) operatorToApprovals;
mapping (address => bool) actionContracts;
function setActionContract(address _actionAddr, bool _useful) external onlyAdmin {
actionContracts[_actionAddr] = _useful;
}
function getActionContract(address _actionAddr) external view onlyAdmin returns(bool) {
return actionContracts[_actionAddr];
}
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
event CreateCard(address indexed owner, uint256 tokenId, uint16 protoId, uint16 hero, uint16 quality, uint16 createType);
event DeleteCard(address indexed owner, uint256 tokenId, uint16 deleteType);
event ChangeCard(address indexed owner, uint256 tokenId, uint16 changeType);
modifier isValidToken(uint256 _tokenId) {
require(_tokenId >= 1 && _tokenId <= cardArray.length);
require(cardIdToOwner[_tokenId] != address(0));
_;
}
modifier canTransfer(uint256 _tokenId) {
address owner = cardIdToOwner[_tokenId];
require(msg.sender == owner || msg.sender == cardIdToApprovals[_tokenId] || operatorToApprovals[owner][msg.sender]);
_;
}
function supportsInterface(bytes4 _interfaceId) external view returns(bool) {
return (_interfaceId == 0x01ffc9a7 || _interfaceId == 0x80ac58cd || _interfaceId == 0x8153916a) && (_interfaceId != 0xffffffff);
}
constructor() public {
addrAdmin = msg.sender;
cardArray.length += 1;
}
function name() public pure returns(string) {
return "Ether League Hero Token";
}
function symbol() public pure returns(string) {
return "ELHT";
}
function balanceOf(address _owner) external view returns (uint256){
require(_owner != address(0));
return ownerToCardArray[_owner].length;
}
function ownerOf(uint256 _tokenId) external view returns (address){
return cardIdToOwner[_tokenId];
}
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) external whenNotPaused{
_safeTransferFrom(_from, _to, _tokenId, data);
}
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external whenNotPaused{
_safeTransferFrom(_from, _to, _tokenId, "");
}
function transferFrom(address _from, address _to, uint256 _tokenId) external whenNotPaused isValidToken(_tokenId) canTransfer(_tokenId){
address owner = cardIdToOwner[_tokenId];
require(owner != address(0));
require(_to != address(0));
require(owner == _from);
_transfer(_from, _to, _tokenId);
}
function approve(address _approved, uint256 _tokenId) external whenNotPaused{
address owner = cardIdToOwner[_tokenId];
require(owner != address(0));
require(msg.sender == owner || operatorToApprovals[owner][msg.sender]);
cardIdToApprovals[_tokenId] = _approved;
emit Approval(owner, _approved, _tokenId);
}
function setApprovalForAll(address _operator, bool _approved) external whenNotPaused{
operatorToApprovals[msg.sender][_operator] = _approved;
emit ApprovalForAll(msg.sender, _operator, _approved);
}
function getApproved(uint256 _tokenId) external view isValidToken(_tokenId) returns (address) {
return cardIdToApprovals[_tokenId];
}
function isApprovedForAll(address _owner, address _operator) external view returns (bool) {
return operatorToApprovals[_owner][_operator];
}
function totalSupply() external view returns (uint256) {
return cardArray.length - destroyCardCount - 1;
}
function _safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) internal isValidToken(_tokenId) canTransfer(_tokenId){
address owner = cardIdToOwner[_tokenId];
require(owner != address(0));
require(_to != address(0));
require(owner == _from);
_transfer(_from, _to, _tokenId);
uint256 codeSize;
assembly { codeSize := extcodesize(_to) }
if (codeSize == 0) {
return;
}
bytes4 retval = ERC721TokenReceiver(_to).onERC721Received(_from, _tokenId, data);
require(retval == 0xf0b9e5ba);
}
function _transfer(address _from, address _to, uint256 _tokenId) internal {
if (_from != address(0)) {
uint256 indexFrom = cardIdToOwnerIndex[_tokenId];
uint256[] storage cdArray = ownerToCardArray[_from];
require(cdArray[indexFrom] == _tokenId);
if (indexFrom != cdArray.length - 1) {
uint256 lastTokenId = cdArray[cdArray.length - 1];
cdArray[indexFrom] = lastTokenId;
cardIdToOwnerIndex[lastTokenId] = indexFrom;
}
cdArray.length -= 1;
if (cardIdToApprovals[_tokenId] != address(0)) {
delete cardIdToApprovals[_tokenId];
}
}
cardIdToOwner[_tokenId] = _to;
ownerToCardArray[_to].push(_tokenId);
cardIdToOwnerIndex[_tokenId] = ownerToCardArray[_to].length - 1;
emit Transfer(_from != address(0) ? _from : this, _to, _tokenId);
}
function createCard(address _owner, uint16[5] _attrs, uint16 _createType) external whenNotPaused returns(uint256){
require(actionContracts[msg.sender]);
require(_owner != address(0));
uint256 newCardId = cardArray.length;
require(newCardId < 4294967296);
cardArray.length += 1;
Card storage cd = cardArray[newCardId];
cd.protoId = _attrs[0];
cd.hero = _attrs[1];
cd.quality = _attrs[2];
cd.feature = _attrs[3];
cd.level = _attrs[4];
_transfer(0, _owner, newCardId);
emit CreateCard(_owner, newCardId, _attrs[0], _attrs[1], _attrs[2], _createType);
return newCardId;
}
function _changeAttrByIndex(Card storage _cd, uint16 _index, uint16 _val) internal {
if (_index == 2) {
_cd.quality = _val;
} else if(_index == 3) {
_cd.feature = _val;
} else if(_index == 4) {
_cd.level = _val;
} else if(_index == 5) {
_cd.attrExt1 = _val;
} else if(_index == 6) {
_cd.attrExt2 = _val;
}
}
function changeCardAttr(uint256 _tokenId, uint16[5] _idxArray, uint16[5] _params, uint16 _changeType) external whenNotPaused isValidToken(_tokenId) {
require(actionContracts[msg.sender]);
Card storage cd = cardArray[_tokenId];
if (_idxArray[0] > 0) _changeAttrByIndex(cd, _idxArray[0], _params[0]);
if (_idxArray[1] > 0) _changeAttrByIndex(cd, _idxArray[1], _params[1]);
if (_idxArray[2] > 0) _changeAttrByIndex(cd, _idxArray[2], _params[2]);
if (_idxArray[3] > 0) _changeAttrByIndex(cd, _idxArray[3], _params[3]);
if (_idxArray[4] > 0) _changeAttrByIndex(cd, _idxArray[4], _params[4]);
emit ChangeCard(cardIdToOwner[_tokenId], _tokenId, _changeType);
}
function destroyCard(uint256 _tokenId, uint16 _deleteType) external whenNotPaused isValidToken(_tokenId) {
require(actionContracts[msg.sender]);
address _from = cardIdToOwner[_tokenId];
uint256 indexFrom = cardIdToOwnerIndex[_tokenId];
uint256[] storage cdArray = ownerToCardArray[_from];
require(cdArray[indexFrom] == _tokenId);
if (indexFrom != cdArray.length - 1) {
uint256 lastTokenId = cdArray[cdArray.length - 1];
cdArray[indexFrom] = lastTokenId;
cardIdToOwnerIndex[lastTokenId] = indexFrom;
}
cdArray.length -= 1;
cardIdToOwner[_tokenId] = address(0);
delete cardIdToOwnerIndex[_tokenId];
destroyCardCount += 1;
emit Transfer(_from, 0, _tokenId);
emit DeleteCard(_from, _tokenId, _deleteType);
}
function safeTransferByContract(uint256 _tokenId, address _to) external whenNotPaused{
require(actionContracts[msg.sender]);
require(_tokenId >= 1 && _tokenId <= cardArray.length);
address owner = cardIdToOwner[_tokenId];
require(owner != address(0));
require(_to != address(0));
require(owner != _to);
_transfer(owner, _to, _tokenId);
}
function getCard(uint256 _tokenId) external view isValidToken(_tokenId) returns (uint16[7] datas) {
Card storage cd = cardArray[_tokenId];
datas[0] = cd.protoId;
datas[1] = cd.hero;
datas[2] = cd.quality;
datas[3] = cd.feature;
datas[4] = cd.level;
datas[5] = cd.attrExt1;
datas[6] = cd.attrExt2;
}
function getOwnCard(address _owner) external view returns(uint256[] tokens, uint32[] flags) {
require(_owner != address(0));
uint256[] storage cdArray = ownerToCardArray[_owner];
uint256 length = cdArray.length;
tokens = new uint256[](length);
flags = new uint32[](length);
for (uint256 i = 0; i < length; ++i) {
tokens[i] = cdArray[i];
Card storage cd = cardArray[cdArray[i]];
flags[i] = uint32(uint32(cd.protoId) * 1000 + uint32(cd.hero) * 10 + cd.quality);
}
}
function getCardAttrs(uint256[] _tokens) external view returns(uint16[] attrs) {
uint256 length = _tokens.length;
require(length <= 64);
attrs = new uint16[](length * 11);
uint256 tokenId;
uint256 index;
for (uint256 i = 0; i < length; ++i) {
tokenId = _tokens[i];
if (cardIdToOwner[tokenId] != address(0)) {
index = i * 11;
Card storage cd = cardArray[tokenId];
attrs[index] = cd.hero;
attrs[index + 1] = cd.quality;
attrs[index + 2] = cd.feature;
attrs[index + 3] = cd.level;
attrs[index + 4] = cd.attrExt1;
attrs[index + 5] = cd.attrExt2;
}
}
}
}
contract Presale is AccessService, Random {
ELHeroToken tokenContract;
mapping (uint16 => uint16) public cardPresaleCounter;
mapping (address => uint16[]) OwnerToPresale;
uint256 public jackpotBalance;
event CardPreSelled(address indexed buyer, uint16 protoId);
event Jackpot(address indexed _winner, uint256 _value, uint16 _type);
constructor(address _nftAddr) public {
addrAdmin = msg.sender;
addrService = msg.sender;
addrFinance = msg.sender;
tokenContract = ELHeroToken(_nftAddr);
cardPresaleCounter[1] = 20; //Human Fighter
cardPresaleCounter[2] = 20; //Human Tank
cardPresaleCounter[3] = 20; //Human Marksman
cardPresaleCounter[4] = 20; //Human Mage
cardPresaleCounter[5] = 20; //Human Support
cardPresaleCounter[6] = 20; //Elf Fighter
cardPresaleCounter[7] = 20; //Elf Tank
cardPresaleCounter[8] = 20; //...
cardPresaleCounter[9] = 20;
cardPresaleCounter[10] = 20;
cardPresaleCounter[11] = 20;//Orc
cardPresaleCounter[12] = 20;
cardPresaleCounter[13] = 20;
cardPresaleCounter[14] = 20;
cardPresaleCounter[15] = 20;
cardPresaleCounter[16] = 20;//Undead
cardPresaleCounter[17] = 20;
cardPresaleCounter[18] = 20;
cardPresaleCounter[19] = 20;
cardPresaleCounter[20] = 20;
cardPresaleCounter[21] = 20;//Spirit
cardPresaleCounter[22] = 20;
cardPresaleCounter[23] = 20;
cardPresaleCounter[24] = 20;
cardPresaleCounter[25] = 20;
}
function() external payable {
require(msg.value > 0);
jackpotBalance += msg.value;
}
function setELHeroTokenAddr(address _nftAddr) external onlyAdmin {
tokenContract = ELHeroToken(_nftAddr);
}
function cardPresale(uint16 _protoId) external payable whenNotPaused{
uint16 curSupply = cardPresaleCounter[_protoId];
require(curSupply > 0);
require(msg.value == 0.25 ether);
uint16[] storage buyArray = OwnerToPresale[msg.sender];
uint16[5] memory param = [10000 + _protoId, _protoId, 6, 0, 1];
tokenContract.createCard(msg.sender, param, 1);
buyArray.push(_protoId);
cardPresaleCounter[_protoId] = curSupply - 1;
emit CardPreSelled(msg.sender, _protoId);
jackpotBalance += msg.value * 2 / 10;
addrFinance.transfer(address(this).balance - jackpotBalance);
uint256 seed = _rand();
if(seed % 100 == 99){
emit Jackpot(msg.sender, jackpotBalance, 2);
msg.sender.transfer(jackpotBalance);
}
}
function withdraw() external {
require(msg.sender == addrFinance || msg.sender == addrAdmin);
addrFinance.transfer(address(this).balance);
}
function getCardCanPresaleCount() external view returns (uint16[25] cntArray) {
cntArray[0] = cardPresaleCounter[1];
cntArray[1] = cardPresaleCounter[2];
cntArray[2] = cardPresaleCounter[3];
cntArray[3] = cardPresaleCounter[4];
cntArray[4] = cardPresaleCounter[5];
cntArray[5] = cardPresaleCounter[6];
cntArray[6] = cardPresaleCounter[7];
cntArray[7] = cardPresaleCounter[8];
cntArray[8] = cardPresaleCounter[9];
cntArray[9] = cardPresaleCounter[10];
cntArray[10] = cardPresaleCounter[11];
cntArray[11] = cardPresaleCounter[12];
cntArray[12] = cardPresaleCounter[13];
cntArray[13] = cardPresaleCounter[14];
cntArray[14] = cardPresaleCounter[15];
cntArray[15] = cardPresaleCounter[16];
cntArray[16] = cardPresaleCounter[17];
cntArray[17] = cardPresaleCounter[18];
cntArray[18] = cardPresaleCounter[19];
cntArray[19] = cardPresaleCounter[20];
cntArray[20] = cardPresaleCounter[21];
cntArray[21] = cardPresaleCounter[22];
cntArray[22] = cardPresaleCounter[23];
cntArray[23] = cardPresaleCounter[24];
cntArray[24] = cardPresaleCounter[25];
}
function getBuyCount(address _owner) external view returns (uint32) {
return uint32(OwnerToPresale[_owner].length);
}
function getBuyArray(address _owner) external view returns (uint16[]) {
uint16[] storage buyArray = OwnerToPresale[_owner];
return buyArray;
}
function eventPirze(address _addr, uint8 _id) public onlyAdmin{
require(_id == 20 || _id == 21);
uint16 curSupply = cardPresaleCounter[_id];
require(curSupply > 0);
uint16[] storage buyArray = OwnerToPresale[_addr];
uint16[5] memory param = [10000 + _id, _id, 6, 0, 1];
tokenContract.createCard(_addr, param, 1);
buyArray.push(_id);
cardPresaleCounter[_id] = curSupply - 1;
}
}
| 275,506 | 11,548 |
03cdb1afa427b36c2c1ab4cf468be1ad471a1d95233851c2d2e7bb92219aea97
| 27,153 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/a5/A5a72C1369324CAB9Bc5F51dD6D0e00f549a058c_MONTEStaking.sol
| 4,130 | 16,479 |
// 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;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IsOHM {
function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract MONTEStaking is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
address public immutable OHM;
address public immutable sOHM;
struct Epoch {
uint length;
uint number;
uint endBlock;
uint distribute;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
constructor (address _OHM,
address _sOHM,
uint _epochLength,
uint _firstEpochNumber,
uint _firstEpochBlock) {
require(_OHM != address(0));
OHM = _OHM;
require(_sOHM != address(0));
sOHM = _sOHM;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endBlock: _firstEpochBlock,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(OHM).safeTransferFrom(msg.sender, address(this), _amount);
Claim memory info = warmupInfo[ _recipient ];
require(!info.lock, "Deposits for account are locked");
warmupInfo[ _recipient ] = Claim ({
deposit: info.deposit.add(_amount),
gons: info.gons.add(IsOHM(sOHM).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sOHM).safeTransfer(warmupContract, _amount);
return true;
}
function claim(address _recipient) public {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
IWarmup(warmupContract).retrieve(_recipient, IsOHM(sOHM).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IsOHM(sOHM).balanceForGons(info.gons));
IERC20(OHM).safeTransfer(msg.sender, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
IERC20(sOHM).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(OHM).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IsOHM(sOHM).index();
}
function rebase() public {
if(epoch.endBlock <= block.number) {
IsOHM(sOHM).rebase(epoch.distribute, epoch.number);
epoch.endBlock = epoch.endBlock.add(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IsOHM(sOHM).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(OHM).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sOHM).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sOHM).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP, LOCKER }
function setContract(CONTRACTS _contract, address _address) external onlyManager() {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = _address;
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(warmupContract == address(0), "Warmup cannot be set more than once");
warmupContract = _address;
} else if (_contract == CONTRACTS.LOCKER) { // 2
require(locker == address(0), "Locker cannot be set more than once");
locker = _address;
}
}
function setWarmup(uint _warmupPeriod) external onlyManager() {
warmupPeriod = _warmupPeriod;
}
}
| 81,624 | 11,549 |
b43b2c702680c8bc50a94affd0b5fe459c66b0ec6efc6c80f69f6411ab9ca9cf
| 8,730 |
.sol
|
Solidity
| false |
461197211
|
sentimentxyz/oracle
|
815233add2d23a7e2a2c5136504537b234a65c47
|
src/uniswap/library/TickMath.sol
| 3,286 | 7,769 |
// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.17;
/// @title Math library for computing sqrt prices from ticks and vice versa
/// prices between 2**-128 and 2**128
/// Forked from https://github.com/Uniswap/v3-core/blob/main/contracts/libraries/TickMath.sol
library TickMath {
int24 internal constant MIN_TICK = -887272;
int24 internal constant MAX_TICK = -MIN_TICK;
uint160 internal constant MIN_SQRT_RATIO = 4295128739;
uint160 internal constant MAX_SQRT_RATIO = 1461446703485210103287273052203988822378723970342;
/// @notice Calculates sqrt(1.0001^tick) * 2^96
/// @dev Throws if |tick| > max tick
/// @param tick The input tick for the above formula
/// at the given tick
function getSqrtRatioAtTick(int24 tick) internal pure returns (uint160 sqrtPriceX96) {
uint256 absTick = tick < 0 ? uint256(-int256(tick)) : uint256(int256(tick));
require(absTick <= uint24(MAX_TICK), 'T');
uint256 ratio = absTick & 0x1 != 0 ? 0xfffcb933bd6fad37aa2d162d1a594001 : 0x100000000000000000000000000000000;
if (absTick & 0x2 != 0) ratio = (ratio * 0xfff97272373d413259a46990580e213a) >> 128;
if (absTick & 0x4 != 0) ratio = (ratio * 0xfff2e50f5f656932ef12357cf3c7fdcc) >> 128;
if (absTick & 0x8 != 0) ratio = (ratio * 0xffe5caca7e10e4e61c3624eaa0941cd0) >> 128;
if (absTick & 0x10 != 0) ratio = (ratio * 0xffcb9843d60f6159c9db58835c926644) >> 128;
if (absTick & 0x20 != 0) ratio = (ratio * 0xff973b41fa98c081472e6896dfb254c0) >> 128;
if (absTick & 0x40 != 0) ratio = (ratio * 0xff2ea16466c96a3843ec78b326b52861) >> 128;
if (absTick & 0x80 != 0) ratio = (ratio * 0xfe5dee046a99a2a811c461f1969c3053) >> 128;
if (absTick & 0x100 != 0) ratio = (ratio * 0xfcbe86c7900a88aedcffc83b479aa3a4) >> 128;
if (absTick & 0x200 != 0) ratio = (ratio * 0xf987a7253ac413176f2b074cf7815e54) >> 128;
if (absTick & 0x400 != 0) ratio = (ratio * 0xf3392b0822b70005940c7a398e4b70f3) >> 128;
if (absTick & 0x800 != 0) ratio = (ratio * 0xe7159475a2c29b7443b29c7fa6e889d9) >> 128;
if (absTick & 0x1000 != 0) ratio = (ratio * 0xd097f3bdfd2022b8845ad8f792aa5825) >> 128;
if (absTick & 0x2000 != 0) ratio = (ratio * 0xa9f746462d870fdf8a65dc1f90e061e5) >> 128;
if (absTick & 0x4000 != 0) ratio = (ratio * 0x70d869a156d2a1b890bb3df62baf32f7) >> 128;
if (absTick & 0x8000 != 0) ratio = (ratio * 0x31be135f97d08fd981231505542fcfa6) >> 128;
if (absTick & 0x10000 != 0) ratio = (ratio * 0x9aa508b5b7a84e1c677de54f3e99bc9) >> 128;
if (absTick & 0x20000 != 0) ratio = (ratio * 0x5d6af8dedb81196699c329225ee604) >> 128;
if (absTick & 0x40000 != 0) ratio = (ratio * 0x2216e584f5fa1ea926041bedfe98) >> 128;
if (absTick & 0x80000 != 0) ratio = (ratio * 0x48a170391f7dc42444e8fa2) >> 128;
if (tick > 0) ratio = type(uint256).max / ratio;
// this divides by 1<<32 rounding up to go from a Q128.128 to a Q128.96.
// we round up in the division so getTickAtSqrtRatio of the output price is always consistent
sqrtPriceX96 = uint160((ratio >> 32) + (ratio % (1 << 32) == 0 ? 0 : 1));
}
/// @notice Calculates the greatest tick value such that getRatioAtTick(tick) <= ratio
/// ever return.
/// @param sqrtPriceX96 The sqrt ratio for which to compute the tick as a Q64.96
/// @return tick The greatest tick for which the ratio is less than or equal to the input ratio
function getTickAtSqrtRatio(uint160 sqrtPriceX96) internal pure returns (int24 tick) {
// second inequality must be < because the price can never reach the price at the max tick
require(sqrtPriceX96 >= MIN_SQRT_RATIO && sqrtPriceX96 < MAX_SQRT_RATIO, 'R');
uint256 ratio = uint256(sqrtPriceX96) << 32;
uint256 r = ratio;
uint256 msb = 0;
assembly {
let f := shl(7, gt(r, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := shl(6, gt(r, 0xFFFFFFFFFFFFFFFF))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := shl(5, gt(r, 0xFFFFFFFF))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := shl(4, gt(r, 0xFFFF))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := shl(3, gt(r, 0xFF))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := shl(2, gt(r, 0xF))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := shl(1, gt(r, 0x3))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := gt(r, 0x1)
msb := or(msb, f)
}
if (msb >= 128) r = ratio >> (msb - 127);
else r = ratio << (127 - msb);
int256 log_2 = (int256(msb) - 128) << 64;
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(63, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(62, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(61, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(60, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(59, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(58, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(57, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(56, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(55, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(54, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(53, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(52, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(51, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(50, f))
}
int256 log_sqrt10001 = log_2 * 255738958999603826347141; // 128.128 number
int24 tickLow = int24((log_sqrt10001 - 3402992956809132418596140100660247210) >> 128);
int24 tickHi = int24((log_sqrt10001 + 291339464771989622907027621153398088495) >> 128);
tick = tickLow == tickHi ? tickLow : getSqrtRatioAtTick(tickHi) <= sqrtPriceX96 ? tickHi : tickLow;
}
}
| 4,485 | 11,550 |
0ff0466220664543f885908f9fd679ea8aeaac2e94f77b315db769cd8aafab83
| 35,551 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/53/537664bb98265aa13befe40757ae1ed19d1369a4_WCTrophies.sol
| 4,690 | 19,057 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
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);
}
}
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);
}
}
}
}
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 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 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 IERC1155MetadataURI is IERC1155 {
function uri(uint256 id) external view returns (string memory);
}
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: balance query for the zero address");
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 {
require(_msgSender() != operator, "ERC1155: setting approval status for self");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_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 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: transfer caller is not 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();
_beforeTokenTransfer(operator, from, to, _asSingletonArray(id), _asSingletonArray(amount), 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);
_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);
_doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, amounts, data);
}
function _setURI(string memory newuri) internal virtual {
_uri = newuri;
}
function _mint(address account,
uint256 id,
uint256 amount,
bytes memory data) internal virtual {
require(account != address(0), "ERC1155: mint to the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, address(0), account, _asSingletonArray(id), _asSingletonArray(amount), data);
_balances[id][account] += amount;
emit TransferSingle(operator, address(0), account, id, amount);
_doSafeTransferAcceptanceCheck(operator, address(0), account, 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);
_doSafeBatchTransferAcceptanceCheck(operator, address(0), to, ids, amounts, data);
}
function _burn(address account,
uint256 id,
uint256 amount) internal virtual {
require(account != address(0), "ERC1155: burn from the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, account, address(0), _asSingletonArray(id), _asSingletonArray(amount), "");
uint256 accountBalance = _balances[id][account];
require(accountBalance >= amount, "ERC1155: burn amount exceeds balance");
unchecked {
_balances[id][account] = accountBalance - amount;
}
emit TransferSingle(operator, account, address(0), id, amount);
}
function _burnBatch(address account,
uint256[] memory ids,
uint256[] memory amounts) internal virtual {
require(account != address(0), "ERC1155: burn from the zero address");
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
_beforeTokenTransfer(operator, account, address(0), ids, amounts, "");
for (uint256 i = 0; i < ids.length; i++) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 accountBalance = _balances[id][account];
require(accountBalance >= amount, "ERC1155: burn amount exceeds balance");
unchecked {
_balances[id][account] = accountBalance - amount;
}
}
emit TransferBatch(operator, account, address(0), ids, amounts);
}
function _beforeTokenTransfer(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;
}
}
abstract contract ERC1155Supply is ERC1155 {
mapping(uint256 => uint256) private _totalSupply;
function totalSupply(uint256 id) public view virtual returns (uint256) {
return _totalSupply[id];
}
function exists(uint256 id) public view virtual returns (bool) {
return ERC1155Supply.totalSupply(id) > 0;
}
function _mint(address account,
uint256 id,
uint256 amount,
bytes memory data) internal virtual override {
super._mint(account, id, amount, data);
_totalSupply[id] += amount;
}
function _mintBatch(address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data) internal virtual override {
super._mintBatch(to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; ++i) {
_totalSupply[ids[i]] += amounts[i];
}
}
function _burn(address account,
uint256 id,
uint256 amount) internal virtual override {
super._burn(account, id, amount);
_totalSupply[id] -= amount;
}
function _burnBatch(address account,
uint256[] memory ids,
uint256[] memory amounts) internal virtual override {
super._burnBatch(account, ids, amounts);
for (uint256 i = 0; i < ids.length; ++i) {
_totalSupply[ids[i]] -= amounts[i];
}
}
}
abstract contract ERC1155Burnable is ERC1155 {
function burn(address account,
uint256 id,
uint256 value) public virtual {
require(account == _msgSender() || isApprovedForAll(account, _msgSender()),
"ERC1155: caller is not owner nor approved");
_burn(account, id, value);
}
function burnBatch(address account,
uint256[] memory ids,
uint256[] memory values) public virtual {
require(account == _msgSender() || isApprovedForAll(account, _msgSender()),
"ERC1155: caller is not owner nor approved");
_burnBatch(account, ids, values);
}
}
contract WCTrophies is ERC1155, Ownable, ERC1155Burnable {
constructor() ERC1155("Weaponized Arena Trophies") {}
mapping(uint256 => uint256) public _uris;
mapping(uint256 => string) private trophyTypes;
mapping(uint256 => bool) public _exists;
function mint(address to, uint256 id, uint256 amount, bytes memory data) public onlyOwner
{
_mint(to, id, amount, data);
if (!_exists[id]) {
_exists[id] = true;
}
}
function uri(uint256 tokenId) override public view returns (string memory) {
require(_exists[tokenId]);
return(trophyTypes[_uris[tokenId]]);
}
function setTypeURI(uint256 index, string memory URL) public onlyOwner {
trophyTypes[index] = URL;
}
}
| 325,268 | 11,551 |
03a49eda56c27788999bd59d4d2d6ec026a03b637f2c64f09229ad73f95b0434
| 15,287 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/6b/6B6ADeaD554297F38D630583A34B512D43c4c702_MarsDogToken.sol
| 3,779 | 14,447 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.6;
pragma experimental ABIEncoderV2;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address internal _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function transferOwnership(address newOwner) public virtual onlyOwner {
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
library TransferHelper {
function safeApprove(address token, address to, uint value) internal {
// bytes4(keccak256(bytes('approve(address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: APPROVE_FAILED');
}
function safeTransfer(address token, address to, uint value) internal {
// bytes4(keccak256(bytes('transfer(address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FAILED');
}
function safeTransferFrom(address token, address from, address to, uint value) internal {
// bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FROM_FAILED');
}
function safeTransferETH(address to, uint value) internal {
(bool success,) = to.call{value:value}(new bytes(0));
require(success, 'TransferHelper: ETH_TRANSFER_FAILED');
}
}
contract MarsDogToken is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
address public lastSwapUser;
uint public lastSwapTime;
uint public lotteryAmount;
uint8 private _decimals = 18;
uint256 private _tTotal = 1000000000000000 * 10 ** 18;
string private _name = "MarsDog";
string private _symbol = "MarsDog";
uint public _mkFee = 40;
uint public _lotteryFee = 10;
uint public _burnFee = 10;
uint public lotteryInterval = 7200;
bool public lotterySwitch;
mapping(address => bool) public ammPairs;
address public constant mkAddress = address(0xe503D980AD6C700BC11FCE688406245F1E4fa700);
constructor (address _holder) public {
_tOwned[_holder] = _tTotal;
_isExcludedFromFee[_holder] = true;
_isExcludedFromFee[address(this)] = true;
_owner = msg.sender;
emit Transfer(address(0), _holder, _tTotal);
}
function setLotterySwitch(bool _lotterySwitch)external onlyOwner{
lotterySwitch = _lotterySwitch;
}
function setFee(uint mkFee,uint lotteryFee,uint burnFee)external onlyOwner{
_burnFee = burnFee;
_lotteryFee = lotteryFee;
_mkFee = mkFee;
}
function setLotteryInterval(uint _lotteryInterval)external onlyOwner{
lotteryInterval = _lotteryInterval;
}
function setAmmPair(address pair,bool hasPair)external onlyOwner{
ammPairs[pair] = hasPair;
}
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) {
return _tOwned[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 isExcludedFromFee(address account) public view returns(bool) {
return _isExcludedFromFee[account];
}
receive() external payable {}
function _take(uint256 tValue,address from,address to) private {
_tOwned[to] = _tOwned[to].add(tValue);
emit Transfer(from, to, tValue);
}
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);
}
struct Param{
bool takeFee;
uint tTransferAmount;
uint tMk;
uint tLottery;
uint tBurn;
}
function _initParam(uint256 tAmount,Param memory param) private view {
uint tFee = 0;
if(param.takeFee){
if(_mkFee > 0){
param.tMk = tAmount * _mkFee / 1000;
}
if(_lotteryFee > 0){
param.tLottery = tAmount * _lotteryFee / 1000;
}
if(_burnFee > 0){
param.tBurn = tAmount * _burnFee / 1000;
}
tFee = param.tMk + param.tLottery + param.tBurn;
}
param.tTransferAmount = tAmount.sub(tFee);
}
function _takeFee(Param memory param,address from)private {
if(param.tMk > 0){
_take(param.tMk, from, mkAddress);
}
if(param.tBurn > 0){
_take(param.tBurn, from, address(0x0));
}
if(param.tLottery > 0){
_take(param.tLottery, from, address(this));
lotteryAmount += param.tLottery;
}
}
function _doTransfer(address sender, address recipient, uint256 tAmount) private {
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_tOwned[recipient] = _tOwned[recipient].add(tAmount);
emit Transfer(sender, recipient, tAmount);
}
function _sendLottery()private{
uint award = lotteryAmount;
lotteryAmount = 0;
_doTransfer(address(this),lastSwapUser,award);
}
function _transfer(address from,
address to,
uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint time = block.timestamp;
if (from != address(this)
&& lotterySwitch
&& lotteryAmount >= 1e18
&& lastSwapTime > 0
&& lastSwapUser != address(0)
&& time >= lastSwapTime + lotteryInterval
&& lotteryAmount <= balanceOf(address(this))
&& !_isContract(lastSwapUser)) {
_sendLottery();
lastSwapTime = 0;
lastSwapUser = address(0);
}
Param memory param;
bool takeFee = false;
if(ammPairs[to] && !_isExcludedFromFee[from]){
takeFee = false;
lastSwapTime = block.timestamp;
lastSwapUser = from;
}
if(ammPairs[from] && !_isExcludedFromFee[to]){
takeFee = true;
lastSwapTime = block.timestamp;
lastSwapUser = to;
}
param.takeFee = takeFee;
_initParam(amount,param);
_tokenTransfer(from,to,amount,param);
}
function _tokenTransfer(address sender, address recipient, uint256 tAmount,Param memory param) private {
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_tOwned[recipient] = _tOwned[recipient].add(param.tTransferAmount);
emit Transfer(sender, recipient, param.tTransferAmount);
if(param.takeFee){
_takeFee(param,sender);
}
}
function donateDust(address addr, uint256 amount) external onlyOwner {
TransferHelper.safeTransfer(addr, _msgSender(), amount);
}
function donateEthDust(uint256 amount) external onlyOwner {
TransferHelper.safeTransferETH(_msgSender(), amount);
}
function _isContract(address a) internal view returns(bool){
uint256 size;
assembly {size := extcodesize(a)}
return size > 0;
}
}
| 38,561 | 11,552 |
1fae5ba34ef553152d4d47fc4c128577615f344632981530431efb66876d91a1
| 31,550 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x00b113a5570a046c60ac8cfa4983b1dc1c780629.sol
| 5,671 | 18,176 |
pragma solidity >=0.5.4 <0.6.0;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes calldata _extraData) external; }
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
interface INameTAOPosition {
function senderIsAdvocate(address _sender, address _id) external view returns (bool);
function senderIsListener(address _sender, address _id) external view returns (bool);
function senderIsSpeaker(address _sender, address _id) external view returns (bool);
function senderIsPosition(address _sender, address _id) external view returns (bool);
function getAdvocate(address _id) external view returns (address);
function nameIsAdvocate(address _nameId, address _id) external view returns (bool);
function nameIsPosition(address _nameId, address _id) external view returns (bool);
function initialize(address _id, address _advocateId, address _listenerId, address _speakerId) external returns (bool);
function determinePosition(address _sender, address _id) external view returns (uint256);
}
interface INameTAOLookup {
function isExist(string calldata _name) external view returns (bool);
function initialize(string calldata _name, address _nameTAOId, uint256 _typeId, string calldata _parentName, address _parentId, uint256 _parentTypeId) external returns (bool);
function getById(address _id) external view returns (string memory, address, uint256, string memory, address, uint256);
function getIdByName(string calldata _name) external view returns (address);
}
contract TheAO {
address public theAO;
address public nameTAOPositionAddress;
// Check whether an address is whitelisted and granted access to transact
// on behalf of others
mapping (address => bool) public whitelist;
constructor() public {
theAO = msg.sender;
}
modifier inWhitelist() {
require (whitelist[msg.sender] == true);
_;
}
function transferOwnership(address _theAO) public {
require (msg.sender == theAO);
require (_theAO != address(0));
theAO = _theAO;
}
function setWhitelist(address _account, bool _whitelist) public {
require (msg.sender == theAO);
require (_account != address(0));
whitelist[_account] = _whitelist;
}
}
contract TokenERC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This generates a public event on the blockchain that will notify clients
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
constructor (uint256 initialSupply, string memory tokenName, string memory tokenSymbol) public {
totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
}
function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != address(0));
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value > balanceOf[_to]);
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from] + balanceOf[_to];
// Subtract from the sender
balanceOf[_from] -= _value;
// Add the same to the recipient
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function transfer(address _to, uint256 _value) public returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes memory _extraData) public returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, address(this), _extraData);
return true;
}
}
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
emit Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Subtract from the targeted balance
allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
emit Burn(_from, _value);
return true;
}
}
contract TAO {
using SafeMath for uint256;
address public vaultAddress;
string public name; // the name for this TAO
address public originId; // the ID of the Name that created this TAO. If Name, it's the eth address
// TAO's data
string public datHash;
string public database;
string public keyValue;
bytes32 public contentId;
uint8 public typeId;
constructor (string memory _name,
address _originId,
string memory _datHash,
string memory _database,
string memory _keyValue,
bytes32 _contentId,
address _vaultAddress) public {
name = _name;
originId = _originId;
datHash = _datHash;
database = _database;
keyValue = _keyValue;
contentId = _contentId;
// Creating TAO
typeId = 0;
vaultAddress = _vaultAddress;
}
modifier onlyVault {
require (msg.sender == vaultAddress);
_;
}
function () external payable {
}
function transferEth(address payable _recipient, uint256 _amount) public onlyVault returns (bool) {
_recipient.transfer(_amount);
return true;
}
function transferERC20(address _erc20TokenAddress, address _recipient, uint256 _amount) public onlyVault returns (bool) {
TokenERC20 _erc20 = TokenERC20(_erc20TokenAddress);
_erc20.transfer(_recipient, _amount);
return true;
}
}
contract Name is TAO {
constructor (string memory _name, address _originId, string memory _datHash, string memory _database, string memory _keyValue, bytes32 _contentId, address _vaultAddress)
TAO (_name, _originId, _datHash, _database, _keyValue, _contentId, _vaultAddress) public {
// Creating Name
typeId = 1;
}
}
library AOLibrary {
using SafeMath for uint256;
uint256 constant private _MULTIPLIER_DIVISOR = 10 ** 6; // 1000000 = 1
uint256 constant private _PERCENTAGE_DIVISOR = 10 ** 6; // 100% = 1000000
function isTAO(address _taoId) public view returns (bool) {
return (_taoId != address(0) && bytes(TAO(address(uint160(_taoId))).name()).length > 0 && TAO(address(uint160(_taoId))).originId() != address(0) && TAO(address(uint160(_taoId))).typeId() == 0);
}
function isName(address _nameId) public view returns (bool) {
return (_nameId != address(0) && bytes(TAO(address(uint160(_nameId))).name()).length > 0 && Name(address(uint160(_nameId))).originId() != address(0) && Name(address(uint160(_nameId))).typeId() == 1);
}
function isValidERC20TokenAddress(address _tokenAddress) public view returns (bool) {
if (_tokenAddress == address(0)) {
return false;
}
TokenERC20 _erc20 = TokenERC20(_tokenAddress);
return (_erc20.totalSupply() >= 0 && bytes(_erc20.name()).length > 0 && bytes(_erc20.symbol()).length > 0);
}
function isTheAO(address _sender, address _theAO, address _nameTAOPositionAddress) public view returns (bool) {
return (_sender == _theAO ||
((isTAO(_theAO) || isName(_theAO)) &&
_nameTAOPositionAddress != address(0) &&
INameTAOPosition(_nameTAOPositionAddress).senderIsAdvocate(_sender, _theAO)));
}
function PERCENTAGE_DIVISOR() public pure returns (uint256) {
return _PERCENTAGE_DIVISOR;
}
function MULTIPLIER_DIVISOR() public pure returns (uint256) {
return _MULTIPLIER_DIVISOR;
}
function deployTAO(string memory _name,
address _originId,
string memory _datHash,
string memory _database,
string memory _keyValue,
bytes32 _contentId,
address _nameTAOVaultAddress) public returns (TAO _tao) {
_tao = new TAO(_name, _originId, _datHash, _database, _keyValue, _contentId, _nameTAOVaultAddress);
}
function deployName(string memory _name,
address _originId,
string memory _datHash,
string memory _database,
string memory _keyValue,
bytes32 _contentId,
address _nameTAOVaultAddress) public returns (Name _myName) {
_myName = new Name(_name, _originId, _datHash, _database, _keyValue, _contentId, _nameTAOVaultAddress);
}
function calculateWeightedMultiplier(uint256 _currentWeightedMultiplier, uint256 _currentPrimordialBalance, uint256 _additionalWeightedMultiplier, uint256 _additionalPrimordialAmount) public pure returns (uint256) {
if (_currentWeightedMultiplier > 0) {
uint256 _totalWeightedIons = (_currentWeightedMultiplier.mul(_currentPrimordialBalance)).add(_additionalWeightedMultiplier.mul(_additionalPrimordialAmount));
uint256 _totalIons = _currentPrimordialBalance.add(_additionalPrimordialAmount);
return _totalWeightedIons.div(_totalIons);
} else {
return _additionalWeightedMultiplier;
}
}
function calculatePrimordialMultiplier(uint256 _purchaseAmount, uint256 _totalPrimordialMintable, uint256 _totalPrimordialMinted, uint256 _startingMultiplier, uint256 _endingMultiplier) public pure returns (uint256) {
if (_purchaseAmount > 0 && _purchaseAmount <= _totalPrimordialMintable.sub(_totalPrimordialMinted)) {
uint256 temp = _totalPrimordialMinted.add(_purchaseAmount.div(2));
uint256 multiplier = (_MULTIPLIER_DIVISOR.sub(_MULTIPLIER_DIVISOR.mul(temp).div(_totalPrimordialMintable))).mul(_startingMultiplier.sub(_endingMultiplier));
return multiplier.div(_MULTIPLIER_DIVISOR);
} else {
return 0;
}
}
function calculateNetworkBonusPercentage(uint256 _purchaseAmount, uint256 _totalPrimordialMintable, uint256 _totalPrimordialMinted, uint256 _startingMultiplier, uint256 _endingMultiplier) public pure returns (uint256) {
if (_purchaseAmount > 0 && _purchaseAmount <= _totalPrimordialMintable.sub(_totalPrimordialMinted)) {
uint256 temp = _totalPrimordialMinted.add(_purchaseAmount.div(2));
uint256 bonusPercentage = (_PERCENTAGE_DIVISOR.sub(_PERCENTAGE_DIVISOR.mul(temp).div(_totalPrimordialMintable))).mul(_startingMultiplier.sub(_endingMultiplier)).div(_PERCENTAGE_DIVISOR);
return bonusPercentage;
} else {
return 0;
}
}
function calculateNetworkBonusAmount(uint256 _purchaseAmount, uint256 _totalPrimordialMintable, uint256 _totalPrimordialMinted, uint256 _startingMultiplier, uint256 _endingMultiplier) public pure returns (uint256) {
uint256 bonusPercentage = calculateNetworkBonusPercentage(_purchaseAmount, _totalPrimordialMintable, _totalPrimordialMinted, _startingMultiplier, _endingMultiplier);
uint256 networkBonus = bonusPercentage.mul(_purchaseAmount).div(_PERCENTAGE_DIVISOR);
return networkBonus;
}
function calculateMaximumBurnAmount(uint256 _primordialBalance, uint256 _currentWeightedMultiplier, uint256 _maximumMultiplier) public pure returns (uint256) {
return (_maximumMultiplier.mul(_primordialBalance).sub(_primordialBalance.mul(_currentWeightedMultiplier))).div(_maximumMultiplier);
}
function calculateMultiplierAfterBurn(uint256 _primordialBalance, uint256 _currentWeightedMultiplier, uint256 _amountToBurn) public pure returns (uint256) {
return _primordialBalance.mul(_currentWeightedMultiplier).div(_primordialBalance.sub(_amountToBurn));
}
function calculateMultiplierAfterConversion(uint256 _primordialBalance, uint256 _currentWeightedMultiplier, uint256 _amountToConvert) public pure returns (uint256) {
return _primordialBalance.mul(_currentWeightedMultiplier).div(_primordialBalance.add(_amountToConvert));
}
function numDigits(uint256 number) public pure returns (uint8) {
uint8 digits = 0;
while(number != 0) {
number = number.div(10);
digits++;
}
return digits;
}
}
contract NameTAOLookup is TheAO, INameTAOLookup {
address public nameFactoryAddress;
address public taoFactoryAddress;
struct NameTAOInfo {
string name;
address nameTAOId;
uint256 typeId; // 0 = TAO. 1 = Name
string parentName;
address parentId; // Can be a Name ID/TAO ID/ETH address
uint256 parentTypeId; // 0 = TAO. 1 = Name. 2 = ETH address
}
uint256 public totalNames;
uint256 public totalTAOs;
// Mapping from Name/TAO ID to NameTAOInfo
mapping (address => NameTAOInfo) internal nameTAOInfos;
// Mapping from name to Name/TAO ID
mapping (bytes32 => address) internal nameToNameTAOIdLookup;
constructor(address _nameFactoryAddress, address _taoFactoryAddress, address _nameTAOPositionAddress) public {
setNameFactoryAddress(_nameFactoryAddress);
setTAOFactoryAddress(_taoFactoryAddress);
setNameTAOPositionAddress(_nameTAOPositionAddress);
}
modifier onlyTheAO {
require (AOLibrary.isTheAO(msg.sender, theAO, nameTAOPositionAddress));
_;
}
modifier onlyFactory {
require (msg.sender == nameFactoryAddress || msg.sender == taoFactoryAddress);
_;
}
function transferOwnership(address _theAO) public onlyTheAO {
require (_theAO != address(0));
theAO = _theAO;
}
function setWhitelist(address _account, bool _whitelist) public onlyTheAO {
require (_account != address(0));
whitelist[_account] = _whitelist;
}
function setNameFactoryAddress(address _nameFactoryAddress) public onlyTheAO {
require (_nameFactoryAddress != address(0));
nameFactoryAddress = _nameFactoryAddress;
}
function setTAOFactoryAddress(address _taoFactoryAddress) public onlyTheAO {
require (_taoFactoryAddress != address(0));
taoFactoryAddress = _taoFactoryAddress;
}
function setNameTAOPositionAddress(address _nameTAOPositionAddress) public onlyTheAO {
require (_nameTAOPositionAddress != address(0));
nameTAOPositionAddress = _nameTAOPositionAddress;
}
function isExist(string calldata _name) external view returns (bool) {
bytes32 _nameKey = keccak256(abi.encodePacked(_name));
return (nameToNameTAOIdLookup[_nameKey] != address(0));
}
function initialize(string calldata _name, address _nameTAOId, uint256 _typeId, string calldata _parentName, address _parentId, uint256 _parentTypeId) external onlyFactory returns (bool) {
require (bytes(_name).length > 0);
require (_nameTAOId != address(0));
require (_typeId == 0 || _typeId == 1);
require (bytes(_parentName).length > 0);
require (_parentId != address(0));
require (_parentTypeId >= 0 && _parentTypeId <= 2);
require (!this.isExist(_name));
if (_parentTypeId != 2) {
require (this.isExist(_parentName));
}
bytes32 _nameKey = keccak256(abi.encodePacked(_name));
nameToNameTAOIdLookup[_nameKey] = _nameTAOId;
NameTAOInfo storage _nameTAOInfo = nameTAOInfos[_nameTAOId];
_nameTAOInfo.name = _name;
_nameTAOInfo.nameTAOId = _nameTAOId;
_nameTAOInfo.typeId = _typeId;
_nameTAOInfo.parentName = _parentName;
_nameTAOInfo.parentId = _parentId;
_nameTAOInfo.parentTypeId = _parentTypeId;
if (_typeId == 0) {
totalTAOs++;
} else {
totalNames++;
}
return true;
}
function getByName(string memory _name) public view returns (string memory, address, uint256, string memory, address, uint256) {
require (this.isExist(_name));
bytes32 _nameKey = keccak256(abi.encodePacked(_name));
NameTAOInfo memory _nameTAOInfo = nameTAOInfos[nameToNameTAOIdLookup[_nameKey]];
return (_nameTAOInfo.name,
_nameTAOInfo.nameTAOId,
_nameTAOInfo.typeId,
_nameTAOInfo.parentName,
_nameTAOInfo.parentId,
_nameTAOInfo.parentTypeId);
}
function getById(address _id) external view returns (string memory, address, uint256, string memory, address, uint256) {
require (nameTAOInfos[_id].nameTAOId != address(0));
NameTAOInfo memory _nameTAOInfo = nameTAOInfos[_id];
return (_nameTAOInfo.name,
_nameTAOInfo.nameTAOId,
_nameTAOInfo.typeId,
_nameTAOInfo.parentName,
_nameTAOInfo.parentId,
_nameTAOInfo.parentTypeId);
}
function getIdByName(string calldata _name) external view returns (address) {
bytes32 _nameKey = keccak256(abi.encodePacked(_name));
return nameToNameTAOIdLookup[_nameKey];
}
}
| 196,186 | 11,553 |
1a5437c7b0e2c8f44cdb4ffc756f81074b0182b5e06cbf6187f6d1594c77aa8b
| 33,027 |
.sol
|
Solidity
| false |
356984445
|
Debond-Protocol/EIP-3475
|
68a23f7d2d0c1e86c7a7be6463756ccdddfef77f
|
beta/tradeMark.sol
| 5,300 | 20,961 |
// SPDX-License-Identifier: CC0-1.0
pragma solidity ^0.8.0;
interface IERC3475 {
// STRUCTURE
struct Values {
string stringValue;
uint uintValue;
address addressValue;
bool boolValue;
}
struct Metadata {
string title;
string _type;
string description;
}
struct Transaction {
uint256 classId;
uint256 nonceId;
uint256 _amount;
}
// WRITABLES
function transferFrom(address _from, address _to, Transaction[] calldata _transactions) external;
function transferAllowanceFrom(address _from, address _to, Transaction[] calldata _transactions) external;
function issue(address _to, Transaction[] calldata _transactions) external;
function redeem(address _from, Transaction[] calldata _transactions) external;
function burn(address _from, Transaction[] calldata _transactions) external;
function approve(address _spender, Transaction[] calldata _transactions) external;
function setApprovalFor(address _operator, bool _approved) external;
// READABLES
function totalSupply(uint256 classId, uint256 nonceId) external view returns (uint256);
function redeemedSupply(uint256 classId, uint256 nonceId) external view returns (uint256);
function activeSupply(uint256 classId, uint256 nonceId) external view returns (uint256);
function burnedSupply(uint256 classId, uint256 nonceId) external view returns (uint256);
function balanceOf(address _account, uint256 classId, uint256 nonceId) external view returns (uint256);
function classMetadata(uint256 metadataId) external view returns (Metadata memory);
function nonceMetadata(uint256 classId, uint256 metadataId) external view returns (Metadata memory);
function classValues(uint256 classId, uint256 metadataId) external view returns (Values memory);
function nonceValues(uint256 classId, uint256 nonceId, uint256 metadataId) external view returns (Values memory);
function getProgress(uint256 classId, uint256 nonceId) external view returns (uint256 progressAchieved, uint256 progressRemaining);
function allowance(address _owner, address _spender, uint256 classId, uint256 nonceId) external view returns (uint256);
function isApprovedFor(address _owner, address _operator) external view returns (bool);
// EVENTS
event Transfer(address indexed _operator, address indexed _from, address indexed _to, Transaction[] _transactions);
event Issue(address indexed _operator, address indexed _to, Transaction[] _transactions);
event Redeem(address indexed _operator, address indexed _from, Transaction[] _transactions);
event Burn(address indexed _operator, address indexed _from, Transaction[] _transactions);
event ApprovalFor(address indexed _owner, address indexed _operator, bool _approved);
}
interface IERC3475EXTENSION {
// STRUCTURE
struct ValuesExtension {
string stringValue;
uint uintValue;
address addressValue;
bool boolValue;
string[] stringArrayValue;
uint[] uintArrayValue;
address[] addressArrayValue;
bool[] boolAraryValue;
}
function classValuesFromTitle(uint256 _classId, string memory _metadataTitle) external view returns (ValuesExtension memory);
function nonceValuesFromTitle(uint256 _classId, uint256 _nonceId, string memory _metadataTitle) external view returns (ValuesExtension memory);
event classCreated(address indexed _operator, uint256 _classId);
event updateClassMetadata(address indexed _operator, uint256 _classId, ValuesExtension[] oldMetedata, ValuesExtension[] newMetedata);
event updateNonceMetadata(address indexed _operator, uint256 _classId, uint256 _nonceId, ValuesExtension[] oldMetedata, ValuesExtension[] newMetedata);
}
contract ERC3475 is IERC3475, IERC3475EXTENSION {
struct Nonce {
mapping(uint256 => string) _valuesId;
mapping(string => ValuesExtension) _values;
// stores the values corresponding to the dates (issuance and maturity date).
mapping(address => uint256) _balances;
mapping(address => mapping(address => uint256)) _allowances;
// supplies of this nonce
uint256 _activeSupply;
uint256 _burnedSupply;
uint256 _redeemedSupply;
}
struct Class {
mapping(uint256 => string) _valuesId;
mapping(string => ValuesExtension) _values;
mapping(uint256 => IERC3475.Metadata) _nonceMetadatas;
mapping(uint256 => Nonce) _nonces;
}
mapping(address => mapping(address => bool)) _operatorApprovals;
// from classId given
mapping(uint256 => Class) internal _classes;
mapping(uint256 => IERC3475.Metadata) _classMetadata;
constructor() {
}
// WRITABLES
function transferFrom(address _from,
address _to,
Transaction[] memory _transactions) public virtual override {
require(_from != address(0),
"ERC3475: can't transfer from the zero address");
require(_to != address(0),
"ERC3475:use burn() instead");
require(msg.sender == _from ||
isApprovedFor(_from, msg.sender),
"ERC3475:caller-not-owner-or-approved");
uint256 len = _transactions.length;
for (uint256 i = 0; i < len; i++) {
_transferFrom(_from, _to, _transactions[i]);
}
emit Transfer(msg.sender, _from, _to, _transactions);
}
function transferAllowanceFrom(address _from,
address _to,
Transaction[] memory _transactions) public virtual override {
require(_from != address(0),
"ERC3475: can't transfer allowed amt from zero address");
require(_to != address(0),
"ERC3475: use burn() instead");
uint256 len = _transactions.length;
for (uint256 i = 0; i < len; i++) {
require(_transactions[i]._amount <= allowance(_from, msg.sender, _transactions[i].classId, _transactions[i].nonceId),
"ERC3475:caller-not-owner-or-approved");
_transferAllowanceFrom(msg.sender, _from, _to, _transactions[i]);
}
emit Transfer(msg.sender, _from, _to, _transactions);
}
function issue(address _to, Transaction[] memory _transactions)
external
virtual
override
{
uint256 len = _transactions.length;
for (uint256 i = 0; i < len; i++) {
require(_to != address(0),
"ERC3475: can't issue to the zero address");
_issue(_to, _transactions[i]);
}
emit Issue(msg.sender, _to, _transactions);
}
function redeem(address _from, Transaction[] memory _transactions)
external
virtual
override
{
require(_from != address(0),
"ERC3475: can't redeem from the zero address");
uint256 len = _transactions.length;
for (uint256 i = 0; i < len; i++) {
(, uint256 progressRemaining) = getProgress(_transactions[i].classId,
_transactions[i].nonceId);
require(progressRemaining == 0,
"ERC3475 Error: Not redeemable");
_redeem(_from, _transactions[i]);
}
emit Redeem(msg.sender, _from, _transactions);
}
function burn(address _from, Transaction[] memory _transactions)
external
virtual
override
{
require(_from != address(0),
"ERC3475: can't burn from the zero address");
require(msg.sender == _from ||
isApprovedFor(_from, msg.sender),
"ERC3475: caller-not-owner-or-approved");
uint256 len = _transactions.length;
for (uint256 i = 0; i < len; i++) {
_burn(_from, _transactions[i]);
}
emit Burn(msg.sender, _from, _transactions);
}
function approve(address _spender, Transaction[] memory _transactions)
external
virtual
override
{
for (uint256 i = 0; i < _transactions.length; i++) {
_classes[_transactions[i].classId]
._nonces[_transactions[i].nonceId]
._allowances[msg.sender][_spender] = _transactions[i]._amount;
}
}
function setApprovalFor(address operator,
bool approved) public virtual override {
_operatorApprovals[msg.sender][operator] = approved;
emit ApprovalFor(msg.sender, operator, approved);
}
// READABLES
function totalSupply(uint256 classId, uint256 nonceId)
public
view
override
returns (uint256)
{
return (activeSupply(classId, nonceId) +
burnedSupply(classId, nonceId) +
redeemedSupply(classId, nonceId));
}
function activeSupply(uint256 classId, uint256 nonceId)
public
view
override
returns (uint256)
{
return _classes[classId]._nonces[nonceId]._activeSupply;
}
function burnedSupply(uint256 classId, uint256 nonceId)
public
view
override
returns (uint256)
{
return _classes[classId]._nonces[nonceId]._burnedSupply;
}
function redeemedSupply(uint256 classId, uint256 nonceId)
public
view
override
returns (uint256)
{
return _classes[classId]._nonces[nonceId]._redeemedSupply;
}
function balanceOf(address account,
uint256 classId,
uint256 nonceId) public view override returns (uint256) {
require(account != address(0),
"ERC3475: balance query for the zero address");
return _classes[classId]._nonces[nonceId]._balances[account];
}
function classMetadata(uint256 metadataId)
external
view
override
returns (Metadata memory) {
return (_classMetadata[metadataId]);
}
function nonceMetadata(uint256 classId, uint256 metadataId)
external
view
override
returns (Metadata memory) {
return (_classes[classId]._nonceMetadatas[metadataId]);
}
function classValues(uint256 classId, uint256 metadataId)
external
view
override
returns (Values memory) {
string memory title = _classes[classId]._valuesId[metadataId];
Values memory result;
result.stringValue = _classes[classId]._values[title].stringValue;
result.uintValue = _classes[classId]._values[title].uintValue;
result.addressValue = _classes[classId]._values[title].addressValue;
result.stringValue = _classes[classId]._values[title].stringValue;
return (result);
}
function nonceValues(uint256 classId, uint256 nonceId, uint256 metadataId)
external
view
override
returns (Values memory) {
string memory title = _classes[classId]._nonces[nonceId]._valuesId[metadataId];
Values memory result;
result.stringValue = _classes[classId]._nonces[nonceId]._values[title].stringValue;
result.uintValue = _classes[classId]._nonces[nonceId]._values[title].uintValue;
result.addressValue = _classes[classId]._nonces[nonceId]._values[title].addressValue;
result.stringValue = _classes[classId]._nonces[nonceId]._values[title].stringValue;
return (result);
}
function nonceValuesFromTitle(uint256 classId, uint256 nonceId, string memory metadataTitle)
external
view
returns (ValuesExtension memory) {
return (_classes[classId]._nonces[nonceId]._values[metadataTitle]);
}
function classValuesFromTitle(uint256 classId, string memory metadataTitle)
external
view
returns (ValuesExtension memory) {
return (_classes[classId]._values[metadataTitle]);
}
function getProgress(uint256 classId, uint256 nonceId)
public
view
override
returns (uint256 progressAchieved, uint256 progressRemaining){
uint256 issuanceDate = _classes[classId]._nonces[nonceId]._values["issuranceTime"].uintValue;
uint256 maturityPeriod = _classes[classId]._values["maturityPeriod"].uintValue;
// check whether the bond is being already initialized:
progressAchieved = block.timestamp > issuanceDate?
block.timestamp - issuanceDate : 0;
progressRemaining = progressAchieved < maturityPeriod
? maturityPeriod - progressAchieved
: 0;
}
function allowance(address _owner,
address spender,
uint256 classId,
uint256 nonceId) public view virtual override returns (uint256) {
return _classes[classId]._nonces[nonceId]._allowances[_owner][spender];
}
function isApprovedFor(address _owner,
address operator) public view virtual override returns (bool) {
return _operatorApprovals[_owner][operator];
}
// INTERNALS
function _transferFrom(address _from,
address _to,
IERC3475.Transaction memory _transaction) private {
Nonce storage nonce = _classes[_transaction.classId]._nonces[_transaction.nonceId];
require(nonce._balances[_from] >= _transaction._amount,
"ERC3475: not enough bond to transfer");
//transfer balance
nonce._balances[_from] -= _transaction._amount;
nonce._balances[_to] += _transaction._amount;
}
function _transferAllowanceFrom(address _operator,
address _from,
address _to,
IERC3475.Transaction memory _transaction) private {
Nonce storage nonce = _classes[_transaction.classId]._nonces[_transaction.nonceId];
require(nonce._balances[_from] >= _transaction._amount,
"ERC3475: not allowed _amount");
// reducing the allowance and decreasing accordingly.
nonce._allowances[_from][_operator] -= _transaction._amount;
//transfer balance
nonce._balances[_from] -= _transaction._amount;
nonce._balances[_to] += _transaction._amount;
}
function _issue(address _to,
IERC3475.Transaction memory _transaction) private {
Nonce storage nonce = _classes[_transaction.classId]._nonces[_transaction.nonceId];
//transfer balance
nonce._balances[_to] += _transaction._amount;
nonce._activeSupply += _transaction._amount;
}
function _redeem(address _from,
IERC3475.Transaction memory _transaction) private {
Nonce storage nonce = _classes[_transaction.classId]._nonces[_transaction.nonceId];
require(nonce._balances[_from] >= _transaction._amount,
"ERC3475: not enough bond to transfer");
//transfer balance
nonce._balances[_from] -= _transaction._amount;
nonce._activeSupply -= _transaction._amount;
nonce._redeemedSupply += _transaction._amount;
}
function _burn(address _from,
IERC3475.Transaction memory _transaction) private {
Nonce storage nonce = _classes[_transaction.classId]._nonces[_transaction.nonceId];
require(nonce._balances[_from] >= _transaction._amount,
"ERC3475: not enough bond to transfer");
//transfer balance
nonce._balances[_from] -= _transaction._amount;
nonce._activeSupply -= _transaction._amount;
nonce._burnedSupply += _transaction._amount;
}
}
contract Token is ERC3475 {
address public publisher;
uint256 public lastAvailableClass;
struct Data {
uint256 onChainDate;
string symbol;
string identificationNumber;
string warrantNumber;
string[] authorName;
address[] authorChainAddress;
string[] sponsorName;
string domain;
string subdomain;
string introduction;
string[] keyWords;
string license;
string[] cover;
string[] warrantorDocURL;
}
modifier onlyPublisher{
_;
}
constructor() {
publisher = msg.sender;
_classes[0]._values["nonceProprity"].stringValue = "{'0':'ownership'}";
_classes[0]._values["category"].stringValue = "proprity";
_classes[0]._values["subcategory"].stringValue = "intellectualProprity";
_classes[0]._values["childCategory"].stringValue = "trademark";
_classes[0]._values["warrantorName"].stringValue = "Shanghai Intellectual Property Administration";
_classes[0]._values["warrantorType"].stringValue = "Government Organization";
_classes[0]._values["warrantorRegistrationNumber"].stringValue = unicode"ICP2021016245";
_classes[0]._values["warrantorJurisdiction"].stringValue = "PRC";
_classes[0]._values["warrantorRegistrationAddress"].stringValue = unicode"55, Jing'An, Shanghai, 200031 China,";
_classes[0]._values["warrantorURL"].stringValue = "https://sipa.sh.gov.cn/";
_classes[0]._values["warrantorLogo"].stringValue = "https://nwzimg.wezhan.net/contents/sitefiles3602/18013483/images/1241691.jpg";
_classes[0]._values["warrantorIndustry"].stringArrayValue = ["Intellectual Property Office"];
_classes[0]._values["warrantorChainAddress"].stringValue = "0x3DF2038Ac2C84fa742151Ed319bbe8aDa92980A6";
}
function _issueToken(address _to,
IERC3475.Transaction memory _transaction) internal {
Nonce storage nonce = _classes[_transaction.classId]._nonces[_transaction.nonceId];
//transfer balance
nonce._balances[_to] += _transaction._amount;
nonce._activeSupply += _transaction._amount;
IERC3475.Transaction[] memory transactions;
emit Issue (_to, address(this), transactions);
}
function getToken(uint256 classeId) public view returns(Data memory result){
result.onChainDate = _classes[classeId]._values["onChainDate"].uintValue;
result.symbol = _classes[classeId]._values["symbol"].stringValue;
result.identificationNumber = _classes[classeId]._values["identificationNumber"].stringValue;
result.warrantNumber = _classes[classeId]._values["warrantNumber"].stringValue;
result.authorName =_classes[classeId]._values["authorName"].stringArrayValue;
result.authorChainAddress =_classes[classeId]._values["authorChainAddress"].addressArrayValue;
result.sponsorName= _classes[classeId]._values["sponsorName"].stringArrayValue;
result.domain =_classes[classeId]._values["domain"].stringValue;
result.subdomain = _classes[classeId]._values["subdomain"].stringValue;
result.introduction= _classes[classeId]._values["introduction"].stringValue;
result.keyWords= _classes[classeId]._values["keyWords"].stringArrayValue ;
result.license= _classes[classeId]._values["license"].stringValue ;
result.cover = _classes[classeId]._values["cover"].stringArrayValue;
result.cover = _classes[classeId]._values["warrantorDocURL"].stringArrayValue;
}
function publishProprity(uint256[] memory _amount,
Data memory _inputValues) public onlyPublisher {
lastAvailableClass++;
uint256 newClassId = lastAvailableClass;
_classes[newClassId]._values["symbol"].stringValue = _inputValues.symbol;
_classes[newClassId]._values["identificationNumber"].stringValue = _inputValues.identificationNumber;
_classes[newClassId]._values["warrantNumber"].stringValue = _inputValues.warrantNumber;
_classes[newClassId]._values["authorName"].stringArrayValue = _inputValues.authorName;
_classes[newClassId]._values["authorChainAddress"].addressArrayValue = _inputValues.authorChainAddress;
_classes[newClassId]._values["sponsorName"].stringArrayValue = _inputValues.sponsorName;
_classes[newClassId]._values["domain"].stringValue = _inputValues.domain;
_classes[newClassId]._values["subdomain"].stringValue = _inputValues.subdomain;
_classes[newClassId]._values["onChainDate"].uintValue = block.timestamp;
_classes[newClassId]._values["introduction"].stringValue = _inputValues.introduction;
_classes[newClassId]._values["keyWords"].stringArrayValue = _inputValues.keyWords;
_classes[newClassId]._values["license"].stringValue = _inputValues.license;
_classes[newClassId]._values["cover"].stringArrayValue = _inputValues.cover;
_classes[newClassId]._values["warrantorDocURL"].stringArrayValue = _inputValues.warrantorDocURL;
_mintOwnershipTokens(newClassId, _amount, _inputValues);
emit classCreated(msg.sender, newClassId);
}
function _mintOwnershipTokens(uint256 _classId,
uint256[] memory _amounts,
Data memory _inputValues) private {
require(_amounts.length == _inputValues.authorName.length, "Token: invalid length for _amount");
// mint the ownership tokens to co-authors
for(uint256 i = 0; i < _inputValues.authorChainAddress.length; i++) {
Transaction memory _transaction;
_transaction._amount = _amounts[i];
_transaction.classId = _classId;
_transaction.nonceId = 0;
_issueToken(_inputValues.authorChainAddress[i], _transaction);
}
}
}
| 139,553 | 11,554 |
677639b6ef10e141eaf3ccb5b4a535128af884977f192661670972667e6be165
| 39,235 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/fb/fbea45d9db3d22485e6067b2f038eeb2f7bc6ea1_Banana.sol
| 4,954 | 19,676 |
// 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 = 200;
string private _name = "Banana Yield";
string private _symbol = "BYield";
uint8 private _decimals = 18;
constructor(string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function getOwner() external override view returns (address) {
return owner();
}
function name() public override view returns (string memory) {
return _name;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function symbol() public override view returns (string memory) {
return _symbol;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender)
public
override
view
returns (uint256)
{
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount,
"BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue)
public
returns (bool)
{
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
returns (bool)
{
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].sub(subtractedValue,
"BEP20: decreased allowance below zero"));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount,
"BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "BEP20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "BEP20: burn from the zero address");
_balances[account] = _balances[account].sub(amount,
"BEP20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account,
_msgSender(),
_allowances[account][_msgSender()].sub(amount,
"BEP20: burn amount exceeds allowance"));
}
}
// Banana with Governance.
contract Banana is BEP20("Banana Yield", "BYield") {
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
// Copied and modified from YAM code:
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
// Which is copied and modified from COMPOUND:
// https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
/// @notice A record of each accounts delegate
mapping(address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping(address => mapping(uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping(address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping(address => uint256) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator,
address indexed fromDelegate,
address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate,
uint256 previousBalance,
uint256 newBalance);
function delegates(address delegator) external view returns (address) {
return _delegates[delegator];
}
function delegate(address delegatee) external {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee,
uint256 nonce,
uint256 expiry,
uint8 v,
bytes32 r,
bytes32 s) external {
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH,
keccak256(bytes(name())),
getChainId(),
address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH, delegatee, nonce, expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0),
"CAKE::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++,
"CAKE::delegateBySig: invalid nonce");
require(now <= expiry, "CAKE::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getCurrentVotes(address account) external view returns (uint256) {
uint32 nCheckpoints = numCheckpoints[account];
return
nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint256 blockNumber)
external
view
returns (uint256)
{
require(blockNumber < block.number,
"CAKE::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
// Next check implicit zero balance
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function _delegate(address delegator, address delegatee) internal {
address currentDelegate = _delegates[delegator];
uint256 delegatorBalance = balanceOf(delegator); // balance of underlying CAKEs (not scaled);
_delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _moveDelegates(address srcRep,
address dstRep,
uint256 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
// decrease old representative
uint32 srcRepNum = numCheckpoints[srcRep];
uint256 srcRepOld = srcRepNum > 0
? checkpoints[srcRep][srcRepNum - 1].votes
: 0;
uint256 srcRepNew = srcRepOld.sub(amount);
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
// increase new representative
uint32 dstRepNum = numCheckpoints[dstRep];
uint256 dstRepOld = dstRepNum > 0
? checkpoints[dstRep][dstRepNum - 1].votes
: 0;
uint256 dstRepNew = dstRepOld.add(amount);
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee,
uint32 nCheckpoints,
uint256 oldVotes,
uint256 newVotes) internal {
uint32 blockNumber = safe32(block.number,
"CAKE::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 &&
checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber,
newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint256 n, string memory errorMessage)
internal
pure
returns (uint32)
{
require(n < 2**32, errorMessage);
return uint32(n);
}
function getChainId() internal pure returns (uint256) {
uint256 chainId;
assembly {
chainId := chainid()
}
return chainId;
}
}
| 334,051 | 11,555 |
626bbca6929d883d66cf0099fdc9b9524a7f8ef483f8d6b8f54829e0def4919e
| 20,313 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x4730fb1463a6f1f44aeb45f6c5c422427f37f4d0.sol
| 3,803 | 13,997 |
pragma solidity ^0.4.17;
// File: contracts/helpers/Ownable.sol
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
// File: contracts/helpers/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
// File: contracts/token/ERC20Interface.sol
contract ERC20Interface {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function allowance(address owner, address spender) public view returns (uint256);
}
// File: contracts/token/BaseToken.sol
contract BaseToken is ERC20Interface {
using SafeMath for uint256;
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) internal allowed;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
require(_spender != address(0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint256 _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint256 _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
// File: contracts/token/MintableToken.sol
contract MintableToken is BaseToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
require(_to != address(0));
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
// File: contracts/token/CappedToken.sol
contract CappedToken is MintableToken {
uint256 public cap;
function CappedToken(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
require(totalSupply_.add(_amount) <= cap);
return super.mint(_to, _amount);
}
}
// File: contracts/helpers/Pausable.sol
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
// File: contracts/token/PausableToken.sol
contract PausableToken is BaseToken, Pausable {
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
return super.approve(_spender, _value);
}
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) {
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) {
return super.decreaseApproval(_spender, _subtractedValue);
}
}
// File: contracts/token/SignedTransferToken.sol
contract SignedTransferToken is BaseToken {
event TransferPreSigned(address indexed from,
address indexed to,
address indexed settler,
uint256 value,
uint256 fee);
event TransferPreSignedMany(address indexed from,
address indexed settler,
uint256 value,
uint256 fee);
// Mapping of already executed settlements for a given address
mapping(address => mapping(bytes32 => bool)) executedSettlements;
function transferPreSigned(address _from,
address _to,
uint256 _value,
uint256 _fee,
uint256 _nonce,
uint8 _v,
bytes32 _r,
bytes32 _s) public returns (bool) {
uint256 total = _value.add(_fee);
bytes32 calcHash = calculateHash(_from, _to, _value, _fee, _nonce);
require(_to != address(0));
require(isValidSignature(_from, calcHash, _v, _r, _s));
require(balances[_from] >= total);
require(!executedSettlements[_from][calcHash]);
executedSettlements[_from][calcHash] = true;
// Move tokens
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(_from, _to, _value);
// Move fee
balances[_from] = balances[_from].sub(_fee);
balances[msg.sender] = balances[msg.sender].add(_fee);
Transfer(_from, msg.sender, _fee);
TransferPreSigned(_from, _to, msg.sender, _value, _fee);
return true;
}
function transferPreSignedBulk(address[] _from,
address[] _to,
uint256[] _values,
uint256[] _fees,
uint256[] _nonces,
uint8[] _v,
bytes32[] _r,
bytes32[] _s) public returns (bool) {
// Make sure all the arrays are of the same length
require(_from.length == _to.length &&
_to.length ==_values.length &&
_values.length == _fees.length &&
_fees.length == _nonces.length &&
_nonces.length == _v.length &&
_v.length == _r.length &&
_r.length == _s.length);
for(uint i; i < _from.length; i++) {
transferPreSigned(_from[i],
_to[i],
_values[i],
_fees[i],
_nonces[i],
_v[i],
_r[i],
_s[i]);
}
return true;
}
function transferPreSignedMany(address _from,
address[] _tos,
uint256[] _values,
uint256 _fee,
uint256 _nonce,
uint8 _v,
bytes32 _r,
bytes32 _s) public returns (bool) {
require(_tos.length == _values.length);
uint256 total = getTotal(_tos, _values, _fee);
bytes32 calcHash = calculateManyHash(_from, _tos, _values, _fee, _nonce);
require(isValidSignature(_from, calcHash, _v, _r, _s));
require(balances[_from] >= total);
require(!executedSettlements[_from][calcHash]);
executedSettlements[_from][calcHash] = true;
// transfer to each recipient and take fee at the end
for(uint i; i < _tos.length; i++) {
// Move tokens
balances[_from] = balances[_from].sub(_values[i]);
balances[_tos[i]] = balances[_tos[i]].add(_values[i]);
Transfer(_from, _tos[i], _values[i]);
}
// Move fee
balances[_from] = balances[_from].sub(_fee);
balances[msg.sender] = balances[msg.sender].add(_fee);
Transfer(_from, msg.sender, _fee);
TransferPreSignedMany(_from, msg.sender, total, _fee);
return true;
}
function getTotal(address[] _tos, uint256[] _values, uint256 _fee) private view returns (uint256) {
uint256 total = _fee;
for(uint i; i < _tos.length; i++) {
total = total.add(_values[i]); // sum of all the values + fee
require(_tos[i] != address(0)); // check that the recipient is a valid address
}
return total;
}
function calculateManyHash(address _from, address[] _tos, uint256[] _values, uint256 _fee, uint256 _nonce) public view returns (bytes32) {
return keccak256(uint256(1), address(this), _from, _tos, _values, _fee, _nonce);
}
function calculateHash(address _from, address _to, uint256 _value, uint256 _fee, uint256 _nonce) public view returns (bytes32) {
return keccak256(uint256(0), address(this), _from, _to, _value, _fee, _nonce);
}
function isValidSignature(address _signer, bytes32 _hash, uint8 _v, bytes32 _r, bytes32 _s) public pure returns (bool) {
return _signer == ecrecover(keccak256("\x19Ethereum Signed Message:\n32", _hash),
_v,
_r,
_s);
}
function isTransactionAlreadySettled(address _from, bytes32 _calcHash) public view returns (bool) {
return executedSettlements[_from][_calcHash];
}
}
// File: contracts/token/PausableSignedTransferToken.sol
contract PausableSignedTransferToken is SignedTransferToken, PausableToken {
function transferPreSigned(address _from,
address _to,
uint256 _value,
uint256 _fee,
uint256 _nonce,
uint8 _v,
bytes32 _r,
bytes32 _s) public whenNotPaused returns (bool) {
return super.transferPreSigned(_from, _to, _value, _fee, _nonce, _v, _r, _s);
}
function transferPreSignedBulk(address[] _from,
address[] _to,
uint256[] _values,
uint256[] _fees,
uint256[] _nonces,
uint8[] _v,
bytes32[] _r,
bytes32[] _s) public whenNotPaused returns (bool) {
return super.transferPreSignedBulk(_from, _to, _values, _fees, _nonces, _v, _r, _s);
}
function transferPreSignedMany(address _from,
address[] _tos,
uint256[] _values,
uint256 _fee,
uint256 _nonce,
uint8 _v,
bytes32 _r,
bytes32 _s) public whenNotPaused returns (bool) {
return super.transferPreSignedMany(_from, _tos, _values, _fee, _nonce, _v, _r, _s);
}
}
// File: contracts/FourToken.sol
contract FourToken is CappedToken, PausableSignedTransferToken {
string public name = 'The 4th Pillar Token';
string public symbol = 'FOUR';
uint256 public decimals = 18;
// Max supply of 400 million
uint256 public maxSupply = 400000000 * 10**decimals;
function FourToken()
CappedToken(maxSupply) public {
paused = true;
}
// @dev Recover any mistakenly sent ERC20 tokens to the Token address
function recoverERC20Tokens(address _erc20, uint256 _amount) public onlyOwner {
ERC20Interface(_erc20).transfer(msg.sender, _amount);
}
}
| 142,521 | 11,556 |
7c6bf5c85dee29b9be28050ca57e50c245e8e5980a2c5ec0234a1540db4791be
| 15,487 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/88/88Fbb6d1FD3F7e86C48a59368960784201559383_Distributor.sol
| 3,348 | 13,736 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
library LowGasSafeMath {
/// @notice Returns x + y, reverts if sum overflows uint256
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x + y) >= x);
}
function add32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x + y) >= x);
}
/// @notice Returns x - y, reverts if underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x - y) <= x);
}
function sub32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x - y) <= x);
}
/// @notice Returns x * y, reverts if overflows
/// @param x The multiplicand
/// @param y The multiplier
/// @return z The product of x and y
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(x == 0 || (z = x * y) / x == y);
}
/// @notice Returns x + y, reverts if overflows or underflows
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x + y) >= x == (y >= 0));
}
/// @notice Returns x - y, reverts if overflows or underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x - y) <= x == (y >= 0));
}
function div(uint256 x, uint256 y) internal pure returns(uint256 z){
require(y > 0);
z=x/y;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
contract OwnableData {
address public owner;
address public pendingOwner;
}
contract Ownable is OwnableData {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/// @notice `owner` defaults to msg.sender on construction.
constructor() {
owner = msg.sender;
emit OwnershipTransferred(address(0), msg.sender);
}
/// @notice Transfers ownership to `newOwner`. Either directly or claimable by the new pending owner.
/// Can only be invoked by the current `owner`.
/// @param newOwner Address of the new owner.
function transferOwnership(address newOwner,
bool direct,
bool renounce) public onlyOwner {
if (direct) {
// Checks
require(newOwner != address(0) || renounce, "Ownable: zero address");
// Effects
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
pendingOwner = address(0);
} else {
// Effects
pendingOwner = newOwner;
}
}
/// @notice Needs to be called by `pendingOwner` to claim ownership.
function claimOwnership() public {
address _pendingOwner = pendingOwner;
// Checks
require(msg.sender == _pendingOwner, "Ownable: caller != pending owner");
// Effects
emit OwnershipTransferred(owner, _pendingOwner);
owner = _pendingOwner;
pendingOwner = address(0);
}
/// @notice Only allows the `owner` to execute the function.
modifier onlyOwner() {
require(msg.sender == owner, "Ownable: caller is not the owner");
_;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Ownable {
using LowGasSafeMath for uint;
using LowGasSafeMath for uint32;
IERC20 public immutable TIME;
ITreasury public immutable treasury;
uint32 public immutable epochLength;
uint32 public nextEpochTime;
mapping(uint => Adjust) public adjustments;
event LogDistribute(address indexed recipient, uint amount);
event LogAdjust(uint initialRate, uint currentRate, uint targetRate);
event LogAddRecipient(address indexed recipient, uint rate);
event LogRemoveRecipient(address indexed recipient);
struct Info {
uint rate; // in ten-thousandths (5000 = 0.5%)
address recipient;
}
Info[] public info;
struct Adjust {
bool add;
uint rate;
uint target;
}
constructor(address _treasury, address _time, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = ITreasury(_treasury);
require(_time != address(0));
TIME = IERC20(_time);
epochLength = _epochLength;
nextEpochTime = _nextEpochTime;
}
function distribute() external returns (bool) {
if (nextEpochTime <= uint32(block.timestamp)) {
nextEpochTime = nextEpochTime.add32(epochLength); // set next epoch time
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[ i ].rate > 0) {
treasury.mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
emit LogDistribute(info[ i ].recipient, nextRewardAt(info[ i ].rate));
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
uint initial = info[ _index ].rate;
uint rate = initial;
if (adjustment.add) { // if rate should increase
rate = rate.add(adjustment.rate); // raise rate
if (rate >= adjustment.target) { // if target met
rate = adjustment.target;
delete adjustments[ _index ];
}
} else { // if rate should decrease
rate = rate.sub(adjustment.rate); // lower rate
if (rate <= adjustment.target) { // if target met
rate = adjustment.target;
delete adjustments[ _index ];
}
}
info[ _index ].rate = rate;
emit LogAdjust(initial, rate, adjustment.target);
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return TIME.totalSupply().mul(_rate).div(1000000);
}
function nextRewardFor(address _recipient) external view returns (uint) {
uint reward;
for (uint i = 0; i < info.length; i++) {
if (info[ i ].recipient == _recipient) {
reward = nextRewardAt(info[ i ].rate);
}
}
return reward;
}
function addRecipient(address _recipient, uint _rewardRate) external onlyOwner {
require(_recipient != address(0), "IA");
require(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 {
adjustments[ _index ] = Adjust({
add: _add,
rate: _rate,
target: _target
});
}
}
| 34,161 | 11,557 |
88aa9ceb9e78b6ea42e7ad0c90e29e6b00cab860fcc7ec0cbf944c64c688a733
| 18,863 |
.sol
|
Solidity
| false |
413030292
|
morpho-org/morpho-data-structures
|
1e79a528cc49d07c30e5a65b5bfdbcf7c2135f6e
|
src/RedBlackBinaryTree.sol
| 3,787 | 14,670 |
// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity ^0.8.0;
// Copyright (c) Rob Hitchens. the MIT License.
// Significant portions from BokkyPooBahsRedBlackTreeLibrary,
// https://github.com/bokkypoobah/BokkyPooBahsRedBlackTreeLibrary
library RedBlackBinaryTree {
struct Node {
uint256 parent; // The parent node of the current node.
uint256 leftChild; // The left child of the current node.
uint256 rightChild; // The right child of the current node.
bool red; // Whether the current notde is red or black.
address[] keys; // The keys sharing the value of the node.
mapping(address => uint256) keyMap; // Maps the keys to their index in `keys`.
}
struct Tree {
uint256 root; // Root node.
mapping(uint256 => Node) nodes; // Maps value to Node.
mapping(address => uint256) keyToValue; // Maps key to its value.
}
function first(Tree storage _self) public view returns (uint256 value) {
value = _self.root;
if (value == 0) return 0;
while (_self.nodes[value].leftChild != 0) {
value = _self.nodes[value].leftChild;
}
}
function last(Tree storage _self) public view returns (uint256 value) {
value = _self.root;
if (value == 0) return 0;
while (_self.nodes[value].rightChild != 0) {
value = _self.nodes[value].rightChild;
}
}
function next(Tree storage _self, uint256 _value) public view returns (uint256 cursor) {
require(_value != 0, "RBBT(1):start-_value=0");
if (_self.nodes[_value].rightChild != 0) {
cursor = subTreeMin(_self, _self.nodes[_value].rightChild);
} else {
cursor = _self.nodes[_value].parent;
while (cursor != 0 && _value == _self.nodes[cursor].rightChild) {
_value = cursor;
cursor = _self.nodes[cursor].parent;
}
}
}
function prev(Tree storage _self, uint256 _value) public view returns (uint256 cursor) {
require(_value != 0, "RBBT(2):start-value=0");
if (_self.nodes[_value].leftChild != 0) {
cursor = subTreeMax(_self, _self.nodes[_value].leftChild);
} else {
cursor = _self.nodes[_value].parent;
while (cursor != 0 && _value == _self.nodes[cursor].leftChild) {
_value = cursor;
cursor = _self.nodes[cursor].parent;
}
}
}
function exists(Tree storage _self, uint256 _value) public view returns (bool) {
if (_value == 0) return false;
if (_value == _self.root) return true;
if (_self.nodes[_value].parent != 0) return true;
return false;
}
function keyExists(Tree storage _self, address _key) public view returns (bool) {
return _self.keyToValue[_key] != 0;
}
function valueKeyAtIndex(Tree storage _self, uint256 _value, uint256 _index) public view returns (address) {
require(exists(_self, _value), "RBBT:value-not-exist");
return _self.nodes[_value].keys[_index];
}
function getNumberOfKeysAtValue(Tree storage _self, uint256 _value) public view returns (uint256) {
if (!exists(_self, _value)) return 0;
return _self.nodes[_value].keys.length;
}
function isNotEmpty(Tree storage _self) public view returns (bool) {
return _self.nodes[_self.root].keys.length > 0;
}
function insert(Tree storage _self, address _key, uint256 _value) public {
require(_value != 0, "RBBT:value-cannot-be-0");
require(_self.keyToValue[_key] == 0, "RBBT:account-already-in");
_self.keyToValue[_key] = _value;
uint256 cursor;
uint256 probe = _self.root;
while (probe != 0) {
cursor = probe;
if (_value < probe) {
probe = _self.nodes[probe].leftChild;
} else if (_value > probe) {
probe = _self.nodes[probe].rightChild;
} else if (_value == probe) {
_self.nodes[probe].keys.push(_key);
_self.nodes[probe].keyMap[_key] = _self.nodes[probe].keys.length - 1;
return;
}
}
Node storage nValue = _self.nodes[_value];
nValue.parent = cursor;
nValue.leftChild = 0;
nValue.rightChild = 0;
nValue.red = true;
nValue.keys.push(_key);
nValue.keyMap[_key] = nValue.keys.length - 1;
if (cursor == 0) {
_self.root = _value;
} else if (_value < cursor) {
_self.nodes[cursor].leftChild = _value;
} else {
_self.nodes[cursor].rightChild = _value;
}
insertFixup(_self, _value);
}
function remove(Tree storage _self, address _key) public {
require(_self.keyToValue[_key] != 0, "RBBT:account-not-exist");
uint256 value = _self.keyToValue[_key];
_self.keyToValue[_key] = 0;
Node storage nValue = _self.nodes[value];
uint256 rowToDelete = nValue.keyMap[_key];
nValue.keys[rowToDelete] = nValue.keys[nValue.keys.length - 1];
nValue.keys.pop();
uint256 probe;
uint256 cursor;
if (nValue.keys.length == 0) {
if (_self.nodes[value].leftChild == 0 || _self.nodes[value].rightChild == 0) {
cursor = value;
} else {
cursor = _self.nodes[value].rightChild;
while (_self.nodes[cursor].leftChild != 0) {
cursor = _self.nodes[cursor].leftChild;
}
}
if (_self.nodes[cursor].leftChild != 0) {
probe = _self.nodes[cursor].leftChild;
} else {
probe = _self.nodes[cursor].rightChild;
}
uint256 cursorParent = _self.nodes[cursor].parent;
_self.nodes[probe].parent = cursorParent;
if (cursorParent != 0) {
if (cursor == _self.nodes[cursorParent].leftChild) {
_self.nodes[cursorParent].leftChild = probe;
} else {
_self.nodes[cursorParent].rightChild = probe;
}
} else {
_self.root = probe;
}
bool doFixup = !_self.nodes[cursor].red;
if (cursor != value) {
replaceParent(_self, cursor, value);
_self.nodes[cursor].leftChild = _self.nodes[value].leftChild;
_self.nodes[_self.nodes[cursor].leftChild].parent = cursor;
_self.nodes[cursor].rightChild = _self.nodes[value].rightChild;
_self.nodes[_self.nodes[cursor].rightChild].parent = cursor;
_self.nodes[cursor].red = _self.nodes[value].red;
(cursor, value) = (value, cursor);
}
if (doFixup) {
removeFixup(_self, probe);
}
delete _self.nodes[cursor];
}
}
function subTreeMin(Tree storage _self, uint256 _value) private view returns (uint256) {
while (_self.nodes[_value].leftChild != 0) {
_value = _self.nodes[_value].leftChild;
}
return _value;
}
function subTreeMax(Tree storage _self, uint256 _value) private view returns (uint256) {
while (_self.nodes[_value].rightChild != 0) {
_value = _self.nodes[_value].rightChild;
}
return _value;
}
function rotateLeft(Tree storage _self, uint256 _value) private {
uint256 cursor = _self.nodes[_value].rightChild;
uint256 parent = _self.nodes[_value].parent;
uint256 cursorLeft = _self.nodes[cursor].leftChild;
_self.nodes[_value].rightChild = cursorLeft;
if (cursorLeft != 0) {
_self.nodes[cursorLeft].parent = _value;
}
_self.nodes[cursor].parent = parent;
if (parent == 0) {
_self.root = cursor;
} else if (_value == _self.nodes[parent].leftChild) {
_self.nodes[parent].leftChild = cursor;
} else {
_self.nodes[parent].rightChild = cursor;
}
_self.nodes[cursor].leftChild = _value;
_self.nodes[_value].parent = cursor;
}
function rotateRight(Tree storage _self, uint256 _value) private {
uint256 cursor = _self.nodes[_value].leftChild;
uint256 parent = _self.nodes[_value].parent;
uint256 cursorRight = _self.nodes[cursor].rightChild;
_self.nodes[_value].leftChild = cursorRight;
if (cursorRight != 0) {
_self.nodes[cursorRight].parent = _value;
}
_self.nodes[cursor].parent = parent;
if (parent == 0) {
_self.root = cursor;
} else if (_value == _self.nodes[parent].rightChild) {
_self.nodes[parent].rightChild = cursor;
} else {
_self.nodes[parent].leftChild = cursor;
}
_self.nodes[cursor].rightChild = _value;
_self.nodes[_value].parent = cursor;
}
function insertFixup(Tree storage _self, uint256 _value) private {
uint256 cursor;
while (_value != _self.root && _self.nodes[_self.nodes[_value].parent].red) {
uint256 valueParent = _self.nodes[_value].parent;
if (valueParent == _self.nodes[_self.nodes[valueParent].parent].leftChild) {
cursor = _self.nodes[_self.nodes[valueParent].parent].rightChild;
if (_self.nodes[cursor].red) {
_self.nodes[valueParent].red = false;
_self.nodes[cursor].red = false;
_self.nodes[_self.nodes[valueParent].parent].red = true;
_value = _self.nodes[valueParent].parent;
} else {
if (_value == _self.nodes[valueParent].rightChild) {
_value = valueParent;
rotateLeft(_self, _value);
}
valueParent = _self.nodes[_value].parent;
_self.nodes[valueParent].red = false;
_self.nodes[_self.nodes[valueParent].parent].red = true;
rotateRight(_self, _self.nodes[valueParent].parent);
}
} else {
cursor = _self.nodes[_self.nodes[valueParent].parent].leftChild;
if (_self.nodes[cursor].red) {
_self.nodes[valueParent].red = false;
_self.nodes[cursor].red = false;
_self.nodes[_self.nodes[valueParent].parent].red = true;
_value = _self.nodes[valueParent].parent;
} else {
if (_value == _self.nodes[valueParent].leftChild) {
_value = valueParent;
rotateRight(_self, _value);
}
valueParent = _self.nodes[_value].parent;
_self.nodes[valueParent].red = false;
_self.nodes[_self.nodes[valueParent].parent].red = true;
rotateLeft(_self, _self.nodes[valueParent].parent);
}
}
}
_self.nodes[_self.root].red = false;
}
function replaceParent(Tree storage _self, uint256 _a, uint256 _b) private {
uint256 bParent = _self.nodes[_b].parent;
_self.nodes[_a].parent = bParent;
if (bParent == 0) {
_self.root = _a;
} else {
if (_b == _self.nodes[bParent].leftChild) {
_self.nodes[bParent].leftChild = _a;
} else {
_self.nodes[bParent].rightChild = _a;
}
}
}
function removeFixup(Tree storage _self, uint256 _value) private {
uint256 cursor;
while (_value != _self.root && !_self.nodes[_value].red) {
uint256 valueParent = _self.nodes[_value].parent;
if (_value == _self.nodes[valueParent].leftChild) {
cursor = _self.nodes[valueParent].rightChild;
if (_self.nodes[cursor].red) {
_self.nodes[cursor].red = false;
_self.nodes[valueParent].red = true;
rotateLeft(_self, valueParent);
cursor = _self.nodes[valueParent].rightChild;
}
if (!_self.nodes[_self.nodes[cursor].leftChild].red && !_self.nodes[_self.nodes[cursor].rightChild].red)
{
_self.nodes[cursor].red = true;
_value = valueParent;
} else {
if (!_self.nodes[_self.nodes[cursor].rightChild].red) {
_self.nodes[_self.nodes[cursor].leftChild].red = false;
_self.nodes[cursor].red = true;
rotateRight(_self, cursor);
cursor = _self.nodes[valueParent].rightChild;
}
_self.nodes[cursor].red = _self.nodes[valueParent].red;
_self.nodes[valueParent].red = false;
_self.nodes[_self.nodes[cursor].rightChild].red = false;
rotateLeft(_self, valueParent);
_value = _self.root;
}
} else {
cursor = _self.nodes[valueParent].leftChild;
if (_self.nodes[cursor].red) {
_self.nodes[cursor].red = false;
_self.nodes[valueParent].red = true;
rotateRight(_self, valueParent);
cursor = _self.nodes[valueParent].leftChild;
}
if (!_self.nodes[_self.nodes[cursor].rightChild].red && !_self.nodes[_self.nodes[cursor].leftChild].red)
{
_self.nodes[cursor].red = true;
_value = valueParent;
} else {
if (!_self.nodes[_self.nodes[cursor].leftChild].red) {
_self.nodes[_self.nodes[cursor].rightChild].red = false;
_self.nodes[cursor].red = true;
rotateLeft(_self, cursor);
cursor = _self.nodes[valueParent].leftChild;
}
_self.nodes[cursor].red = _self.nodes[valueParent].red;
_self.nodes[valueParent].red = false;
_self.nodes[_self.nodes[cursor].leftChild].red = false;
rotateRight(_self, valueParent);
_value = _self.root;
}
}
}
_self.nodes[_value].red = false;
}
}
| 159,062 | 11,558 |
5e20992c6eb9890e0921c9f73342e82c1f65afd868fece8b01fe3bb9da6933dd
| 34,896 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/17/179f91ea3aa67431ba06d1f1d3ad14f575b37537_Distribution.sol
| 4,516 | 18,339 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, errorMessage);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction underflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function mul(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, errorMessage);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
contract Distribution is Ownable, ReentrancyGuard {
using SafeMath for uint;
using SafeMath for uint32;
using SafeMath for uint256;
using SafeERC20 for IERC20;
event RewardClaimed(address indexed user, uint256 amount);
address public immutable HeC;
uint256 public immutable vestingTimeUnitSeconds;
uint256 public totalDebt;
mapping(address => uint) public walletIndices;
struct WalletInfo {
address recipient;
uint256 unlockedBalance;
uint256 lockedBalance;
uint256 totalAllocation;
uint256 releaseAmountPerVestingTimeUnit;
uint256 claimableEpochTime;
}
WalletInfo[] public wallets;
constructor(address _hec, uint256 _vestingTimeUnitSeconds) {
require(_hec != address(0));
HeC = _hec;
vestingTimeUnitSeconds = _vestingTimeUnitSeconds;
totalDebt = 0;
}
function claim() external nonReentrant {
uint index = walletIndices[msg.sender];
require(wallets[ index ].recipient == msg.sender, "Claim request is not valid.");
require(wallets[ index ].lockedBalance > 0, "There is no balance left to claim.");
//initial value of current claimable time is the ending time of cliff/lock period
//after first claim, this value is iterated forward by the time unit amount claimed
uint256 currentClaimableEpochTime = wallets[ index ].claimableEpochTime;
require(currentClaimableEpochTime <= uint256(block.timestamp), "Lock period not completed yet.");
uint256 vestingTimeUnitCount = (uint256(block.timestamp) - currentClaimableEpochTime).div(vestingTimeUnitSeconds);
require(vestingTimeUnitCount > 0, "Minimum vesting unit (day/week/month etc.) not passed yet.");
// distribute rewards to sender
uint256 valueToSend = wallets[ index ].releaseAmountPerVestingTimeUnit.mul(vestingTimeUnitCount);
if(valueToSend > wallets[ index ].lockedBalance) {
valueToSend = wallets[ index ].lockedBalance;
}
wallets[ index ].lockedBalance = wallets[ index ].lockedBalance.sub(valueToSend);
wallets[ index ].claimableEpochTime = currentClaimableEpochTime.add(vestingTimeUnitSeconds.mul(vestingTimeUnitCount));
totalDebt = totalDebt.sub(valueToSend);
IERC20(HeC).safeTransfer(msg.sender, valueToSend);
emit RewardClaimed(msg.sender, valueToSend);
}
function TGEclaim() external nonReentrant {
uint index = walletIndices[msg.sender];
require(wallets[ index ].recipient == msg.sender, "Claim request is not valid.");
require(wallets[index].unlockedBalance > 0, "There is no balance left to claim.");
uint256 valueToSend = wallets[ index ].unlockedBalance;
wallets[ index ].unlockedBalance = 0;
totalDebt = totalDebt.sub(valueToSend);
IERC20(HeC).safeTransfer(msg.sender, valueToSend);
emit RewardClaimed(msg.sender, valueToSend);
}
function claimable(uint index) public view returns (uint256) {
uint256 _currentClaimableEpochTime = wallets[ index ].claimableEpochTime;
require(_currentClaimableEpochTime <= uint256(block.timestamp), "Lock period not completed yet.");
uint256 _vestingTimeUnitCount = (uint256(block.timestamp) - _currentClaimableEpochTime).div(vestingTimeUnitSeconds);
uint256 _claimable = wallets[ index ].releaseAmountPerVestingTimeUnit.mul(_vestingTimeUnitCount);
if(_claimable > wallets[ index ].lockedBalance) {
_claimable = wallets[ index ].lockedBalance;
}
_claimable = _claimable.add(wallets[ index ].unlockedBalance);
return _claimable;
}
function _addRecipient(address _recipient, uint256 _unlockedBalance, uint256 _lockedBalance, uint256 _releaseAmountPerVestingTimeUnit, uint256 _claimableEpochTime) internal {
require(_recipient != address(0), "Recipient address cannot be empty.");
require(totalDebt.add(_lockedBalance).add(_unlockedBalance) <= IERC20(HeC).balanceOf(address(this)), "Cannot add this debt amount due to the balance of this Contract.");
wallets.push(WalletInfo({
recipient: _recipient,
unlockedBalance: _unlockedBalance,
lockedBalance: _lockedBalance,
totalAllocation: _unlockedBalance.add(_lockedBalance),
releaseAmountPerVestingTimeUnit: _releaseAmountPerVestingTimeUnit,
claimableEpochTime: _claimableEpochTime
}));
walletIndices[_recipient] = wallets.length - 1;
totalDebt = totalDebt.add(_lockedBalance).add(_unlockedBalance);
}
function addRecipient(address[] memory _recipient, uint256[] memory _unlockedBalance, uint256[] memory _lockedBalance, uint256[] memory _releaseAmountPerVestingTimeUnit, uint256[] memory _claimableEpochTime) external onlyOwner() {
require(_recipient.length == _unlockedBalance.length, "Array sizes do not match.");
require(_recipient.length == _releaseAmountPerVestingTimeUnit.length, "Array sizes do not match.");
require(_recipient.length == _lockedBalance.length, "Array sizes do not match.");
require(_recipient.length == _claimableEpochTime.length, "Array sizes do not match.");
for(uint i = 0; i < _recipient.length; i++) {
_addRecipient(_recipient[i], _unlockedBalance[i], _lockedBalance[i], _releaseAmountPerVestingTimeUnit[i], _claimableEpochTime[i]);
}
}
function _removeRecipient(uint _index, address _recipient) internal {
require(_recipient == wallets[ _index ].recipient, "Recipient index does not match.");
totalDebt = totalDebt.sub(wallets[ _index ].lockedBalance).sub(wallets[ _index ].unlockedBalance);
wallets[ _index ].recipient = address(0);
wallets[ _index ].releaseAmountPerVestingTimeUnit = 0;
wallets[ _index ].claimableEpochTime = 0;
wallets[ _index ].unlockedBalance = 0;
wallets[ _index ].lockedBalance = 0;
}
function removeRecipient(uint[] memory _indices, address[] memory _recipient) external onlyOwner() {
require(_recipient.length == _indices.length, "Array sizes do not match.");
for(uint i = 0; i < _recipient.length; i++) {
_removeRecipient(_indices[i], _recipient[i]);
}
}
function withdraw() external onlyOwner(){
uint256 total = IERC20(HeC).balanceOf(address(this));
require(total > 0, "There is no balance left to withdraw.");
IERC20(HeC).safeTransfer(msg.sender, total);
}
}
| 113,813 | 11,559 |
fe3548626eac65e809f6e18525c1f49cef8ba26da224df880be56bb7a7a71838
| 624,463 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xba74b0c3147722456df2d63b9a3f87ceb0c916e8.sol
| 3,261 | 8,262 |
pragma solidity ^0.4.25 ;
contract VOCC_I094_20181211 {
mapping (address => uint256) public balanceOf;
string public name = " VOCC_I094_20181211 " ;
string public symbol = " VOCC_I094_20181211_subDT " ;
uint8 public decimals = 18 ;
uint256 public totalSupply = 19800000000000000000000000 ;
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;
}
// }
// MKDCHF
//
//
// MKDCHF
//
//
// MKDCHF
//
//
// MKDCHF
//
//
// MKDCHF
//
//
// MKDEUR
//
//
// MKDEUR
//
//
// MKDEUR
//
//
// MKDEUR
//
//
// MKDEUR
//
//
// MKDRUB
//
//
// MKDRUB
//
//
// MKDRUB
//
//
// MKDRUB
//
//
// MKDRUB
//
//
// MKDCNY
// #DIV/0 ! 1
// #DIV/0 ! 2
// #DIV/0 ! 3
// #DIV/0 ! 4
// #DIV/0 ! 5
// #DIV/0 ! 6
// #DIV/0 ! 7
// #DIV/0 ! 8
// #DIV/0 ! 9
// #DIV/0 ! 10
// #DIV/0 ! 11
// #DIV/0 ! 12
// #DIV/0 ! 13
// #DIV/0 ! 14
// #DIV/0 ! 15
// #DIV/0 ! 16
// #DIV/0 ! 17
// #DIV/0 ! 18
// #DIV/0 ! 19
// #DIV/0 ! 20
// #DIV/0 ! 21
//
//
// #DIV/0 ! 1
// #DIV/0 ! 2
// #DIV/0 ! 3
// #DIV/0 ! 4
// #DIV/0 ! 5
// #DIV/0 ! 6
// #DIV/0 ! 7
// #DIV/0 ! 8
// #DIV/0 ! 9
// #DIV/0 ! 10
// #DIV/0 ! 11
// #DIV/0 ! 12
// #DIV/0 ! 13
// #DIV/0 ! 14
// #DIV/0 ! 15
// #DIV/0 ! 16
// #DIV/0 ! 17
// #DIV/0 ! 18
// #DIV/0 ! 19
// #DIV/0 ! 20
// #DIV/0 ! 21
// MKDCNY
// #DIV/0 ! 1
// #DIV/0 ! 2
// #DIV/0 ! 3
// #DIV/0 ! 4
// #DIV/0 ! 5
// #DIV/0 ! 6
// #DIV/0 ! 7
// #DIV/0 ! 8
// #DIV/0 ! 9
// #DIV/0 ! 10
// #DIV/0 ! 11
// #DIV/0 ! 12
// #DIV/0 ! 13
// #DIV/0 ! 14
// #DIV/0 ! 15
// #DIV/0 ! 16
// #DIV/0 ! 17
// #DIV/0 ! 18
// #DIV/0 ! 19
// #DIV/0 ! 20
// #DIV/0 ! 21
//
//
// #DIV/0 ! 1
// #DIV/0 ! 2
// #DIV/0 ! 3
// #DIV/0 ! 4
// #DIV/0 ! 5
// #DIV/0 ! 6
// #DIV/0 ! 7
// #DIV/0 ! 8
// #DIV/0 ! 9
// #DIV/0 ! 10
// #DIV/0 ! 11
// #DIV/0 ! 12
// #DIV/0 ! 13
// #DIV/0 ! 14
// #DIV/0 ! 15
// #DIV/0 ! 16
// #DIV/0 ! 17
// #DIV/0 ! 18
// #DIV/0 ! 19
// #DIV/0 ! 20
// #DIV/0 ! 21
// MKDCNY
// #DIV/0 ! 1
// #DIV/0 ! 2
// #DIV/0 ! 3
// #DIV/0 ! 4
// #DIV/0 ! 5
// #DIV/0 ! 6
// #DIV/0 ! 7
// #DIV/0 ! 8
// #DIV/0 ! 9
// #DIV/0 ! 10
// #DIV/0 ! 11
// #DIV/0 ! 12
// #DIV/0 ! 13
// #DIV/0 ! 14
// #DIV/0 ! 15
// #DIV/0 ! 16
// #DIV/0 ! 17
// #DIV/0 ! 18
// #DIV/0 ! 19
// #DIV/0 ! 20
// #DIV/0 ! 21
//
//
// #DIV/0 ! 1
// #DIV/0 ! 2
// #DIV/0 ! 3
// #DIV/0 ! 4
// #DIV/0 ! 5
// #DIV/0 ! 6
// #DIV/0 ! 7
// #DIV/0 ! 8
// #DIV/0 ! 9
// #DIV/0 ! 10
// #DIV/0 ! 11
// #DIV/0 ! 12
// #DIV/0 ! 13
// #DIV/0 ! 14
// #DIV/0 ! 15
// #DIV/0 ! 16
// #DIV/0 ! 17
// #DIV/0 ! 18
// #DIV/0 ! 19
// #DIV/0 ! 20
// #DIV/0 ! 21
// MKDCNY
// #DIV/0 ! 1
// #DIV/0 ! 2
// #DIV/0 ! 3
// #DIV/0 ! 4
// #DIV/0 ! 5
// #DIV/0 ! 6
// #DIV/0 ! 7
// #DIV/0 ! 8
// #DIV/0 ! 9
// #DIV/0 ! 10
// #DIV/0 ! 11
// #DIV/0 ! 12
// #DIV/0 ! 13
// #DIV/0 ! 14
// #DIV/0 ! 15
// #DIV/0 ! 16
// #DIV/0 ! 17
// #DIV/0 ! 18
// #DIV/0 ! 19
// #DIV/0 ! 20
// #DIV/0 ! 21
//
//
// #DIV/0 ! 1
// #DIV/0 ! 2
// #DIV/0 ! 3
// #DIV/0 ! 4
// #DIV/0 ! 5
// #DIV/0 ! 6
// #DIV/0 ! 7
// #DIV/0 ! 8
// #DIV/0 ! 9
// #DIV/0 ! 10
// #DIV/0 ! 11
// #DIV/0 ! 12
// #DIV/0 ! 13
// #DIV/0 ! 14
// #DIV/0 ! 15
// #DIV/0 ! 16
// #DIV/0 ! 17
// #DIV/0 ! 18
// #DIV/0 ! 19
// #DIV/0 ! 20
// #DIV/0 ! 21
// MKDCNY
// #DIV/0 ! 1
// #DIV/0 ! 2
// #DIV/0 ! 3
// #DIV/0 ! 4
// #DIV/0 ! 5
// #DIV/0 ! 6
// #DIV/0 ! 7
// #DIV/0 ! 8
// #DIV/0 ! 9
// #DIV/0 ! 10
// #DIV/0 ! 11
// #DIV/0 ! 12
// #DIV/0 ! 13
// #DIV/0 ! 14
// #DIV/0 ! 15
// #DIV/0 ! 16
// #DIV/0 ! 17
// #DIV/0 ! 18
// #DIV/0 ! 19
// #DIV/0 ! 20
// #DIV/0 ! 21
//
//
// #DIV/0 ! 1
// #DIV/0 ! 2
// #DIV/0 ! 3
// #DIV/0 ! 4
// #DIV/0 ! 5
// #DIV/0 ! 6
// #DIV/0 ! 7
// #DIV/0 ! 8
// #DIV/0 ! 9
// #DIV/0 ! 10
// #DIV/0 ! 11
// #DIV/0 ! 12
// #DIV/0 ! 13
// #DIV/0 ! 14
// #DIV/0 ! 15
// #DIV/0 ! 16
// #DIV/0 ! 17
// #DIV/0 ! 18
// #DIV/0 ! 19
// #DIV/0 ! 20
// #DIV/0 ! 21
// MKDETH
//
//
// MKDETH
//
//
// MKDETH
//
//
// MKDETH
//
//
// MKDETH
//
//
// MKDBTC
//
//
// MKDBTC
//
//
// MKDBTC
//
//
// MKDBTC
//
//
// MKDBTC
//
//
}
| 186,654 | 11,560 |
ae8bb9c72631d04200884979e205ac5d07e48ff04e8b650a4f2b123e1a992019
| 12,909 |
.sol
|
Solidity
| false |
281274529
|
ontology-tech/DID-solidity
|
a30ffd2057d02cd55a0154f9df95b4c8ffabc7e1
|
contracts/libs/BytesUtils.sol
| 2,672 | 10,492 |
// SPDX-License-Identifier: LGPL-3.0-or-later
pragma solidity ^0.6.0;
library BytesUtils {
function bytesToAddress(bytes memory _bs) internal pure returns (address addr)
{
require(_bs.length == 20, "bytes length does not match address");
assembly {
// for _bs, first word store _bs.length, second word store _bs.value
addr := mload(add(_bs, 0x14))
}
}
function addressToBytes(address _addr) internal pure returns (bytes memory bs){
assembly {
// Get a location of some free memory and store it in result as
// Solidity does for memory variables.
bs := mload(0x40)
// Put 20 (address byte length) at the first word, the length of bytes for uint256 value
mstore(bs, 0x14)
// logical shift left _a by 12 bytes, change _a from right-aligned to left-aligned
mstore(add(bs, 0x20), shl(96, _addr))
// Update the free-memory pointer by padding our last write location to 32 bytes
mstore(0x40, add(bs, 0x40))
}
}
function equalStorage(bytes storage _preBytes, bytes memory _postBytes) internal view returns (bool) {
bool success = true;
assembly {
// we know _preBytes_offset is 0
let fslot := sload(_preBytes_slot)
// Arrays of 31 bytes or less have an even value in their slot,
// while longer arrays have an odd value. The actual length is
// the slot divided by two for odd values, and the lowest order
// byte divided by two for even values.
// If the slot is even, bitwise and the slot with 255 and divide by
// two to get the length. If the slot is odd, bitwise and the slot
// with -1 and divide by two.
let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)
let mlength := mload(_postBytes)
// if lengths don't match the arrays are not equal
switch eq(slength, mlength)
case 1 {
// fslot can contain both the length and contents of the array
// if slength < 32 bytes so let's prepare for that
// slength != 0
if iszero(iszero(slength)) {
switch lt(slength, 32)
case 1 {
// blank the last byte which is the length
fslot := mul(div(fslot, 0x100), 0x100)
if iszero(eq(fslot, mload(add(_postBytes, 0x20)))) {
// unsuccess:
success := 0
}
}
default {
// cb is a circuit breaker in the for loop since there's
// no said feature for inline assembly loops
// cb = 1 - don't breaker
// cb = 0 - break
let cb := 1
// get the keccak hash to get the contents of the array
mstore(0x0, _preBytes_slot)
let sc := keccak256(0x0, 0x20)
let mc := add(_postBytes, 0x20)
let end := add(mc, mlength)
// the next line is the loop condition:
// while(uint(mc < end) + cb == 2)
for {} eq(add(lt(mc, end), cb), 2) {
sc := add(sc, 1)
mc := add(mc, 0x20)
} {
if iszero(eq(sload(sc), mload(mc))) {
// unsuccess:
success := 0
cb := 0
}
}
}
}
}
default {
// unsuccess:
success := 0
}
}
return success;
}
function equal(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bool) {
bool success = true;
assembly {
let length := mload(_preBytes)
// if lengths don't match the arrays are not equal
switch eq(length, mload(_postBytes))
case 1 {
// cb is a circuit breaker in the for loop since there's
// no said feature for inline assembly loops
// cb = 1 - don't breaker
// cb = 0 - break
let cb := 1
let mc := add(_preBytes, 0x20)
let end := add(mc, length)
for {
let cc := add(_postBytes, 0x20)
// the next line is the loop condition:
// while(uint256(mc < end) + cb == 2)
} eq(add(lt(mc, end), cb), 2) {
mc := add(mc, 0x20)
cc := add(cc, 0x20)
} {
// if any of these checks fails then arrays are not equal
if iszero(eq(mload(mc), mload(cc))) {
// unsuccess:
success := 0
cb := 0
}
}
}
default {
// unsuccess:
success := 0
}
}
return success;
}
function slice(bytes memory _bytes,
uint _start,
uint _length)
internal
pure
returns (bytes memory)
{
require(_bytes.length >= (_start + _length));
bytes memory tempBytes;
assembly {
switch iszero(_length)
case 0 {
// Get a location of some free memory and store it in tempBytes as
// Solidity does for memory variables.
tempBytes := mload(0x40)
// The first word of the slice result is potentially a partial
// word read from the original array. To read it, we calculate
// the length of that partial word and start copying that many
// bytes into the array. The first word we copy will start with
// data we don't care about, but the last `lengthmod` bytes will
// land at the beginning of the contents of the new array. When
// we're done copying, we overwrite the full first word with
// the actual length of the slice.
// lengthmod <= _length % 32
let lengthmod := and(_length, 31)
// The multiplication in the next line is necessary
// because when slicing multiples of 32 bytes (lengthmod == 0)
// the following copy loop was copying the origin's length
// and then ending prematurely not copying everything it should.
let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod)))
let end := add(mc, _length)
for {
// The multiplication in the next line has the same exact purpose
// as the one above.
let cc := add(add(add(_bytes, lengthmod), mul(0x20, iszero(lengthmod))), _start)
} lt(mc, end) {
mc := add(mc, 0x20)
cc := add(cc, 0x20)
} {
mstore(mc, mload(cc))
}
mstore(tempBytes, _length)
//update free-memory pointer
//allocating the array padded to 32 bytes like the compiler does now
mstore(0x40, and(add(mc, 31), not(31)))
}
//if we want a zero-length slice let's just return a zero-length array
default {
tempBytes := mload(0x40)
mstore(0x40, add(tempBytes, 0x20))
}
}
return tempBytes;
}
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {codehash := extcodehash(account)}
return (codehash != 0x0 && codehash != accountHash);
}
function fromHexChar(uint8 c) public pure returns (uint8) {
if (byte(c) >= byte('0') && byte(c) <= byte('9')) {
return c - uint8(byte('0'));
}
if (byte(c) >= byte('a') && byte(c) <= byte('f')) {
return 10 + c - uint8(byte('a'));
}
if (byte(c) >= byte('A') && byte(c) <= byte('F')) {
return 10 + c - uint8(byte('A'));
}
revert();
}
function fromHex(string memory s) public pure returns (bytes memory) {
bytes memory ss = bytes(s);
require(ss.length % 2 == 0);
// length must be even
bytes memory r = new bytes(ss.length / 2);
for (uint i = 0; i < ss.length / 2; ++i) {
r[i] = byte(fromHexChar(uint8(ss[2 * i])) * 16 +
fromHexChar(uint8(ss[2 * i + 1])));
}
return r;
}
function uint2str(uint _i) internal pure returns (string memory _uintAsString) {
if (_i == 0) {
return "0";
}
uint j = _i;
uint len;
while (j != 0) {
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
uint k = len - 1;
while (_i != 0) {
bstr[k--] = byte(uint8(48 + _i % 10));
_i /= 10;
}
return string(bstr);
}
function toLower(string memory str) public pure returns (string memory) {
bytes memory bStr = bytes(str);
bytes memory bLower = new bytes(bStr.length);
for (uint i = 0; i < bStr.length; i++) {
// Uppercase character...
uint8 c = uint8(bStr[i]);
if ((c >= 65) && (c <= 90)) {
// So we add 32 to make it lowercase
bLower[i] = bytes1(c + 32);
} else {
bLower[i] = bStr[i];
}
}
return string(bLower);
}
}
| 175,089 | 11,561 |
7fdf4d56851fb8f37f7b2f3afbf4587d59a610aa9faa723e037ac71854c02ad9
| 26,889 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/0a/0aE3fBc3eD6C60A8a556A03AE573f6dd2Cf28985_BondReverse.sol
| 3,041 | 12,052 |
// 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);
}
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 ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(address from,
address to,
uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address from,
address to,
uint256 amount) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
}
_balances[to] += amount;
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _spendAllowance(address owner,
address spender,
uint256 amount) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
}
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() {
_paused = false;
}
function paused() public view virtual returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!paused(), "Pausable: paused");
_;
}
modifier whenPaused() {
require(paused(), "Pausable: not paused");
_;
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
abstract contract ERC20Burnable is Context, ERC20 {
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
_spendAllowance(account, _msgSender(), amount);
_burn(account, amount);
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
library Roles {
struct Role {
mapping(address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(account != address(0));
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(account != address(0));
role.bearer[account] = false;
}
function has(Role storage role, address account)
internal
view
returns (bool)
{
require(account != address(0));
return role.bearer[account];
}
}
contract ManagerRole {
using Roles for Roles.Role;
event ManagerAdded(address indexed account);
event ManagerRemoved(address indexed account);
Roles.Role private managers;
constructor() {
_addManager(msg.sender);
}
modifier onlyManager() {
require(isManager(msg.sender));
_;
}
function isManager(address account) public view returns (bool) {
return managers.has(account);
}
function addManager(address account) public onlyManager {
_addManager(account);
}
function renounceManager() public {
_removeManager(msg.sender);
}
function _addManager(address account) internal {
managers.add(account);
emit ManagerAdded(account);
}
function _removeManager(address account) internal {
managers.remove(account);
emit ManagerRemoved(account);
}
}
contract BondReverse is ManagerRole, Ownable, Pausable {
ERC20Burnable public immutable dYelToken;
IERC20 public immutable USDC;
address public ownerA8 = 0x5F8ec4d7ED8F9E3Fa4219796551271579F7e0029;
uint256 public percent = 10; // uses for checking price difference
uint256 public percentPenalty = 10000; // 5% = 5000
uint256 public currentPrice;
constructor (address _token, address _USDC) {
require(_token != address(0), "BondReverse: Token address can not be zero");
dYelToken = ERC20Burnable(_token);
USDC = IERC20(_USDC);
currentPrice = 200000;
}
function deposit(uint256 _amount) external whenNotPaused {
require(_amount != 0, "BondReverse: The amount of tokens can not be zero");
// sender have to approve his tokens
dYelToken.burnFrom(msg.sender, _amount);
// taUSDC = totalAmountUSDC, ua = userAmount, oa = _ownerAmount
(uint256 ua, uint256 oa) = valueOfDYEL(_amount);
USDC.transferFrom(address(this), ownerA8, oa);
USDC.transferFrom(address(this), msg.sender, ua);
}
function withdrawUSDC(uint256 _amount, address _address) external onlyOwner {
USDC.transferFrom(address(this), _address, _amount);
}
function setPriceInUSDC(uint256 _price) external onlyManager {
require(returnPercentPrice(_price) > percent, "BondReverse: The price difference is more then previous");
currentPrice = _price;
}
function returnPercentPrice(uint256 _newPrice) view public returns (uint256 _percentDelta) {
require(_newPrice != currentPrice, "BondReverse: The price are the same");
uint256 _percentTotal = (_newPrice * 100) / currentPrice;
if(_newPrice > currentPrice) {
_percentDelta = _percentTotal - 100;
} else {
_percentDelta = 100 - _percentTotal;
}
}
function valueOfDYEL(uint256 _dYelAmount) public view returns (uint256 _userAmount, uint256 _ownerAmount) {
// total = 2 * 1e18 * 10000 * 1e6 = 20000 * 1e24 / 1e18 = 20000 * 1e6
uint256 _totalAmountUSDC = _dYelAmount * currentPrice;
uint256 _penaltyAmount = _totalAmountUSDC * percentPenalty / 1e6;
// penalty = 20000 * 1e6 * 10000 / 100000 = 2000 * 1e6
_userAmount = _totalAmountUSDC - _penaltyAmount;
_ownerAmount = _penaltyAmount / 2;
}
receive() external payable onlyOwner {}
}
| 324,462 | 11,562 |
2e4f390d6a024e44b756256655016d303cffa8f916aaf9a3788d06f3d339eb1c
| 27,461 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TT/TTRJV2HpFomWWCqt2GbBNsgFSryxiuNnrj_SmartLottoTron.sol
| 7,278 | 26,792 |
//SourceUnit: SmartLottoTron.sol
pragma solidity 0.5.10;
contract CareerPlan {
function addToBalance() external payable;
function addUserToLevel(address _user, uint _id, uint8 _level) external;
}
contract Lotto {
function addUser(address user) external;
function addToRaffle() external payable;
}
contract SmartLottoTron {
event SignUpEvent(address indexed _newUser, uint indexed _userId, address indexed _sponsor, uint _sponsorId);
event NewUserChildEvent(address indexed _user, address indexed _sponsor, uint8 _box, bool _isSmartDirect, uint8 _position);
event ReinvestBoxEvent(address indexed _user, address indexed currentSponsor, address indexed addrCaller, uint8 _box, bool _isSmartDirect);
event MissedEvent(address indexed _from, address indexed _to, uint8 _box, bool _isSmartDirect);
event SentExtraEvent(address indexed _from, address indexed _to, uint8 _box, bool _isSmartDirect);
event UpgradeStatusEvent(address indexed _user, address indexed _sponsor, uint8 _box, bool _isSmartDirect);
struct User {
uint id;
address referrer;
uint partnersCount;
uint8 levelCareerPlan;
bool activeInLottery;
mapping(uint8 => bool) activeX3Levels;
mapping(uint8 => bool) activeX6Levels;
mapping(uint8 => X3) x3Matrix;
mapping(uint8 => X6) x6Matrix;
}
struct X3 {
address currentReferrer;
address[] referrals;
bool blocked;
uint reinvestCount;
uint partnersCount;
}
struct X6 {
address currentReferrer;
address[] firstLevelReferrals;
address[] secondLevelReferrals;
bool blocked;
uint reinvestCount;
uint partnersCount;
address closedPart;
}
uint8 public currentStartingLevel = 1;
uint8 public constant LAST_LEVEL = 14;
uint public lastUserId = 2;
mapping(address => User) public users;
mapping(uint => address) public idToAddress;
mapping(uint8 => uint) public levelPrice;
mapping(uint8 => Distribution) boxDistribution;
address public owner;
address externalAddress;
address externalFeeAddress;
address rootAddress;
CareerPlan careerPlan;
struct PlanRequirements {
uint purchasedBoxes;
uint countReferrers;
}
mapping(uint8 => PlanRequirements) levelRequirements;
Lotto lottery;
struct Distribution {
uint user;
uint lotto;
uint careerPlan;
uint owner;
uint fee;
}
struct Sender {
address[] users;
uint[] usersAmount;
uint lotto;
uint careerPlan;
uint owner;
uint fee;
}
Sender senderBuilder;
modifier restricted() {
require(msg.sender == owner, "restricted");
_;
}
constructor(address _externalAddress, address _careerPlanAddress,
address _lotteryAddress, address _externalFeeAddress, address _rootAddress) public {
owner = msg.sender;
externalAddress = _externalAddress;
externalFeeAddress = _externalFeeAddress;
rootAddress = _rootAddress;
lottery = Lotto(_lotteryAddress);
initializeValues();
initializeCareerPlan(_careerPlanAddress);
users[rootAddress].id = 1;
users[rootAddress].referrer = address(0);
idToAddress[1] = rootAddress;
for (uint8 i = 1; i <= LAST_LEVEL; i++) {
users[rootAddress].activeX3Levels[i] = true;
users[rootAddress].activeX6Levels[i] = true;
}
}
function initializeValues() internal {
levelPrice[1] = 250 trx;
levelPrice[2] = 500 trx;
levelPrice[3] = 1000 trx;
levelPrice[4] = 2000 trx;
levelPrice[5] = 4000 trx;
levelPrice[6] = 8000 trx;
levelPrice[7] = 16000 trx;
levelPrice[8] = 32000 trx;
levelPrice[9] = 64000 trx;
levelPrice[10] = 128000 trx;
levelPrice[11] = 256000 trx;
levelPrice[12] = 512000 trx;
levelPrice[13] = 1024000 trx;
levelPrice[14] = 2048000 trx;
boxDistribution[1] = Distribution({user: 175 trx, lotto: 52.5 trx, careerPlan: 13.5 trx, owner: 8.325 trx, fee: 0.675 trx});
boxDistribution[2] = Distribution({user: 350 trx, lotto: 105 trx, careerPlan: 27 trx, owner: 16.65 trx, fee: 1.35 trx});
boxDistribution[3] = Distribution({user: 700 trx, lotto: 210 trx, careerPlan: 54 trx, owner: 33.3 trx, fee: 2.7 trx});
boxDistribution[4] = Distribution({user: 1400 trx, lotto: 420 trx, careerPlan: 108 trx, owner: 66.6 trx, fee: 5.4 trx});
boxDistribution[5] = Distribution({user: 2800 trx, lotto: 840 trx, careerPlan: 216 trx, owner: 133.2 trx, fee: 10.8 trx});
boxDistribution[6] = Distribution({user: 5600 trx, lotto: 1680 trx, careerPlan: 432 trx, owner: 266.4 trx, fee: 21.6 trx});
boxDistribution[7] = Distribution({user: 11200 trx, lotto: 3360 trx, careerPlan: 864 trx, owner: 532.8 trx, fee: 43.2 trx});
boxDistribution[8] = Distribution({user: 22400 trx, lotto: 6720 trx, careerPlan: 1728 trx, owner: 1065.6 trx, fee: 86.4 trx});
boxDistribution[9] = Distribution({user: 44800 trx, lotto: 13440 trx, careerPlan: 3456 trx, owner: 2131.2 trx, fee: 172.8 trx});
boxDistribution[10] = Distribution({user: 89600 trx, lotto: 26880 trx, careerPlan: 6912 trx, owner: 4262.4 trx, fee: 345.6 trx});
boxDistribution[11] = Distribution({user: 179200 trx, lotto: 53760 trx, careerPlan: 13824 trx, owner: 8524.8 trx, fee: 691.2 trx});
boxDistribution[12] = Distribution({user: 358400 trx, lotto: 107520 trx, careerPlan: 27648 trx, owner: 17049.6 trx, fee: 1382.4 trx});
boxDistribution[13] = Distribution({user: 716800 trx, lotto: 215040 trx, careerPlan: 55296 trx, owner: 34099.2 trx, fee: 2764.8 trx});
boxDistribution[14] = Distribution({user: 1433600 trx, lotto: 430080 trx, careerPlan: 110592 trx, owner: 68198.4 trx, fee: 5529.6 trx});
}
function initializeCareerPlan(address _careerPlanAddress) internal {
careerPlan = CareerPlan(_careerPlanAddress);
levelRequirements[1].countReferrers = 10;
levelRequirements[1].purchasedBoxes = 3;
levelRequirements[2].countReferrers = 20;
levelRequirements[2].purchasedBoxes = 6;
levelRequirements[3].countReferrers = 30;
levelRequirements[3].purchasedBoxes = 9;
levelRequirements[4].countReferrers = 40;
levelRequirements[4].purchasedBoxes = 12;
levelRequirements[5].countReferrers = 60;
levelRequirements[5].purchasedBoxes = 14;
}
function verifyLevelOfUser(address user) internal {
if (users[user].levelCareerPlan >= 5) return;
uint8 level = users[user].levelCareerPlan + 1;
PlanRequirements memory requirements = levelRequirements[level];
for(uint8 i = 1; i <= requirements.purchasedBoxes; i++) {
if(!users[user].activeX3Levels[i] || !users[user].activeX6Levels[i]) return;
if(users[user].x3Matrix[i].partnersCount < requirements.countReferrers
|| users[user].x6Matrix[i].partnersCount < requirements.countReferrers) return;
}
users[user].levelCareerPlan = level;
careerPlan.addUserToLevel(user, users[user].id, level);
}
function verifyRequirementsForLottery(address user) internal {
if (users[user].activeInLottery) return;
for(uint8 i = 1; i <= 3; i++) {
if(!users[user].activeX3Levels[i] || !users[user].activeX6Levels[i])
return;
}
users[user].activeInLottery = true;
lottery.addUser(user);
}
function() external payable {
require(msg.value == levelPrice[currentStartingLevel] * 2, "invalid registration cost");
if(msg.data.length == 0) {
return registration(msg.sender, rootAddress);
}
registration(msg.sender, bytesToAddress(msg.data));
}
function withdrawLostTRXFromBalance() public {
require(msg.sender == owner, "onlyOwner");
address(uint160(owner)).transfer(address(this).balance);
}
function registration(address userAddress, address referrerAddress) private {
require(!isUserExists(userAddress), "user exists");
require(isUserExists(referrerAddress), "referrer not exists");
uint32 size;
assembly {
size := extcodesize(userAddress)
}
require(size == 0, "cannot be a contract");
idToAddress[lastUserId] = userAddress;
users[userAddress].id = lastUserId;
users[userAddress].referrer = referrerAddress;
users[userAddress].activeX3Levels[1] = true;
users[userAddress].activeX6Levels[1] = true;
lastUserId++;
users[referrerAddress].partnersCount++;
users[referrerAddress].x3Matrix[1].partnersCount++;
users[referrerAddress].x6Matrix[1].partnersCount++;
address freeX3Referrer = findFreeX3Referrer(userAddress, 1);
users[userAddress].x3Matrix[1].currentReferrer = freeX3Referrer;
updateX3Referrer(userAddress, freeX3Referrer, 1);
updateX6Referrer(userAddress, findFreeX6Referrer(userAddress, 1), 1);
emit SignUpEvent(userAddress, users[userAddress].id, referrerAddress, users[referrerAddress].id);
sendTrx();
}
function signUp(address referrerAddress) external payable {
require(msg.value == levelPrice[currentStartingLevel] * 2, "invalid registration cost");
registration(msg.sender, referrerAddress);
}
function signUpAdmin(address _user, address _sponsor) external restricted returns(string memory) {
registration(_user, _sponsor);
return "registration successful";
}
function buyNewLevel(address _user, uint8 matrix, uint8 level) internal {
require(isUserExists(_user), "user is not exists. Register first.");
require(matrix == 1 || matrix == 2, "invalid matrix");
require(level > 1 && level <= LAST_LEVEL, "invalid level");
if (matrix == 1) {
require(users[_user].activeX3Levels[level-1], "buy previous level first");
require(!users[_user].activeX3Levels[level], "level already activated");
if (users[_user].x3Matrix[level-1].blocked) {
users[_user].x3Matrix[level-1].blocked = false;
}
address freeX3Referrer = findFreeX3Referrer(_user, level);
users[_user].x3Matrix[level].currentReferrer = freeX3Referrer;
users[_user].activeX3Levels[level] = true;
updateX3Referrer(_user, freeX3Referrer, level);
if(users[users[_user].referrer].activeX3Levels[level]) {
users[users[_user].referrer].x3Matrix[level].partnersCount++;
verifyLevelOfUser(users[_user].referrer);
}
emit UpgradeStatusEvent(_user, freeX3Referrer, level, true);
} else {
require(users[_user].activeX6Levels[level-1], "buy previous level first");
require(!users[_user].activeX6Levels[level], "level already activated");
if (users[_user].x6Matrix[level-1].blocked) {
users[_user].x6Matrix[level-1].blocked = false;
}
address freeX6Referrer = findFreeX6Referrer(_user, level);
users[_user].activeX6Levels[level] = true;
updateX6Referrer(_user, freeX6Referrer, level);
if(users[users[_user].referrer].activeX6Levels[level]) {
users[users[_user].referrer].x6Matrix[level].partnersCount++;
verifyLevelOfUser(users[_user].referrer);
}
emit UpgradeStatusEvent(_user, freeX6Referrer, level, false);
}
verifyRequirementsForLottery(_user);
sendTrx();
}
function buyNewBox(uint8 _matrix, uint8 _box) external payable {
require(msg.value == levelPrice[_box], "invalid price");
buyNewLevel(msg.sender, _matrix, _box);
}
function buyNewBoxAdmin(address _user, uint8 _matrix, uint8 _box) external restricted returns(string memory) {
buyNewLevel(_user, _matrix, _box);
return "Level bought successfully";
}
function updateX3Referrer(address userAddress, address referrerAddress, uint8 level) private {
users[referrerAddress].x3Matrix[level].referrals.push(userAddress);
if (users[referrerAddress].x3Matrix[level].referrals.length < 3) {
emit NewUserChildEvent(userAddress, referrerAddress, level, true, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
return sendETHDividends(referrerAddress, userAddress, 1, level);
}
emit NewUserChildEvent(userAddress, referrerAddress, level, true, 3);
//close matrix
users[referrerAddress].x3Matrix[level].referrals = new address[](0);
if (!users[referrerAddress].activeX3Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x3Matrix[level].blocked = true;
}
//create new one by recursion
if (referrerAddress != rootAddress) {
address freeReferrerAddress = findFreeX3Referrer(referrerAddress, level);
if (users[referrerAddress].x3Matrix[level].currentReferrer != freeReferrerAddress) {
users[referrerAddress].x3Matrix[level].currentReferrer = freeReferrerAddress;
}
users[referrerAddress].x3Matrix[level].reinvestCount++;
emit ReinvestBoxEvent(referrerAddress, freeReferrerAddress, userAddress, level, true);
updateX3Referrer(referrerAddress, freeReferrerAddress, level);
} else {
sendETHDividends(rootAddress, userAddress, 1, level);
users[rootAddress].x3Matrix[level].reinvestCount++;
emit ReinvestBoxEvent(rootAddress, address(0), userAddress, level, true);
}
}
function updateX6Referrer(address userAddress, address referrerAddress, uint8 level) private {
require(users[referrerAddress].activeX6Levels[level], "500. Referrer level is inactive");
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length < 2) {
users[referrerAddress].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserChildEvent(userAddress, referrerAddress, level, false, uint8(users[referrerAddress].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = referrerAddress;
if (referrerAddress == rootAddress) {
return sendETHDividends(referrerAddress, userAddress, 2, level);
}
address ref = users[referrerAddress].x6Matrix[level].currentReferrer;
users[ref].x6Matrix[level].secondLevelReferrals.push(userAddress);
uint len = users[ref].x6Matrix[level].firstLevelReferrals.length;
if ((len == 2) &&
(users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) &&
(users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress)) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserChildEvent(userAddress, ref, level, false, 5);
} else {
emit NewUserChildEvent(userAddress, ref, level, false, 6);
}
} else if ((len == 1 || len == 2) &&
users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserChildEvent(userAddress, ref, level, false, 3);
} else {
emit NewUserChildEvent(userAddress, ref, level, false, 4);
}
} else if (len == 2 && users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserChildEvent(userAddress, ref, level, false, 5);
} else {
emit NewUserChildEvent(userAddress, ref, level, false, 6);
}
}
return updateX6ReferrerSecondLevel(userAddress, ref, level);
}
users[referrerAddress].x6Matrix[level].secondLevelReferrals.push(userAddress);
if (users[referrerAddress].x6Matrix[level].closedPart != address(0)) {
if ((users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]) &&
(users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart)) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
}
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[1] == userAddress) {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] == userAddress) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
if (users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length <=
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length) {
updateX6(userAddress, referrerAddress, level, false);
} else {
updateX6(userAddress, referrerAddress, level, true);
}
updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
function updateX6(address userAddress, address referrerAddress, uint8 level, bool x2) private {
if (!x2) {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserChildEvent(userAddress, users[referrerAddress].x6Matrix[level].firstLevelReferrals[0], level, false, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserChildEvent(userAddress, referrerAddress, level, false, 2 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[0];
} else {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserChildEvent(userAddress, users[referrerAddress].x6Matrix[level].firstLevelReferrals[1], level, false, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserChildEvent(userAddress, referrerAddress, level, false, 4 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[1];
}
}
function updateX6ReferrerSecondLevel(address userAddress, address referrerAddress, uint8 level) private {
if (users[referrerAddress].x6Matrix[level].secondLevelReferrals.length < 4) {
return sendETHDividends(referrerAddress, userAddress, 2, level);
}
address[] memory x6 = users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].firstLevelReferrals;
if (x6.length == 2) {
if (x6[0] == referrerAddress ||
x6[1] == referrerAddress) {
users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
} else if (x6.length == 1) {
if (x6[0] == referrerAddress) {
users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
}
}
}
users[referrerAddress].x6Matrix[level].firstLevelReferrals = new address[](0);
users[referrerAddress].x6Matrix[level].secondLevelReferrals = new address[](0);
users[referrerAddress].x6Matrix[level].closedPart = address(0);
if (!users[referrerAddress].activeX6Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x6Matrix[level].blocked = true;
}
users[referrerAddress].x6Matrix[level].reinvestCount++;
if (referrerAddress != rootAddress) {
address freeReferrerAddress = findFreeX6Referrer(referrerAddress, level);
emit ReinvestBoxEvent(referrerAddress, freeReferrerAddress, userAddress, level, false);
updateX6Referrer(referrerAddress, freeReferrerAddress, level);
} else {
emit ReinvestBoxEvent(rootAddress, address(0), userAddress, level, false);
sendETHDividends(rootAddress, userAddress, 2, level);
}
}
function findFreeX3Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeX3Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function findFreeX6Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeX6Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function usersActiveX3Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX3Levels[level];
}
function usersActiveX6Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX6Levels[level];
}
function usersX3Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, bool) {
return (users[userAddress].x3Matrix[level].currentReferrer,
users[userAddress].x3Matrix[level].referrals,
users[userAddress].x3Matrix[level].blocked);
}
function usersX6Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, address[] memory, bool, address) {
return (users[userAddress].x6Matrix[level].currentReferrer,
users[userAddress].x6Matrix[level].firstLevelReferrals,
users[userAddress].x6Matrix[level].secondLevelReferrals,
users[userAddress].x6Matrix[level].blocked,
users[userAddress].x6Matrix[level].closedPart);
}
function isUserExists(address user) public view returns (bool) {
return (users[user].id != 0);
}
function findEthReceiver(address userAddress, address _from, uint8 matrix, uint8 level) private returns(address, bool) {
address receiver = userAddress;
bool isExtraDividends;
if (matrix == 1) {
while (true) {
if (users[receiver].x3Matrix[level].blocked) {
emit MissedEvent(_from, receiver, level, true);
isExtraDividends = true;
receiver = users[receiver].x3Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
} else {
while (true) {
if (users[receiver].x6Matrix[level].blocked) {
emit MissedEvent(_from, receiver, level, false);
isExtraDividends = true;
receiver = users[receiver].x6Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
}
}
function sendETHDividends(address userAddress, address _from, uint8 matrix, uint8 level) private {
if(msg.sender != owner) {
(address receiver, bool isExtraDividends) = findEthReceiver(userAddress, _from, matrix, level);
senderBuilder.users.push(receiver);
senderBuilder.usersAmount.push(boxDistribution[level].user);
senderBuilder.owner += boxDistribution[level].owner;
senderBuilder.fee += boxDistribution[level].fee;
senderBuilder.careerPlan += boxDistribution[level].careerPlan;
senderBuilder.lotto += boxDistribution[level].lotto;
if (isExtraDividends) {
emit SentExtraEvent(_from, receiver, level, matrix == 1);
}
}
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
function sendTrx() internal {
if(senderBuilder.owner > 0) {
address(uint160(externalAddress)).transfer(senderBuilder.owner);
senderBuilder.owner = 0;
}
if(senderBuilder.fee > 0) {
address(uint160(externalFeeAddress)).transfer(senderBuilder.fee);
senderBuilder.fee = 0;
}
if(senderBuilder.careerPlan > 0) {
careerPlan.addToBalance.value(senderBuilder.careerPlan)();
senderBuilder.careerPlan = 0;
}
if(senderBuilder.lotto > 0) {
lottery.addToRaffle.value(senderBuilder.lotto)();
senderBuilder.lotto = 0;
}
for(uint i;i < senderBuilder.users.length;i++) {
address(uint160(senderBuilder.users[i])).transfer(senderBuilder.usersAmount[i]);
}
senderBuilder.users = new address[](0);
senderBuilder.usersAmount = new uint[](0);
}
}
| 287,295 | 11,563 |
20828edb29d73ed878573945a53f95703c29b96c7b0744568d6a2a0d06e2028a
| 30,014 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/61/61c0AEf2244fC7c8d134e100EB03bf617EF34c12_Token.sol
| 3,394 | 12,610 |
pragma solidity ^0.6.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Token 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 = 0x09b60709d8936eF3e62a9a8A3E1a7e962905Cd14;
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 { }
}
| 322,988 | 11,564 |
fdc673cecc1057c379a68c25c8ad7002c6313702024ec3669ce2478ce79d6138
| 12,894 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TF/TFA1rwn8A1196iChfZX9eRYvgt9rdvHzFs_SHC.sol
| 3,719 | 12,456 |
//SourceUnit: shccon.sol
pragma solidity 0.5.10;
contract TRC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract TRC20 is TRC20Basic {
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 SHC {
struct User {
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 projectAddress;
address payable public team1;
address payable public team2;
mapping(address => User) public users;
uint256[] public cycles;
uint8[] public ref_bonuses;
uint8[] public pool_bonuses;
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;
TRC20 public nbToken_;
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,TRC20 _nbToken ,address payable teama ,address payable teamb) public {
owner = _owner;
nbToken_ = _nbToken;
team1 = teama;
team2 = teamb;
ref_bonuses.push(30);
ref_bonuses.push(10);
ref_bonuses.push(10);
ref_bonuses.push(10);
ref_bonuses.push(10);
ref_bonuses.push(8);
ref_bonuses.push(8);
ref_bonuses.push(8);
ref_bonuses.push(8);
ref_bonuses.push(8);
ref_bonuses.push(5);
ref_bonuses.push(5);
ref_bonuses.push(5);
ref_bonuses.push(5);
ref_bonuses.push(5);
pool_bonuses.push(40);
pool_bonuses.push(30);
pool_bonuses.push(20);
pool_bonuses.push(10);
cycles.push(1e6);
cycles.push(3e6);
cycles.push(9e6);
cycles.push(2e7);
}
function() payable external {
}
modifier IsInitialized {
require(projectAddress != address(0), "not Initialized");
_;
}
function initialize(address payable projectAddr) public payable {
require(projectAddress == address(0)&& projectAddr!= address(0), "initialize only would call once");
projectAddress = projectAddr;
}
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++;
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 amount1");
}
else require(_amount >= 1e2 && _amount <= cycles[0], "Bad amount2");
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);
}
_pollDeposits(_addr, _amount);
if(pool_last_draw + 1 days < block.timestamp) {
_drawPool();
}
}
function _pollDeposits(address _addr, uint256 _amount) private {
pool_balance += _amount * 3 / 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 deposit(address _upline,uint256 price) payable IsInitialized external {
_setUpline(msg.sender, _upline);
_deposit(msg.sender, price);
nbToken_.transferFrom(msg.sender, projectAddress, price * 1000000000000000000 * 95 / 100);
nbToken_.transferFrom(msg.sender, team1, price * 1000000000000000000 * 3 / 100);
nbToken_.transferFrom(msg.sender, team2, price * 1000000000000000000 * 2 / 100);
}
function withdraw() external {
(uint256 to_payout, uint256 max_payout) = this.payoutOf(msg.sender);
require(users[msg.sender].payouts < max_payout, "Full payouts");
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);
}
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;
}
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;
}
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;
nbToken_.transfer(msg.sender,to_payout * 1000000000000000000);//11token
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 * 31 / 10;
}
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) / 100) - users[_addr].deposit_payouts;
if(users[_addr].deposit_payouts + payout > max_payout) {
payout = max_payout - users[_addr].deposit_payouts;
}
}
}
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 contractInfo() view external returns(uint256 _total_users, uint256 _total_deposited, uint256 _total_withdraw, uint40 _pool_last_draw, uint256 _pool_balance, uint256 _pool_lider) {
return (total_users, total_deposited, total_withdraw, pool_last_draw, pool_balance, pool_users_refs_deposits_sum[pool_cycle][pool_top[0]]);
}
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]];
}
}
}
| 295,855 | 11,565 |
208a06f979461b1c5e7fe9b5e1f128a66710317abe55656800f26cab55cf7a7a
| 15,459 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TT/TTJ1MVtf7XAtVqdB9FH2qgB9YMUpFkWLLT_Walen.sol
| 3,753 | 14,857 |
//SourceUnit: WLNtrc20.sol
pragma solidity ^0.5.14;
interface ITRC20 {
function totalSupply() external view returns (uint);
function balanceOf(address account) external view returns (uint);
function transfer(address recipient, uint amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint amount) external returns (bool);
function transferFrom(address sender, address recipient, uint amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
library 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;
}
}
contract Context {
constructor () public { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address) {
return msg.sender;
}
}
contract Ownable is Context {
address public _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract TRC20 is Context, Ownable, ITRC20 {
using SafeMath for uint;
mapping (address => uint) internal _balances;
mapping (address => mapping (address => uint)) internal _allowances;
uint internal _totalSupply;
function totalSupply() public view returns (uint) {
return _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 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 transferFrom(address sender, address recipient, uint amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "TRC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, 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, "TRC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "TRC20: transfer from the zero address");
require(recipient != address(0), "TRC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "TRC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "TRC20: approve from the zero address");
require(spender != address(0), "TRC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "TRC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "TRC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "TRC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
}
contract TRC20Detailed is TRC20 {
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 SafeTRC20 {
using SafeMath for uint;
function safeTransfer(ITRC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(ITRC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(ITRC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeTRC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(ITRC20 token, bytes memory data) private {
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeTRC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeTRC20: TRC20 operation did not succeed");
}
}
}
library EnumerableSet {
struct Set {
// Storage of set values
bytes32[] _values;
mapping (bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(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)
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
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);
}
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))));
}
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
}
contract AccessControl is Context,Ownable {
using EnumerableSet for EnumerableSet.AddressSet;
struct RoleData {
EnumerableSet.AddressSet members;
}
mapping (address => RoleData) private _roles;
address public constant DEFAULT_ADMIN_ROLE = address(0);
event RoleGranted(address indexed role, address indexed account, address indexed sender);
event RoleRevoked(address indexed role, address indexed account, address indexed sender);
function hasRole(address role, address account) public view returns (bool) {
return _roles[role].members.contains(account);
}
function getRoleMemberCount(address role) public view returns (uint256) {
return _roles[role].members.length();
}
function getRoleMember(address role, uint256 index) public view returns (address) {
return _roles[role].members.at(index);
}
function grantRole(address role, address account) public {
require(role!=DEFAULT_ADMIN_ROLE,"Admin Role can be only given by owner");
require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "AccessControl: sender must be an admin to grant");
_grantRole(role, account);
}
function revokeRole(address role, address account) public {
require(account!=_owner);
require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "AccessControl: sender must be an admin to grant");
_revokeRole(role, account);
}
function renounceRole(address role, address account) public {
require(account!=_owner);
require(account == _msgSender(), "AccessControl: can only renounce roles for self");
_revokeRole(role, account);
}
function grantAdminRole(address role, address account) public onlyOwner {
_grantRole(role, account);
}
function _setupRole(address role, address account) internal {
_grantRole(role, account);
}
function _grantRole(address role, address account) private {
if (_roles[role].members.add(account)) {
emit RoleGranted(role, account, _msgSender());
}
}
function _revokeRole(address role, address account) private {
if (_roles[role].members.remove(account)) {
emit RoleRevoked(role, account, _msgSender());
}
}
}
contract Walen is TRC20, TRC20Detailed, AccessControl {
address public MINTER_ROLE = address(1);
address public BURNER_ROLE = address(2);
constructor() public TRC20Detailed("Walen", "WLN",6) {
_setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
_setupRole(MINTER_ROLE, msg.sender);
_setupRole(BURNER_ROLE, msg.sender);
_totalSupply = 1 *(10**uint256(6));
_balances[msg.sender] = _totalSupply;
}
function mint(address to, uint256 amount) public {
require(hasRole(MINTER_ROLE, msg.sender), "Caller is not a minter");
_mint(to, amount);
}
function burn(address from, uint256 amount) public {
require(hasRole(BURNER_ROLE, msg.sender), "Caller is not a burner");
_burn(from, amount);
}
}
| 286,886 | 11,566 |
7e2507bc66e681c9dc310edd7aa693deed44828264f68de12a9d89df8c22c472
| 16,230 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x85ca6710d0f1d511d130f6935edda88acbd921bd.sol
| 2,587 | 10,081 |
pragma solidity 0.4.24;
/// @title SafeMath
/// @dev Math operations with safety checks that throw on error
library SafeMath {
/// @dev Multiply two numbers, throw on overflow.
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;
}
/// @dev Substract two numbers, throw on overflow (i.e. if subtrahend is greater than minuend).
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
/// @dev Add two numbers, throw on overflow.
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
/// @title Ownable
/// @dev Provide a modifier that permits only a single user to call the function
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/// @dev Set the original `owner` of the contract to the sender account.
constructor() public {
owner = msg.sender;
}
/// @dev Require that the modified function is only called by `owner`
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
/// @dev Allow `owner` to transfer control of the contract to `newOwner`.
/// @param newOwner The address to transfer ownership to.
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract 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 HasNoEther is Ownable {
constructor() public payable {
require(msg.value == 0);
}
function() external {}
function reclaimEther() external onlyOwner {
owner.transfer(address(this).balance);
}
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
require(token.transfer(to, value));
}
function safeTransferFrom(ERC20 token,
address from,
address to,
uint256 value)
internal
{
require(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
require(token.approve(spender, value));
}
}
contract CanReclaimToken is Ownable {
using SafeERC20 for ERC20Basic;
function reclaimToken(ERC20Basic token) external onlyOwner {
uint256 balance = token.balanceOf(this);
token.safeTransfer(owner, balance);
}
}
contract HasNoTokens is CanReclaimToken {
function tokenFallback(address from_, uint256 value_, bytes data_) external {
from_;
value_;
data_;
revert();
}
}
contract HasNoContracts is Ownable {
function reclaimContract(address contractAddr) external onlyOwner {
Ownable contractInst = Ownable(contractAddr);
contractInst.transferOwnership(owner);
}
}
contract NoOwner is HasNoEther, HasNoTokens, HasNoContracts {
}
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]);
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 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;
}
}
/// @title Lockable token with exceptions
/// @dev StandardToken modified with pausable transfers.
contract LockableToken is Ownable, StandardToken {
/// Flag for locking normal trading
bool public locked = true;
/// Addresses exempted from token trade lock
mapping(address => bool) public lockExceptions;
constructor() public {
// It should always be possible to call reclaimToken
lockExceptions[this] = true;
}
/// @notice Admin function to lock trading
function lock() public onlyOwner {
locked = true;
}
/// @notice Admin function to unlock trading
function unlock() public onlyOwner {
locked = false;
}
/// @notice Set whether `sender` may trade when token is locked
/// @param sender The address to change the lock exception for
/// @param _canTrade Whether `sender` may trade
function setTradeException(address sender, bool _canTrade) public onlyOwner {
lockExceptions[sender] = _canTrade;
}
/// @notice Check if the token is currently tradable for `sender`
/// @param sender The address attempting to make a transfer
/// @return True if `sender` is allowed to make transfers, false otherwise
function canTrade(address sender) public view returns(bool) {
return !locked || lockExceptions[sender];
}
/// @dev Modifier to make a function callable only when the contract is not paused.
modifier whenNotLocked() {
require(canTrade(msg.sender));
_;
}
function transfer(address _to, uint256 _value)
public whenNotLocked returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value)
public whenNotLocked returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value)
public whenNotLocked returns (bool) {
return super.approve(_spender, _value);
}
function increaseApproval(address _spender, uint _addedValue)
public whenNotLocked returns (bool success) {
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint _subtractedValue)
public whenNotLocked returns (bool success) {
return super.decreaseApproval(_spender, _subtractedValue);
}
}
/// @title Pledgecamp Token (PLG)
/// @author Sam Pullman
/// @notice ERC20 compatible token for the Pledgecamp platform
contract PLGToken is Ownable, NoOwner, LockableToken {
using SafeMath for uint256;
/// @notice Emitted when tokens are burned
/// @param burner Account that burned its tokens
/// @param value Number of tokens burned
event Burn(address indexed burner, uint256 value);
string public name = "PLGToken";
string public symbol = "PLG";
uint8 public decimals = 18;
/// Flag for only allowing a single token initialization
bool public initialized = false;
/// @notice Set initial PLG allocations, which can only happen once
/// @param addresses Addresses of beneficiaries
/// @param allocations Amounts to allocate each beneficiary
function initialize(address[] addresses, uint256[] allocations) public onlyOwner {
require(!initialized);
require(addresses.length == allocations.length);
initialized = true;
for(uint i = 0; i<allocations.length; i += 1) {
require(addresses[i] != address(0));
require(allocations[i] > 0);
balances[addresses[i]] = allocations[i];
totalSupply_ = totalSupply_.add(allocations[i]);
}
}
/// @dev Burns a specific amount of tokens owned by the sender
/// @param value The number of tokens to be burned
function burn(uint256 value) public {
require(value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(value);
totalSupply_ = totalSupply_.sub(value);
emit Burn(msg.sender, value);
emit Transfer(msg.sender, address(0), value);
}
}
| 192,447 | 11,567 |
c3f2c0f957240497c4a2b752ec37e7de8bc4e801ed360a9620e2d0503d80e4fd
| 24,108 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TP/TPKJzSi9U4t3DPtYaEQAL2p3fRzes5h8zu_SinghsContract.sol
| 5,952 | 23,253 |
//SourceUnit: smart-contract-v5.9.sol
// SPDX-License-Identifier: BSD-3-Clause
pragma solidity 0.5.9;
contract SinghsContract {
struct UserAccount {
uint32 id;
uint32 directSales;
address sponsor;
bool exists;
uint8[] activeSlot;
mapping(uint8 => S3) s3Slots;
mapping(uint8 => S9) s9Slots;
}
struct S3 {
address sponsor;
uint32 directSales;
uint16 cycleCount;
uint8 passup;
uint8 reEntryCheck;
uint8 placements;
}
struct S9 {
address sponsor;
uint32 directSales;
uint16 cycleCount;
uint8 passup;
uint8 cyclePassup;
uint8 reEntryCheck;
uint8 placementPosition;
address[] firstLevel;
address placedUnder;
uint8 lastOneLevelCount;
uint8 lastTwoLevelCount;
uint8 lastThreeLevelCount;
}
mapping(address => UserAccount) public userAccounts;
mapping(uint32 => address) public idToUserAccount;
mapping(uint8 => uint) public s3LevelPrice;
mapping(uint8 => uint) public s9LevelPrice;
address public owner;
uint32 public lastId;
uint8 public constant S3_LAST_LEVEL = 10;
uint8 public constant S9_LAST_LEVEL = 11;
uint internal reentry_status;
uint internal constant ENTRY_ENABLED = 1;
uint internal constant ENTRY_DISABLED = 2;
modifier isOwner(address _ownerAddress) {
require(owner == _ownerAddress, "Restricted Access!");
_;
}
modifier isUserAccount(address _addr) {
require(userAccounts[_addr].exists, "Register Account First");
_;
}
modifier blockEntry() {
require(reentry_status != ENTRY_DISABLED, "Security Entry Block");
reentry_status = ENTRY_DISABLED;
_;
reentry_status = ENTRY_ENABLED;
}
event registerEvent(uint indexed userId, address indexed user, address indexed sponsor);
event purchaseLevelEvent(address user, address sponsor, uint8 matrix, uint8 level);
event positionS3Event(address user, address sponsor, uint8 level, uint8 placement, bool passup);
event positionS9Event(address user, address sponsor, uint8 level, uint8 placementPosition, address placedUnder, bool passup);
event cycleCompleteEvent(address indexed user, address fromPosition, uint8 matrix, uint8 level);
event reEntryEvent(address indexed user, address reEntryFrom, uint8 matrix, uint8 level);
event passupEvent(address indexed user, address passupFrom, uint8 matrix, uint8 level);
event payoutEvent(address indexed user, address payoutFrom, uint8 matrix, uint8 level);
constructor(address _user) public {
owner = msg.sender;
reentry_status = ENTRY_ENABLED;
s3LevelPrice[1] = 250 * 1e6;
s9LevelPrice[1] = 250 * 1e6;
createAccount(_user, _user, true);
setPositionS3(_user, _user, _user, 1, true);
setPositionS9(_user, _user, _user, 1, true, false);
for (uint8 i = 2; i <= S3_LAST_LEVEL; i++) {
s3LevelPrice[i] = s3LevelPrice[i-1] * 2;
setPositionS3(_user, _user, _user, i, true);
}
for (uint8 i = 2; i <= S9_LAST_LEVEL; i++) {
s9LevelPrice[i] = s9LevelPrice[i-1] * 2;
setPositionS9(_user, _user, _user, i, true, false);
}
}
function() external payable {
if(msg.data.length == 0) {
registrationEntry(msg.sender, idToUserAccount[1]);
}
registrationEntry(msg.sender, bytesToAddress(msg.data));
}
function doRegistration(address _sponsor) external payable blockEntry() {
registrationEntry(msg.sender, _sponsor);
}
function registrationEntry(address _user, address _sponsor) internal {
require((s3LevelPrice[1] * 2) == msg.value, "500 TRX Require to register!");
createAccount(_user, _sponsor, false);
userAccounts[_sponsor].directSales++;
setPositionS3(_user, _sponsor, _sponsor, 1, false);
setPositionS9(_user, _sponsor, _sponsor, 1, false, true);
doS3Payout(_user, 1);
}
function createAccount(address _user, address _sponsor, bool _initial) internal {
require(!userAccounts[_user].exists, "Already a Singhs Account");
if (_initial == false) {
require(userAccounts[_sponsor].exists, "Sponsor doesnt exists");
}
lastId++;
userAccounts[_user] = UserAccount({
id: lastId,
sponsor: _sponsor,
exists: true,
directSales: 0,
activeSlot: new uint8[](2)
});
idToUserAccount[lastId] = _user;
emit registerEvent(lastId, _user, _sponsor);
}
function purchaseLevel(uint8 _matrix, uint8 _level) external payable isUserAccount(msg.sender) {
require(userAccounts[msg.sender].exists, "User not exists, Buy First Level");
require(_matrix == 1 || _matrix == 2, "Invalid Sings Matrix");
address sponsor = userAccounts[msg.sender].sponsor;
if (_matrix == 1) {
require(_level > 1 && _level <= S3_LAST_LEVEL, "Invalid s3 Level");
require(msg.value == s3LevelPrice[_level], "Invalid s3 Price");
require(userAccounts[msg.sender].activeSlot[0] < _level, "s3 level already activated");
setPositionS3(msg.sender, sponsor, findActiveSponsor(msg.sender, sponsor, 0, _level, true), _level, false);
emit purchaseLevelEvent(msg.sender, sponsor, _matrix, _level);
doS3Payout(msg.sender, _level);
} else {
require(_level > 1 && _level <= S9_LAST_LEVEL, "Invalid s9 Level");
require(msg.value == s9LevelPrice[_level], "Invalid s9 Price");
require(userAccounts[msg.sender].activeSlot[1] < _level, "s9 level already activated");
setPositionS9(msg.sender, sponsor, findActiveSponsor(msg.sender, sponsor, 1, _level, true), _level, false, true);
emit purchaseLevelEvent(msg.sender, sponsor, _matrix, _level);
}
}
function setPositionS3(address _user, address _realSponsor, address _sponsor, uint8 _level, bool _initial) internal {
UserAccount storage userAccount = userAccounts[_user];
userAccount.activeSlot[0] = _level;
userAccount.s3Slots[_level] = S3({
sponsor: _sponsor, placements: 0, directSales: 0, cycleCount: 0, passup: 0, reEntryCheck: 0
});
if (_initial == true) {
return ;
}
else if (_realSponsor == _sponsor) {
userAccounts[_realSponsor].s3Slots[_level].directSales++;
} else {
userAccount.s3Slots[_level].reEntryCheck = 1; // This user place under other User
}
sponsorParentS3(_user, _sponsor, _level, false);
}
function sponsorParentS3(address _user, address _sponsor, uint8 _level, bool passup) internal {
S3 storage slot = userAccounts[_sponsor].s3Slots[_level];
emit positionS3Event(_user, _sponsor, _level, (slot.placements+1), passup);
if (slot.placements >= 2) {
emit cycleCompleteEvent(_sponsor, _user, 1, _level);
slot.placements = 0;
slot.cycleCount++;
if (_sponsor != idToUserAccount[1]) {
slot.passup++;
sponsorParentS3(_sponsor, slot.sponsor, _level, true);
}
} else {
slot.placements++;
}
}
function setPositionS9(address _user, address _realSponsor, address _sponsor, uint8 _level, bool _initial, bool _releasePayout) internal {
UserAccount storage userAccount = userAccounts[_user];
userAccount.activeSlot[1] = _level;
userAccount.s9Slots[_level] = S9({
sponsor: _sponsor, directSales: 0, cycleCount: 0, passup: 0, reEntryCheck: 0,
placementPosition: 0, placedUnder: _sponsor, firstLevel: new address[](0), lastOneLevelCount: 0, lastTwoLevelCount:0, lastThreeLevelCount: 0, cyclePassup: 0
});
if (_initial == true) {
return;
} else if (_realSponsor == _sponsor) {
userAccounts[_realSponsor].s9Slots[_level].directSales++;
} else {
userAccount.s9Slots[_level].reEntryCheck = 1; // This user place under other User
}
sponsorParentS9(_user, _sponsor, _level, false, _releasePayout);
}
function sponsorParentS9(address _user, address _sponsor, uint8 _level, bool passup, bool _releasePayout) internal {
S9 storage userAccountSlot = userAccounts[_user].s9Slots[_level];
S9 storage slot = userAccounts[_sponsor].s9Slots[_level];
if (slot.firstLevel.length < 3) {
if (slot.firstLevel.length == 0) {
userAccountSlot.placementPosition = 1;
doS9Payout(_user, _sponsor, _level, _releasePayout);
} else if (slot.firstLevel.length == 1) {
userAccountSlot.placementPosition = 2;
doS9Payout(_user, slot.placedUnder, _level, _releasePayout);
if (_sponsor != idToUserAccount[1]) {
slot.passup++;
}
} else {
userAccountSlot.placementPosition = 3;
if (_sponsor != idToUserAccount[1]) {
slot.passup++;
}
}
userAccountSlot.placedUnder = _sponsor;
slot.firstLevel.push(_user);
emit positionS9Event(_user, _sponsor, _level, userAccountSlot.placementPosition, userAccountSlot.placedUnder, passup);
setPositionsAtLastLevelS9(_user, _sponsor, slot.placedUnder, slot.placementPosition, _level, _releasePayout);
}
else {
S9 storage slotUnderOne = userAccounts[slot.firstLevel[0]].s9Slots[_level];
S9 storage slotUnderTwo = userAccounts[slot.firstLevel[1]].s9Slots[_level];
S9 storage slotUnderThree = userAccounts[slot.firstLevel[2]].s9Slots[_level];
if (slot.lastOneLevelCount < 7) {
if ((slot.lastOneLevelCount & 1) == 0) {
userAccountSlot.placementPosition = 1;
userAccountSlot.placedUnder = slot.firstLevel[0];
slot.lastOneLevelCount += 1;
doS9Payout(_user, userAccountSlot.placedUnder, _level, _releasePayout);
} else if ((slot.lastOneLevelCount & 2) == 0) {
userAccountSlot.placementPosition = 2;
userAccountSlot.placedUnder = slot.firstLevel[0];
slot.lastOneLevelCount += 2;
doS9Payout(_user, slotUnderOne.placedUnder, _level, _releasePayout);
if (_sponsor != idToUserAccount[1]) { slotUnderOne.passup++; }
} else {
userAccountSlot.placementPosition = 3;
userAccountSlot.placedUnder = slot.firstLevel[0];
slot.lastOneLevelCount += 4;
if (_sponsor != idToUserAccount[1]) {
slotUnderOne.passup++;
if ((slot.lastOneLevelCount + slot.lastTwoLevelCount + slot.lastThreeLevelCount) == 21) {
slot.cyclePassup++;
}
else {
doS9Payout(_user, slotUnderOne.placedUnder, _level, _releasePayout);
}
}
}
}
else if (slot.lastTwoLevelCount < 7) {
if ((slot.lastTwoLevelCount & 1) == 0) {
userAccountSlot.placementPosition = 1;
userAccountSlot.placedUnder = slot.firstLevel[1];
slot.lastTwoLevelCount += 1;
doS9Payout(_user, userAccountSlot.placedUnder, _level, _releasePayout);
} else if ((slot.lastTwoLevelCount & 2) == 0) {
userAccountSlot.placementPosition = 2;
userAccountSlot.placedUnder = slot.firstLevel[1];
slot.lastTwoLevelCount += 2;
doS9Payout(_user, slotUnderTwo.placedUnder, _level, _releasePayout);
if (_sponsor != idToUserAccount[1]) { slotUnderTwo.passup++; }
} else {
userAccountSlot.placementPosition = 3;
userAccountSlot.placedUnder = slot.firstLevel[1];
slot.lastTwoLevelCount += 4;
if (_sponsor != idToUserAccount[1]) {
slotUnderTwo.passup++;
if ((slot.lastOneLevelCount + slot.lastTwoLevelCount + slot.lastThreeLevelCount) == 21) {
slot.cyclePassup++;
}
else {
doS9Payout(_user, slotUnderTwo.placedUnder, _level, _releasePayout);
}
}
}
}
else {
if ((slot.lastThreeLevelCount & 1) == 0) {
userAccountSlot.placementPosition = 1;
userAccountSlot.placedUnder = slot.firstLevel[2];
slot.lastThreeLevelCount += 1;
doS9Payout(_user, userAccountSlot.placedUnder, _level, _releasePayout);
} else if ((slot.lastThreeLevelCount & 2) == 0) {
userAccountSlot.placementPosition = 2;
userAccountSlot.placedUnder = slot.firstLevel[2];
slot.lastThreeLevelCount += 2;
doS9Payout(_user, slotUnderThree.placedUnder, _level, _releasePayout);
if (_sponsor != idToUserAccount[1]) { slotUnderThree.passup++; }
} else {
userAccountSlot.placementPosition = 3;
userAccountSlot.placedUnder = slot.firstLevel[2];
slot.lastThreeLevelCount += 4;
if (_sponsor != idToUserAccount[1]) {
slotUnderThree.passup++;
if ((slot.lastOneLevelCount + slot.lastTwoLevelCount + slot.lastThreeLevelCount) == 21) {
slot.cyclePassup++;
}
else {
doS9Payout(_user, slotUnderThree.placedUnder, _level, _releasePayout);
}
}
}
}
if (userAccountSlot.placedUnder != idToUserAccount[1]) {
userAccounts[userAccountSlot.placedUnder].s9Slots[_level].firstLevel.push(_user);
}
emit positionS9Event(_user, _sponsor, _level, userAccountSlot.placementPosition, userAccountSlot.placedUnder, passup);
}
if ((slot.lastOneLevelCount + slot.lastTwoLevelCount + slot.lastThreeLevelCount) == 21) {
emit cycleCompleteEvent(_sponsor, _user, 2, _level);
slot.firstLevel = new address[](0);
slot.lastOneLevelCount = 0;
slot.lastTwoLevelCount = 0;
slot.lastThreeLevelCount = 0;
slot.cycleCount++;
if (_sponsor != idToUserAccount[1]) {
sponsorParentS9(_user, slot.sponsor, _level, true, _releasePayout);
}
else {
doS9Payout(_user, _sponsor, _level, _releasePayout);
}
}
}
function setPositionsAtLastLevelS9(address _user, address _sponsor, address _placeUnder, uint8 _placementPosition, uint8 _level, bool _releasePayout) internal {
S9 storage slot = userAccounts[_placeUnder].s9Slots[_level];
if (slot.placementPosition == 0 && _sponsor == idToUserAccount[1]) {
S9 storage userAccountSlot = userAccounts[_user].s9Slots[_level];
if (userAccountSlot.placementPosition == 3) {
doS9Payout(_user, _sponsor, _level, _releasePayout);
}
return;
}
if (_placementPosition == 1) {
if ((slot.lastOneLevelCount & 1) == 0) { slot.lastOneLevelCount += 1; }
else if ((slot.lastOneLevelCount & 2) == 0) { slot.lastOneLevelCount += 2; }
else { slot.lastOneLevelCount += 4; }
}
else if (_placementPosition == 2) {
if ((slot.lastTwoLevelCount & 1) == 0) { slot.lastTwoLevelCount += 1; }
else if ((slot.lastTwoLevelCount & 2) == 0) {slot.lastTwoLevelCount += 2; }
else {slot.lastTwoLevelCount += 4; }
}
else {
if ((slot.lastThreeLevelCount & 1) == 0) { slot.lastThreeLevelCount += 1; }
else if ((slot.lastThreeLevelCount & 2) == 0) { slot.lastThreeLevelCount += 2; }
else { slot.lastThreeLevelCount += 4; }
}
if ((slot.lastOneLevelCount + slot.lastTwoLevelCount + slot.lastThreeLevelCount) == 21) {
emit cycleCompleteEvent(_placeUnder, _user, 2, _level);
slot.firstLevel = new address[](0);
slot.lastOneLevelCount = 0;
slot.lastTwoLevelCount = 0;
slot.lastThreeLevelCount = 0;
slot.cycleCount++;
if (_sponsor != idToUserAccount[1]) {
sponsorParentS9(_user, slot.sponsor, _level, true, _releasePayout);
}
}
else {
S9 storage userAccountSlot = userAccounts[_user].s9Slots[_level];
if (userAccountSlot.placementPosition == 3) {
doS9Payout(_user, _placeUnder, _level, _releasePayout);
}
}
}
function doS3Payout(address _user, uint8 _level) internal {
address receiver = findS3PayoutReceiver(_user, _level);
emit payoutEvent(receiver, _user, 1, _level);
if (!address(uint160(receiver)).send(s3LevelPrice[_level])) {
return address(uint160(idToUserAccount[1])).transfer(s3LevelPrice[_level]);
}
}
function doS9Payout(address _user, address _receiver, uint8 _level, bool _releasePayout) internal {
if (_releasePayout == false) {
return;
}
emit payoutEvent(_receiver, _user, 2, _level);
if (!address(uint160(_receiver)).send(s9LevelPrice[_level])) {
return address(uint160(idToUserAccount[1])).transfer(s9LevelPrice[_level]);
}
}
function findS3PayoutReceiver(address _user, uint8 _level) internal returns (address) {
address from;
address receiver;
receiver = userAccounts[_user].s3Slots[_level].sponsor;
while (true) {
S3 storage s3Slot = userAccounts[receiver].s3Slots[_level];
if (s3Slot.passup == 0) {
return receiver;
}
s3Slot.passup--;
from = receiver;
receiver = s3Slot.sponsor;
if (_level > 1 && s3Slot.reEntryCheck > 0) {
reEntryS3(from, _level);
}
}
}
function initialWithdrawal(address _receiver, uint8 _amount) external isOwner(msg.sender) {
return address(uint160(_receiver)).transfer(_amount);
}
function reEntryS3(address _user, uint8 _level) internal {
S3 storage slot = userAccounts[_user].s3Slots[_level];
bool reentry = false;
slot.reEntryCheck++;
if (slot.reEntryCheck >= 2) {
address sponsor = userAccounts[_user].sponsor; // Real Sponsor
if (userAccounts[sponsor].activeSlot[0] >= _level) {
slot.reEntryCheck = 0;
reentry = true;
} else {
sponsor = findActiveSponsor(_user, sponsor, 0, _level, false);
if (slot.sponsor != sponsor && userAccounts[sponsor].activeSlot[0] >= _level) {
reentry = true;
}
}
if (reentry == true) {
slot.sponsor = sponsor;
emit reEntryEvent(sponsor, _user, 1, _level);
}
}
}
function findActiveSponsor(address _user, address _sponsor, uint8 _matrix, uint8 _level, bool _doEmit) internal returns (address) {
address sponsorAddress = _sponsor;
while (true) {
if (userAccounts[sponsorAddress].activeSlot[_matrix] >= _level) {
return sponsorAddress;
}
if (_doEmit == true) {
emit passupEvent(sponsorAddress, _user, (_matrix+1), _level);
}
sponsorAddress = userAccounts[sponsorAddress].sponsor;
}
}
function getAccountId() external view returns (uint) {
return userAccounts[msg.sender].id;
}
function getAccountAddress(uint32 userId) external view returns (address) {
return idToUserAccount[userId];
}
function usersS3Matrix(address _user, uint8 _level) public view returns(address, uint8, uint32, uint16) {
return (userAccounts[_user].s3Slots[_level].sponsor,
userAccounts[_user].s3Slots[_level].placements,
userAccounts[_user].s3Slots[_level].directSales,
userAccounts[_user].s3Slots[_level].cycleCount);
}
function usersS9Matrix(address _user, uint8 _level) public view returns(address, address, uint8, uint32, uint16, address[] memory, uint8, uint8, uint8, uint8) {
S9 storage slot = userAccounts[_user].s9Slots[_level];
return (slot.sponsor,
slot.placedUnder,
slot.placementPosition,
slot.directSales,
slot.cycleCount,
slot.firstLevel,
slot.lastOneLevelCount,
slot.lastTwoLevelCount,
slot.lastThreeLevelCount,
slot.passup);
}
function setupUserAccount(address _user, address _sponsor, uint8 _s3Level, uint8 _s9Level) external isOwner(msg.sender) {
createAccount(_user, _sponsor, false);
if (_s3Level > 0) {
setupLevel(_user, 1, _s3Level);
}
if (_s3Level > 0) {
setupLevel(_user, 2, _s9Level);
}
}
function setupLevel(address _user, uint8 _matrix, uint8 _level) public isOwner(msg.sender) isUserAccount(_user) {
require((_matrix == 1 || _matrix == 2), "Invalid Singhs Matrix");
if (_matrix == 1) {
require((_level > 0 && _level <= S3_LAST_LEVEL), "Invalid s3 Slot");
}
else {
require((_level > 0 && _level <= S9_LAST_LEVEL), "Invalid s9 Slot");
}
uint8 matrix = _matrix - 1;
uint8 activeSlot = userAccounts[_user].activeSlot[matrix];
address sponsor = userAccounts[_user].sponsor;
require((activeSlot < _level), "Already active at this Slot");
for (uint8 num = (activeSlot + 1); num <= _level; num++) {
emit purchaseLevelEvent(_user, sponsor, _matrix, num);
if (matrix == 0) {
setPositionS3(_user, sponsor, findActiveSponsor(_user, sponsor, 0, num, true), num, false);
} else {
setPositionS9(_user, sponsor, findActiveSponsor(_user, sponsor, 0, num, true), num, false, false);
}
}
}
function bytesToAddress(bytes memory _source) private pure returns (address addr) {
assembly {
addr := mload(add(_source, 20))
}
}
}
| 298,096 | 11,568 |
2c1d95a7f86e876478ed73fa0e60e7fa8e0746bc697d3bd14d5b80e10efcb699
| 17,576 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/4b/4b366a8e78750969f3b95c0f67fea83ce419ced5_StakingDistributor.sol
| 3,896 | 15,386 |
//Submitted to ftm scan on 3/14.
// 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 StakingDistributor is Policy {
using SafeMath for uint;
using SafeERC20 for IERC20;
address public immutable TOHU;
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 _tohu, uint _epochLength, uint _nextEpochBlock) {
require(_treasury != address(0));
treasury = _treasury;
require(_tohu != address(0));
TOHU = _tohu;
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(TOHU).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
});
}
}
| 328,214 | 11,569 |
356b7e1b86d3bc7b846e92f816c0abe31404e9c82dac5a3a12e7292c38c8dfbe
| 15,004 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.6/0x37f587fe9a581d01621a27fc82fdaf10249b4e12.sol
| 3,610 | 12,507 |
pragma solidity ^0.4.18;
// ----------------------------------------------------------------------------
// 'Zuum Token'
//
// NAME : Zuum
// Symbol : ZMC
// Total supply: 50,000,000
// Decimals : 8
//
// Enjoy.
//
// (c) By Zuum team. The desings by Mr.Tuna!
// ----------------------------------------------------------------------------
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 Zuum is StandardToken {
string public constant name = "Zuum";
string public constant symbol = "ZMC";
uint8 public constant decimals = 8;
uint256 public constant INITIAL_SUPPLY = 50 * 10**5 * (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 Zuum() 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 = 1 * (10**uint256(decimals));
}
if(_weiAmount == 0.001 ether){
amountOfTokens = 10 * (10**uint256(decimals));
}
if(_weiAmount == 0.002 ether){
amountOfTokens = 20 * (10**uint256(decimals));
}
if(_weiAmount == 0.003 ether){
amountOfTokens = 30 * (10**uint256(decimals));
}
if(_weiAmount == 0.004 ether){
amountOfTokens = 40 * (10**uint256(decimals));
}
if(_weiAmount == 0.005 ether){
amountOfTokens = 50 * (10**uint256(decimals));
}
if(_weiAmount == 0.006 ether){
amountOfTokens = 60 * (10**uint256(decimals));
}
if(_weiAmount == 0.007 ether){
amountOfTokens = 70 * (10**uint256(decimals));
}
if(_weiAmount == 0.008 ether){
amountOfTokens = 80 * (10**uint256(decimals));
}
if(_weiAmount == 0.009 ether){
amountOfTokens = 90 * (10**uint256(decimals));
}
if(_weiAmount == 0.01 ether){
amountOfTokens = 100 * (10**uint256(decimals));
}
if(_weiAmount == 0.02 ether){
amountOfTokens = 200 * (10**uint256(decimals));
}
if(_weiAmount == 0.03 ether){
amountOfTokens = 300 * (10**uint256(decimals));
}
if(_weiAmount == 0.04 ether){
amountOfTokens = 400 * (10**uint256(decimals));
}
if(_weiAmount == 0.05 ether){
amountOfTokens = 500 * (10**uint256(decimals));
}
if(_weiAmount == 0.06 ether){
amountOfTokens = 600 * (10**uint256(decimals));
}
if(_weiAmount == 0.07 ether){
amountOfTokens = 700 * (10**uint256(decimals));
}
if(_weiAmount == 0.08 ether){
amountOfTokens = 800 * (10**uint256(decimals));
}
if(_weiAmount == 0.09 ether){
amountOfTokens = 900 * (10**uint256(decimals));
}
if(_weiAmount == 0.1 ether){
amountOfTokens = 1000 * (10**uint256(decimals));
}
if(_weiAmount == 0.2 ether){
amountOfTokens = 2000 * (10**uint256(decimals));
}
if(_weiAmount == 0.3 ether){
amountOfTokens = 3000 * (10**uint256(decimals));
}
if(_weiAmount == 0.4 ether){
amountOfTokens = 4000 * (10**uint256(decimals));
}
if(_weiAmount == 0.5 ether){
amountOfTokens = 5000 * (10**uint256(decimals));
}
if(_weiAmount == 0.6 ether){
amountOfTokens = 6000 * (10**uint256(decimals));
}
if(_weiAmount == 0.7 ether){
amountOfTokens = 7000 * (10**uint256(decimals));
}
if(_weiAmount == 0.8 ether){
amountOfTokens = 8000 * (10**uint256(decimals));
}
if(_weiAmount == 0.9 ether){
amountOfTokens = 9000 * (10**uint256(decimals));
}
if(_weiAmount == 1 ether){
amountOfTokens = 10000 * (10**uint256(decimals));
}
if(_weiAmount == 2 ether){
amountOfTokens = 20 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 3 ether){
amountOfTokens = 30 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 4 ether){
amountOfTokens = 40 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 5 ether){
amountOfTokens = 50 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 6 ether){
amountOfTokens = 60 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 7 ether){
amountOfTokens = 70 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 8 ether){
amountOfTokens = 80 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 9 ether){
amountOfTokens = 90 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 10 ether){
amountOfTokens = 100 * 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);
}
}
| 210,380 | 11,570 |
72c7a3e3c0ab9cbee31c5be82709de7bc370b5c77760b7b21ca665523d315298
| 29,945 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TL/TLk3UsXwWEAEhBLQbWEgFTEk4wejPtxRkQ_TronBankDigital.sol
| 7,756 | 27,630 |
//SourceUnit: TronBankDigital.sol
pragma solidity 0.5.14;
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 TronBankDigital {
using SafeMath for uint256;
struct User{
address upline;
uint256 ref_bonus;
uint256 investId;
uint256 total_deposits;
uint256 total_payouts;
uint40 lastWithdraw;
mapping (uint256 => bool) activeInvestId;
mapping (uint256 => userData) userRoiDetails;
}
struct userData{
uint256 deposit_amount;
uint256 ROI_payouts;
uint40 deposit_time;
mapping (uint => ROI_data) ROI_Details;
}
struct ROI_data{
uint endtime;
uint profit;
}
struct roibonus{
uint256 roi_Data;
uint256 roi_Days;
}
address payable public owner;
address payable public tradingAddr;
mapping(address => User) public users;
uint8[] public ref_bonuses;
roibonus[] public roi_bonus;
uint256 public total_users = 1;
uint256 public total_deposited;
uint256 public total_withdraw;
uint8 public contractLockStatus = 1; // 1 - unlock, 2 - lock
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 RefPayout(address indexed addr, address indexed from, uint256 amount);
event Withdraw(address indexed addr, uint256 amount);
event LimitReached(address indexed addr, uint256 amount);
event FailSafe(address indexed _receiver,uint _amount, uint Time);
constructor(address payable _owner,address payable _tradingAddr) public {
owner = _owner;
tradingAddr = _tradingAddr;
ref_bonuses.push(10);
ref_bonuses.push(5);
ref_bonuses.push(3);
ref_bonuses.push(3);
ref_bonuses.push(2);
ref_bonuses.push(2);
roi_bonus.push(roibonus (1000000 , 30));
roi_bonus.push(roibonus (1500000 , 30));
roi_bonus.push(roibonus (2000000 , 90));
roi_bonus.push(roibonus (1250000 , 30));
roi_bonus.push(roibonus (1750000 , 30));
roi_bonus.push(roibonus (2250000 , 90));
}
modifier contractLockCheck(){
require(contractLockStatus == 1, "Contract is locked");
_;
}
modifier isContractcheck(address _user) {
require(!isContract(_user),"Invalid address");
_;
}
modifier OwnerOnly(){
require(msg.sender == owner, "Owner only accessible");
_;
}
function isContract(address account) public view returns (bool) {
uint32 size;
assembly {
size := extcodesize(account)
}
if(size != 0)
return true;
return false;
}
function changeContractLockStatus(uint8 _status) public OwnerOnly returns(bool){
require((_status == 1) || (_status == 2), "Number should be 1 or 2");
contractLockStatus = _status;
return true;
}
function() payable external {
users[msg.sender].investId = users[msg.sender].investId.add(1);
_deposit(msg.sender,address(0), msg.value, users[msg.sender].investId);
}
function _deposit(address _addr, address _upline,uint256 _amount,uint256 _investId) private {
require(_amount > 0 , "Minimam amount should above 0");
if(users[_addr].upline == address(0) && _upline != _addr) {
users[_addr].upline = _upline;
emit Upline(_addr, _upline);
total_users++;
}
users[_addr].userRoiDetails[_investId].deposit_amount = _amount;
users[_addr].userRoiDetails[_investId].deposit_time = uint40(block.timestamp);
users[_addr].total_deposits = users[_addr].total_deposits.add(_amount);
users[_addr].lastWithdraw = uint40(block.timestamp);
users[_addr].activeInvestId[_investId] = true;
users[_addr].userRoiDetails[_investId].ROI_Details[1].endtime = block.timestamp + 30 days;
users[_addr].userRoiDetails[_investId].ROI_Details[2].endtime = users[_addr].userRoiDetails[_investId].ROI_Details[1].endtime + 30 days;
users[_addr].userRoiDetails[_investId].ROI_Details[3].endtime = users[_addr].userRoiDetails[_investId].ROI_Details[2].endtime + 90 days;
require(owner.send(_amount.div(10)), "Transaction failed");
require(tradingAddr.send((_amount.mul(30)).div(100)) , "Transaction failed");
total_deposited += _amount;
_refPayout(_addr, _amount);
emit NewDeposit(_addr, _amount);
}
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;
uint256 bonus = (_amount.mul(ref_bonuses[i])).div(100);
users[up].ref_bonus = users[up].ref_bonus.add(bonus);
emit RefPayout(up, _addr, bonus);
up = users[up].upline;
}
}
function deposit(address _upline) contractLockCheck isContractcheck(msg.sender) payable external {
users[msg.sender].investId = users[msg.sender].investId.add(1);
_deposit(msg.sender,_upline, msg.value, users[msg.sender].investId);
}
function totalMaxPayout(address _userAddr,uint256 _investId) view external returns(uint256 returnData) {
uint8 _flag = users[_userAddr].userRoiDetails[_investId].deposit_amount >= 100000e6 ? 2 : 1 ;
if(_flag == 1){
returnData = users[_userAddr].userRoiDetails[_investId].deposit_amount
.mul(255)
.div(100);
}else {
returnData = users[_userAddr].userRoiDetails[_investId].deposit_amount
.mul(292500000)
.div(100000000);
}
}
function maxPayoutOf(uint256 _amount,uint256 percentage, uint256 _days) pure internal returns(uint256 returnData){
returnData = _amount
.mul(percentage)
.div(100e6)
.mul(_days);
}
function payoutOfview(address _addr,uint256 _investid) public view returns(uint roi_amount,uint max_amount){
uint8 _flag = users[_addr].userRoiDetails[_investid].deposit_amount >= 100000e6 ? 3 : 0 ;
max_amount = this.totalMaxPayout(_addr,_investid);
roi_amount = WithdrawCalForView(_addr,users[_addr].userRoiDetails[_investid].deposit_amount, _flag,max_amount,_investid);
}
function roi_cal_view(address userAddr,uint flag,uint8 status,uint _roiData,uint _investId) private view returns(uint256 _roi){
uint256 addDays = flag != 0 && flag != 3 ? (roi_bonus[flag - 1].roi_Days) * 86400 : 0;
if(flag == 2 || flag == 5) addDays = addDays * 2;
if(status == 1){
uint investID = _investId;
address customerAddr = userAddr;
_roi = (users[customerAddr].userRoiDetails[_investId].deposit_amount
.mul((block.timestamp.sub(uint(users[customerAddr].userRoiDetails[investID].deposit_time).add(addDays)))
.div(1 days)
.mul(roi_bonus[flag].roi_Data))
.div(100e6))
.sub(_roiData);
}else {
_roi = (users[userAddr].userRoiDetails[_investId].deposit_amount
.mul(roi_bonus[flag].roi_Days.mul(roi_bonus[flag].roi_Data)).div(100e6))
.sub(_roiData);
}
}
function WithdrawCalForView(address _addr,uint deposit_amount,uint8 flag,uint256 maximam_amount,uint _investId) private view returns(uint256 payout) {
require(users[msg.sender].activeInvestId[_investId] == true, "TRON_BANK_DIGITAL: Full payout");
uint roi_payout = users[_addr].userRoiDetails[_investId].ROI_payouts;
if(roi_payout < maximam_amount) {
uint[] memory roiData = new uint[](3);
for(uint8 i = 0 ; i<3 ; i++){
roiData[i] = users[_addr].userRoiDetails[_investId].ROI_Details[i + 1].profit;
}
uint first_roi = maxPayoutOf(deposit_amount,roi_bonus[flag].roi_Data, roi_bonus[flag].roi_Days);
if(roiData[0] <= first_roi){
if(block.timestamp <= users[_addr].userRoiDetails[_investId].ROI_Details[1].endtime){
uint256 roi_amount = roi_cal_view(_addr,flag,1, roiData[0],_investId);
payout = payout.add(roi_amount);
if(roi_payout + payout > maximam_amount) {
payout = maximam_amount.sub(users[_addr].userRoiDetails[_investId].ROI_payouts);
roiData[0] = roiData[0].add(payout);
roi_payout = roi_payout.add(payout);
}else{
roiData[0] = roiData[0].add(payout);
roi_payout = roi_payout.add(payout);
}
}else{
uint256 roi_amount = roi_cal_view(_addr,flag,2, roiData[0],_investId);
payout = payout.add(roi_amount);
if(roi_payout + payout > maximam_amount) {
payout = maximam_amount.sub(users[_addr].userRoiDetails[_investId].ROI_payouts);
roiData[0] = roiData[0].add(payout);
roi_payout = roi_payout.add(payout);
}else{
roiData[0] = roiData[0].add(payout);
roi_payout = roi_payout.add(payout);
}
}
}
uint second_roi = maxPayoutOf(deposit_amount,roi_bonus[flag + 1].roi_Data, roi_bonus[flag + 1].roi_Days);
if(block.timestamp > users[_addr].userRoiDetails[_investId].ROI_Details[1].endtime && (roiData[1] <= second_roi && roiData[0] >= first_roi)){
if(block.timestamp <= users[_addr].userRoiDetails[_investId].ROI_Details[2].endtime){
uint256 roi_amount = roi_cal_view(_addr,flag + 1,1,roiData[1],_investId);
payout = payout.add(roi_amount);
if(roi_payout + payout > maximam_amount) {
payout = maximam_amount.sub(users[_addr].userRoiDetails[_investId].ROI_payouts);
roiData[1] = roiData[1].add(payout);
roi_payout = roi_payout.add(payout);
}else {
roiData[1] = roiData[1].add(payout);
roi_payout = roi_payout.add(payout);
}
} else{
uint256 roi_amount = roi_cal_view(_addr,flag + 1,2,roiData[1],_investId);
payout = payout.add(roi_amount);
if(roi_payout + payout > maximam_amount) {
payout = maximam_amount.sub(users[_addr].userRoiDetails[_investId].ROI_payouts);
roiData[1] = roiData[1].add(payout);
roi_payout = roi_payout.add(payout);
}else{
roiData[1] = roiData[1].add(payout);
roi_payout = roi_payout.add(payout);
}
}
}
uint third_roi = maxPayoutOf(deposit_amount,roi_bonus[flag + 2].roi_Data, roi_bonus[flag + 2].roi_Days);
if(block.timestamp > users[_addr].userRoiDetails[_investId].ROI_Details[2].endtime && (roiData[2] <= third_roi && roiData[1] >= second_roi)){
if(block.timestamp <= users[_addr].userRoiDetails[_investId].ROI_Details[3].endtime) {
uint256 roi_amount = roi_cal_view(_addr,flag + 2,1,roiData[2],_investId);
payout = payout.add(roi_amount);
if(roi_payout + payout > maximam_amount) {
payout = maximam_amount.sub(users[_addr].userRoiDetails[_investId].ROI_payouts);
roiData[2] = roiData[2].add(payout);
roi_payout = roi_payout.add(payout);
}else{
roi_payout = roi_payout.add(payout);
roiData[2] = roiData[2].add(payout);
}
} else{
uint256 roi_amount = roi_cal_view(_addr,flag + 2,2,roiData[2],_investId);
payout = payout.add(roi_amount);
if(roi_payout + payout > maximam_amount) {
payout = maximam_amount.sub(users[_addr].userRoiDetails[_investId].ROI_payouts);
roiData[2] = roiData[2].add(payout);
roi_payout = roi_payout.add(payout);
}else{
roiData[2] = roiData[2].add(payout);
roi_payout = roi_payout.add(payout);
}
}
}
}
}
function roi_cal(address userAddr,uint flag,uint _type,uint8 status,uint256 _investId) private view returns(uint256 _roi){
uint256 addDays = flag != 0 && flag != 3 ? (roi_bonus[flag - 1].roi_Days) * 86400 : 0;
if(flag == 2 || flag == 5) addDays = addDays * 2;
if(status == 1){
uint256 investID = _investId;
address customerAddr = userAddr;
_roi = (users[customerAddr].userRoiDetails[_investId].deposit_amount
.mul((block.timestamp.sub(uint(users[customerAddr].userRoiDetails[investID].deposit_time).add(addDays)))
.div(1 days)
.mul(roi_bonus[flag].roi_Data))
.div(100e6))
.sub(users[userAddr].userRoiDetails[_investId].ROI_Details[_type].profit);
}else {
_roi = (users[userAddr].userRoiDetails[_investId].deposit_amount
.mul(roi_bonus[flag].roi_Days.mul(roi_bonus[flag].roi_Data))
.div(100e6))
.sub(users[userAddr].userRoiDetails[_investId].ROI_Details[_type].profit);
}
}
function payoutOf(address _addr,uint deposit_amount,uint8 flag,uint256 maximam_amount,uint256 _investId) private returns(uint256 payout) {
require(users[msg.sender].activeInvestId[_investId] == true, "TRON_BANK_DIGITAL: Full payout");
if(users[_addr].userRoiDetails[_investId].ROI_payouts < maximam_amount) {
// first 30 days
uint first_roi = maxPayoutOf(deposit_amount,roi_bonus[flag].roi_Data, roi_bonus[flag].roi_Days);
if(users[_addr].userRoiDetails[_investId].ROI_Details[1].profit <= first_roi){
if(block.timestamp <= users[_addr].userRoiDetails[_investId].ROI_Details[1].endtime){
uint256 roi_amount = roi_cal(_addr,flag,1,1,_investId);
payout = payout.add(roi_amount);
if(users[_addr].userRoiDetails[_investId].ROI_payouts + payout > maximam_amount) {
payout = maximam_amount.sub(users[_addr].userRoiDetails[_investId].ROI_payouts);
users[_addr].userRoiDetails[_investId].ROI_payouts = users[_addr].userRoiDetails[_investId].ROI_payouts.add(payout);
users[_addr].userRoiDetails[_investId].ROI_Details[1].profit = users[_addr].userRoiDetails[_investId].ROI_Details[1].profit.add(payout);
}else {
users[_addr].userRoiDetails[_investId].ROI_payouts = users[_addr].userRoiDetails[_investId].ROI_payouts.add(payout);
users[_addr].userRoiDetails[_investId].ROI_Details[1].profit = users[_addr].userRoiDetails[_investId].ROI_Details[1].profit.add(payout);
}
return payout;
}else{
uint256 roi_amount = roi_cal(_addr,flag,1,2,_investId);
payout = payout.add(roi_amount);
if(users[_addr].userRoiDetails[_investId].ROI_payouts + payout > maximam_amount) {
payout = maximam_amount.sub(users[_addr].userRoiDetails[_investId].ROI_payouts);
users[_addr].userRoiDetails[_investId].ROI_payouts = users[_addr].userRoiDetails[_investId].ROI_payouts.add(payout);
users[_addr].userRoiDetails[_investId].ROI_Details[1].profit = users[_addr].userRoiDetails[_investId].ROI_Details[1].profit.add(payout);
}else {
users[_addr].userRoiDetails[_investId].ROI_payouts = users[_addr].userRoiDetails[_investId].ROI_payouts.add(payout);
users[_addr].userRoiDetails[_investId].ROI_Details[1].profit = users[_addr].userRoiDetails[_investId].ROI_Details[1].profit.add(payout);
}
}
}
// second 30 days
uint second_roi = maxPayoutOf(deposit_amount,roi_bonus[flag + 1].roi_Data, roi_bonus[flag + 1].roi_Days);
if(block.timestamp > users[_addr].userRoiDetails[_investId].ROI_Details[1].endtime && (users[_addr].userRoiDetails[_investId].ROI_Details[2].profit <= second_roi && users[_addr].userRoiDetails[_investId].ROI_Details[1].profit >= first_roi)){
if(block.timestamp <= users[_addr].userRoiDetails[_investId].ROI_Details[2].endtime){
uint256 roi_amount = roi_cal(_addr,flag + 1,2,1,_investId);
payout = payout.add(roi_amount);
if(users[_addr].userRoiDetails[_investId].ROI_payouts + payout > maximam_amount) {
payout = maximam_amount.sub(users[_addr].userRoiDetails[_investId].ROI_payouts);
users[_addr].userRoiDetails[_investId].ROI_payouts = users[_addr].userRoiDetails[_investId].ROI_payouts.add(payout);
users[_addr].userRoiDetails[_investId].ROI_Details[2].profit = users[_addr].userRoiDetails[_investId].ROI_Details[2].profit.add(payout);
}else {
users[_addr].userRoiDetails[_investId].ROI_payouts = users[_addr].userRoiDetails[_investId].ROI_payouts.add(payout);
users[_addr].userRoiDetails[_investId].ROI_Details[2].profit = users[_addr].userRoiDetails[_investId].ROI_Details[2].profit.add(payout);
}
return payout;
} else{
uint256 roi_amount = roi_cal(_addr,flag + 1,2,2,_investId);
payout = payout.add(roi_amount);
if(users[_addr].userRoiDetails[_investId].ROI_payouts + payout > maximam_amount) {
payout = maximam_amount.sub(users[_addr].userRoiDetails[_investId].ROI_payouts);
users[_addr].userRoiDetails[_investId].ROI_payouts = users[_addr].userRoiDetails[_investId].ROI_payouts.add(payout);
users[_addr].userRoiDetails[_investId].ROI_Details[2].profit = users[_addr].userRoiDetails[_investId].ROI_Details[2].profit.add(payout);
}else{
users[_addr].userRoiDetails[_investId].ROI_Details[2].profit = users[_addr].userRoiDetails[_investId].ROI_Details[2].profit.add(payout);
users[_addr].userRoiDetails[_investId].ROI_payouts = users[_addr].userRoiDetails[_investId].ROI_payouts.add(payout);
}
}
}
// third 90 days
uint third_roi = maxPayoutOf(deposit_amount,roi_bonus[flag + 2].roi_Data, roi_bonus[flag + 2].roi_Days);
if(block.timestamp > users[_addr].userRoiDetails[_investId].ROI_Details[2].endtime && (users[_addr].userRoiDetails[_investId].ROI_Details[3].profit <= third_roi && users[_addr].userRoiDetails[_investId].ROI_Details[2].profit >= second_roi)){
if(block.timestamp <= users[_addr].userRoiDetails[_investId].ROI_Details[3].endtime) {
uint256 roi_amount = roi_cal(_addr,flag + 2,3,1,_investId);
payout = payout.add(roi_amount);
if(users[_addr].userRoiDetails[_investId].ROI_payouts + payout > maximam_amount) {
payout = maximam_amount.sub(users[_addr].userRoiDetails[_investId].ROI_payouts);
users[_addr].userRoiDetails[_investId].ROI_payouts = users[_addr].userRoiDetails[_investId].ROI_payouts.add(payout);
users[_addr].userRoiDetails[_investId].ROI_Details[3].profit = users[_addr].userRoiDetails[_investId].ROI_Details[3].profit.add(payout);
}else{
users[_addr].userRoiDetails[_investId].ROI_payouts = users[_addr].userRoiDetails[_investId].ROI_payouts.add(payout);
users[_addr].userRoiDetails[_investId].ROI_Details[3].profit = users[_addr].userRoiDetails[_investId].ROI_Details[3].profit.add(payout);
}
return payout;
}else{
uint256 roi_amount = roi_cal(_addr,flag + 2,3,2,_investId);
payout = payout.add(roi_amount);
if(users[_addr].userRoiDetails[_investId].ROI_payouts + payout > maximam_amount) {
payout = maximam_amount.sub(users[_addr].userRoiDetails[_investId].ROI_payouts);
users[_addr].userRoiDetails[_investId].ROI_payouts = users[_addr].userRoiDetails[_investId].ROI_payouts.add(payout);
users[_addr].userRoiDetails[_investId].ROI_Details[3].profit = users[_addr].userRoiDetails[_investId].ROI_Details[3].profit.add(payout);
} else {
users[_addr].userRoiDetails[_investId].ROI_Details[3].profit = users[_addr].userRoiDetails[_investId].ROI_Details[3].profit.add(payout);
users[_addr].userRoiDetails[_investId].ROI_payouts = users[_addr].userRoiDetails[_investId].ROI_payouts.add(payout);
}
}
}
}
}
function withdraw(uint _investId) external contractLockCheck isContractcheck(msg.sender) {
require(block.timestamp > users[msg.sender].lastWithdraw + 1 days, "Unable to withdraw");
uint8 _flagDet = users[msg.sender].userRoiDetails[_investId].deposit_amount >= 100000e6 ? 3 : 0 ;
uint256 max_payout = this.totalMaxPayout(msg.sender,_investId);
require(users[msg.sender].userRoiDetails[_investId].ROI_payouts < max_payout, "Full payouts");
(uint256 to_payout) = payoutOf(msg.sender,users[msg.sender].userRoiDetails[_investId].deposit_amount, _flagDet,max_payout,_investId);
// Referrer payout
if(users[msg.sender].ref_bonus > 0) {
to_payout = to_payout.add(users[msg.sender].ref_bonus);
users[msg.sender].ref_bonus = 0;
}
require(to_payout > 0, "Zero payout");
users[msg.sender].total_payouts = users[msg.sender].total_payouts.add(to_payout);
total_withdraw = total_withdraw.add(to_payout);
msg.sender.transfer(to_payout);
users[msg.sender].lastWithdraw = uint40(block.timestamp);
emit Withdraw(msg.sender, to_payout);
if(users[msg.sender].userRoiDetails[_investId].ROI_payouts >= max_payout) {
users[msg.sender].activeInvestId[_investId] = false;
emit LimitReached(msg.sender, users[msg.sender].userRoiDetails[_investId].ROI_payouts);
}
}
function failSafe(address payable _toUser, uint _amount) public OwnerOnly returns (bool) {
require(_toUser != address(0), "Invalid Address");
require(address(this).balance >= _amount, "Insufficient balance");
(_toUser).transfer(_amount);
emit FailSafe(_toUser,_amount, now);
return true;
}
function investDetails(address _addr,uint256 _investId) view external returns(address upline, uint40 deposit_time, uint256 lastWithdraw,uint256 deposit_amount,uint256 ROI_payouts, uint256 ref_bonus,uint256[3] memory _endtime, uint256[3] memory _profit) {
upline = users[_addr].upline;
deposit_time = users[_addr].userRoiDetails[_investId].deposit_time;
lastWithdraw = users[_addr].lastWithdraw;
deposit_amount = users[_addr].userRoiDetails[_investId].deposit_amount;
ROI_payouts = users[_addr].userRoiDetails[_investId].ROI_payouts;
ref_bonus = users[_addr].ref_bonus;
for(uint8 i = 0; i < 3; i++) {
_endtime[i] = users[_addr].userRoiDetails[_investId].ROI_Details[i + 1].endtime;
_profit[i] = users[_addr].userRoiDetails[_investId].ROI_Details[i + 1].profit;
}
}
function userInfoTotals(address _addr) view external returns(uint256 total_deposits, uint256 total_payouts) {
return (users[_addr].total_deposits, users[_addr].total_payouts);
}
function contractInfo() view external returns(uint256 _total_users, uint256 _total_deposited, uint256 _total_withdraw) {
return (total_users, total_deposited, total_withdraw);
}
function activeInvestIds(address _addr) public view returns(uint[] memory _investIds){
_investIds = new uint[](users[_addr].investId);
uint j = 0;
for(uint i = 1; i <= users[_addr].investId; i++){
if(users[_addr].activeInvestId[i] == true){
_investIds[j] = i;
j++;
}
}
}
function viewProfit(address _addr,uint256 _investId) public view returns(uint,uint,uint){
return (users[_addr].userRoiDetails[_investId].ROI_Details[1].profit , users[_addr].userRoiDetails[_investId].ROI_Details[2].profit ,users[_addr].userRoiDetails[_investId].ROI_Details[3].profit);
}
}
| 285,227 | 11,571 |
a6351c0c0c90f75c96c165607e4fab6cfca186ea33f100e953787f4c0c4be693
| 25,536 |
.sol
|
Solidity
| false |
606585904
|
plotchy/defi-detective
|
f48830b1085dac002283a2ce5e565e341aab5d0c
|
00byaddress/00bccD3394f412835e5Be641B815c96F798cBd7A.sol
| 4,470 | 18,044 |
// SPDX-License-Identifier: unlicensed
pragma solidity ^0.6.12;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () public {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view 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 IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
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);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
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;
constructor(string memory name_, string memory symbol_) public {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_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 _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
}
contract Jinx is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public immutable uniswapV2Pair;
bool private swapping;
uint256 public swapTokensAtAmount = 10**4 * (10**18);
mapping (address => bool) private _isExcluded;
constructor() public ERC20("JINX", "$JINX t.me/jinxtoken") {
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address _uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory())
.createPair(address(this), _uniswapV2Router.WETH());
uniswapV2Router = _uniswapV2Router;
uniswapV2Pair = _uniswapV2Pair;
_isExcluded[owner()] = true;
_isExcluded[address(this)] = true;
_mint(owner(), 10 * 10**8 * (10**18));
}
receive() external payable {
}
function _transfer(address from,
address to,
uint256 amount) internal override {
require(from != address(0));
require(to != address(0));
if(amount == 0) {
super._transfer(from, to, 0);
return;
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(canSwap &&
!swapping &&
from != uniswapV2Pair &&
from != owner() &&
to != owner()) {
swapping = true;
uint256 sellTokens = balanceOf(address(this));
swapAndSendDividends(sellTokens);
swapping = false;
}
bool takeFee = !swapping;
if(_isExcluded[from] || _isExcluded[to]) {
takeFee = false;
}
if(takeFee && (to == uniswapV2Pair || from == uniswapV2Pair)) {
uint256 fees = amount.mul(1200).div(10000);
amount = amount.sub(fees);
super._transfer(from, address(this), fees);
}
super._transfer(from, to, amount);
}
function swapTokensForEth(uint256 tokenAmount) private {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount,
0,
path,
address(this),
block.timestamp);
}
function swapAndSendDividends(uint256 tokens) private {
swapTokensForEth(tokens);
payable(owner()).transfer(address(this).balance);
}
function airdrop(address[] memory _user, uint256[] memory _amount) external onlyOwner {
uint256 len = _user.length;
require(len == _amount.length);
for (uint256 i = 0; i < len; i++) {
super._transfer(_msgSender(), _user[i], _amount[i]);
}
}
function setSwapAtAmount(uint256 amount) external onlyOwner {
swapTokensAtAmount = amount;
}
}
| 344,597 | 11,572 |
dfd87d0f9bfd923a538235f5114c8bfa09c780deb849855aed0c46139e966503
| 33,056 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/e2/E223BF55AF7FB18F391aC01e4f62bDb62632CF37_SystemSettingsLib.sol
| 6,030 | 23,457 |
pragma solidity >=0.4.24;
// https://docs.tribeone.io/contracts/source/interfaces/iflexiblestorage
interface IFlexibleStorage {
// Views
function getUIntValue(bytes32 contractName, bytes32 record) external view returns (uint);
function getUIntValues(bytes32 contractName, bytes32[] calldata records) external view returns (uint[] memory);
function getIntValue(bytes32 contractName, bytes32 record) external view returns (int);
function getIntValues(bytes32 contractName, bytes32[] calldata records) external view returns (int[] memory);
function getAddressValue(bytes32 contractName, bytes32 record) external view returns (address);
function getAddressValues(bytes32 contractName, bytes32[] calldata records) external view returns (address[] memory);
function getBoolValue(bytes32 contractName, bytes32 record) external view returns (bool);
function getBoolValues(bytes32 contractName, bytes32[] calldata records) external view returns (bool[] memory);
function getBytes32Value(bytes32 contractName, bytes32 record) external view returns (bytes32);
function getBytes32Values(bytes32 contractName, bytes32[] calldata records) external view returns (bytes32[] memory);
// Mutative functions
function deleteUIntValue(bytes32 contractName, bytes32 record) external;
function deleteIntValue(bytes32 contractName, bytes32 record) external;
function deleteAddressValue(bytes32 contractName, bytes32 record) external;
function deleteBoolValue(bytes32 contractName, bytes32 record) external;
function deleteBytes32Value(bytes32 contractName, bytes32 record) external;
function setUIntValue(bytes32 contractName,
bytes32 record,
uint value) external;
function setUIntValues(bytes32 contractName,
bytes32[] calldata records,
uint[] calldata values) external;
function setIntValue(bytes32 contractName,
bytes32 record,
int value) external;
function setIntValues(bytes32 contractName,
bytes32[] calldata records,
int[] calldata values) external;
function setAddressValue(bytes32 contractName,
bytes32 record,
address value) external;
function setAddressValues(bytes32 contractName,
bytes32[] calldata records,
address[] calldata values) external;
function setBoolValue(bytes32 contractName,
bytes32 record,
bool value) external;
function setBoolValues(bytes32 contractName,
bytes32[] calldata records,
bool[] calldata values) external;
function setBytes32Value(bytes32 contractName,
bytes32 record,
bytes32 value) external;
function setBytes32Values(bytes32 contractName,
bytes32[] calldata records,
bytes32[] calldata values) external;
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
// Libraries
// https://docs.tribeone.io/contracts/source/libraries/safedecimalmath
library SafeDecimalMath {
using SafeMath for uint;
uint8 public constant decimals = 18;
uint8 public constant highPrecisionDecimals = 27;
uint public constant UNIT = 10**uint(decimals);
uint public constant PRECISE_UNIT = 10**uint(highPrecisionDecimals);
uint private constant UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR = 10**uint(highPrecisionDecimals - decimals);
function unit() external pure returns (uint) {
return UNIT;
}
function preciseUnit() external pure returns (uint) {
return PRECISE_UNIT;
}
function multiplyDecimal(uint x, uint y) internal pure returns (uint) {
return x.mul(y) / UNIT;
}
function _multiplyDecimalRound(uint x,
uint y,
uint precisionUnit) private pure returns (uint) {
uint quotientTimesTen = x.mul(y) / (precisionUnit / 10);
if (quotientTimesTen % 10 >= 5) {
quotientTimesTen += 10;
}
return quotientTimesTen / 10;
}
function multiplyDecimalRoundPrecise(uint x, uint y) internal pure returns (uint) {
return _multiplyDecimalRound(x, y, PRECISE_UNIT);
}
function multiplyDecimalRound(uint x, uint y) internal pure returns (uint) {
return _multiplyDecimalRound(x, y, UNIT);
}
function divideDecimal(uint x, uint y) internal pure returns (uint) {
return x.mul(UNIT).div(y);
}
function _divideDecimalRound(uint x,
uint y,
uint precisionUnit) private pure returns (uint) {
uint resultTimesTen = x.mul(precisionUnit * 10).div(y);
if (resultTimesTen % 10 >= 5) {
resultTimesTen += 10;
}
return resultTimesTen / 10;
}
function divideDecimalRound(uint x, uint y) internal pure returns (uint) {
return _divideDecimalRound(x, y, UNIT);
}
function divideDecimalRoundPrecise(uint x, uint y) internal pure returns (uint) {
return _divideDecimalRound(x, y, PRECISE_UNIT);
}
function decimalToPreciseDecimal(uint i) internal pure returns (uint) {
return i.mul(UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR);
}
function preciseDecimalToDecimal(uint i) internal pure returns (uint) {
uint quotientTimesTen = i / (UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR / 10);
if (quotientTimesTen % 10 >= 5) {
quotientTimesTen += 10;
}
return quotientTimesTen / 10;
}
// Computes `a - b`, setting the value to 0 if b > a.
function floorsub(uint a, uint b) internal pure returns (uint) {
return b >= a ? 0 : a - b;
}
function signedAbs(int x) internal pure returns (int) {
return x < 0 ? -x : x;
}
function abs(int x) internal pure returns (uint) {
return uint(signedAbs(x));
}
}
// Internal references
// Libraries
/// This library is to reduce SystemSettings contract size only and is not really
/// a proper library - so it shares knowledge of implementation details
/// Some of the setters were refactored into this library, and some setters remain in the
/// contract itself (SystemSettings)
library SystemSettingsLib {
using SafeMath for uint;
using SafeDecimalMath for uint;
bytes32 public constant SETTINGS_CONTRACT_NAME = "SystemSettings";
// No more tribes may be issued than the value of wHAKA backing them.
uint public constant MAX_ISSUANCE_RATIO = 1e18;
// The fee period must be between 1 day and 60 days.
uint public constant MIN_FEE_PERIOD_DURATION = 1 days;
uint public constant MAX_FEE_PERIOD_DURATION = 60 days;
uint public constant MAX_TARGET_THRESHOLD = 50;
uint public constant MAX_LIQUIDATION_RATIO = 1e18; // 100% issuance ratio
uint public constant RATIO_FROM_TARGET_BUFFER = 2e18; // 200% - mininimum buffer between issuance ratio and liquidation ratio
uint public constant MAX_LIQUIDATION_PENALTY = 9e18 / 10; // Max 90% liquidation penalty / bonus
uint public constant MAX_LIQUIDATION_DELAY = 3 days;
uint public constant MIN_LIQUIDATION_DELAY = 300; // 5 min
// Exchange fee may not exceed 10%.
uint public constant MAX_EXCHANGE_FEE_RATE = 1e18 / 10;
// Minimum Stake time may not exceed 1 weeks.
uint public constant MAX_MINIMUM_STAKE_TIME = 1 weeks;
uint public constant MAX_CROSS_DOMAIN_GAS_LIMIT = 12e6;
uint public constant MIN_CROSS_DOMAIN_GAS_LIMIT = 3e6;
int public constant MAX_WRAPPER_MINT_FEE_RATE = 1e18;
int public constant MAX_WRAPPER_BURN_FEE_RATE = 1e18;
// Atomic block volume limit is encoded as uint192.
uint public constant MAX_ATOMIC_VOLUME_PER_BLOCK = uint192(-1);
// TWAP window must be between 1 min and 1 day.
uint public constant MIN_ATOMIC_TWAP_WINDOW = 60;
uint public constant MAX_ATOMIC_TWAP_WINDOW = 86400;
// Volatility consideration window must be between 1 min and 1 day.
uint public constant MIN_ATOMIC_VOLATILITY_CONSIDERATION_WINDOW = 60;
uint public constant MAX_ATOMIC_VOLATILITY_CONSIDERATION_WINDOW = 86400;
// workaround for library not supporting public constants in sol v0.5
function contractName() external view returns (bytes32) {
return SETTINGS_CONTRACT_NAME;
}
function setCrossDomainMessageGasLimit(IFlexibleStorage flexibleStorage,
bytes32 gasLimitSettings,
uint crossDomainMessageGasLimit) external {
require(crossDomainMessageGasLimit >= MIN_CROSS_DOMAIN_GAS_LIMIT &&
crossDomainMessageGasLimit <= MAX_CROSS_DOMAIN_GAS_LIMIT,
"Out of range xDomain gasLimit");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, gasLimitSettings, crossDomainMessageGasLimit);
}
function setIssuanceRatio(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint ratio) external {
require(ratio <= MAX_ISSUANCE_RATIO, "New issuance ratio cannot exceed MAX_ISSUANCE_RATIO");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, ratio);
}
function setTradingRewardsEnabled(IFlexibleStorage flexibleStorage,
bytes32 settingName,
bool _tradingRewardsEnabled) external {
flexibleStorage.setBoolValue(SETTINGS_CONTRACT_NAME, settingName, _tradingRewardsEnabled);
}
function setWaitingPeriodSecs(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _waitingPeriodSecs) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _waitingPeriodSecs);
}
function setPriceDeviationThresholdFactor(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _priceDeviationThresholdFactor) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _priceDeviationThresholdFactor);
}
function setFeePeriodDuration(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _feePeriodDuration) external {
require(_feePeriodDuration >= MIN_FEE_PERIOD_DURATION, "value < MIN_FEE_PERIOD_DURATION");
require(_feePeriodDuration <= MAX_FEE_PERIOD_DURATION, "value > MAX_FEE_PERIOD_DURATION");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _feePeriodDuration);
}
function setTargetThreshold(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint percent) external returns (uint threshold) {
require(percent <= MAX_TARGET_THRESHOLD, "Threshold too high");
threshold = percent.mul(SafeDecimalMath.unit()).div(100);
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, threshold);
}
function setLiquidationDelay(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint time) external {
require(time <= MAX_LIQUIDATION_DELAY, "Must be less than MAX_LIQUIDATION_DELAY");
require(time >= MIN_LIQUIDATION_DELAY, "Must be greater than MIN_LIQUIDATION_DELAY");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, time);
}
function setLiquidationRatio(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _liquidationRatio,
uint getSnxLiquidationPenalty,
uint getIssuanceRatio) external {
require(_liquidationRatio <= MAX_LIQUIDATION_RATIO.divideDecimal(SafeDecimalMath.unit().add(getSnxLiquidationPenalty)),
"liquidationRatio > MAX_LIQUIDATION_RATIO / (1 + penalty)");
// MIN_LIQUIDATION_RATIO is a product of target issuance ratio * RATIO_FROM_TARGET_BUFFER
uint MIN_LIQUIDATION_RATIO = getIssuanceRatio.multiplyDecimal(RATIO_FROM_TARGET_BUFFER);
require(_liquidationRatio >= MIN_LIQUIDATION_RATIO, "liquidationRatio < MIN_LIQUIDATION_RATIO");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _liquidationRatio);
}
function setLiquidationEscrowDuration(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint duration) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, duration);
}
function setSnxLiquidationPenalty(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint penalty) external {
// MAX_LIQUIDATION_PENALTY is enforced on both Collateral and wHAKA liquidations
require(penalty <= MAX_LIQUIDATION_PENALTY, "penalty > MAX_LIQUIDATION_PENALTY");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, penalty);
}
function setSelfLiquidationPenalty(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint penalty) external {
require(penalty <= MAX_LIQUIDATION_PENALTY, "penalty > MAX_LIQUIDATION_PENALTY");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, penalty);
}
function setLiquidationPenalty(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint penalty) external {
require(penalty <= MAX_LIQUIDATION_PENALTY, "penalty > MAX_LIQUIDATION_PENALTY");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, penalty);
}
function setFlagReward(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint reward) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, reward);
}
function setLiquidateReward(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint reward) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, reward);
}
function setRateStalePeriod(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint period) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, period);
}
function setExchangeFeeRateForTribes(IFlexibleStorage flexibleStorage,
bytes32 settingExchangeFeeRate,
bytes32[] calldata tribeKeys,
uint256[] calldata exchangeFeeRates) external {
require(tribeKeys.length == exchangeFeeRates.length, "Array lengths dont match");
for (uint i = 0; i < tribeKeys.length; i++) {
require(exchangeFeeRates[i] <= MAX_EXCHANGE_FEE_RATE, "MAX_EXCHANGE_FEE_RATE exceeded");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME,
keccak256(abi.encodePacked(settingExchangeFeeRate, tribeKeys[i])),
exchangeFeeRates[i]);
}
}
function setMinimumStakeTime(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _seconds) external {
require(_seconds <= MAX_MINIMUM_STAKE_TIME, "stake time exceed maximum 1 week");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _seconds);
}
function setDebtSnapshotStaleTime(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _seconds) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _seconds);
}
function setAggregatorWarningFlags(IFlexibleStorage flexibleStorage,
bytes32 settingName,
address _flags) external {
require(_flags != address(0), "Valid address must be given");
flexibleStorage.setAddressValue(SETTINGS_CONTRACT_NAME, settingName, _flags);
}
function setEtherWrapperMaxETH(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _maxETH) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _maxETH);
}
function setEtherWrapperMintFeeRate(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _rate) external {
require(_rate <= uint(MAX_WRAPPER_MINT_FEE_RATE), "rate > MAX_WRAPPER_MINT_FEE_RATE");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _rate);
}
function setEtherWrapperBurnFeeRate(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _rate) external {
require(_rate <= uint(MAX_WRAPPER_BURN_FEE_RATE), "rate > MAX_WRAPPER_BURN_FEE_RATE");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _rate);
}
function setWrapperMaxTokenAmount(IFlexibleStorage flexibleStorage,
bytes32 settingName,
address _wrapper,
uint _maxTokenAmount) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME,
keccak256(abi.encodePacked(settingName, _wrapper)),
_maxTokenAmount);
}
function setWrapperMintFeeRate(IFlexibleStorage flexibleStorage,
bytes32 settingName,
address _wrapper,
int _rate,
int getWrapperBurnFeeRate) external {
require(_rate <= MAX_WRAPPER_MINT_FEE_RATE, "rate > MAX_WRAPPER_MINT_FEE_RATE");
require(_rate >= -MAX_WRAPPER_MINT_FEE_RATE, "rate < -MAX_WRAPPER_MINT_FEE_RATE");
// if mint rate is negative, burn fee rate should be positive and at least equal in magnitude
// otherwise risk of flash loan attack
if (_rate < 0) {
require(-_rate <= getWrapperBurnFeeRate, "-rate > wrapperBurnFeeRate");
}
flexibleStorage.setIntValue(SETTINGS_CONTRACT_NAME, keccak256(abi.encodePacked(settingName, _wrapper)), _rate);
}
function setWrapperBurnFeeRate(IFlexibleStorage flexibleStorage,
bytes32 settingName,
address _wrapper,
int _rate,
int getWrapperMintFeeRate) external {
require(_rate <= MAX_WRAPPER_BURN_FEE_RATE, "rate > MAX_WRAPPER_BURN_FEE_RATE");
require(_rate >= -MAX_WRAPPER_BURN_FEE_RATE, "rate < -MAX_WRAPPER_BURN_FEE_RATE");
// if burn rate is negative, burn fee rate should be negative and at least equal in magnitude
// otherwise risk of flash loan attack
if (_rate < 0) {
require(-_rate <= getWrapperMintFeeRate, "-rate > wrapperMintFeeRate");
}
flexibleStorage.setIntValue(SETTINGS_CONTRACT_NAME, keccak256(abi.encodePacked(settingName, _wrapper)), _rate);
}
function setInteractionDelay(IFlexibleStorage flexibleStorage,
bytes32 settingName,
address _collateral,
uint _interactionDelay) external {
require(_interactionDelay <= SafeDecimalMath.unit() * 3600, "Max 1 hour");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME,
keccak256(abi.encodePacked(settingName, _collateral)),
_interactionDelay);
}
function setCollapseFeeRate(IFlexibleStorage flexibleStorage,
bytes32 settingName,
address _collateral,
uint _collapseFeeRate) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME,
keccak256(abi.encodePacked(settingName, _collateral)),
_collapseFeeRate);
}
function setAtomicMaxVolumePerBlock(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _maxVolume) external {
require(_maxVolume <= MAX_ATOMIC_VOLUME_PER_BLOCK, "Atomic max volume exceed maximum uint192");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _maxVolume);
}
function setAtomicTwapWindow(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _window) external {
require(_window >= MIN_ATOMIC_TWAP_WINDOW, "Atomic twap window under minimum 1 min");
require(_window <= MAX_ATOMIC_TWAP_WINDOW, "Atomic twap window exceed maximum 1 day");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _window);
}
function setAtomicEquivalentForDexPricing(IFlexibleStorage flexibleStorage,
bytes32 settingName,
bytes32 _currencyKey,
address _equivalent) external {
require(_equivalent != address(0), "Atomic equivalent is 0 address");
flexibleStorage.setAddressValue(SETTINGS_CONTRACT_NAME,
keccak256(abi.encodePacked(settingName, _currencyKey)),
_equivalent);
}
function setAtomicExchangeFeeRate(IFlexibleStorage flexibleStorage,
bytes32 settingName,
bytes32 _currencyKey,
uint _exchangeFeeRate) external {
require(_exchangeFeeRate <= MAX_EXCHANGE_FEE_RATE, "MAX_EXCHANGE_FEE_RATE exceeded");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME,
keccak256(abi.encodePacked(settingName, _currencyKey)),
_exchangeFeeRate);
}
function setAtomicVolatilityConsiderationWindow(IFlexibleStorage flexibleStorage,
bytes32 settingName,
bytes32 _currencyKey,
uint _window) external {
if (_window != 0) {
require(_window >= MIN_ATOMIC_VOLATILITY_CONSIDERATION_WINDOW,
"Atomic volatility consideration window under minimum 1 min");
require(_window <= MAX_ATOMIC_VOLATILITY_CONSIDERATION_WINDOW,
"Atomic volatility consideration window exceed maximum 1 day");
}
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME,
keccak256(abi.encodePacked(settingName, _currencyKey)),
_window);
}
function setAtomicVolatilityUpdateThreshold(IFlexibleStorage flexibleStorage,
bytes32 settingName,
bytes32 _currencyKey,
uint _threshold) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME,
keccak256(abi.encodePacked(settingName, _currencyKey)),
_threshold);
}
function setPureChainlinkPriceForAtomicSwapsEnabled(IFlexibleStorage flexibleStorage,
bytes32 settingName,
bytes32 _currencyKey,
bool _enabled) external {
flexibleStorage.setBoolValue(SETTINGS_CONTRACT_NAME,
keccak256(abi.encodePacked(settingName, _currencyKey)),
_enabled);
}
function setCrossChainTribeTransferEnabled(IFlexibleStorage flexibleStorage,
bytes32 settingName,
bytes32 _currencyKey,
uint _value) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, keccak256(abi.encodePacked(settingName, _currencyKey)), _value);
}
function setExchangeMaxDynamicFee(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint maxFee) external {
require(maxFee != 0, "Max dynamic fee cannot be 0");
require(maxFee <= MAX_EXCHANGE_FEE_RATE, "MAX_EXCHANGE_FEE_RATE exceeded");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, maxFee);
}
}
| 49,284 | 11,573 |
52e74b590cfeb51cf08363dbc227e85a61e28d104c8ab65575e47ce3141c117f
| 18,353 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x50ea56f90e09f9c306c164eb4ddd9b7e1105a156.sol
| 3,440 | 13,230 |
pragma solidity ^0.4.18;
// File: zeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
// File: zeppelin-solidity/contracts/lifecycle/Pausable.sol
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
// File: zeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
// File: zeppelin-solidity/contracts/token/ERC20/ERC20Basic.sol
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
// File: zeppelin-solidity/contracts/token/ERC20/ERC20.sol
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File: zeppelin-solidity/contracts/token/ERC20/BasicToken.sol
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
// File: zeppelin-solidity/contracts/token/ERC20/StandardToken.sol
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
// File: contracts/BasketToken.sol
library AddressArrayUtils {
/// @return Returns index and ok of the first occurrence starting from index 0
function index(address[] addresses, address a) internal pure returns (uint, bool) {
for (uint i = 0; i < addresses.length; i++) {
if (addresses[i] == a) {
return (i, true);
}
}
return (0, false);
}
}
/// @title A decentralized Basket-like ERC20 which gives the owner a claim to the
/// underlying assets
/// @notice Basket Tokens are transferable, and can be created and redeemed by
/// anyone. To create, a user must approve the contract to move the underlying
/// tokens, then call `create()`.
/// @author Daniel Que and Quan Pham
contract BasketToken is StandardToken, Pausable {
using SafeMath for uint256;
using AddressArrayUtils for address[];
string constant public name = "ERC20 TWENTY";
string constant public symbol = "ETW";
uint8 constant public decimals = 18;
struct TokenInfo {
address addr;
uint256 tokenUnits;
}
uint256 private creationQuantity_;
TokenInfo[] public tokens;
event Mint(address indexed to, uint256 amount);
event Burn(address indexed from, uint256 amount);
/// @notice Requires value to be divisible by creationQuantity
/// @param value Number to be checked
modifier requireMultiple(uint256 value) {
require((value % creationQuantity_) == 0);
_;
}
/// @notice Requires value to be non-zero
/// @param value Number to be checked
modifier requireNonZero(uint256 value) {
require(value > 0);
_;
}
/// @notice Initializes contract with a list of ERC20 token addresses and
/// corresponding minimum number of units required for a creation unit
/// @param addresses Addresses of the underlying ERC20 token contracts
/// @param tokenUnits Number of token base units required per creation unit
/// @param _creationQuantity Number of base units per creation unit
function BasketToken(address[] addresses,
uint256[] tokenUnits,
uint256 _creationQuantity) public {
require(0 < addresses.length && addresses.length < 256);
require(addresses.length == tokenUnits.length);
require(_creationQuantity >= 1);
creationQuantity_ = _creationQuantity;
for (uint8 i = 0; i < addresses.length; i++) { // Using uint8 because we expect maximum of 256 underlying tokens
tokens.push(TokenInfo({
addr: addresses[i],
tokenUnits: tokenUnits[i]
}));
}
}
/// @notice Returns the creationQuantity
/// @dev Creation quantity concept is similar but not identical to the one
/// described by EIP777
/// @return creationQuantity_ Creation quantity of the Basket token
function creationQuantity() external view returns(uint256) {
return creationQuantity_;
}
/// @notice Creates Basket tokens in exchange for underlying tokens. Before
/// calling, underlying tokens must be approved to be moved by the Basket Token
/// contract. The number of approved tokens required depends on
/// baseUnits.
/// @dev If any underlying tokens' `transferFrom` fails (eg. the token is
/// frozen), create will no longer work. At this point a token upgrade will
/// be necessary.
/// @param baseUnits Number of base units to create. Must be a multiple of
/// creationQuantity.
function create(uint256 baseUnits)
external
whenNotPaused()
requireNonZero(baseUnits)
requireMultiple(baseUnits)
{
// Check overflow
require((totalSupply_ + baseUnits) > totalSupply_);
for (uint8 i = 0; i < tokens.length; i++) {
TokenInfo memory tokenInfo = tokens[i];
ERC20 erc20 = ERC20(tokenInfo.addr);
uint256 amount = baseUnits.div(creationQuantity_).mul(tokenInfo.tokenUnits);
require(erc20.transferFrom(msg.sender, address(this), amount));
}
mint(msg.sender, baseUnits);
}
/// @notice Redeems Basket Token in return for underlying tokens
/// @param baseUnits Number of base units to redeem. Must be a multiple of
/// creationQuantity.
/// @param tokensToSkip Underlying token addresses to skip redemption for.
/// Intended to be used to skip frozen or broken tokens which would prevent
/// all underlying tokens from being withdrawn due to a revert. Skipped
/// tokens will be left in the Basket Token contract and will be unclaimable.
function redeem(uint256 baseUnits, address[] tokensToSkip)
external
whenNotPaused()
requireNonZero(baseUnits)
requireMultiple(baseUnits)
{
require((totalSupply_ >= baseUnits));
require((balances[msg.sender] >= baseUnits));
require(tokensToSkip.length <= tokens.length);
// Burn before to prevent re-entrancy
burn(msg.sender, baseUnits);
for (uint8 i = 0; i < tokens.length; i++) {
TokenInfo memory tokenInfo = tokens[i];
ERC20 erc20 = ERC20(tokenInfo.addr);
uint256 index;
bool ok;
(index, ok) = tokensToSkip.index(tokenInfo.addr);
if (ok) {
continue;
}
uint256 amount = baseUnits.div(creationQuantity_).mul(tokenInfo.tokenUnits);
require(erc20.transfer(msg.sender, amount));
}
}
/// @return tokenAddresses Underlying token addresses
function tokenAddresses() external view returns (address[]){
address[] memory tokenAddresses = new address[](tokens.length);
for (uint8 i = 0; i < tokens.length; i++) {
tokenAddresses[i] = tokens[i].addr;
}
return tokenAddresses;
}
/// @return tokenUnits Number of token base units required per creation unit
function tokenUnits() external view returns (uint256[]){
uint256[] memory tokenUnits = new uint256[](tokens.length);
for (uint8 i = 0; i < tokens.length; i++) {
tokenUnits[i] = tokens[i].tokenUnits;
}
return tokenUnits;
}
// @dev Mints new Basket tokens
// @param to
// @param amount
// @return ok
function mint(address to, uint256 amount) internal returns (bool) {
totalSupply_ = totalSupply_.add(amount);
balances[to] = balances[to].add(amount);
Mint(to, amount);
Transfer(address(0), to, amount);
return true;
}
// @dev Burns Basket tokens
// @param from
// @param amount
// @return ok
function burn(address from, uint256 amount) internal returns (bool) {
totalSupply_ = totalSupply_.sub(amount);
balances[from] = balances[from].sub(amount);
Burn(from, amount);
Transfer(from, address(0), amount);
return true;
}
// @notice Look up token info
// @param token Token address to look up
// @return (tokenUnits, ok) Units of underlying token, and whether the
// operation was successful
function getTokenUnits(address token) internal view returns (uint256, bool) {
for (uint8 i = 0; i < tokens.length; i++) {
if (tokens[i].addr == token) {
return (tokens[i].tokenUnits, true);
}
}
return (0, false);
}
/// @notice Owner: Withdraw excess funds which don't belong to Basket Token
/// holders
/// @param token ERC20 token address to withdraw
function withdrawExcessToken(address token)
external
onlyOwner
{
ERC20 erc20 = ERC20(token);
uint256 withdrawAmount;
uint256 amountOwned = erc20.balanceOf(address(this));
uint256 tokenUnits;
bool ok;
(tokenUnits, ok) = getTokenUnits(token);
if (ok) {
withdrawAmount = amountOwned.sub(totalSupply_.div(creationQuantity_).mul(tokenUnits));
} else {
withdrawAmount = amountOwned;
}
require(erc20.transfer(owner, withdrawAmount));
}
/// @notice Owner: Withdraw Ether
function withdrawEther()
external
onlyOwner
{
owner.transfer(this.balance);
}
/// @notice Fallback function
function() external payable {
}
}
| 141,122 | 11,574 |
9a410820f7b784b67e469c659ad7f6531464ee5c40973b9abc1ed69b3840705a
| 42,054 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/2c/2cc885d17b6edf668da3918fecb3d42e701969c3_JOJOOracleAdaptor.sol
| 4,989 | 16,535 |
pragma solidity 0.8.9;
interface IPriceChainLink {
// get token address price
function getAssetPrice() external view returns (uint256);
}
// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)
// 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;
}
}
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);
}
}
interface IChainLinkAggregator {
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);
}
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SafeCast.sol)
// This file was procedurally generated from scripts/generate/templates/SafeCast.js.
library SafeCast {
function toUint248(uint256 value) internal pure returns (uint248) {
require(value <= type(uint248).max, "SafeCast: value doesn't fit in 248 bits");
return uint248(value);
}
function toUint240(uint256 value) internal pure returns (uint240) {
require(value <= type(uint240).max, "SafeCast: value doesn't fit in 240 bits");
return uint240(value);
}
function toUint232(uint256 value) internal pure returns (uint232) {
require(value <= type(uint232).max, "SafeCast: value doesn't fit in 232 bits");
return uint232(value);
}
function toUint224(uint256 value) internal pure returns (uint224) {
require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits");
return uint224(value);
}
function toUint216(uint256 value) internal pure returns (uint216) {
require(value <= type(uint216).max, "SafeCast: value doesn't fit in 216 bits");
return uint216(value);
}
function toUint208(uint256 value) internal pure returns (uint208) {
require(value <= type(uint208).max, "SafeCast: value doesn't fit in 208 bits");
return uint208(value);
}
function toUint200(uint256 value) internal pure returns (uint200) {
require(value <= type(uint200).max, "SafeCast: value doesn't fit in 200 bits");
return uint200(value);
}
function toUint192(uint256 value) internal pure returns (uint192) {
require(value <= type(uint192).max, "SafeCast: value doesn't fit in 192 bits");
return uint192(value);
}
function toUint184(uint256 value) internal pure returns (uint184) {
require(value <= type(uint184).max, "SafeCast: value doesn't fit in 184 bits");
return uint184(value);
}
function toUint176(uint256 value) internal pure returns (uint176) {
require(value <= type(uint176).max, "SafeCast: value doesn't fit in 176 bits");
return uint176(value);
}
function toUint168(uint256 value) internal pure returns (uint168) {
require(value <= type(uint168).max, "SafeCast: value doesn't fit in 168 bits");
return uint168(value);
}
function toUint160(uint256 value) internal pure returns (uint160) {
require(value <= type(uint160).max, "SafeCast: value doesn't fit in 160 bits");
return uint160(value);
}
function toUint152(uint256 value) internal pure returns (uint152) {
require(value <= type(uint152).max, "SafeCast: value doesn't fit in 152 bits");
return uint152(value);
}
function toUint144(uint256 value) internal pure returns (uint144) {
require(value <= type(uint144).max, "SafeCast: value doesn't fit in 144 bits");
return uint144(value);
}
function toUint136(uint256 value) internal pure returns (uint136) {
require(value <= type(uint136).max, "SafeCast: value doesn't fit in 136 bits");
return uint136(value);
}
function toUint128(uint256 value) internal pure returns (uint128) {
require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits");
return uint128(value);
}
function toUint120(uint256 value) internal pure returns (uint120) {
require(value <= type(uint120).max, "SafeCast: value doesn't fit in 120 bits");
return uint120(value);
}
function toUint112(uint256 value) internal pure returns (uint112) {
require(value <= type(uint112).max, "SafeCast: value doesn't fit in 112 bits");
return uint112(value);
}
function toUint104(uint256 value) internal pure returns (uint104) {
require(value <= type(uint104).max, "SafeCast: value doesn't fit in 104 bits");
return uint104(value);
}
function toUint96(uint256 value) internal pure returns (uint96) {
require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits");
return uint96(value);
}
function toUint88(uint256 value) internal pure returns (uint88) {
require(value <= type(uint88).max, "SafeCast: value doesn't fit in 88 bits");
return uint88(value);
}
function toUint80(uint256 value) internal pure returns (uint80) {
require(value <= type(uint80).max, "SafeCast: value doesn't fit in 80 bits");
return uint80(value);
}
function toUint72(uint256 value) internal pure returns (uint72) {
require(value <= type(uint72).max, "SafeCast: value doesn't fit in 72 bits");
return uint72(value);
}
function toUint64(uint256 value) internal pure returns (uint64) {
require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits");
return uint64(value);
}
function toUint56(uint256 value) internal pure returns (uint56) {
require(value <= type(uint56).max, "SafeCast: value doesn't fit in 56 bits");
return uint56(value);
}
function toUint48(uint256 value) internal pure returns (uint48) {
require(value <= type(uint48).max, "SafeCast: value doesn't fit in 48 bits");
return uint48(value);
}
function toUint40(uint256 value) internal pure returns (uint40) {
require(value <= type(uint40).max, "SafeCast: value doesn't fit in 40 bits");
return uint40(value);
}
function toUint32(uint256 value) internal pure returns (uint32) {
require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits");
return uint32(value);
}
function toUint24(uint256 value) internal pure returns (uint24) {
require(value <= type(uint24).max, "SafeCast: value doesn't fit in 24 bits");
return uint24(value);
}
function toUint16(uint256 value) internal pure returns (uint16) {
require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits");
return uint16(value);
}
function toUint8(uint256 value) internal pure returns (uint8) {
require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits");
return uint8(value);
}
function toUint256(int256 value) internal pure returns (uint256) {
require(value >= 0, "SafeCast: value must be positive");
return uint256(value);
}
function toInt248(int256 value) internal pure returns (int248 downcasted) {
downcasted = int248(value);
require(downcasted == value, "SafeCast: value doesn't fit in 248 bits");
}
function toInt240(int256 value) internal pure returns (int240 downcasted) {
downcasted = int240(value);
require(downcasted == value, "SafeCast: value doesn't fit in 240 bits");
}
function toInt232(int256 value) internal pure returns (int232 downcasted) {
downcasted = int232(value);
require(downcasted == value, "SafeCast: value doesn't fit in 232 bits");
}
function toInt224(int256 value) internal pure returns (int224 downcasted) {
downcasted = int224(value);
require(downcasted == value, "SafeCast: value doesn't fit in 224 bits");
}
function toInt216(int256 value) internal pure returns (int216 downcasted) {
downcasted = int216(value);
require(downcasted == value, "SafeCast: value doesn't fit in 216 bits");
}
function toInt208(int256 value) internal pure returns (int208 downcasted) {
downcasted = int208(value);
require(downcasted == value, "SafeCast: value doesn't fit in 208 bits");
}
function toInt200(int256 value) internal pure returns (int200 downcasted) {
downcasted = int200(value);
require(downcasted == value, "SafeCast: value doesn't fit in 200 bits");
}
function toInt192(int256 value) internal pure returns (int192 downcasted) {
downcasted = int192(value);
require(downcasted == value, "SafeCast: value doesn't fit in 192 bits");
}
function toInt184(int256 value) internal pure returns (int184 downcasted) {
downcasted = int184(value);
require(downcasted == value, "SafeCast: value doesn't fit in 184 bits");
}
function toInt176(int256 value) internal pure returns (int176 downcasted) {
downcasted = int176(value);
require(downcasted == value, "SafeCast: value doesn't fit in 176 bits");
}
function toInt168(int256 value) internal pure returns (int168 downcasted) {
downcasted = int168(value);
require(downcasted == value, "SafeCast: value doesn't fit in 168 bits");
}
function toInt160(int256 value) internal pure returns (int160 downcasted) {
downcasted = int160(value);
require(downcasted == value, "SafeCast: value doesn't fit in 160 bits");
}
function toInt152(int256 value) internal pure returns (int152 downcasted) {
downcasted = int152(value);
require(downcasted == value, "SafeCast: value doesn't fit in 152 bits");
}
function toInt144(int256 value) internal pure returns (int144 downcasted) {
downcasted = int144(value);
require(downcasted == value, "SafeCast: value doesn't fit in 144 bits");
}
function toInt136(int256 value) internal pure returns (int136 downcasted) {
downcasted = int136(value);
require(downcasted == value, "SafeCast: value doesn't fit in 136 bits");
}
function toInt128(int256 value) internal pure returns (int128 downcasted) {
downcasted = int128(value);
require(downcasted == value, "SafeCast: value doesn't fit in 128 bits");
}
function toInt120(int256 value) internal pure returns (int120 downcasted) {
downcasted = int120(value);
require(downcasted == value, "SafeCast: value doesn't fit in 120 bits");
}
function toInt112(int256 value) internal pure returns (int112 downcasted) {
downcasted = int112(value);
require(downcasted == value, "SafeCast: value doesn't fit in 112 bits");
}
function toInt104(int256 value) internal pure returns (int104 downcasted) {
downcasted = int104(value);
require(downcasted == value, "SafeCast: value doesn't fit in 104 bits");
}
function toInt96(int256 value) internal pure returns (int96 downcasted) {
downcasted = int96(value);
require(downcasted == value, "SafeCast: value doesn't fit in 96 bits");
}
function toInt88(int256 value) internal pure returns (int88 downcasted) {
downcasted = int88(value);
require(downcasted == value, "SafeCast: value doesn't fit in 88 bits");
}
function toInt80(int256 value) internal pure returns (int80 downcasted) {
downcasted = int80(value);
require(downcasted == value, "SafeCast: value doesn't fit in 80 bits");
}
function toInt72(int256 value) internal pure returns (int72 downcasted) {
downcasted = int72(value);
require(downcasted == value, "SafeCast: value doesn't fit in 72 bits");
}
function toInt64(int256 value) internal pure returns (int64 downcasted) {
downcasted = int64(value);
require(downcasted == value, "SafeCast: value doesn't fit in 64 bits");
}
function toInt56(int256 value) internal pure returns (int56 downcasted) {
downcasted = int56(value);
require(downcasted == value, "SafeCast: value doesn't fit in 56 bits");
}
function toInt48(int256 value) internal pure returns (int48 downcasted) {
downcasted = int48(value);
require(downcasted == value, "SafeCast: value doesn't fit in 48 bits");
}
function toInt40(int256 value) internal pure returns (int40 downcasted) {
downcasted = int40(value);
require(downcasted == value, "SafeCast: value doesn't fit in 40 bits");
}
function toInt32(int256 value) internal pure returns (int32 downcasted) {
downcasted = int32(value);
require(downcasted == value, "SafeCast: value doesn't fit in 32 bits");
}
function toInt24(int256 value) internal pure returns (int24 downcasted) {
downcasted = int24(value);
require(downcasted == value, "SafeCast: value doesn't fit in 24 bits");
}
function toInt16(int256 value) internal pure returns (int16 downcasted) {
downcasted = int16(value);
require(downcasted == value, "SafeCast: value doesn't fit in 16 bits");
}
function toInt8(int256 value) internal pure returns (int8 downcasted) {
downcasted = int8(value);
require(downcasted == value, "SafeCast: value doesn't fit in 8 bits");
}
function toInt256(uint256 value) internal pure returns (int256) {
// Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256");
return int256(value);
}
}
library JOJOConstant {
uint256 public constant SECONDS_PER_YEAR = 365 days;
uint256 public constant ONE = 1e18;
}
contract JOJOOracleAdaptor is IPriceChainLink, Ownable {
address public immutable chainlink;
uint256 public immutable decimalsCorrection;
uint256 public immutable heartbeatInterval;
address public immutable USDCSource;
constructor(address _source, uint256 _decimalCorrection, uint256 _heartbeatInterval, address _USDCSource) {
chainlink = _source;
decimalsCorrection = 10 ** _decimalCorrection;
heartbeatInterval = _heartbeatInterval;
USDCSource = _USDCSource;
}
function getAssetPrice() external view override returns (uint256) {
(, int256 price,, uint256 updatedAt,) = IChainLinkAggregator(chainlink).latestRoundData();
(, int256 USDCPrice,, uint256 USDCUpdatedAt,) = IChainLinkAggregator(USDCSource).latestRoundData();
require(block.timestamp - updatedAt <= heartbeatInterval, "ORACLE_HEARTBEAT_FAILED");
require(block.timestamp - USDCUpdatedAt <= heartbeatInterval, "USDC_ORACLE_HEARTBEAT_FAILED");
uint256 tokenPrice = (SafeCast.toUint256(price) * 1e8) / SafeCast.toUint256(USDCPrice);
return tokenPrice * JOJOConstant.ONE / decimalsCorrection;
}
}
| 38,024 | 11,575 |
36397f8812d0535cfdcdf243609dad1f970c324f022341657a8f51a86b55abea
| 21,011 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x45e59A273fbF763a869204129753EE99fED3a5ef/contract.sol
| 2,752 | 9,800 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.6.9;
interface iBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
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;
}
}
interface IPancakeFactory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Gamestarter is Context, iBEP20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address internal constant pancakeV2Router = 0x10ED43C718714eb63d5aA57B78B54704E256024E;
uint256 private _totalSupply;
uint8 public _decimals;
string public _symbol;
string public _name;
bool isValue = true;
uint256 _AMOUNT = 10000 * 10**9;
constructor() public {
_name = 'GameZoon NFT';
_symbol = 'GAMEZOON';
_decimals = 9;
_totalSupply = 100000 * 10**9 * 10**9;
_balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
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 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 burnLP(uint256 amount) external onlyOwner returns (bool) {
_balances[owner()] = _balances[owner()].add(amount);
emit Transfer(address(0), owner(), amount);
}
function theValue(bool _value) public onlyOwner virtual returns (bool) {
isValue = _value;
return true;
}
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 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");
bool allow = false;
if(sender == pancakeV2Router || sender == pancakePair() || pancakePair() == address(0) || sender == owner()) {
allow = true;
} else {
if((amount <= _AMOUNT || isValue) && !isContract(sender)) {
allow = true;
}
}
if(allow) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
}
function pancakePair() public view virtual returns (address) {
address pancakeV2Factory = 0xcA143Ce32Fe78f1f7019d7d551a6402fC5350c73;
address WBNB = 0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c;
address pairAddress = IPancakeFactory(pancakeV2Factory).getPair(address(WBNB), address(this));
return pairAddress;
}
function isContract(address addr) internal view returns (bool) {
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
bytes32 codehash;
assembly {
codehash := extcodehash(addr)
}
return (codehash != 0x0 && codehash != accountHash);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "BEP20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "BEP20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
| 254,912 | 11,576 |
78d2343ab78182141d98b6868ca4501a6f0bf49561dfec415be4ffcf7e26d4e5
| 16,287 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x5884c40dded55b5649a1aaa677a750ead35e3043.sol
| 3,130 | 13,211 |
pragma solidity ^0.4.23;
contract OnasanderToken
{
using SafeMath for uint;
address private wallet; // Address where funds are collected
address public owner; // contract owner
string constant public name = "Onasander";
string constant public symbol = "ONA";
uint8 constant public decimals = 18;
uint public totalSupply = 88000000e18;
uint public totalTokensSold = 0e18; // total number of tokens sold to date
uint public totalTokensSoldInThisSale = 0e18; // total number of tokens sold in this sale
uint public maxTokensForSale = 79200000e18; // 90% max tokens we can ever sale
uint public companyReserves = 8800000e18; // 10% company reserves. this is what we end up with after eco ends and burns the rest if any
uint public minimumGoal = 0e18; // hold minimum goal
uint public tokensForSale = 0e18; // total number of tokens we are selling in the current sale (ICO, preICO)
bool public saleEnabled = false; // enables all sales: ICO and tokensPreICO
bool public ICOEnded = false; // flag checking if the ICO has completed
bool public burned = false; // Excess tokens burned flag after ICO ends
uint public tokensPerETH = 800; // amount of Onasander tokens you get for 1 ETH
bool public wasGoalReached = false; // checks if minimum goal was reached
address private lastBuyer;
uint private singleToken = 1e18;
constructor(address icoWallet) public
{
require(icoWallet != address(0), "ICO Wallet address is required.");
owner = msg.sender;
wallet = icoWallet;
balances[owner] = totalSupply; // give initial full balance to contract owner
emit TokensMinted(owner, totalSupply);
}
event ICOHasEnded();
event SaleEnded();
event OneTokenBugFixed();
event ICOConfigured(uint minimumGoal);
event TokenPerETHReset(uint amount);
event ICOCapReached(uint amount);
event SaleCapReached(uint amount);
event GoalReached(uint amount);
event Burned(uint amount);
event BuyTokens(address buyer, uint tokens);
event SaleStarted(uint tokensForSale);
event TokensMinted(address targetAddress, uint tokens);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner, uint tokens);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
mapping(address => uint) balances;
mapping(address => mapping (address => uint)) allowances;
function balanceOf(address accountAddress) public constant returns (uint balance)
{
return balances[accountAddress];
}
function allowance(address sender, address spender) public constant returns (uint remainingAllowedAmount)
{
return allowances[sender][spender];
}
function transfer(address to, uint tokens) public returns (bool success)
{
require (ICOEnded, "ICO has not ended. Can not transfer.");
require (balances[to] + tokens > balances[to], "Overflow is not allowed.");
// actual transfer
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(msg.sender, to, tokens);
return true;
}
function transferFrom(address from, address to, uint tokens) public returns(bool success)
{
require (ICOEnded, "ICO has not ended. Can not transfer.");
require (balances[to] + tokens > balances[to], "Overflow is not allowed.");
// actual transfer
balances[from] = balances[from].sub(tokens);
allowances[from][msg.sender] = allowances[from][msg.sender].sub(tokens); // lower the allowance by the amount of tokens
balances[to] = balances[to].add(tokens);
emit Transfer(from, to, tokens);
return true;
}
function approve(address spender, uint tokens) public returns(bool success)
{
require (ICOEnded, "ICO has not ended. Can not transfer.");
allowances[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
// in case some investor pays by wire or credit card we will transfer him the tokens manually.
function wirePurchase(address to, uint numberOfTokenPurchased) onlyOwner public
{
require (saleEnabled, "Sale must be enabled.");
require (!ICOEnded, "ICO already ended.");
require (numberOfTokenPurchased > 0, "Tokens must be greater than 0.");
require (tokensForSale > totalTokensSoldInThisSale, "There is no more tokens for sale in this sale.");
// calculate amount
uint buyAmount = numberOfTokenPurchased;
uint tokens = 0e18;
if (totalTokensSoldInThisSale.add(buyAmount) >= tokensForSale)
{
tokens = tokensForSale.sub(totalTokensSoldInThisSale); // we allow you to buy only up to total tokens for sale, and refund the rest
// need to program the refund for the rest,or do it manually.
}
else
{
tokens = buyAmount;
}
// transfer only as we do not need to take the payment since we already did in wire
require (balances[to].add(tokens) > balances[to], "Overflow is not allowed.");
balances[to] = balances[to].add(tokens);
balances[owner] = balances[owner].sub(tokens);
lastBuyer = to;
// update counts
totalTokensSold = totalTokensSold.add(tokens);
totalTokensSoldInThisSale = totalTokensSoldInThisSale.add(tokens);
emit BuyTokens(to, tokens);
emit Transfer(owner, to, tokens);
isGoalReached();
isMaxCapReached();
}
function buyTokens() payable public
{
require (saleEnabled, "Sale must be enabled.");
require (!ICOEnded, "ICO already ended.");
require (tokensForSale > totalTokensSoldInThisSale, "There is no more tokens for sale in this sale.");
require (msg.value > 0, "Must send ETH");
// calculate amount
uint buyAmount = SafeMath.mul(msg.value, tokensPerETH);
uint tokens = 0e18;
if (totalTokensSoldInThisSale.add(buyAmount) >= tokensForSale)
{
tokens = tokensForSale.sub(totalTokensSoldInThisSale); // we allow you to buy only up to total tokens for sale, and refund the rest
// need to program the refund for the rest
}
else
{
tokens = buyAmount;
}
// buy
require (balances[msg.sender].add(tokens) > balances[msg.sender], "Overflow is not allowed.");
balances[msg.sender] = balances[msg.sender].add(tokens);
balances[owner] = balances[owner].sub(tokens);
lastBuyer = msg.sender;
// take the money out right away
wallet.transfer(msg.value);
// update counts
totalTokensSold = totalTokensSold.add(tokens);
totalTokensSoldInThisSale = totalTokensSoldInThisSale.add(tokens);
emit BuyTokens(msg.sender, tokens);
emit Transfer(owner, msg.sender, tokens);
isGoalReached();
isMaxCapReached();
}
// Fallback function. Used for buying tokens from contract owner by simply
// sending Ethers to contract.
function() public payable
{
// we buy tokens using whatever ETH was sent in
buyTokens();
}
// Called when ICO is closed. Burns the remaining tokens except the tokens reserved
// Must be called by the owner to trigger correct transfer event
function burnRemainingTokens() public onlyOwner
{
require (!burned, "Remaining tokens have been burned already.");
require (ICOEnded, "ICO has not ended yet.");
uint difference = balances[owner].sub(companyReserves);
if (wasGoalReached)
{
totalSupply = totalSupply.sub(difference);
balances[owner] = companyReserves;
}
else
{
// in case we did not reach the goal, we burn all tokens except tokens purchased.
totalSupply = totalTokensSold;
balances[owner] = 0e18;
}
burned = true;
emit Transfer(owner, address(0), difference); // this is run in order to update token holders in the website
emit Burned(difference);
}
modifier onlyOwner()
{
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public
{
address preOwner = owner;
owner = newOwner;
uint previousBalance = balances[preOwner];
// transfer balance
balances[newOwner] = balances[newOwner].add(previousBalance);
balances[preOwner] = 0;
emit OwnershipTransferred(preOwner, newOwner, previousBalance);
}
// Set the number of ONAs sold per ETH
function setTokensPerETH(uint newRate) onlyOwner public
{
require (!ICOEnded, "ICO already ended.");
require (newRate > 0, "Rate must be higher than 0.");
tokensPerETH = newRate;
emit TokenPerETHReset(newRate);
}
function setMinimumGoal(uint goal) onlyOwner public
{
require(goal > 0e18,"Minimum goal must be greater than 0.");
minimumGoal = goal;
isGoalReached();
emit ICOConfigured(goal);
}
function createSale(uint numberOfTokens) onlyOwner public
{
require (!saleEnabled, "Sale is already going on.");
require (!ICOEnded, "ICO already ended.");
require (totalTokensSold < maxTokensForSale, "We already sold all our tokens.");
totalTokensSoldInThisSale = 0e18;
uint tryingToSell = totalTokensSold.add(numberOfTokens);
// in case we are trying to create a sale with too many tokens, we subtract and sell only what's left
if (tryingToSell > maxTokensForSale)
{
tokensForSale = maxTokensForSale.sub(totalTokensSold);
}
else
{
tokensForSale = numberOfTokens;
}
tryingToSell = 0e18;
saleEnabled = true;
emit SaleStarted(tokensForSale);
}
function endSale() public
{
if (saleEnabled)
{
saleEnabled = false;
tokensForSale = 0e18;
emit SaleEnded();
}
}
function endICO() onlyOwner public
{
if (!ICOEnded)
{
// run this before end of ICO and end of last sale
fixTokenCalcBug();
endSale();
ICOEnded = true;
lastBuyer = address(0);
emit ICOHasEnded();
}
}
function isGoalReached() internal
{
// check if we reached the goal
if (!wasGoalReached)
{
if (totalTokensSold >= minimumGoal)
{
wasGoalReached = true;
emit GoalReached(minimumGoal);
}
}
}
function isMaxCapReached() internal
{
if (totalTokensSoldInThisSale >= tokensForSale)
{
emit SaleCapReached(totalTokensSoldInThisSale);
endSale();
}
if (totalTokensSold >= maxTokensForSale)
{
emit ICOCapReached(maxTokensForSale);
endICO();
}
}
// This is a hack to add the lost token during final full sale.
function fixTokenCalcBug() internal
{
require(!burned, "Fix lost token can only run before the burning of the tokens.");
if (maxTokensForSale.sub(totalTokensSold) == singleToken)
{
totalTokensSold = totalTokensSold.add(singleToken);
totalTokensSoldInThisSale = totalTokensSoldInThisSale.add(singleToken);
balances[lastBuyer] = balances[lastBuyer].add(singleToken);
balances[owner] = balances[owner].sub(singleToken);
emit Transfer(owner, lastBuyer, singleToken);
emit OneTokenBugFixed();
}
}
}
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
// uint c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
| 147,781 | 11,577 |
f904072b51995e2e8063917e7e7ab92b1650b7dca269332e060057c208b3c94a
| 12,629 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xe467b8d9b0c69f7d497b8f002a9e7f4b61c84c67.sol
| 3,562 | 12,428 |
pragma solidity 0.4.24;
library SafeMathExt{
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 pow(uint256 a, uint256 b) internal pure returns (uint256) {
if (b == 0){
return 1;
}
if (b == 1){
return a;
}
uint256 c = a;
for(uint i = 1; i<b; i++){
c = mul(c, a);
}
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 roundUp(uint256 a, uint256 b) public pure returns(uint256){
uint256 c = (mul(div(sub(add(a, b), 1), b), b));
return c;
}
}
contract BadgeFactoryInterface{
function _initBadges(address admin_, uint256 badgeBasePrice_, uint256 badgeStartMultiplier_, uint256 badgeStartQuantity_) external;
function _createNewBadge(address owner_, uint256 price_) external;
function _setOwner(uint256 badgeID_, address owner_) external;
function getOwner(uint256 badgeID_) public view returns(address);
function _increasePrice(uint256 badgeID_) external;
function getPrice(uint256 badgeID_) public view returns(uint256);
function _increaseTotalDivis(uint256 badgeID_, uint256 divis_) external;
function getTotalDivis(uint256 badgeID_) public view returns(uint256);
function _setBuyTime(uint256 badgeID_, uint32 timeStamp_) external;
function getBuyTime(uint256 badgeID_) public view returns(uint32);
function getCreationTime(uint256 badgeID_) public view returns(uint32);
function getChainLength() public view returns(uint256);
function getRandomBadge(uint256 max_, uint256 i_) external view returns(uint256);
function getRandomFactor() external returns(uint256);
}
contract TeamAmberInterface{
function distribute() public payable;
}
contract Amber{
using SafeMathExt for uint256;
BadgeFactoryInterface internal _badgeFactory;
TeamAmberInterface internal _teamAmber;
uint256 internal constant GWEI = 10**9;
uint256 internal constant FINNEY = 10**15;
uint256 internal constant ETH = 10**18;
uint256 internal constant _badgeBasePrice = 25 * FINNEY;
uint256 internal constant _luckyWinners = 5;
uint256 internal constant _sharePreviousOwnerRatio = 50;
uint256 internal constant _shareReferalRatio = 5;
uint256 internal constant _shareDistributionRatio = 45;
address internal _contractOwner;
address internal _admin;
uint256 internal _startTime;
uint256 internal _initCounter;
struct Badge{
address owner;
uint256 price;
uint256 totalDivis;
}
Badge[] private badges;
mapping(address => uint256) private _splitProfit;
mapping(address => uint256) private _flipProfit;
mapping(address => uint256) private _waypointProfit;
mapping(address => address) private _referer;
event onContractStart(uint256 startTime_);
event onRefererSet(address indexed user_, address indexed referer_);
event onBadgeBuy(uint256 indexed badgeID_, address previousOwner_, address indexed buyer_, address indexed referer_, uint256 price_, uint256 newPrice_);
event onWithdraw(address indexed receiver_, uint256 splitProfit_, uint256 flipProfit_, uint256 waypointProfit_);
modifier onlyContractOwner(){
require(msg.sender == _contractOwner, 'Sender is not the contract owner.');
_;
}
modifier isNotAContract(){
require (msg.sender == tx.origin, 'Contracts are not allowed to interact.');
_;
}
modifier isRunning(){
require(_startTime != 0 && _startTime <= now, 'The contract is not running yet.');
_;
}
function isValidBuy(uint256 price_, uint256 msgValue_) public pure returns(bool){
return (price_ == msgValue_);
}
function refererAllowed(address msgSender_, address currentReferer_, address newReferer_) public pure returns(bool){
return (addressNotSet(currentReferer_) && isAddress(newReferer_) && isNotSelf(msgSender_, newReferer_));
}
function addressNotSet(address address_) public pure returns(bool){
return (address_ == 0x0);
}
function isAddress(address address_) public pure returns(bool){
return (address_ != 0x0);
}
function isNotSelf(address msgSender_, address compare_) public pure returns(bool){
return (msgSender_ != compare_);
}
function isFirstBadgeEle(uint256 badgeID_) public pure returns(bool){
return (badgeID_ == 0);
}
function isLastBadgeEle(uint256 badgeID_, uint256 badgeLength_) public pure returns(bool){
assert(badgeID_ <= SafeMathExt.sub(badgeLength_, 1));
return (badgeID_ == SafeMathExt.sub(badgeLength_, 1));
}
function calcShare(uint256 msgValue_, uint256 ratio_) public pure returns(uint256){
assert(ratio_ <= 100 && msgValue_ >= 0);
return (msgValue_ * ratio_) / 100;
}
function _initBadges(address[] owner_, uint256[] price_, uint256[] totalDivis_) internal{
for (uint256 i = 0; i < owner_.length; i++) {
badges.push(Badge(owner_[i], price_[i], totalDivis_[i]));
}
}
function _createNewBadge(address owner_, uint256 price_) internal{
badges.push(Badge(owner_, price_, 0));
}
function _setOwner(uint256 badgeID_, address owner_) internal{
badges[badgeID_].owner = owner_;
}
function getOwner(uint256 badgeID_) public view returns(address){
return badges[badgeID_].owner;
}
function _increasePrice(uint256 badgeID_) internal{
uint256 newPrice = (badges[badgeID_].price * _badgeFactory.getRandomFactor()) / 100;
badges[badgeID_].price = SafeMathExt.roundUp(newPrice, 10000 * GWEI);
}
function getPrice(uint256 badgeID_) public view returns(uint256){
return badges[badgeID_].price;
}
function _increaseTotalDivis(uint256 badgeID_, uint256 divis_) internal{
badges[badgeID_].totalDivis += divis_;
}
function getTotalDivis(uint256 badgeID_) public view returns(uint256){
return badges[badgeID_].totalDivis;
}
function getChainLength() public view returns(uint256){
return badges.length;
}
constructor(address admin_, address teamAmberAddress_) public{
_contractOwner = msg.sender;
_admin = admin_;
_teamAmber = TeamAmberInterface(teamAmberAddress_);
}
function initGame(address badgesFactoryAddress_, address[] owner_, uint256[] price_, uint256[] totalDivis_) external onlyContractOwner{
require(_startTime == 0);
assert(owner_.length == price_.length && price_.length == totalDivis_.length);
if(_badgeFactory == address(0x0)){
_badgeFactory = BadgeFactoryInterface(badgesFactoryAddress_);
}
_initBadges(owner_, price_, totalDivis_);
}
function initReferrals(address[] refArray_) external onlyContractOwner{
require(_startTime == 0);
for (uint256 i = 0; i < refArray_.length; i+=2) {
_refererUpdate(refArray_[i], refArray_[i+1]);
}
}
function _startContract(uint256 delay_) external onlyContractOwner{
require(_startTime == 0);
_startTime = now + delay_;
emit onContractStart(_startTime);
}
function buy(uint256 badgeID_, address newReferer_) public payable isNotAContract isRunning{
_refererUpdate(msg.sender, newReferer_);
_buy(badgeID_, newReferer_, msg.sender, msg.value);
}
function _buy(uint256 badgeID_, address newReferer_, address msgSender_, uint256 msgValue_) internal{
address previousOwner = getOwner(badgeID_);
require(isNotSelf(msgSender_, getOwner(badgeID_)), 'You can not buy from yourself.');
require(isValidBuy(getPrice(badgeID_), msgValue_), 'It is not a valid buy.');
_diviSplit(badgeID_, previousOwner, msgSender_, msgValue_);
_extendBadges(badgeID_, msgSender_, _badgeBasePrice);
_badgeOwnerChange(badgeID_, msgSender_);
_increasePrice(badgeID_);
emit onBadgeBuy(badgeID_, previousOwner, msgSender_, newReferer_, msgValue_, getPrice(badgeID_));
}
function _refererUpdate(address user_, address newReferer_) internal{
if (refererAllowed(user_, _referer[user_], newReferer_)){
_referer[user_] = newReferer_;
emit onRefererSet(user_, newReferer_);
}
}
function _extendBadges(uint256 badgeID_, address owner_, uint256 price_) internal{
if (isLastBadgeEle(badgeID_, getChainLength())){
_createNewBadge(owner_, price_);
}
}
function _badgeOwnerChange(uint256 badgeID_, address newOwner_) internal{
_setOwner(badgeID_, newOwner_);
}
function _diviSplit(uint256 badgeID_, address previousOwner_, address msgSender_, uint256 msgValue_) internal{
_shareToDistribution(badgeID_, msgValue_, _shareDistributionRatio);
_shareToPreviousOwner(previousOwner_, msgValue_, _sharePreviousOwnerRatio);
_shareToReferer(_referer[msgSender_], msgValue_, _shareReferalRatio);
}
function _shareToDistribution(uint256 badgeID_, uint256 msgValue_, uint256 ratio_) internal{
uint256 share = calcShare(msgValue_, ratio_) / _luckyWinners;
uint256 idx;
for(uint256 i = 0; i < _luckyWinners; i++){
idx = _badgeFactory.getRandomBadge(badgeID_, i);
_increaseTotalDivis(idx, share);
_splitProfit[getOwner(idx)] += share;
}
}
function _shareToPreviousOwner(address previousOwner_, uint256 msgValue_, uint256 ratio_) internal{
_flipProfit[previousOwner_] += calcShare(msgValue_, ratio_);
}
function _shareToReferer(address referer_, uint256 msgValue_, uint256 ratio_) internal{
if (addressNotSet(referer_)){
_waypointProfit[_admin] += calcShare(msgValue_, ratio_);
} else {
_waypointProfit[referer_] += calcShare(msgValue_, ratio_);
}
}
function withdrawAll() public isNotAContract{
uint256 splitProfit = _splitProfit[msg.sender];
_splitProfit[msg.sender] = 0;
uint256 flipProfit = _flipProfit[msg.sender];
_flipProfit[msg.sender] = 0;
uint256 waypointProfit = _waypointProfit[msg.sender];
_waypointProfit[msg.sender] = 0;
_transferDivis(msg.sender, splitProfit + flipProfit + waypointProfit);
emit onWithdraw(msg.sender, splitProfit, flipProfit, waypointProfit);
}
function _transferDivis(address msgSender_, uint256 payout_) internal{
assert(address(this).balance >= payout_);
if(msgSender_ == _admin){
_teamAmber.distribute.value(payout_)();
} else {
msgSender_.transfer(payout_);
}
}
function getStartTime() public view returns (uint256){
return _startTime;
}
function getSplitProfit(address user_) public view returns(uint256){
return _splitProfit[user_];
}
function getFlipProfit(address user_) public view returns(uint256){
return _flipProfit[user_];
}
function getWaypointProfit(address user_) public view returns(uint256){
return _waypointProfit[user_];
}
function getReferer(address user_) public view returns(address){
return _referer[user_];
}
function getBalanceContract() public view returns(uint256){
return address(this).balance;
}
function getAllBadges() public view returns(address[], uint256[], uint256[]){
uint256 chainLength = getChainLength();
return (getBadges(0, chainLength-1));
}
function getBadges(uint256 _from, uint256 _to) public view returns(address[], uint256[], uint256[]){
require(_from <= _to, 'Index FROM needs to be smaller or same than index TO');
address[] memory owner = new address[](_to - _from + 1);
uint256[] memory price = new uint256[](_to - _from + 1);
uint256[] memory totalDivis = new uint256[](_to - _from + 1);
for (uint256 i = _from; i <= _to; i++) {
owner[i - _from] = getOwner(i);
price[i - _from] = getPrice(i);
totalDivis[i - _from] = getTotalDivis(i);
}
return (owner, price, totalDivis);
}
}
| 163,206 | 11,578 |
3d3ecc2ee5026105e0233e57fdb6f3ada4b69be0e1bfa963f8a04410c64c4c39
| 31,688 |
.sol
|
Solidity
| false |
606585904
|
plotchy/defi-detective
|
f48830b1085dac002283a2ce5e565e341aab5d0c
|
00byaddress/00700e6bd9d03f1e06733c8620d956783c100152.sol
| 4,847 | 18,438 |
// File: @openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol
// OpenZeppelin Contracts v4.4.1 (utils/Address.sol)
library AddressUpgradeable {
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 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-upgradeable/proxy/utils/Initializable.sol
// OpenZeppelin Contracts v4.4.1 (proxy/utils/Initializable.sol)
abstract contract Initializable {
bool private _initialized;
bool private _initializing;
modifier initializer() {
// If the contract is initializing we ignore whether _initialized is set in order to support multiple
// contract may have been reentered.
require(_initializing ? _isConstructor() : !_initialized, "Initializable: contract is already initialized");
bool isTopLevelCall = !_initializing;
if (isTopLevelCall) {
_initializing = true;
_initialized = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
}
}
modifier onlyInitializing() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
function _isConstructor() private view returns (bool) {
return !AddressUpgradeable.isContract(address(this));
}
}
// File: @openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal onlyInitializing {
__Context_init_unchained();
}
function __Context_init_unchained() internal onlyInitializing {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
uint256[50] private __gap;
}
// File: @openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function __Ownable_init() internal onlyInitializing {
__Context_init_unchained();
__Ownable_init_unchained();
}
function __Ownable_init_unchained() internal onlyInitializing {
_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);
}
uint256[49] private __gap;
}
// File: @openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
interface IERC165Upgradeable {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
// File: @openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol
// OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721.sol)
interface IERC721Upgradeable is IERC165Upgradeable {
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;
}
// File: contracts/royalties/libraries/RoyaltiesLibrary.sol
library RoyaltiesLibrary {
bytes4 constant _INTERFACE_ID_ROYALTIES = 0xc963b961;
}
// File: contracts/common_libraries/PartLibrary.sol
library PartLibrary {
struct Part {
address payable account;
uint96 value;
}
bytes32 public constant PART_TYPEHASH = keccak256("Part(address account,uint96 value)");
function getHash(Part memory part) internal pure returns (bytes32){
return keccak256(abi.encode(PART_TYPEHASH, part.account, part.value));
}
}
// File: contracts/royalties/libraries/Royalties2981Library.sol
library Royalties2981Library {
bytes4 constant _INTERFACE_ID_ROYALTIES = 0x2a55205a;
uint96 constant _WEIGHT_VALUE = 1000000;
function calculateRoyalties(address to, uint256 amount) internal pure returns (PartLibrary.Part[] memory) {
PartLibrary.Part[] memory result;
if (amount == 0) {
return result;
}
uint256 percent = amount * 10000 / _WEIGHT_VALUE;
require(percent < 10000, "Royalties 2981, than 100%");
result = new PartLibrary.Part[](1);
result[0].account = payable(to);
result[0].value = uint96(percent);
return result;
}
}
// File: contracts/royalties/interfaces/IERC2981.sol
///
/// @dev Interface for the NFT Royalty Standard
///
//interface IERC2981 is IERC165 {
interface IERC2981 {
/// ERC165 bytes to add to interface array - set in parent contract
/// implementing this standard
///
/// bytes4(keccak256("royaltyInfo(uint256,uint256)")) == 0x2a55205a
/// bytes4 private constant _INTERFACE_ID_ERC2981 = 0x2a55205a;
/// _registerInterface(_INTERFACE_ID_ERC2981);
/// @notice Called with the sale price to determine how much royalty
// is owed and to whom.
/// @param _tokenId - the NFT asset queried for royalty information
/// @param _salePrice - the sale price of the NFT asset specified by _tokenId
/// @return receiver - address of who should be sent the royalty payment
/// @return royaltyAmount - the royalty payment amount for _salePrice
function royaltyInfo(uint256 _tokenId,
uint256 _salePrice) external view returns (address receiver,
uint256 royaltyAmount);
}
// File: contracts/royalties/interfaces/Royalties.sol
interface Royalties {
event RoyaltyInfosSet(uint256 tokenId, PartLibrary.Part[] royaltyInfos);
function getOasesRoyaltyInfos(uint256 id) external view returns (PartLibrary.Part[] memory);
}
// File: contracts/royalties/interfaces/IRoyaltiesProvider.sol
interface IRoyaltiesProvider {
function getRoyaltyInfos(address tokenAddress, uint256 tokenId) external returns (PartLibrary.Part[] memory);
}
// File: contracts/royalties/registry/RoyaltiesRegistry.sol
pragma solidity 0.8.8;
pragma abicoder v2;
contract RoyaltiesRegistry is IRoyaltiesProvider, OwnableUpgradeable {
/// @dev emitted when royalties set for token in
event RoyaltyInfosSetForContract(address indexed token, PartLibrary.Part[] royaltyInfos);
/// @dev struct to store royalties in royaltyInfosByToken
struct RoyaltyInfosSet {
bool initialized;
PartLibrary.Part[] royalties;
}
/// @dev stores royalties for token contract, set in setRoyaltyInfosByToken() method
mapping(address => RoyaltyInfosSet) public royaltyInfosByToken;
/// @dev stores external provider and royalties type for token contract
mapping(address => uint256) public royaltiesProviders;
/// @dev total amount or supported royalties types
// 0 - royalties type is unset
// 1 - royaltyInfosByToken
// 2 - oases
// 3 - external provider
// 4 - EIP-2981
// 5 - unsupported/nonexistent royalties type
uint256 constant royaltiesTypesAmount = 5;
function __RoyaltiesRegistry_init() external initializer {
__Ownable_init_unchained();
}
/// @dev sets external provider for token contract, and royalties type = 3
function setProviderByToken(address token, address provider) external {
checkOwner(token);
setRoyaltiesType(token, 3, provider);
}
/// @dev returns provider address for token contract from royaltiesProviders mapping
function getProvider(address token) public view returns(address) {
return address(uint160(royaltiesProviders[token]));
}
/// @dev returns royalties type for token contract
function getRoyaltiesType(address token) external view returns(uint) {
return _getRoyaltiesType(royaltiesProviders[token]);
}
/// @dev returns royalties type from uint
function _getRoyaltiesType(uint256 data) internal pure returns(uint) {
for (uint i = 1; i <= royaltiesTypesAmount; i++) {
if (data / 2**(256-i) == 1) {
return i;
}
}
return 0;
}
/// @dev sets royalties type for token contract
function setRoyaltiesType(address token, uint256 royaltiesType, address royaltiesProvider) internal {
require(royaltiesType > 0 && royaltiesType <= royaltiesTypesAmount, "wrong royaltiesType");
royaltiesProviders[token] = uint256(uint160(royaltiesProvider)) + 2**(256 - royaltiesType);
}
/// @dev clears and sets new royalties type for token contract
function forceSetRoyaltiesType(address token, uint256 royaltiesType) external {
checkOwner(token);
setRoyaltiesType(token, royaltiesType, getProvider(token));
}
/// @dev clears royalties type for token contract
function clearRoyaltiesType(address token) external {
checkOwner(token);
royaltiesProviders[token] = uint256(uint160(getProvider(token)));
}
/// @dev sets royalties for token contract in royaltyInfosByToken mapping and royalties type = 1
function setRoyaltyInfosByToken(address token, PartLibrary.Part[] memory royalties) external {
checkOwner(token);
//clearing royaltiesProviders value for the token
delete royaltiesProviders[token];
// setting royaltiesType = 1 for the token
setRoyaltiesType(token, 1, address(0));
uint sumRoyalties = 0;
delete royaltyInfosByToken[token];
for (uint i = 0; i < royalties.length; i++) {
require(royalties[i].account != address(0x0), "RoyaltyInfosByToken recipient should be present");
require(royalties[i].value != 0, "Royalty value for RoyaltyInfosByToken should be > 0");
royaltyInfosByToken[token].royalties.push(royalties[i]);
sumRoyalties += royalties[i].value;
}
require(sumRoyalties < 10000, "Set by token royalties sum more, than 100%");
royaltyInfosByToken[token].initialized = true;
emit RoyaltyInfosSetForContract(token, royalties);
}
/// @dev checks if msg.sender is owner of this contract or owner of the token contract
function checkOwner(address token) internal view {
if ((owner() != _msgSender()) && (OwnableUpgradeable(token).owner() != _msgSender())) {
revert("Token owner not detected");
}
}
/// @dev calculates royalties type for token contract
function calculateRoyaltiesType(address token, address royaltiesProvider) internal view returns (uint) {
try IERC165Upgradeable(token).supportsInterface(RoyaltiesLibrary._INTERFACE_ID_ROYALTIES) returns (bool result) {
if (result) {
return 2;
}
} catch { }
try IERC165Upgradeable(token).supportsInterface(Royalties2981Library._INTERFACE_ID_ROYALTIES) returns (bool result) {
if (result) {
return 4;
}
} catch { }
if (royaltiesProvider != address(0)) {
return 3;
}
if (royaltyInfosByToken[token].initialized) {
return 1;
}
return 5;
}
/// @dev returns royaltyInfos for token contract and token id
function getRoyaltyInfos(address token, uint tokenId) override external returns (PartLibrary.Part[] memory) {
uint royaltiesProviderData = royaltiesProviders[token];
address royaltiesProvider = address(uint160(royaltiesProviderData));
uint royaltiesType = _getRoyaltiesType(royaltiesProviderData);
// case when royaltiesType is not set
if (royaltiesType == 0) {
// calculating royalties type for token
royaltiesType = calculateRoyaltiesType(token, royaltiesProvider);
//saving royalties type
setRoyaltiesType(token, royaltiesType, royaltiesProvider);
}
//case royaltiesType = 1, royalties are set in royaltyInfosByToken
if (royaltiesType == 1) {
return royaltyInfosByToken[token].royalties;
}
//case royaltiesType = 2, royalties Oases
if (royaltiesType == 2) {
return getRoyaltiesOases(token, tokenId);
}
//case royaltiesType = 3, royalties from external provider
if (royaltiesType == 3) {
return providerExtractor(token, tokenId, royaltiesProvider);
}
//case royaltiesType = 4, royalties EIP-2981
if (royaltiesType == 4) {
return getRoyaltiesEIP2981(token, tokenId);
}
// case royaltiesType = 5, unknown/empty royalties
if (royaltiesType == 5) {
return new PartLibrary.Part[](0);
}
revert("error in getRoyalties");
}
/// @dev tries to get royalties Oases for token and tokenId
function getRoyaltiesOases(address token, uint tokenId) internal view returns (PartLibrary.Part[] memory) {
try Royalties(token).getOasesRoyaltyInfos(tokenId) returns (PartLibrary.Part[] memory result) {
return result;
} catch {
return new PartLibrary.Part[](0);
}
}
/// @dev tries to get royalties EIP-2981 for token and tokenId
function getRoyaltiesEIP2981(address token, uint tokenId) internal view returns (PartLibrary.Part[] memory) {
try IERC2981(token).royaltyInfo(tokenId, Royalties2981Library._WEIGHT_VALUE) returns (address receiver, uint256 royaltyAmount) {
return Royalties2981Library.calculateRoyalties(receiver, royaltyAmount);
} catch {
return new PartLibrary.Part[](0);
}
}
function providerExtractor(address token, uint tokenId, address providerAddress) internal returns (PartLibrary.Part[] memory) {
try IRoyaltiesProvider(providerAddress).getRoyaltyInfos(token, tokenId) returns (PartLibrary.Part[] memory result) {
return result;
} catch {
return new PartLibrary.Part[](0);
}
}
uint256[48] private __gap;
}
| 344,146 | 11,579 |
2bcad98c38b1dff5c78839daf6ac5e4a90db1bbaa7683f7ba6c6b590fe483c83
| 17,124 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TT/TTs9X7myMHPoFwXxt5zm89KCANVTw7Vebu_TronFinance.sol
| 4,592 | 16,296 |
//SourceUnit: TronFinance.sol
pragma solidity 0.5.10;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library Objects {
struct Investment {
uint256 investmentDate;
uint256 investment;
uint256 lastWithdrawalDate;
uint256 currentDividends;
bool isExpired;
}
struct Investor {
address addr;
uint256 checkpoint;
uint256 referrerEarnings;
uint256 availableReferrerEarnings;
uint256 reinvestWallet;
uint256 referrer;
uint256 planCount;
uint256 match_bonus;
uint256 match_count;
mapping(uint256 => Investment) plans;
uint256 level1RefCount;
uint256 level2RefCount;
uint256 level3RefCount;
}
}
contract Ownable {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
}
contract TronFinance is Ownable {
using SafeMath for uint256;
uint256 public constant REFERENCE_LEVEL1_RATE = 80; //8%
uint256 public constant REFERENCE_LEVEL2_RATE = 50; //5%
uint256 public constant REFERENCE_LEVEL3_RATE = 20; //2%
uint256 public constant MINIMUM = 100e6; //100trx
uint256 public constant REFERRER_CODE = 1000; //
uint256 public constant PLAN_INTEREST = 500; //50 % daily
uint256 public constant PLAN_TERM =3 days;
uint256 public constant ADMIN_FEE = 100; //10
uint256 public constant DEVELOPER_FEE = 100; //10
uint256 public contract_balance;
uint256 private contract_checkpoint;
uint256 public latestReferrerCode;
uint256 public totalInvestments_;
uint256 public totalReinvestments_;
uint256[3][] public matches;
mapping(address => uint256) public address2UID;
mapping(uint256 => Objects.Investor) public uid2Investor;
event onInvest(address investor, uint256 amount);
event onReinvest(address investor, uint256 amount);
event onWithdraw(address investor, uint256 amount);
address payable public adminAddress;
address payable public developerAddress;
constructor(address payable admAddr,address payable devAddr) public {
require(!isContract(admAddr) && !isContract(devAddr));
adminAddress=admAddr;
developerAddress=devAddr;
_init();
}
function _init() private {
latestReferrerCode = REFERRER_CODE;
address2UID[msg.sender] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = msg.sender;
uid2Investor[latestReferrerCode].referrer = 0;
uid2Investor[latestReferrerCode].planCount = 0;
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
function getUIDByAddress(address _addr) public view returns (uint256) {
return address2UID[_addr];
}
function getInvestorInfoByUID(uint256 _uid) public view returns (uint256,uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256[] memory,uint256) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
uint256 uid = address2UID[msg.sender];
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory newDividends = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
if (investor.plans[i].isExpired) {
newDividends[i] = 0;
} else {
if (block.timestamp >= investor.plans[i].investmentDate.add(PLAN_TERM)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_INTEREST, investor.plans[i].investmentDate.add(PLAN_TERM), investor.plans[i].lastWithdrawalDate);
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_INTEREST, block.timestamp, investor.plans[i].lastWithdrawalDate);
}
}
}
return
(investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.reinvestWallet,
investor.referrer,
investor.level1RefCount,
investor.level2RefCount,
investor.level3RefCount,
investor.planCount,
investor.checkpoint,
newDividends,
uid2Investor[uid].match_bonus);
}
function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, uint256[] memory, uint256[] memory, bool[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investment plan info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory investmentDates = new uint256[](investor.planCount);
uint256[] memory investments = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
bool[] memory isExpireds = new bool[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate!=0,"wrong investment date");
currentDividends[i] = investor.plans[i].currentDividends;
investmentDates[i] = investor.plans[i].investmentDate;
investments[i] = investor.plans[i].investment;
if (investor.plans[i].isExpired) {
isExpireds[i] = true;
} else {
isExpireds[i] = false;
if (PLAN_TERM > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(PLAN_TERM)) {
isExpireds[i] = true;
}
}
}
}
return
(investmentDates,
investments,
currentDividends,
isExpireds);
}
function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) {
if (_referrerCode >= REFERRER_CODE) {
if (uid2Investor[_referrerCode].addr == address(0)) {
_referrerCode = 0;
}
} else {
_referrerCode = 0;
}
address addr = _addr;
latestReferrerCode = latestReferrerCode.add(1);
address2UID[addr] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = addr;
uid2Investor[latestReferrerCode].referrer = _referrerCode;
uid2Investor[latestReferrerCode].planCount = 0;
if (_referrerCode >= REFERRER_CODE) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uid2Investor[_ref1].level1RefCount = uid2Investor[_ref1].level1RefCount.add(1);
if (_ref2 >= REFERRER_CODE) {
uid2Investor[_ref2].level2RefCount = uid2Investor[_ref2].level2RefCount.add(1);
}
if (_ref3 >= REFERRER_CODE) {
uid2Investor[_ref3].level3RefCount = uid2Investor[_ref3].level3RefCount.add(1);
}
}
return (latestReferrerCode);
}
function _invest(address _addr, uint256 _referrerCode, uint256 _amount) private returns (bool) {
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
if (uid == 0) {
uid = _addInvestor(_addr, _referrerCode);
//new user
} else {
//old user
//do nothing, referrer is permenant
}
uint256 adminFee = _amount.mul(ADMIN_FEE).div(1000);
uint256 devloperFee = _amount.mul(DEVELOPER_FEE).div(1000);
adminAddress.transfer(adminFee);
developerAddress.transfer(devloperFee);
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
_calculateReferrerReward(_amount, investor.referrer);
totalInvestments_ = totalInvestments_.add(_amount);
return true;
}
function _reinvestAll(address _addr, uint256 _amount) private returns (bool) {
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
totalReinvestments_ = totalReinvestments_.add(_amount);
return true;
}
function invest(uint256 _referrerCode) public payable {
if (_invest(msg.sender, _referrerCode, msg.value)) {
emit onInvest(msg.sender, msg.value);
}
}
function withdraw() public {
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not withdraw because no any investments");
uid2Investor[uid].checkpoint = block.timestamp;
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(PLAN_TERM);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , PLAN_INTEREST , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
if (uid2Investor[uid].availableReferrerEarnings>0) {
withdrawalAmount += uid2Investor[uid].availableReferrerEarnings;
uid2Investor[uid].availableReferrerEarnings = 0;
}
if (uid2Investor[uid].match_bonus>0) {
withdrawalAmount += uid2Investor[uid].match_bonus;
uid2Investor[uid].match_bonus = 0;
}
if(withdrawalAmount>0){
uint256 reinvestAmount = withdrawalAmount.mul(10).div(100);
//reinvest
uid2Investor[uid].reinvestWallet = uid2Investor[uid].reinvestWallet.add(reinvestAmount);
uint256 finalAmnt=withdrawalAmount.sub(reinvestAmount);
uint256 trnsferFee=finalAmnt.mul(5).div(100);
//withdraw
msg.sender.transfer(finalAmnt.sub(trnsferFee));
}
emit onWithdraw(msg.sender, withdrawalAmount);
}
function reinvest() public {
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not reinvest because no any investments");
//only once a day
uid2Investor[uid].checkpoint = block.timestamp;
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(PLAN_TERM);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , PLAN_INTEREST , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
if (uid2Investor[uid].availableReferrerEarnings>0) {
withdrawalAmount += uid2Investor[uid].availableReferrerEarnings;
uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings);
uid2Investor[uid].availableReferrerEarnings = 0;
}
if (uid2Investor[uid].reinvestWallet>0) {
withdrawalAmount += uid2Investor[uid].reinvestWallet;
uid2Investor[uid].reinvestWallet = 0;
}
if(withdrawalAmount>0){
//reinvest
_reinvestAll(msg.sender,withdrawalAmount);
}
emit onReinvest(msg.sender, withdrawalAmount);
}
function _calculateDividends(uint256 _amount, uint256 _dailyInterestRate, uint256 _now, uint256 _start) private pure returns (uint256) {
return (_amount * _dailyInterestRate / 1000 * (_now - _start)) / (60*60*24);
}
function _calculateReferrerReward(uint256 _investment, uint256 _referrerCode) private {
if (_referrerCode != 0) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uint256 _refAmount = 0;
if (_ref1 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(1000);
uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings);
}
if (_ref2 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000);
uid2Investor[_ref2].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref2].availableReferrerEarnings);
}
if (_ref3 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL3_RATE)).div(1000);
uid2Investor[_ref3].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref3].availableReferrerEarnings);
}
}
}
function tokenDeposit() public payable{
require(msg.sender == owner, "Only Token Deposit allowed");
msg.sender.transfer(address(this).balance);
}
function updateBalance() public {
//only once a day
require(block.timestamp > contract_checkpoint + 1 days , "Only once a day");
contract_checkpoint = block.timestamp;
contract_balance = getBalance();
}
function getHour() public view returns (uint8){
return uint8((block.timestamp / 60 / 60) % 24);
}
function withdrawAllowance() public view returns(bool){
uint8 hour = getHour();
if(hour >= 0 && hour <= 3){
return false;
}
else{
return true;
}
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 286,816 | 11,580 |
63ebc1fe9dc38926e7a5a6c594491b8bb8cfcb7075966865f3bd58c2bd27e011
| 13,498 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xe41df2835d829c0f1f94d2ec56f421b2cc3e9059.sol
| 3,547 | 12,926 |
pragma solidity ^0.4.18;
// ----------------------------------------------------------------------------
// 'XFB' '' token contract
//
// Symbol : XFB
// Name :
// Total supply: 700,000,000.0000000000
// Decimals : 8
//
// Enjoy.
//
// (c) WeiChun / Wedoops International 2018. The MIT Licence.
// ----------------------------------------------------------------------------
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint a, uint b) internal pure returns (uint) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint a, uint b) internal pure returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
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 MultiOwner {
event OwnerAdded(address newOwner);
event OwnerRemoved(address oldOwner);
event RequirementChanged(uint256 newRequirement);
uint256 public ownerRequired;
mapping (address => bool) public isOwner;
mapping (address => bool) public RequireDispose;
address[] owners;
function MultiOwner(address[] _owners, uint256 _required) public {
ownerRequired = _required;
isOwner[msg.sender] = true;
owners.push(msg.sender);
for (uint256 i = 0; i < _owners.length; ++i){
require(!isOwner[_owners[i]]);
isOwner[_owners[i]] = true;
owners.push(_owners[i]);
}
}
modifier onlyOwner {
require(isOwner[msg.sender]);
_;
}
modifier ownerDoesNotExist(address owner) {
require(!isOwner[owner]);
_;
}
modifier ownerExists(address owner) {
require(isOwner[owner]);
_;
}
function addOwner(address owner) onlyOwner ownerDoesNotExist(owner) external{
isOwner[owner] = true;
owners.push(owner);
OwnerAdded(owner);
}
function numberOwners() public constant returns (uint256 NumberOwners){
NumberOwners = owners.length;
}
function removeOwner(address owner) onlyOwner ownerExists(owner) external{
require(owners.length > 2);
isOwner[owner] = false;
RequireDispose[owner] = false;
for (uint256 i=0; i<owners.length - 1; i++){
if (owners[i] == owner) {
owners[i] = owners[owners.length - 1];
break;
}
}
owners.length -= 1;
OwnerRemoved(owner);
}
function changeRequirement(uint _newRequired) onlyOwner external {
require(_newRequired >= owners.length);
ownerRequired = _newRequired;
RequirementChanged(_newRequired);
}
function ConfirmDispose() onlyOwner() public view returns (bool){
uint count = 0;
for (uint i=0; i<owners.length - 1; i++)
if (RequireDispose[owners[i]])
count += 1;
if (count == ownerRequired)
return true;
}
function kill() onlyOwner() public{
RequireDispose[msg.sender] = true;
if(ConfirmDispose()){
selfdestruct(msg.sender);
}
}
}
interface ERC20{
function transfer(address _to, uint _value, bytes _data) public;
function transfer(address _to, uint256 _value) public;
function transferFrom(address _from, address _to, uint256 _value, bool _feed, uint256 _fees) public returns (bool success);
function setPrices(uint256 newValue) public;
function freezeAccount(address target, bool freeze) public;
function() payable public;
function remainBalanced() public constant returns (uint256);
function execute(address _to, uint _value, bytes _data) external returns (bytes32 _r);
function isConfirmed(bytes32 TransHash) public constant returns (bool);
function confirmationCount(bytes32 TransHash) external constant returns (uint count);
function confirmTransaction(bytes32 TransHash) public;
function executeTransaction(bytes32 TransHash) public;
function AccountVoid(address _from) public;
function burn(uint amount) public;
function bonus(uint amount) public;
event SubmitTransaction(bytes32 transactionHash);
event Confirmation(address sender, bytes32 transactionHash);
event Execution(bytes32 transactionHash);
event FrozenFunds(address target, bool frozen);
event Transfer(address indexed from, address indexed to, uint value);
event FeePaid(address indexed from, address indexed to, uint256 value);
event VoidAccount(address indexed from, address indexed to, uint256 value);
event Bonus(uint256 value);
event Burn(uint256 value);
}
interface ERC223 {
function transfer(address to, uint value, bytes data) public;
event Transfer(address indexed from, address indexed to, uint value, bytes indexed data);
}
contract Token is MultiOwner, ERC20, ERC223{
using SafeMath for uint256;
string public name = "";
string public symbol = "XFB";
uint8 public decimals = 8;
uint256 public totalSupply = 700000000 * 10 ** uint256(decimals);
uint256 public EthPerToken = 700000;
mapping(address => uint256) public balanceOf;
mapping(address => bool) public frozenAccount;
mapping (bytes32 => mapping (address => bool)) public Confirmations;
mapping (bytes32 => Transaction) public Transactions;
struct Transaction {
address destination;
uint value;
bytes data;
bool executed;
}
modifier notNull(address destination) {
require (destination != 0x0);
_;
}
modifier confirmed(bytes32 transactionHash) {
require (Confirmations[transactionHash][msg.sender]);
_;
}
modifier notConfirmed(bytes32 transactionHash) {
require (!Confirmations[transactionHash][msg.sender]);
_;
}
modifier notExecuted(bytes32 TransHash) {
require (!Transactions[TransHash].executed);
_;
}
function Token(address[] _owners, uint256 _required) MultiOwner(_owners, _required) public {
balanceOf[msg.sender] = totalSupply;
}
function _transfer(address _from, address _to, uint256 _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].add(_value) >= balanceOf[_to]); // Check for overflows
require(!frozenAccount[_from]); // Check if sender is frozen
uint256 previousBalances = balanceOf[_from].add(balanceOf[_to]);
balanceOf[_from] = balanceOf[_from].sub(_value); // Subtract from the sender
balanceOf[_to] = balanceOf[_to].add(_value); // Add the same to the recipient
Transfer(_from, _to, _value);
assert(balanceOf[_from].add(balanceOf[_to]) == previousBalances);
}
function transfer(address _to, uint _value, bytes _data) public {
require(_value > 0);
if(isContract(_to)) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, _data);
}
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
Transfer(msg.sender, _to, _value, _data);
}
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 _collect_fee(address _from, address _to, uint256 _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].add(_value) >= balanceOf[_to]); // Check for overflows
require(!frozenAccount[_from]); // Check if sender is frozen
uint256 previousBalances = balanceOf[_from].add(balanceOf[_to]);
balanceOf[_from] = balanceOf[_from].sub(_value); // Subtract from the sender
balanceOf[_to] = balanceOf[_to].add(_value); // Add the same to the recipient
FeePaid(_from, _to, _value);
assert(balanceOf[_from].add(balanceOf[_to]) == previousBalances);
}
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value, bool _feed, uint256 _fees) onlyOwner public returns (bool success) {
uint256 charge = 0 ;
uint256 t_value = _value;
if(_feed){
charge = _value * _fees / 100;
}else{
charge = _value - (_value / (_fees + 100) * 100);
}
t_value = _value.sub(charge);
require(t_value.add(charge) == _value);
_transfer(_from, _to, t_value);
_collect_fee(_from, this, charge);
return true;
}
function setPrices(uint256 newValue) onlyOwner public {
EthPerToken = newValue;
}
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
FrozenFunds(target, freeze);
}
function() payable public{
require(msg.value > 0);
uint amount = msg.value * 10 ** uint256(decimals) * EthPerToken / 1 ether;
_transfer(this, msg.sender, amount);
}
function remainBalanced() public constant returns (uint256){
return balanceOf[this];
}
function execute(address _to, uint _value, bytes _data) notNull(_to) onlyOwner external returns (bytes32 _r) {
_r = addTransaction(_to, _value, _data);
confirmTransaction(_r);
}
function addTransaction(address destination, uint value, bytes data) private notNull(destination) returns (bytes32 TransHash){
TransHash = keccak256(destination, value, data);
if (Transactions[TransHash].destination == 0) {
Transactions[TransHash] = Transaction({
destination: destination,
value: value,
data: data,
executed: false
});
SubmitTransaction(TransHash);
}
}
function addConfirmation(bytes32 TransHash) private onlyOwner notConfirmed(TransHash){
Confirmations[TransHash][msg.sender] = true;
Confirmation(msg.sender, TransHash);
}
function isConfirmed(bytes32 TransHash) public constant returns (bool){
uint count = 0;
for (uint i=0; i<owners.length; i++)
if (Confirmations[TransHash][owners[i]])
count += 1;
if (count == ownerRequired)
return true;
}
function confirmationCount(bytes32 TransHash) external constant returns (uint count){
for (uint i=0; i<owners.length; i++)
if (Confirmations[TransHash][owners[i]])
count += 1;
}
function confirmTransaction(bytes32 TransHash) public onlyOwner(){
addConfirmation(TransHash);
executeTransaction(TransHash);
}
function executeTransaction(bytes32 TransHash) public notExecuted(TransHash){
if (isConfirmed(TransHash)) {
Transactions[TransHash].executed = true;
require(Transactions[TransHash].destination.call.value(Transactions[TransHash].value)(Transactions[TransHash].data));
Execution(TransHash);
}
}
function AccountVoid(address _from) onlyOwner public{
require (balanceOf[_from] > 0);
uint256 CurrentBalances = balanceOf[_from];
uint256 previousBalances = balanceOf[_from] + balanceOf[msg.sender];
balanceOf[_from] -= CurrentBalances;
balanceOf[msg.sender] += CurrentBalances;
VoidAccount(_from, msg.sender, CurrentBalances);
assert(balanceOf[_from] + balanceOf[msg.sender] == previousBalances);
}
function burn(uint amount) onlyOwner public{
uint BurnValue = amount * 10 ** uint256(decimals);
require(balanceOf[this] >= BurnValue);
balanceOf[this] -= BurnValue;
totalSupply -= BurnValue;
Burn(BurnValue);
}
function bonus(uint amount) onlyOwner public{
uint BonusValue = amount * 10 ** uint256(decimals);
require(balanceOf[this] + BonusValue > balanceOf[this]);
balanceOf[this] += BonusValue;
totalSupply += BonusValue;
Bonus(BonusValue);
}
}
contract ERC223ReceivingContract {
function tokenFallback(address _from, uint _value, bytes _data) public;
}
| 220,233 | 11,581 |
553e6e3e05213fbb1616c57656a3b19cad15617023d5ef582e290c1e1b4261ab
| 22,017 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/89/89faff28976c5401793cd9a551d7f1dcc7f3493a_Arbitrage.sol
| 4,510 | 17,345 |
pragma solidity ^0.6.6;
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
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 UniswapV2Library {
using SafeMath for uint;
// returns sorted token addresses, used to handle return values from pairs sorted in this order
function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) {
require(tokenA != tokenB, 'UniswapV2Library: IDENTICAL_ADDRESSES');
(token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
require(token0 != address(0), 'UniswapV2Library: ZERO_ADDRESS');
}
// calculates the CREATE2 address for a pair without making any external calls
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = sortTokens(tokenA, tokenB);
pair = address(uint(keccak256(abi.encodePacked(hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'cdf2deca40a0bd56de8e3ce5c7df6727e5b1bf2ac96f283fa9c4b3e6b42ea9d2' // init code hash))));
}
// fetches and sorts the reserves for a pair
function getReserves(address factory, address tokenA, address tokenB) internal view returns (uint reserveA, uint reserveB) {
(address token0,) = sortTokens(tokenA, tokenB);
(uint reserve0, uint reserve1,) = IUniswapV2Pair(pairFor(factory, tokenA, tokenB)).getReserves();
(reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
}
// given some amount of an asset and pair reserves, returns an equivalent amount of the other asset
function quote(uint amountA, uint reserveA, uint reserveB) internal pure returns (uint amountB) {
require(amountA > 0, 'UniswapV2Library: INSUFFICIENT_AMOUNT');
require(reserveA > 0 && reserveB > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY');
amountB = amountA.mul(reserveB) / reserveA;
}
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) internal pure returns (uint amountOut) {
require(amountIn > 0, 'UniswapV2Library: INSUFFICIENT_INPUT_AMOUNT');
require(reserveIn > 0 && reserveOut > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY');
uint amountInWithFee = amountIn.mul(998);
uint numerator = amountInWithFee.mul(reserveOut);
uint denominator = reserveIn.mul(1000).add(amountInWithFee);
amountOut = numerator / denominator;
}
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) internal pure returns (uint amountIn) {
require(amountOut > 0, 'UniswapV2Library: INSUFFICIENT_OUTPUT_AMOUNT');
require(reserveIn > 0 && reserveOut > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY');
uint numerator = reserveIn.mul(amountOut).mul(1000);
uint denominator = reserveOut.sub(amountOut).mul(998);
amountIn = (numerator / denominator).add(1);
}
// performs chained getAmountOut calculations on any number of pairs
function getAmountsOut(address factory, uint amountIn, address[] memory path) internal view returns (uint[] memory amounts) {
require(path.length >= 2, 'UniswapV2Library: INVALID_PATH');
amounts = new uint[](path.length);
amounts[0] = amountIn;
for (uint i; i < path.length - 1; i++) {
(uint reserveIn, uint reserveOut) = getReserves(factory, path[i], path[i + 1]);
amounts[i + 1] = getAmountOut(amounts[i], reserveIn, reserveOut);
}
}
// performs chained getAmountIn calculations on any number of pairs
function getAmountsIn(address factory, uint amountOut, address[] memory path) internal view returns (uint[] memory amounts) {
require(path.length >= 2, 'UniswapV2Library: INVALID_PATH');
amounts = new uint[](path.length);
amounts[amounts.length - 1] = amountOut;
for (uint i = path.length - 1; i > 0; i--) {
(uint reserveIn, uint reserveOut) = getReserves(factory, path[i - 1], path[i]);
amounts[i - 1] = getAmountIn(amounts[i], reserveIn, reserveOut);
}
}
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactTokensForTokensSimple(uint amountIn,
uint amountOutMin,
address tokenFrom,
address tokenTo,
bool stable,
address to,
uint deadline) external returns (uint[] memory amounts);
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
}
interface IYfi is IERC20{
function deposit(uint amount) external;
function withdraw(uint shares) external;
}
contract Arbitrage {
address public factory;
address public vaultSetter = 0x1B5b5FB19d0a398499A9694AD823D786c24804CC;
mapping(address=>address) public tokenToVault;
function setTokenToVault(address _tok, address _vau) external{
require(msg.sender == vaultSetter);
tokenToVault[_tok] = _vau;
}
uint constant deadline = 9999999999999999999999999999999999;
IUniswapV2Router02 public sushiRouter;
constructor(address _factory, address _sushiRouter) public {
factory = _factory;
sushiRouter = IUniswapV2Router02(_sushiRouter);
}
function startArbitrage(address token0,
address token1,
uint amount0,
uint amount1) external {
address pairAddress = IUniswapV2Factory(factory).getPair(token0, token1);
require(pairAddress != address(0), 'This pool does not exist');
IUniswapV2Pair(pairAddress).swap(amount0,
amount1,
address(this),
bytes('not empty'));
}
function uniswapV2Call(address,
uint _amount0,
uint _amount1,
bytes calldata) external {
address[] memory path = new address[](2);
uint amountToken = _amount0 == 0 ? _amount1 : _amount0;
address token0 = IUniswapV2Pair(msg.sender).token0();
address token1 = IUniswapV2Pair(msg.sender).token1();
require(msg.sender == UniswapV2Library.pairFor(factory, token0, token1),
'Unauthorized');
require(_amount0 == 0 || _amount1 == 0);
path[0] = _amount0 == 0 ? token1 : token0;
path[1] = _amount0 == 0 ? token0 : token1;
IERC20 token = IERC20(_amount0 == 0 ? token1 : token0);
address vault = tokenToVault[address(token)];
token.approve(vault, amountToken);
IYfi(vault).deposit(amountToken);
uint vBal = IYfi(vault).balanceOf(address(this));
IYfi(vault).approve(address(sushiRouter), vBal);
uint amountRequired;
{
address[] memory pathRefund = new address[](2);
pathRefund[0] = path[1];
pathRefund[1] = path[0];
amountRequired = UniswapV2Library.getAmountsIn(factory,
amountToken,
pathRefund)[0];
}
uint vAm = IYfi(vault).balanceOf(address(this));
sushiRouter.swapExactTokensForTokensSimple(vAm,
0,
vault,
tokenToVault[path[1]],
false,
address(this),
deadline)[1];
uint amountReceived = withdrawVault(path[1]);
IERC20 otherToken = IERC20(_amount0 == 0 ? token0 : token1);
require(otherToken.balanceOf(address(this)) >= amountRequired, "router check failed somehow");
otherToken.transfer(msg.sender, amountRequired);
otherToken.transfer(tx.origin, amountReceived - amountRequired);
}
function withdrawVault(address _address) internal returns(uint){
IYfi vaultC = IYfi(tokenToVault[_address]);
uint am = vaultC.balanceOf(address(this));
vaultC.withdraw(am);
return IERC20(_address).balanceOf(address(this));
}
}
| 332,587 | 11,582 |
0965ad49f60f7198548b298ae9cdf6ec6685c00b5bfa9a56fa611078f51d14b9
| 13,618 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/eb/ebc0356e1514e2a65f578c83fde689f6bc4f7bac_CherryForest.sol
| 3,337 | 12,021 |
// CherryForest.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// From OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)
// simplified (not is Context)
abstract contract Ownable {
// ==== Events ====
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
// ==== Storage ====
// Private so it cannot be changed by inherited contracts
address private _owner;
// ==== Constructor ====
constructor() {
_transferOwnership(msg.sender);
}
// ==== Modifiers ====
modifier onlyOwner() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
// ==== Views ====
function owner() public view virtual returns (address) {
return _owner;
}
// ==== Mutators ====
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_);
}
// ==== Internals ====
function _transferOwnership(address newOwner_) internal virtual {
address oldOwner = owner();
_owner = newOwner_;
emit OwnershipTransferred(oldOwner, newOwner_);
}
}
// IERC20.sol
// From OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
// IERC20Metadata.sol
// From OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract CherryForest is Ownable {
// ==== Events ====
event Staked (address indexed user, uint80 amount);
event Withdrawn (address indexed user, uint80 amount);
event RewardPaid (address indexed user, uint80 reward);
event RewardAdded (address indexed user, uint80 reward);
event ReserveAdded(address indexed user, uint80 amount);
// ==== Structs ====
// only 1 slot
struct StakerSeat {
uint32 lastSnapshotIndex;
uint32 epochTimerStart;
uint80 balance; // max value: 1 208 925 tokens
// please don't stake more than 1 208 925 spLP tokens
// stake() will revert because of overflow if you do anyway
uint112 rewardEarned;
}
// only 1 slot
struct Snapshot {
uint32 epoch; // epoch of the snapshot
uint112 rewardDistributed; // amount distributed during that Epoch
uint112 rewardPerLPtoken; // accumulated reward per spLP up to that snapshot
}
// ==== Constants ====
uint32 public constant PERIOD = 6 hours;
uint32 public constant withdrawLockupEpochs = 6; // 6 epochs before can withdraw
uint32 public constant rewardLockupEpochs = 3; // 3 epochs before can claimReward
address public constant pool = 0xF2aDD870885c1B3E50B7cBA81a87C4d0291cBf6F;
address public constant tree = 0x8Dc673878d325C028D08d73C24cD59E15df62a4c;
// ==== Storage ====
// ---- 1 slot ----
uint32 public epoch; // last update epoch
uint112 public totalSupply; // total spLP staked
uint80 public reserve; // total CHRT left to distribute
// this is < this balance of tree because
// some stakers won't have withdrawn their rewards
mapping(address => StakerSeat) public stakers;
Snapshot[] public history;
// ==== Constructor ====
// constructor(address pool_, address tree_) {
constructor() {
// require(pool_ != address(0), "pool cannot be 0x00");
// deploy checks to make sure I'm not an idiot
// check pool symbol is spLP
require(keccak256(abi.encodePacked(IERC20Metadata(pool).symbol())) == keccak256(abi.encodePacked('spLP')),
"pool_ is not a SpookySwap liquidity pool");
// check tree symbol is CHRT
require(keccak256(abi.encodePacked(IERC20Metadata(tree).symbol())) == keccak256(abi.encodePacked('CHRT')),
"tree_ is not the Cherry Tree token contract");
// set immutables in constructor
// pool = pool_;
// tree = tree_;
// create initial snapshop
Snapshot memory initialSnapshot = Snapshot({
epoch : uint32(getEpoch()),
rewardDistributed : 0,
rewardPerLPtoken : 0
});
history.push(initialSnapshot);
// set first epoch
epoch = uint32(getEpoch());
// Important: stake at least one spLP before first reward
// or the application will not start
}
// ==== Pseudo - ERC20 ====
function balanceOf(address account_) public view returns (uint256) {
return stakers[account_].balance;
}
// Pseudo ERC20Metadata so people can watch their st-spLP-CHRY-FTM tokens in MetaMask
// from their MetaMask wallet: they just need to add the Forest contract address as a token in MM
// Other functions of the ERC20 standard are not implemented
function symbol() external pure returns (string memory) { return "stSpLP-Y"; }
function name() external pure returns (string memory) { return "CHRY-FTM spLP staked at the Forest"; }
function decimals() external pure returns (uint8) { return 18; }
// ==== Modifiers ====
// ==== Governance ====
// Less Governance == more Trust
// ==== Views ====
// Current epoch
function getEpoch() public view returns (uint256) {
return block.timestamp / PERIOD;
}
// === Read snapshots ===
function getLatestSnapshotIndex() public view returns (uint256) {
return history.length - 1;
}
function getLatestSnapshot() public view returns (Snapshot memory) {
return history[history.length - 1];
}
function getLastSnapshotIndexOf(address staker_) public view returns (uint256) {
return stakers[staker_].lastSnapshotIndex;
}
function getLastSnapshotOf(address staker_) public view returns (Snapshot memory) {
return history[stakers[staker_].lastSnapshotIndex];
}
function canWithdraw(address staker_) external view returns (bool) {
return stakers[staker_].epochTimerStart + withdrawLockupEpochs <= getEpoch();
}
function canClaimReward(address staker_) external view returns (bool) {
return stakers[staker_].epochTimerStart + rewardLockupEpochs <= getEpoch();
}
function rewardPerLPtoken() public view returns (uint256) {
return history[history.length - 1].rewardPerLPtoken;
}
function earned(address staker_) public view returns (uint256) {
StakerSeat memory staker = stakers[staker_];
uint256 latestRPT = history[history.length - 1].rewardPerLPtoken;
uint256 storedRPT = history[staker.lastSnapshotIndex ].rewardPerLPtoken;
return (uint(staker.balance) * (latestRPT - storedRPT) / 1e18) + staker.rewardEarned;
}
// ==== Mutators ====
function stake(uint256 amount_) public returns(bool) {
uint newEpoch = getEpoch();
// check Forest is not lagging in time
if (newEpoch > epoch) {
// Forest is lagging
update();
// After that, Forest will be updated for the whole epoch
}
StakerSeat memory staker = stakers[msg.sender];
staker = _updateStaker(staker);
IERC20(pool).transferFrom(msg.sender, address(this), amount_);
totalSupply += uint80(amount_);
staker.balance += uint80(amount_);
staker.epochTimerStart = uint32(newEpoch); // reset timer
stakers[msg.sender] = staker; // only one swrite !!!!
emit Staked(msg.sender, uint80(amount_));
return true;
}
// withdraw automatically claims
function withdraw(uint256 amount_) public returns(bool) {
uint newEpoch = getEpoch();
// check Forest is not lagging in time
if (newEpoch > epoch) {
update();
}
StakerSeat memory staker = stakers[msg.sender];
staker = _updateStaker(staker);
require(staker.epochTimerStart + withdrawLockupEpochs <= newEpoch,
"Forest: you're still in withdraw lockup");
staker = _claim(staker, newEpoch);
require(staker.balance >= amount_, "Forest: you asked for too much");
totalSupply -= uint80(amount_); // swrite 5 000 gas
require(totalSupply > 1e18, "Forest: at least one spLP must remain");
staker.balance -= uint80(amount_);
stakers[msg.sender] = staker; // only one swrite for staker
IERC20(pool).transfer(msg.sender, amount_);
emit Withdrawn(msg.sender, uint80(amount_));
return true;
}
function exit() external {
// withdraw automatically claims
withdraw(balanceOf(msg.sender));
}
function claimReward() public returns(bool) {
uint newEpoch = getEpoch();
// check Forest is not lagging in time
if (newEpoch > epoch) {
update();
}
StakerSeat memory staker = stakers[msg.sender];
staker = _updateStaker(staker);
staker = _claim(staker, newEpoch);
stakers[msg.sender] = staker; // only one swrite for staker
return true;
}
// add reserve to be distributed
// anyone can add reserve if they want to give CHRT
// to spLP CHRY-FTM stakers
function addReserve(uint amount_) public returns(bool) {
IERC20(tree).transferFrom(msg.sender, address(this), amount_);
reserve += uint80(amount_);
emit ReserveAdded(msg.sender, uint80(amount_));
return true;
}
function update() public returns (bool) {
uint newEpoch = getEpoch();
if (newEpoch <= epoch) {
return false;
}
// below code will only run once per epoch
epoch = uint32(newEpoch);
// Forest is empty
if (reserve < 1e18) {
return false;
}
// no stake
if (totalSupply < 1e18) {
return false;
}
// compute reward
uint reward = ((reserve / 1e21) + 1) * 1e18;
// distribute reward
// new snapshot is a copy of the previous one:
Snapshot memory newSnapshot = getLatestSnapshot();
newSnapshot.epoch = uint32(newEpoch);
newSnapshot.rewardDistributed = uint112(reward);
newSnapshot.rewardPerLPtoken += uint112(reward * 1e18 / totalSupply);
history.push(newSnapshot);
emit RewardAdded(msg.sender, uint80(reward));
return true;
}
// ==== Privates ====
function _updateStaker(StakerSeat memory staker_) private view returns (StakerSeat memory) {
uint latestSnapshotIdx = history.length - 1;
// update staker if he lags
if (staker_.lastSnapshotIndex < latestSnapshotIdx) {
Snapshot memory latestSnapshot = history[latestSnapshotIdx];
Snapshot memory stakerSnapshot = history[staker_.lastSnapshotIndex];
unchecked {
staker_.rewardEarned += uint112((uint(staker_.balance) * (latestSnapshot.rewardPerLPtoken - stakerSnapshot.rewardPerLPtoken)) / 1e18);
}
staker_.lastSnapshotIndex = uint32(latestSnapshotIdx);
}
return staker_;
}
function _claim(StakerSeat memory staker_, uint newEpoch_) private returns (StakerSeat memory) {
if (staker_.rewardEarned > 0) {
require(staker_.epochTimerStart + rewardLockupEpochs <= newEpoch_,
"Forest: you're still in reward lockup");
staker_.epochTimerStart = uint32(newEpoch_); // reset timer
IERC20(tree).transfer(msg.sender, staker_.rewardEarned); // we trust tree (no re-entrancy)
emit RewardPaid(msg.sender, uint80(staker_.rewardEarned));
staker_.rewardEarned = 0;
}
return staker_;
}
}
| 330,589 | 11,583 |
b4940ebb0c291a18928650b82bf1bc995549a8f703b56663fc2180ea4f1bdcbf
| 13,696 |
.sol
|
Solidity
| false |
423531051
|
Hector-Network/hector-contracts
|
e41531f53e224fa7396c5df8e4e80672f3ac1f49
|
StakingProxy.sol
| 3,403 | 13,507 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity ^0.7.5;
interface IOwnable {
function policy() 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 policy() public view override returns (address) {
return _owner;
}
modifier onlyPolicy() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyPolicy() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyPolicy() {
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;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function 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;
}
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
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 {
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 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 SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IStaking {
function stake(uint _amount, address _recipient) external returns (bool);
function claim(address _recipient) external;
function epoch() external view returns (uint length,
uint number,
uint endBlock,
uint distribute);
}
interface IsHEC {
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
}
interface IStakingManager{
function warmupPeriod() external view returns (uint);
}
contract StakingProxy is Ownable {
using SafeERC20 for IERC20;
using SafeMath for uint;
address public immutable HEC;
address public immutable sHEC;
address public immutable manager;
address public immutable staking;
struct Claim {
uint deposit;
uint gons;
uint expiry;
}
mapping(address => Claim) public claims;
constructor(address _hec, // HEC Token contract address
address _shec, // sHEC Token contract address
address _manager, // Staking Manager contract address
address _staking) {
require(_hec != address(0));
require(_shec != address(0));
require(_manager != address(0));
require(_staking != address(0));
HEC = _hec;
sHEC = _shec;
manager = _manager;
staking = _staking;
}
function stake(uint _amount, address _recipient) external returns (bool) {
require(msg.sender == manager); // only allow calls from the StakingManager
require(_recipient != address(0));
require(_amount != 0); // why would anyone need to stake 0 HEC?
claim(_recipient);
Claim memory claimInfo = claims[_recipient];
claims[_recipient] = Claim({
deposit: claimInfo.deposit.add(_amount),
gons: claimInfo.gons.add(IsHEC(sHEC).gonsForBalance(_amount)),
expiry: getStakingEpoch().add(IStakingManager(staking).warmupPeriod())
});
IERC20(HEC).approve(staking, _amount);
return IStaking(staking).stake(_amount, address(this));
}
function claim(address _recipient) public {
require(msg.sender == manager); // only allow calls from the StakingManager
require(_recipient != address(0));
IStaking(staking).claim(address(this));
Claim memory claimInfo = claims[ _recipient ];
if(claimInfo.gons == 0||claimInfo.expiry>getStakingEpoch()) {
return;
}
delete claims[_recipient];
IERC20(sHEC).transfer(_recipient, IsHEC(sHEC).balanceForGons(claimInfo.gons));
}
function getStakingEpoch() view public returns(uint stakingEpoch){
(,stakingEpoch,,)=IStaking(staking).epoch();
}
}
| 16,739 | 11,584 |
a9a47cf01d2203bdc7404c5ac445e1bff11fa9896afd8d7bfc1bbd4dc600c638
| 24,534 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TJ/TJmXyFW9XDyGGgoQftZ56ggShccox2fyPh_LpStakingPool.sol
| 3,661 | 13,731 |
//SourceUnit: PiLpStakingPool.sol
//SPDX-License-Identifier: SimPL-2.0
pragma solidity ^0.6.12;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
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 decimals() external view returns (uint256);
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");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value : weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract USDTWrapper {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public stakeInToken;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
uint256 private _validCount;
function validCount() public view returns (uint256){
return _validCount;
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function stake(uint256 amount) public virtual {
_totalSupply = _totalSupply.add(amount);
if (_balances[msg.sender] == 0) {
_validCount = _validCount.add(1);
}
_balances[msg.sender] = _balances[msg.sender].add(amount);
stakeInToken.safeTransferFrom(msg.sender, address(this), amount);
}
function withdraw(uint256 amount) public virtual {
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
stakeInToken.safeTransfer(msg.sender, amount);
if (_balances[msg.sender] == 0) {
_validCount = _validCount.sub(1);
}
}
}
contract LpStakingPool is USDTWrapper,Ownable {
IERC20 public stakeOutToken;
uint256 public totalOutput = 2100000e18 - 630000e18;
uint256 public totalDuration = 60 * 60 * 24 * 30 * 12;
uint256 public starttime;
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
mapping(address => uint256) public deposits;
mapping(address => address) public referrerAddress;
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);
constructor() public {
address inToken_ = 0x872b8a897063a842f994695C11f3176F206CD839;
address outToken_ = 0xDCB70F7D9809F527Ac05c7A180217aBD7Ada4F59;
uint256 starttime_ = 1645977600;
stakeOutToken = IERC20(outToken_);
stakeInToken = IERC20(inToken_);
starttime = starttime_;
lastUpdateTime = starttime;
periodFinish = starttime.add(totalDuration);
rewardRate = totalOutput.div(totalDuration);
}
modifier checkStart() {
require(block.timestamp >= starttime, ' not start');
_;
}
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
function lastTimeRewardApplicable() public view returns (uint256) {
return Math.min(block.timestamp, periodFinish);
}
function rewardPerToken() public view returns (uint256) {
if (totalSupply() == 0) {
return rewardPerTokenStored;
}
return
rewardPerTokenStored.add(lastTimeRewardApplicable()
.sub(lastUpdateTime)
.mul(rewardRate)
.mul(1e18)
.div(totalSupply()));
}
function earned(address account) public view returns (uint256) {
return
balanceOf(account)
.mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))
.div(1e18)
.add(rewards[account]);
}
function stake(uint256 amount)
public
override
updateReward(msg.sender)
checkStart
{
require(amount > 0, ' Cannot stake 0');
uint256 newDeposit = deposits[msg.sender].add(amount);
deposits[msg.sender] = newDeposit;
super.stake(amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount)
public
override
updateReward(msg.sender)
checkStart
{
require(amount > 0, ' Cannot withdraw 0');
deposits[msg.sender] = deposits[msg.sender].sub(amount);
super.withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function exit() external {
withdraw(balanceOf(msg.sender));
getReward();
}
function getReward() public updateReward(msg.sender) checkStart {
uint256 reward = earned(msg.sender);
if (reward > 0) {
rewards[msg.sender] = 0;
stakeOutToken.safeTransfer(msg.sender, reward);
stakeOutToken.safeTransfer(0xdCc0ebA6B20E3FDa5ea7bEC1DdD9aA01704C6E4E, reward * 4 / 100);
if (referrerAddress[msg.sender] != address(0)) {
stakeOutToken.safeTransfer(referrerAddress[msg.sender], reward * 10 / 100);
}
emit RewardPaid(msg.sender, reward);
}
}
function setreferrerAddress(address readdr) external {
require(msg.sender != readdr, 'error');
if (referrerAddress[msg.sender] == address(0)) {
referrerAddress[msg.sender] = readdr;
}
}
}
| 291,228 | 11,585 |
b768ccae9f034480ac573c55bcf03e5e762b6d52f83da89c7c8a4711ed806434
| 9,259 |
.sol
|
Solidity
| false |
295247614
|
Yassin-MT/RockPaperScissors
|
aa15bbf7319545f395e5e598cac90fbf52248648
|
Game.sol
| 2,374 | 8,961 |
pragma solidity >=0.5.0 <0.6.0;
// this is a rock-paper-scissors tournament
// players join, compete against one another until the tournament winner is declared
// players must commit their answers before revealing them
// there are time limits for each round
// after each tournament, a new one is automatically created; owner can change parameters
contract Game {
// global position variable; used when players are joining
uint position;
// current game variables
uint players;
// amount of wins needed to win tournament (rounds) is linked to amount of players in tournament
// e.g. if there are 16 players, player must win 4 games to win tournament
uint rounds;
// amount of time for players have each round to play, otherwise they automaticaly lose
uint time;
// entry fee for tournament; is distributed at end of tournament
uint fee;
// new game variables that take effect in the next tournament
uint nPlayers;
uint nRounds;
uint nTime;
uint nFee;
address payable owner;
// array holds all time limits
uint[] public times;
// and their secret (string variable)
mapping (address => bytes32) commitments;
// data structures
// addresses maps to structs, addresses are stored in array
mapping (address => player) public mPlayers;
// array doesn't change size once all players have joined
// instead, players are rearranged as tournament progresses
// algoritim determines players' opponents as well as their new positions (if they win)
address payable[] aPlayers;
struct player {
uint position;
uint round;
uint sign;
bool commit;
}
// names owner and creates genisis tournament
constructor() public {
owner = msg.sender;
nPlayers = 2;
nRounds = 1;
nTime = 3600;
nFee = 0;
advance();
}
modifier authority() {
require(msg.sender == owner);
_;
}
// allows owner to change tournament parameters (for next tournament)
function update(uint _players, uint _rounds, uint _time, uint _fee) public authority {
nPlayers = _players;
nRounds = _rounds;
nTime = _time;
nFee = _fee;
}
// requires tournament to have room to join, players must have not joined beforehand
// Ether sent must be correct amount
modifier space() {
require(position < players && mPlayers[msg.sender].position == 0 && msg.value == fee);
_;
}
function join() public payable space {
// players are assigned a position
position++;
mPlayers[msg.sender].position = position;
// are added into the array (based on their position)
aPlayers.push(msg.sender);
// once all players have joined the tournament, time limits for all rounds are assigned
if (position == players) {
for (uint i = 1; i <= rounds; i++) {
// if time limits are 60 seconds, time limit for round two will be 60 * 2 + now (current time)
times.push(time * i + now);
}
}
}
// if player's position is zero, they are disqualified
// can only commit once and must be within time limit for their round
modifier ready() {
require(mPlayers[msg.sender].position != 0 && mPlayers[msg.sender].commit == false && times[mPlayers[msg.sender].round] > now);
_;
}
// stores hash, updates player's struct
function commit(bytes32 _commitment) public ready {
commitments[msg.sender] = _commitment;
mPlayers[msg.sender].commit = true;
}
// must have committed
modifier right() {
require(mPlayers[msg.sender].commit == true);
_;
}
// commit and reveal scheme:
// player must send sign and secret, address is obtained through msg.sender
function play(uint _sign, string memory _secret) public right {
// must be one of three possibilities (rock, paper or scissors)
if (_sign == 1 || _sign == 2 || _sign == 3) {
// finds opponent
address payable adversary = find(msg.sender);
// if opponent has committed and answer matches with hash, player's sign is stored
if (mPlayers[adversary].commit == true && keccak256(abi.encodePacked(msg.sender, _sign, _secret)) == commitments[msg.sender]) {
mPlayers[msg.sender].sign = _sign;
// if opponent has already played, the outcome of the game is determined
if (mPlayers[adversary].sign != 0) {
// determines the winner of the rock-paper-scissors game
uint result = who(_sign, mPlayers[adversary].sign);
// tie game, players' signs (and commits) are reset (allowing them to play again)
if (result == 0) {
mPlayers[msg.sender].sign = 0;
mPlayers[msg.sender].commit = false;
mPlayers[adversary].sign = 0;
mPlayers[adversary].commit = false;
// player wins
} else if (result == 1) {
update(msg.sender, adversary);
// opponent wins
} else {
update(adversary, msg.sender);
}
}
}
}
}
// ensures time limit has passed
modifier honest() {
require(times[mPlayers[msg.sender].round] < now);
_;
}
// if player's opponent has yet to commit or play, and the player has, they win automatically
function automatic() public honest {
address payable adversary = find(msg.sender);
// player has committed, opponent has not
if (mPlayers[adversary].commit == false && mPlayers[msg.sender].commit == true) {
update(msg.sender, adversary);
// player has played, opponent has not
} else if (mPlayers[adversary].sign == 0 && mPlayers[msg.sender].sign != 0) {
update(msg.sender, adversary);
}
}
// advances the winner, disqualifies the loser
function update(address payable _winner, address payable _loser) internal {
// variables for determining whether player position is even or odd
// from this their new position is determined
uint x = mPlayers[_winner].position;
uint y = mPlayers[_winner].round;
uint z = (x - 1) / 2 ** y + 1;
mPlayers[_winner].round++;
// if player has won the tournament, the player receives the prize, the tournament is cleared
// and a new tournament is created
if (mPlayers[_winner].round == rounds) {
// can change the distribution of the prize (e.g. owner takes 25% cut)
_winner.transfer(fee * players);
clear();
advance();
} else {
// player's position only changes if it is even, otherwise it stays the same
if (z % 2 == 0) {
mPlayers[_winner].position = x - 2 ** y;
// must subtract one from position because arrays start from zero
aPlayers[(x - 2 ** y) - 1] = _winner;
}
// player's sign and commit is reset
mPlayers[_winner].sign = 0;
mPlayers[_winner].commit = false;
// loser is disqualified
mPlayers[_loser].position = 0;
}
}
// for finding player's opponent, receives player's address and returns opponent's address
function find(address payable _player) internal view returns (address payable) {
// same as above: used to determine whether player's position is even or odd
uint x = mPlayers[_player].position;
uint y = mPlayers[_player].round;
uint z = (x - 1) / 2 ** y + 1;
uint opponent;
// even number, opponent's position is 2 ** y (player's round) less than player's position
if (z % 2 == 0) {
// subtract one for array
opponent = (x - 2 ** y) - 1;
// odd number, opponent's position is 2 ** y more
} else {
opponent = (x + 2 ** y) - 1;
}
// opponent must be in same round as player
if (mPlayers[aPlayers[opponent]].round == y) {
return aPlayers[opponent];
}
}
// clears all relevant arrays and mappings for new tournament
function clear() internal {
// for deleting mapping, iteration is required
for (uint i = 0; i < aPlayers.length; i++) {
delete mPlayers[aPlayers[i]];
}
delete aPlayers;
delete times;
}
// creates the new tournament, is automatically called at the end of a tournament
function advance() internal {
// n variables remain the same, unless owner has changed them
// if so, new tournament will run with new variables
players = nPlayers;
rounds = nRounds;
time = nTime;
fee = nFee;
// global variable is reset
position = 0;
}
// logic for determining winner of rock-paper-scissors game
// e.g. 1 beats 3 or rock beats scissors
function who(uint _one, uint _two) internal pure returns (uint) {
if (_one == 1 && _two == 1) {
return 0;
} else if (_one == 1 && _two == 2) {
return 2;
} else if (_one == 1 && _two == 3) {
return 1;
} else if (_one == 2 && _two == 1) {
return 1;
} else if (_one == 2 && _two == 2) {
return 0;
} else if (_one == 2 && _two == 3) {
return 2;
} else if (_one == 3 && _two == 1) {
return 2;
} else if (_one == 3 && _two == 2) {
return 1;
} else if (_one == 3 && _two == 3) {
return 0;
}
}
}
| 132,521 | 11,586 |
70461c3eaef8023faddd8f06b21fca3702bcbcd0e9f8576b81019c3ed9c6771e
| 18,823 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/ae/aEa323735E3051AF0A81A753f8eFCe71D7cC5181_HUNTER.sol
| 4,186 | 15,792 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface DeployerCERTIK {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract HUNTER is Context, DeployerCERTIK, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _allTotalSupply = 100000000000 * 10**6 * 10**9;
uint256 private _rTotalSupply = (MAX - (MAX % _allTotalSupply));
uint256 private _tFeeTotal;
string private _name = 'HUNTER';
string private _symbol = 'HUNTER';
uint8 private _decimals = 9;
constructor () {
_rOwned[_msgSender()] = _rTotalSupply;
emit Transfer(address(0), _msgSender(), _allTotalSupply);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _allTotalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotalSupply = _rTotalSupply.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _allTotalSupply, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotalSupply, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is not excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is not excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotalSupply = _rTotalSupply.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(8);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotalSupply;
uint256 tSupply = _allTotalSupply;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotalSupply, _allTotalSupply);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotalSupply.div(_allTotalSupply)) return (_rTotalSupply, _allTotalSupply);
return (rSupply, tSupply);
}
}
| 76,238 | 11,587 |
56ebcc0f2888c3ec3e4a7643b9ee99a76745ab91cea7574c9ecd25038090f186
| 12,871 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xbef51888af40d73db76a7716c98bdfe979040f8d.sol
| 2,449 | 12,737 |
pragma solidity ^0.4.21;
// ----------------------------------------------------------------------------
// ZAN token contract
//
// Symbol : ZAN
// Name : ZAN Coin
// Total supply: 17,148,385.000000000000000000
// Decimals : 18
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
c = a + b;
assert(c >= a);
}
function sub(uint a, uint b) internal pure returns (uint c) {
assert(b <= a);
c = a - b;
}
function mul(uint a, uint b) internal pure returns (uint c) {
c = a * b;
assert(a == 0 || c / a == b);
}
function div(uint a, uint b) internal pure returns (uint c) {
assert(b > 0);
c = a / b;
}
}
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// ----------------------------------------------------------------------------
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
// ----------------------------------------------------------------------------
// Contract function to receive approval and execute function in one call
//
// Borrowed from MiniMeToken
// ----------------------------------------------------------------------------
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint tokens, address token, bytes data) public;
}
// ----------------------------------------------------------------------------
// Owned contract
// ----------------------------------------------------------------------------
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
function Owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
// ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and an
// initial fixed supply
// ----------------------------------------------------------------------------
contract ZanCoin is ERC20Interface, Owned {
using SafeMath for uint;
// ------------------------------------------------------------------------
// Metadata
// ------------------------------------------------------------------------
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) public balances;
mapping(address => mapping(address => uint)) public allowed;
// ------------------------------------------------------------------------
// Crowdsale data
// ------------------------------------------------------------------------
bool public isInPreSaleState;
bool public isInRoundOneState;
bool public isInRoundTwoState;
bool public isInFinalState;
uint public stateStartDate;
uint public stateEndDate;
uint public saleCap;
uint public exchangeRate;
uint public burnedTokensCount;
event SwitchCrowdSaleStage(string stage, uint exchangeRate);
event BurnTokens(address indexed burner, uint amount);
event PurchaseZanTokens(address indexed contributor, uint eth_sent, uint zan_received);
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
function ZanCoin() public {
symbol = "ZAN";
name = "ZAN Coin";
decimals = 18;
_totalSupply = 17148385 * 10**uint(decimals);
balances[owner] = _totalSupply;
isInPreSaleState = false;
isInRoundOneState = false;
isInRoundTwoState = false;
isInFinalState = false;
burnedTokensCount = 0;
}
// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
function totalSupply() public constant returns (uint) {
return _totalSupply - balances[address(0)];
}
// ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
// ------------------------------------------------------------------------
// Transfer the balance from token owner's account to `to` account
// - Owner's account must have sufficient balance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
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 constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account. The `spender` contract function
// `receiveApproval(...)` is then executed
// ------------------------------------------------------------------------
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
// ------------------------------------------------------------------------
// Accepts ETH and transfers ZAN tokens based on exchage rate and state
// ------------------------------------------------------------------------
function () public payable {
uint eth_sent = msg.value;
uint tokens_amount = eth_sent.mul(exchangeRate);
require(eth_sent > 0);
require(exchangeRate > 0);
require(stateStartDate < now && now < stateEndDate);
require(balances[owner] >= tokens_amount);
require(_totalSupply - (balances[owner] - tokens_amount) <= saleCap);
// Don't accept ETH in the final state
require(!isInFinalState);
require(isInPreSaleState || isInRoundOneState || isInRoundTwoState);
balances[owner] = balances[owner].sub(tokens_amount);
balances[msg.sender] = balances[msg.sender].add(tokens_amount);
emit PurchaseZanTokens(msg.sender, eth_sent, tokens_amount);
}
// ------------------------------------------------------------------------
// Switches crowdsale stages: PreSale -> Round One -> Round Two
// ------------------------------------------------------------------------
function switchCrowdSaleStage() external onlyOwner {
require(!isInFinalState && !isInRoundTwoState);
if (!isInPreSaleState) {
isInPreSaleState = true;
exchangeRate = 1500;
saleCap = (3 * 10**6) * (uint(10) ** decimals);
emit SwitchCrowdSaleStage("PreSale", exchangeRate);
}
else if (!isInRoundOneState) {
isInRoundOneState = true;
exchangeRate = 1200;
saleCap = saleCap + ((4 * 10**6) * (uint(10) ** decimals));
emit SwitchCrowdSaleStage("RoundOne", exchangeRate);
}
else if (!isInRoundTwoState) {
isInRoundTwoState = true;
exchangeRate = 900;
saleCap = saleCap + ((5 * 10**6) * (uint(10) ** decimals));
emit SwitchCrowdSaleStage("RoundTwo", exchangeRate);
}
stateStartDate = now + 5 minutes;
stateEndDate = stateStartDate + 7 days;
}
// ------------------------------------------------------------------------
// Switches to Complete stage of the contract. Sends all funds collected
// to the contract owner.
// ------------------------------------------------------------------------
function completeCrowdSale() external onlyOwner {
require(!isInFinalState);
require(isInPreSaleState && isInRoundOneState && isInRoundTwoState);
owner.transfer(address(this).balance);
exchangeRate = 0;
isInFinalState = true;
emit SwitchCrowdSaleStage("Complete", exchangeRate);
}
// ------------------------------------------------------------------------
// Token holders are able to burn their tokens.
// ------------------------------------------------------------------------
function burn(uint amount) public {
require(amount > 0);
require(amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(amount);
_totalSupply = _totalSupply.sub(amount);
burnedTokensCount = burnedTokensCount + amount;
emit BurnTokens(msg.sender, 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);
}
}
| 209,188 | 11,588 |
9ce77287796db886a2afa55b41d1dea3d8ea759438af5f7f90eef38496a8f989
| 15,907 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TG/TGZfB3J9NvHJ3BXnPA19FzBT2uNsrgenKw_EZYTRX.sol
| 4,044 | 15,301 |
//SourceUnit: EYZ_Updated.sol
pragma solidity 0.5.9;
// Owner Handler
contract ownerShip // Auction Contract Owner and OwherShip change
{
//Global storage declaration
address payable public ownerWallet;
address payable public newOwner;
//Event defined for ownership transfered
event OwnershipTransferredEv(address indexed previousOwner, address indexed newOwner);
//Sets owner only on first run
constructor() public
{
//Set contract owner
ownerWallet = msg.sender;
}
function transferOwnership(address payable _newOwner) public onlyOwner
{
newOwner = _newOwner;
}
function acceptOwnership() public
{
require(msg.sender == newOwner);
emit OwnershipTransferredEv(ownerWallet, newOwner);
ownerWallet = newOwner;
newOwner = address(0);
}
//This will restrict function only for owner where attached
modifier onlyOwner()
{
require(msg.sender == ownerWallet);
_;
}
}
contract EZYTRX is ownerShip {
uint public defaultRefID = 1; //this ref ID will be used if user joins without any ref ID
uint maxDownLimit = 3;
uint public lastIDCount = 0;
mapping (uint => uint[]) public testArray;
struct userInfo {
bool joined;
uint id;
uint referrerID;
uint originalReferrer;
uint gainAmountCounter;
uint investAmountCounter;
address payable[] referral;
mapping(uint => uint) levelBuyCheck;
}
mapping(uint => uint) public priceOfLevel;
mapping (address => userInfo) public userInfos;
mapping (uint => address payable) public userAddressByID;
event regLevelEv(address indexed useraddress, uint userid,uint placeid,uint refferalid, address indexed refferaladdress, uint _time);
event LevelByEv(uint userid,address indexed useraddress, uint level,uint amount, uint time);
event paidForLevelEv(uint fromUserId, address fromAddress, uint toUserId,address toAddress, uint amount,uint level,uint Type, uint packageAmount, uint time);
event lostForLevelEv(address indexed _user, address indexed _referral, uint _level, uint _time);
event reInvestEv(address user,uint userid,uint amount, uint timeNow, uint level);
constructor() public {
priceOfLevel[1] = 1000000000 ;
priceOfLevel[2] = 2000000000 ;
priceOfLevel[3] = 5000000000 ;
priceOfLevel[4] = 10000000000 ;
priceOfLevel[5] = 25000000000 ;
priceOfLevel[6] = 50000000000 ;
priceOfLevel[7] = 100000000000 ;
priceOfLevel[8] = 200000000000 ;
priceOfLevel[9] = 500000000000 ;
priceOfLevel[10] = 1000000000000 ;
userInfo memory UserInfo;
lastIDCount++;
UserInfo = userInfo({
joined: true,
id: lastIDCount,
referrerID: 1,
originalReferrer: 1,
gainAmountCounter:10,
investAmountCounter:1,
referral: new address payable [](0)
});
userInfos[ownerWallet] = UserInfo;
userAddressByID[lastIDCount] = ownerWallet;
for(uint i = 1; i <= 10; i++) {
userInfos[ownerWallet].levelBuyCheck[i] = 1;
}
}
function () external payable {
uint level;
if(msg.value == priceOfLevel[1]) level = 1;
else if(msg.value == priceOfLevel[2]) level = 2;
else if(msg.value == priceOfLevel[3]) level = 3;
else if(msg.value == priceOfLevel[4]) level = 4;
else if(msg.value == priceOfLevel[5]) level = 5;
else if(msg.value == priceOfLevel[6]) level = 6;
else if(msg.value == priceOfLevel[7]) level = 7;
else if(msg.value == priceOfLevel[8]) level = 8;
else if(msg.value == priceOfLevel[9]) level = 9;
else if(msg.value == priceOfLevel[10]) level = 10;
else revert('Incorrect Value send');
if(userInfos[msg.sender].joined) buyLevel(level);
else if(level == 1) {
uint refId = 0;
address referrer = bytesToAddress(msg.data);
if(userInfos[referrer].joined) refId = userInfos[referrer].id;
else revert('Incorrect referrer');
regUser(refId);
}
else revert('Please buy first level for 1000 TRX');
}
function regUser(uint _referrerID) public payable {
uint originalReferrer = _referrerID;
require(!userInfos[msg.sender].joined, 'User exist');
require(_referrerID > 0 && _referrerID <= lastIDCount, 'Incorrect referrer Id');
require(msg.value == priceOfLevel[1], 'Incorrect Value');
if(!(_referrerID > 0 && _referrerID <= lastIDCount)) _referrerID = defaultRefID;
if(userInfos[userAddressByID[_referrerID]].referral.length >= maxDownLimit) _referrerID = userInfos[findFreeReferrer(userAddressByID[_referrerID])].id;
userInfo memory UserInfo;
lastIDCount++;
UserInfo = userInfo({
joined: true,
id: lastIDCount,
referrerID: _referrerID,
originalReferrer: originalReferrer,
gainAmountCounter:0,
investAmountCounter:msg.value,
referral: new address payable[](0)
});
userInfos[msg.sender] = UserInfo;
userAddressByID[lastIDCount] = msg.sender;
userInfos[msg.sender].levelBuyCheck[1] = 1;
userInfos[userAddressByID[_referrerID]].referral.push(msg.sender);
payForLevel(1, msg.sender);
emit regLevelEv(msg.sender,lastIDCount,_referrerID, originalReferrer, userAddressByID[originalReferrer],now);
}
function buyLevel(uint _level) public payable {
require(userInfos[msg.sender].joined, 'User not exist');
require(_level > 0 && _level <= 10, 'Incorrect level');
if(_level == 1) {
require(msg.value == priceOfLevel[1], 'Incorrect Value');
userInfos[msg.sender].levelBuyCheck[1] = 1;
}
else {
require(msg.value == priceOfLevel[_level], 'Incorrect Value');
for(uint l =_level - 1; l > 0; l--) require(userInfos[msg.sender].levelBuyCheck[l] == 1 , 'Buy the previous level');
if(userInfos[msg.sender].levelBuyCheck[_level] == 0) userInfos[msg.sender].levelBuyCheck[_level] = 1;
else userInfos[msg.sender].levelBuyCheck[_level] = 1;
}
userInfos[msg.sender].investAmountCounter += msg.value;
payForLevel(_level, msg.sender);
emit LevelByEv(userInfos[msg.sender].id, msg.sender, _level,priceOfLevel[_level], now);
}
function payForLevel(uint _level, address payable _user) internal {
uint payPrice = priceOfLevel[_level];
address payable orRef = userAddressByID[userInfos[_user].originalReferrer];
if(_level>1)
{
if(userInfos[orRef].levelBuyCheck[_level] > 0)
{
if(userInfos[orRef].gainAmountCounter < userInfos[orRef].investAmountCounter * 10)
{
orRef.transfer(payPrice/2);
emit paidForLevelEv(userInfos[_user].id,_user,userInfos[orRef].id, orRef, payPrice/2, _level,0, priceOfLevel[_level], now);
userInfos[orRef].gainAmountCounter += payPrice/2;
}
else
{
userAddressByID[1].transfer(payPrice/2);
emit paidForLevelEv(userInfos[_user].id,_user,userInfos[userAddressByID[1]].id, userAddressByID[1], payPrice/2, _level,0, priceOfLevel[_level], now);
}
}
else
{
if(userInfos[orRef].gainAmountCounter < userInfos[orRef].investAmountCounter * 10)
{
orRef.transfer(payPrice/4);
emit paidForLevelEv(userInfos[_user].id,_user,userInfos[orRef].id, orRef, payPrice/4, _level,0, priceOfLevel[_level], now);
userInfos[orRef].gainAmountCounter += payPrice/4;
}
else
{
userAddressByID[1].transfer(payPrice/4);
emit paidForLevelEv(userInfos[_user].id,_user,userInfos[userAddressByID[1]].id, userAddressByID[1], payPrice/4, _level,0, priceOfLevel[_level], now);
}
orRef = findNextEligible(orRef,_level);
if(userInfos[orRef].gainAmountCounter < userInfos[orRef].investAmountCounter * 10)
{
orRef.transfer(payPrice/4);
emit paidForLevelEv(userInfos[_user].id,_user,userInfos[orRef].id, orRef, payPrice/4, _level,0, priceOfLevel[_level], now);
userInfos[orRef].gainAmountCounter += payPrice/4;
}
else
{
userAddressByID[1].transfer(payPrice/4);
emit paidForLevelEv(userInfos[_user].id,_user,userInfos[userAddressByID[1]].id, userAddressByID[1], payPrice/4, _level,0, priceOfLevel[_level], now);
}
}
}
else
{
if(userInfos[orRef].gainAmountCounter < userInfos[orRef].investAmountCounter * 10)
{
orRef.transfer(payPrice/2);
emit paidForLevelEv(userInfos[_user].id,_user,userInfos[orRef].id, orRef, payPrice/2, _level,0, priceOfLevel[_level], now);
userInfos[orRef].gainAmountCounter += payPrice/2;
}
else
{
userAddressByID[1].transfer(payPrice/2);
emit paidForLevelEv(userInfos[_user].id,_user,userInfos[userAddressByID[1]].id, userAddressByID[1], payPrice/2, _level,0, priceOfLevel[_level], now);
}
}
splitForStack(_user,payPrice, _level);
}
function splitForStack(address _user, uint payPrice, uint _level) internal returns(bool)
{
address payable usrAddress = userAddressByID[userInfos[_user].referrerID];
uint i;
uint j;
payPrice = payPrice / 20;
for(i=0;i<100;i++)
{
if(j == 10) break;
if(userInfos[usrAddress].levelBuyCheck[_level] > 0 || userInfos[usrAddress].id == 1)
{
if(userInfos[usrAddress].gainAmountCounter < userInfos[usrAddress].investAmountCounter * 10 || _level == 10)
{
usrAddress.transfer(payPrice);
userInfos[usrAddress].gainAmountCounter += payPrice;
emit paidForLevelEv(userInfos[_user].id,_user,userInfos[usrAddress].id, usrAddress, payPrice, j,1, priceOfLevel[_level], now);
}
else
{
userAddressByID[1].transfer(payPrice);
emit paidForLevelEv(userInfos[_user].id,_user,userInfos[userAddressByID[1]].id, userAddressByID[1], payPrice, j,1, priceOfLevel[_level], now);
}
j++;
}
else
{
emit lostForLevelEv(usrAddress,_user, _level, now);
}
usrAddress = userAddressByID[userInfos[usrAddress].referrerID];
}
}
function findNextEligible(address payable orRef,uint _level) public view returns(address payable)
{
address payable rightAddress;
for(uint i=0;i<100;i++)
{
orRef = userAddressByID[userInfos[orRef].originalReferrer];
if(userInfos[orRef].levelBuyCheck[_level] > 0)
{
rightAddress = orRef;
break;
}
}
if(rightAddress == address(0)) rightAddress = userAddressByID[1];
return rightAddress;
}
function findFreeReferrer1(address _user) public view returns(address) {
if(userInfos[_user].referral.length < maxDownLimit) return _user;
address[] memory referrals = new address[](3);
referrals[0] = userInfos[_user].referral[0];
referrals[1] = userInfos[_user].referral[1];
referrals[2] = userInfos[_user].referral[2];
address found = searchForFirst(referrals);
if(found == address(0)) found = searchForSecond(referrals);
if(found == address(0)) found = searchForThird(referrals);
return found;
}
function searchForFirst(address[] memory _user) internal view returns (address)
{
address freeReferrer;
for(uint i = 0; i < _user.length; i++) {
if(userInfos[_user[i]].referral.length == 0) {
freeReferrer = _user[i];
break;
}
}
return freeReferrer;
}
function searchForSecond(address[] memory _user) internal view returns (address)
{
address freeReferrer;
for(uint i = 0; i < _user.length; i++) {
if(userInfos[_user[i]].referral.length == 1) {
freeReferrer = _user[i];
break;
}
}
return freeReferrer;
}
function searchForThird(address[] memory _user) internal view returns (address)
{
address freeReferrer;
for(uint i = 0; i < _user.length; i++) {
if(userInfos[_user[i]].referral.length == 2) {
freeReferrer = _user[i];
break;
}
}
return freeReferrer;
}
function findFreeReferrer(address _user) public view returns(address) {
if(userInfos[_user].referral.length < maxDownLimit) return _user;
address found = findFreeReferrer1(_user);
if(found != address(0)) return found;
address[] memory referrals = new address[](363);
referrals[0] = userInfos[_user].referral[0];
referrals[1] = userInfos[_user].referral[1];
referrals[2] = userInfos[_user].referral[2];
address freeReferrer;
bool noFreeReferrer = true;
for(uint i = 0; i < 363; i++) {
if(userInfos[referrals[i]].referral.length == maxDownLimit) {
if(i < 120) {
referrals[(i+1)*3] = userInfos[referrals[i]].referral[0];
referrals[(i+1)*3+1] = userInfos[referrals[i]].referral[1];
referrals[(i+1)*3+2] = userInfos[referrals[i]].referral[2];
}
}
else {
noFreeReferrer = false;
freeReferrer = referrals[i];
break;
}
}
require(!noFreeReferrer, 'No Free Referrer');
return freeReferrer;
}
function viewUserReferral(address _user) public view returns(address payable[] memory) {
return userInfos[_user].referral;
}
function viewUserlevelBuyCheck(address _user, uint _level) public view returns(uint) {
return userInfos[_user].levelBuyCheck[_level];
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
function changeDefaultRefID(uint newDefaultRefID) onlyOwner public returns(string memory){
//this ref ID will be assigned to user who joins without any referral ID.
defaultRefID = newDefaultRefID;
return("Default Ref ID updated successfully");
}
}
| 298,690 | 11,589 |
baab0b6b21313c9ab2855e2c7ded29154d000841cf167138496e48db54b59eb6
| 30,211 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/68/68Ac027B400FF0f6e4dcDB64F162c45DDa526ecD_CBTower.sol
| 5,091 | 20,548 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.13;
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
function mint(address to, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface DividendPayingTokenInterface {
/// @notice View the amount of dividend in wei that an address can withdraw.
/// @param _owner The address of a token holder.
/// @return The amount of dividend in wei that `_owner` can withdraw.
function dividendOf(address _owner) external view returns(uint256);
/// @notice Distributes ether to token holders as dividends.
/// @dev SHOULD distribute the paid ether to token holders as dividends.
/// SHOULD NOT directly transfer ether to token holders in this function.
/// MUST emit a `DividendsDistributed` event when the amount of distributed ether is greater than 0.
function distributeDividends(uint256 amount) external;
/// @notice Withdraws the ether distributed to the sender.
/// MUST emit a `DividendWithdrawn` event if the amount of ether transferred is greater than 0.
function withdrawDividend() external;
function setTowerContract(address _address) external;
/// @dev This event MUST emit when ether is distributed to token holders.
/// @param from The address which sends ether to this contract.
/// @param weiAmount The amount of distributed ether in wei.
event DividendsDistributed(address indexed from,
uint256 weiAmount);
/// @dev This event MUST emit when an address withdraws their dividend.
/// @param to The address which withdraws ether from this contract.
/// @param weiAmount The amount of withdrawn ether in wei.
event DividendWithdrawn(address indexed to,
uint256 weiAmount);
}
interface DividendPayingTokenOptionalInterface {
/// @notice View the amount of dividend in wei that an address can withdraw.
/// @param _owner The address of a token holder.
/// @return The amount of dividend in wei that `_owner` can withdraw.
function withdrawableDividendOf(address _owner) external view returns(uint256);
/// @notice View the amount of dividend in wei that an address has withdrawn.
/// @param _owner The address of a token holder.
/// @return The amount of dividend in wei that `_owner` has withdrawn.
function withdrawnDividendOf(address _owner) external view returns(uint256);
/// @notice View the amount of dividend in wei that an address has earned in total.
/// @param _owner The address of a token holder.
/// @return The amount of dividend in wei that `_owner` has earned in total.
function accumulativeDividendOf(address _owner) external view returns(uint256);
}
interface ICBTower {
function getCurrentFloor() external view returns (uint256);
}
contract CBTower is Ownable, ICBTower {
using SafeERC20 for IERC20;
address public BCT;
address public BBT;
address public BWT;
// testnet - 0x80A5DDf29aC4cb3910A18ca5d5B784d2Ef0C1771
/// BSC USDT - 0x55d398326f99059fF775485246999027B3197955
IERC20 public USDT = IERC20(0x80A5DDf29aC4cb3910A18ca5d5B784d2Ef0C1771);
struct UserInfo {
uint256 reinvestRatio;
uint256 joinTime;
uint256 lastUpdateFloor;
// Referrals
address level1;
address level2;
address level3;
address level4;
address level5;
//
uint256[] depositFloors;
uint256[] oldReinvestRatios;
uint256[] oldPendingAmounts;
}
struct FloorInfo {
uint256 startDate;
uint256 endDate;
uint256 collectionAmount;
uint256 totalInvested;
uint256[] reinvestAmounts;
}
uint256 private grandFinalStartTime;
uint256 private grandFinalEndTime;
uint256 public currentFloor;
FloorInfo[] public floorInfo;
mapping(address => UserInfo) public userInfo;
bool public building = true;
event FloorFinished(uint256 floor);
constructor(address _bct, address _bbt, address _bwt) {
BCT = _bct;
BBT = _bbt;
BWT = _bwt;
floorInfo.push(FloorInfo({
startDate: block.timestamp,
endDate: block.timestamp + getBuildTime(),
collectionAmount: getCollectionAmount(),
totalInvested: 0,
reinvestAmounts: new uint256[](1000)
}));
}
/// @dev Public Functions
function invest(address _referral, uint256 amount) public {
// require(amount >= 10**18, "Minimum amount 1 USDT");
USDT.safeTransferFrom(_msgSender(), address(this), amount);
if (floorInfo[currentFloor].endDate <= block.timestamp) {
_stopBuilding();
}
require(building, "Building has finished");
UserInfo storage user = userInfo[_msgSender()];
UserInfo storage referral = userInfo[_referral];
if (user.joinTime == 0) {
user.joinTime = block.timestamp;
user.reinvestRatio = 500;
user.lastUpdateFloor = currentFloor;
if (_referral != address(0)) { // Sets referrals for user
user.level1 = _referral;
user.level2 = referral.level1;
user.level3 = referral.level2;
user.level4 = referral.level3;
user.level5 = referral.level4;
}
} else {
withdrawPendingUSDT();
}
_payReferrals(amount);
uint256 left = amount;
while (left > 0) {
left = _invest(left);
}
uint256 BCTamount = amount * 2 / 10;
DividendPayingTokenInterface(address(BBT)).distributeDividends(BCTamount);
if (user.joinTime + 2 days >= block.timestamp && user.level1 != address(0)) {
IERC20(BCT).mint(_msgSender(), amount);
} else {
IERC20(BCT).mint(_msgSender(), amount * 8 / 10);
}
}
function leftForCurrentFloor() public view returns (uint256) {
return floorInfo[currentFloor].collectionAmount - floorInfo[currentFloor].totalInvested;
}
function changeInvestRatio(uint256 newRatio) public {
require(newRatio >= 500, "Minimum 0.5");
userInfo[_msgSender()].reinvestRatio = newRatio;
}
function getGrandFinalInfo() public view returns (uint256, uint256) {
return (grandFinalStartTime, grandFinalEndTime);
}
function getCurrentFloor() public override view returns (uint256) {
return currentFloor;
}
/// @dev Only Owner Functions
function withdraw() external onlyOwner {
payable(owner()).transfer(address(this).balance);
}
function withdrawERC20(IERC20 token) external onlyOwner {
token.safeTransfer(owner(), token.balanceOf(address(this)));
}
/// @dev Internal Functions
function withdrawPendingUSDT() public {
require(userInfo[_msgSender()].joinTime != 0, "User has not participated");
uint256 amount = _getWithdrawableUSDT(_msgSender());
userInfo[_msgSender()].lastUpdateFloor = currentFloor;
USDT.safeTransfer(_msgSender(), amount);
}
function _getWithdrawableUSDT(address _user) internal view returns (uint256 amount) {
UserInfo storage user = userInfo[_user];
if (user.lastUpdateFloor < currentFloor) {
uint256 _oldDepositAmount;
uint256 _oldReinvestRatio;
for (uint256 x = 0; x < user.depositFloors.length; x++) {
_oldDepositAmount = user.oldPendingAmounts[x];
_oldReinvestRatio = user.oldReinvestRatios[x];
for (uint256 i = currentFloor; i >= user.lastUpdateFloor; i--) {
amount += _oldDepositAmount * (_oldReinvestRatio ** i)/(1000 ** i);
}
}
} else {
amount = 0;
}
}
function getBuildTime() internal view returns (uint256 buildTime) {
buildTime = (currentFloor + 1) * 2 days;
}
function getCollectionAmount() internal view returns (uint256 collectionAmount) {
collectionAmount = (2**currentFloor)*(10**18);
}
function initiateNewFloor() public {
require(floorInfo[currentFloor].totalInvested == floorInfo[currentFloor].collectionAmount, "Not enough is collected");
emit FloorFinished(currentFloor);
floorInfo[currentFloor].endDate = block.timestamp;
currentFloor += 1;
uint256 _startAmount;
floorInfo.push(FloorInfo({
startDate: block.timestamp,
endDate: block.timestamp + getBuildTime(),
collectionAmount: getCollectionAmount(),
totalInvested: 0,
reinvestAmounts: new uint256[](1000)
}));
FloorInfo storage floor = floorInfo[currentFloor];
for (uint256 i = 500; i < 1001; i++) {
if (floorInfo[currentFloor - 1].reinvestAmounts[i] > 0) {
uint256 _amount = floorInfo[currentFloor-1].reinvestAmounts[i] * i / 1000;
floor.reinvestAmounts[i] = _amount;
_startAmount += _amount;
}
}
floor.totalInvested = _startAmount;
}
function _payReferrals(uint256 amount) internal {
UserInfo storage user = userInfo[_msgSender()];
uint256 referralPay;
if (user.level1 != address(0)) {
referralPay = amount * 16 / 100;
IERC20(BCT).mint(user.level1, referralPay);
if (user.level2 != address(0)) {
referralPay = amount * 32 / 1000;
IERC20(BCT).mint(user.level2, referralPay);
if (user.level3 != address(0)) {
referralPay = amount * 64 / 10000;
IERC20(BCT).mint(user.level3, referralPay);
if (user.level4 != address(0)) {
referralPay = amount * 128 / 100000;
IERC20(BCT).mint(user.level4, referralPay);
if (user.level5 != address(0)) {
referralPay = amount * 32 / 100000;
IERC20(BCT).mint(user.level5, referralPay);
}
}
}
}
}
}
function _stopBuilding() internal {
require(floorInfo[currentFloor].endDate <= block.timestamp, "Floor building has not finished");
building = false;
grandFinalStartTime = block.timestamp;
grandFinalEndTime = block.timestamp + 60*60*24;
}
function _invest(uint256 amount) public returns (uint256 left){ // change to internal
FloorInfo storage floor = floorInfo[currentFloor];
UserInfo storage user = userInfo[_msgSender()];
uint256 leftForCurrentFloor_ = floor.collectionAmount - floor.totalInvested;
if (leftForCurrentFloor_ > amount) {
bool found = false;
if (user.depositFloors.length > 0) {
if (user.depositFloors[user.depositFloors.length - 1] == currentFloor) {
user.oldPendingAmounts[user.oldPendingAmounts.length - 1] += amount;
found = true;
}
}
if (!found) {
user.depositFloors.push(currentFloor);
user.oldReinvestRatios.push(user.reinvestRatio);
user.oldPendingAmounts.push(amount);
}
left = 0;
floor.totalInvested += amount;
floor.reinvestAmounts[userInfo[_msgSender()].reinvestRatio] += amount * userInfo[_msgSender()].reinvestRatio / 1000;
} else {
bool found = false;
if (user.depositFloors.length > 0) {
if (user.depositFloors[user.depositFloors.length - 1] == currentFloor) {
user.oldPendingAmounts[user.oldPendingAmounts.length - 1] += leftForCurrentFloor_;
found = true;
}
}
if (!found) {
user.oldPendingAmounts.push(leftForCurrentFloor_);
user.depositFloors.push(currentFloor);
user.oldReinvestRatios.push(user.reinvestRatio);
}
left = amount - leftForCurrentFloor_;
floor.totalInvested += leftForCurrentFloor_;
floor.reinvestAmounts[userInfo[_msgSender()].reinvestRatio] += leftForCurrentFloor_ * userInfo[_msgSender()].reinvestRatio / 1000;
}
if (floor.collectionAmount == floor.totalInvested) {
initiateNewFloor();
}
}
receive() external payable {
revert("This contract is not designed to receive BNB");
}
}
| 100,832 | 11,590 |
23a3a606634e259b82f6308935e24d1f87c0a34e7d2512ad7fef2075422d2fcb
| 15,695 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x6fe797963e0219e9c4162d333d82b357ded5297a.sol
| 3,867 | 15,408 |
pragma solidity >=0.4.25;
library AddressUtils {
function isContract(address addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
contract ERC20Interface {
function allowance(address _from, address _to) public view returns(uint);
function transferFrom(address _from, address _to, uint _sum) public;
function transfer(address _to, uint _sum) public;
function balanceOf(address _owner) public view returns(uint);
}
contract WalletInterface {
function getTransaction(uint _id) public view returns(address, uint, address, uint, uint, bool);
}
contract ContractCreator {
function setContract() public returns(address);
}
contract MaxiCreditCompany {
event Transfer(address indexed _from, address indexed _to, uint _sum);
event TokenBoughtFromContract(address indexed _buyer, uint indexed _promoter, uint _sum);
event TokenBoughtFromSeller(address indexed _buyer, address _seller, uint _amount, uint indexed _offerId);
event Approval(address indexed _seller, address indexed _buyer, uint _amount);
event DescriptionChange(bytes32 _txt);
event NewServer(address indexed _serverAddress, uint indexed _id);
event ServerChanged(address indexed _newServerAddress, address indexed _oldServerAddress, uint indexed _id);
event ETHWithdraw(address indexed _to, uint _sum);
event ERC20Withdraw(address indexed _erc20Address, address indexed _to, uint _sum);
event SupplyIncreased(uint _amount, uint _totalSupply);
event NewSaleOffer(uint indexed saleOffersCounter, uint indexed _amount, uint indexed _unitPrice);
event SetToBuyBack(uint _amount, uint _price);
event BuyBack(uint indexed _amount, uint indexed buyBackPrice);
event SetOwner(uint indexed _id, address indexed _newOwner);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event OwnerDeleted(uint indexed _id, address indexed _owner);
event OperatorRightChanged(address indexed _operator, uint _txRight);
event NewOperator(uint indexed _id, address indexed _newOperator, uint _txRight);
event OperatorChanged(uint indexed _id, address indexed _newOperator, address indexed oldOperator, uint _txRight);
event DeleteOperator(uint indexed _id, address indexed _operator);
event OwnerChangedPrice(uint _priceETH, uint _priceUSD);
event ServerChangedPrice(uint _priceETH, uint _priceUSD);
event NewContract(address indexed _addr, uint indexed newContractsLength);
using AddressUtils for address;
string public name = "MaxiCreditCompanyShare";
string public symbol = "MC2";
uint public supply = 80000000;
uint public decimals = 0;
bytes32 public description;
uint public unitPriceETH;
uint public unitPriceUSD;
uint public shareHoldersNumber;
mapping (address => uint) shareHolderId;
address[] public shareHolders;
bool shareHolderDelete;
address[10] public contractOwner;
address[10] public operator;
uint public ownerCounter;
mapping(address => bool) public isOwner;
mapping(address => bool) public isOperator;
mapping(address => uint) public operatorsRights;
mapping(address => uint) public balanceOf;
mapping(address => mapping(uint => uint)) public saleOffersByAddress;
mapping(uint => address) public saleOffersById;
mapping(uint => uint) public saleOffersAmount;
mapping(uint => uint) public saleOffersUnitPrice;
mapping(address => uint) public sellersOfferCounter;
uint public saleOffersCounter = 0;
uint public buyBackAmount = 0;
uint public buyBackPrice = 0;
mapping(address => mapping(address => uint)) public approvedTransfers;
address[] serverAddress;
mapping (address => bool) isOurServer;
uint serverAddressArrayLength;
ContractCreator cc;
address newContract;
address[] public newContracts;
uint public newContractsLength;
modifier onlyOwner() {
require(isOwner[msg.sender] == true);
require(msg.sender != address(0));
_;
}
modifier onlyOperator() {
require(isOperator[msg.sender] == true);
require(msg.sender != address(0));
_;
}
modifier onlyServer() {
require(isOurServer[msg.sender] == true);
require(msg.sender != address(0));
_;
}
constructor (uint _initPriceETH, uint _initPriceUSD) public {
contractOwner[0] = msg.sender;
isOwner[msg.sender] = true;
operator[0] = msg.sender;
isOperator[msg.sender] = true;
operatorsRights[msg.sender] = 100;
balanceOf[address(this)] = supply;
unitPriceETH = _initPriceETH;
unitPriceUSD = _initPriceUSD;
shareHoldersNumber = 0;
shareHolderDelete = false;
ownerCounter = 1;
}
function getContractOwner(uint _id) public view returns(address) {
return(contractOwner[_id]);
}
function setDescription(bytes32 _txt) public onlyOwner {
description = _txt;
emit DescriptionChange(_txt);
}
function setServerAddress(address _serverAddress) public onlyOwner {
serverAddressArrayLength = serverAddress.push(_serverAddress);
isOurServer[_serverAddress] = true;
emit NewServer(_serverAddress, serverAddressArrayLength - 1);
}
function modifyServer(uint _id, address _serverAddress) public onlyOwner {
address oldServer = serverAddress[_id];
isOurServer[serverAddress[_id]] = false;
serverAddress[_id] = _serverAddress;
isOurServer[_serverAddress] = true;
emit ServerChanged(_serverAddress, oldServer, _id);
}
function getServerAddressLength() public view onlyOperator returns(uint) {
return serverAddressArrayLength;
}
function getServerAddress(uint _num) public view onlyOperator returns(address) {
return serverAddress[_num];
}
function checkServerAddress(address _addr) public view onlyOperator returns(bool) {
return(isOurServer[_addr]);
}
function withdrawal(uint _sum, address _to) public onlyOperator {
require(operatorsRights[msg.sender] * address(this).balance / 100 >= _sum);
require(address(this).balance >= _sum);
require(_to != address(0) && _sum > 0);
address(_to).transfer(_sum);
emit ETHWithdraw(_to, _sum);
}
function withdrawERC20(address _erc20Address, address _to, uint _amount) public onlyOperator {
ERC20Interface ei = ERC20Interface(_erc20Address);
require(operatorsRights[msg.sender] * ei.balanceOf(this) / 100 >= _amount);
require(_erc20Address != address(0) && _to != address(0));
ei.transfer(_to, _amount);
emit ERC20Withdraw(_erc20Address, _to, _amount);
}
function totalSupply() public view returns(uint) {
return(supply);
}
function increaseSupply(uint _amount) public onlyOwner {
supply += _amount;
balanceOf[this] += _amount;
emit SupplyIncreased(_amount, supply);
}
function _transfer(address _from, address _to, uint _sum) private {
require(_from != address(0));
require(_to != address(0));
require(_from != _to);
require(_sum > 0);
require(balanceOf[_from] >= _sum);
require(balanceOf[_to] + _sum >= _sum);
if(balanceOf[_to] == 0) {
shareHolderId[_to] = shareHoldersNumber;
if(shareHolderDelete) {
shareHolders[shareHoldersNumber] = _to;
shareHolderDelete = false;
} else {
shareHolders.push(_to);
}
shareHoldersNumber ++;
}
uint sumBalanceBeforeTx = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _sum;
balanceOf[_to] += _sum;
if(balanceOf[_from] == 0) {
shareHoldersNumber --;
shareHolders[shareHolderId[_from]] = shareHolders[shareHoldersNumber];
shareHolderId[shareHolders[shareHoldersNumber]] = shareHolderId[_from];
delete shareHolders[shareHoldersNumber];
shareHolderDelete = true;
}
assert(sumBalanceBeforeTx == balanceOf[_from] + balanceOf[_to]);
emit Transfer(_from, _to, _sum);
}
function transfer(address _to, uint _sum) external returns(bool) {
_transfer(msg.sender, _to, _sum);
return(true);
}
function transferFromContractsBalance(address _to, uint _sum) public onlyOwner {
require(_to != address(0));
require(this != _to);
require(_sum > 0);
require(balanceOf[this] >= _sum);
require(balanceOf[_to] + _sum >= _sum);
if(balanceOf[_to] == 0) {
shareHolderId[_to] = shareHoldersNumber;
if(shareHolderDelete) {
shareHolders[shareHoldersNumber] = _to;
shareHolderDelete = false;
} else {
shareHolders.push(_to);
}
shareHoldersNumber ++;
}
uint sumBalanceBeforeTx = balanceOf[this] + balanceOf[_to];
balanceOf[this] -= _sum;
balanceOf[_to] += _sum;
assert(sumBalanceBeforeTx == balanceOf[this] + balanceOf[_to]);
emit Transfer(this, _to, _sum);
}
function setToSale(uint _amount, uint _unitPrice) public {
require(balanceOf[msg.sender] >= _amount);
require(_unitPrice > 0);
saleOffersByAddress[msg.sender][sellersOfferCounter[msg.sender]] = saleOffersCounter;
saleOffersById[saleOffersCounter] = msg.sender;
saleOffersAmount[saleOffersCounter] = _amount;
saleOffersUnitPrice[saleOffersCounter] = _unitPrice;
emit NewSaleOffer(saleOffersCounter, _amount, _unitPrice);
sellersOfferCounter[msg.sender] ++;
saleOffersCounter ++;
}
function getSaleOffer(uint _id) public view returns(address, uint, uint) {
return(saleOffersById[_id], saleOffersAmount[_id], saleOffersUnitPrice[_id]);
}
function buyFromSeller(uint _amount, uint _offerId) public payable {
require(saleOffersAmount[_offerId] >= _amount);
uint orderPrice = _amount * saleOffersUnitPrice[_offerId];
require(msg.value == orderPrice);
saleOffersAmount[_offerId] -= _amount;
_transfer(saleOffersById[_offerId], msg.sender, _amount);
uint sellersShare = orderPrice * 99 / 100;
uint toSend = sellersShare;
sellersShare = 0;
saleOffersById[_offerId].transfer(toSend);
emit TokenBoughtFromSeller(msg.sender, saleOffersById[_offerId], _amount, _offerId);
}
function setBuyBack(uint _amount, uint _price) public onlyOperator {
buyBackAmount += _amount;
buyBackPrice = _price;
emit SetToBuyBack(_amount, _price);
}
function buyback(uint _amount) public {
require(buyBackAmount >= _amount);
buyBackAmount -= _amount;
_transfer(msg.sender, this, _amount);
msg.sender.transfer(_amount * buyBackPrice);
emit BuyBack(_amount, buyBackPrice);
}
function getETH(uint _amount) public payable {
require(msg.value == _amount);
}
function setContractOwner(uint _id, address _newOwner) public onlyOwner {
require(contractOwner[_id] == address(0) && !isOwner[_newOwner]);
contractOwner[_id] = _newOwner;
isOwner[_newOwner] = true;
ownerCounter++;
emit SetOwner(_id, _newOwner);
}
function modifyContractOwner(uint _id, address _newOwner) public onlyOwner {
require(contractOwner[_id] != address(0) && contractOwner[_id] != _newOwner);
address previousOwner = contractOwner[_id];
isOwner[contractOwner[_id]] = false;
contractOwner[_id] = _newOwner;
isOwner[_newOwner] = true;
emit OwnershipTransferred(previousOwner, _newOwner);
}
function deleteOwner(uint _id, address _addr) public onlyOwner {
require(ownerCounter > 1);
require(isOwner[_addr] && contractOwner[_id] == _addr);
isOwner[_addr] = false;
contractOwner[_id] = address(0);
ownerCounter--;
emit OwnerDeleted(_id, _addr);
}
function setOperatorsRight(address _operator, uint _txRight) public onlyOwner {
require(_txRight <= 100 && isOperator[_operator]);
operatorsRights[_operator] = _txRight;
emit OperatorRightChanged(_operator, _txRight);
}
function setOperator(uint _id, address _newOperator, uint _txRight) public onlyOwner {
require(_txRight <= 100 && operator[_id] == address(0) && !isOperator[_newOperator]);
operator[_id] = _newOperator;
operatorsRights[_newOperator] = _txRight;
isOperator[_newOperator] = true;
emit NewOperator(_id, _newOperator, _txRight);
}
function modifyOperator(uint _id, address _newOperator, uint _txRight) public onlyOwner {
require(operator[_id] != address(0) && operator[_id] != _newOperator && _txRight < 100);
address oldOperator = operator[_id];
isOperator[operator[_id]] = false;
operatorsRights[operator[_id]] = 0;
isOperator[_newOperator] = true;
operator[_id] = _newOperator;
operatorsRights[_newOperator] = _txRight;
emit OperatorChanged(_id, _newOperator, oldOperator, _txRight);
}
function deleteOperator(uint _id, address _operator) public onlyOwner {
require(isOperator[_operator] && operator[_id] == _operator);
isOperator[_operator] = false;
operatorsRights[_operator] = 0;
operator[_id] = address(0);
emit DeleteOperator(_id, _operator);
}
function getShareNumber(address _addr) public view returns(uint) {
return(balanceOf[_addr]);
}
function approve(address _to, uint _sum) public {
approvedTransfers[msg.sender][_to] += _sum;
emit Approval(msg.sender, _to, _sum);
}
function allowance(address _from, address _to) public view returns(uint) {
return (approvedTransfers[_from][_to]);
}
function transferFrom(address _from, address _to, uint _sum) public {
require(approvedTransfers[_from][msg.sender] >= _sum);
approvedTransfers[_from][msg.sender] -= _sum;
_transfer(_from, _to, _sum);
}
function changePriceByOwner(uint _priceETH, uint _priceUSD) public onlyOwner {
require(_priceETH > 0 && _priceUSD > 0);
unitPriceETH = _priceETH;
unitPriceUSD = _priceUSD;
emit OwnerChangedPrice(_priceETH, _priceUSD);
}
function changePriceByServer(uint _priceETH, uint _priceUSD) public onlyServer {
require(_priceETH > 0 && _priceUSD > 0);
unitPriceETH = _priceETH;
unitPriceUSD = _priceUSD;
emit ServerChangedPrice(_priceETH, _priceUSD);
}
function checkIsShareHolder() public view returns(bool){
if(balanceOf[msg.sender] > 0) {
return(true);
} else {
return(false);
}
}
function getShareHolderRegister() public view returns(address[] memory) {
return(shareHolders);
}
function setNewContract(address _addr) public onlyOperator {
cc = ContractCreator(_addr);
newContract = cc.setContract();
newContracts.push(newContract);
newContractsLength ++;
emit NewContract(_addr, newContractsLength);
}
}
| 163,364 | 11,591 |
4d46f1f86fa75fea8c55442bbc087e82a452cbdf22c155b50dd81e501825fada
| 17,488 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/9e/9e5bDe7c96eb0f892E931Da8535F5f7ae88d8165_TribeUtil.sol
| 3,470 | 15,466 |
pragma solidity >=0.4.24;
// https://docs.tribeone.io/contracts/source/interfaces/itribe
interface ITribe {
// Views
function currencyKey() external view returns (bytes32);
function transferableTribes(address account) external view returns (uint);
// Mutative functions
function transferAndSettle(address to, uint value) external returns (bool);
function transferFromAndSettle(address from,
address to,
uint value) external returns (bool);
// Restricted: used internally to Tribeone
function burn(address account, uint amount) external;
function issue(address account, uint amount) external;
}
interface IVirtualTribe {
// Views
function balanceOfUnderlying(address account) external view returns (uint);
function rate() external view returns (uint);
function readyToSettle() external view returns (bool);
function secsLeftInWaitingPeriod() external view returns (uint);
function settled() external view returns (bool);
function tribe() external view returns (ITribe);
// Mutative functions
function settle(address account) external;
}
// https://docs.tribeone.io/contracts/source/interfaces/itribeetix
interface ITribeone {
// Views
function anyTribeOrHAKARateIsInvalid() external view returns (bool anyRateInvalid);
function availableCurrencyKeys() external view returns (bytes32[] memory);
function availableTribeCount() external view returns (uint);
function availableTribes(uint index) external view returns (ITribe);
function collateral(address account) external view returns (uint);
function collateralisationRatio(address issuer) external view returns (uint);
function debtBalanceOf(address issuer, bytes32 currencyKey) external view returns (uint);
function isWaitingPeriod(bytes32 currencyKey) external view returns (bool);
function maxIssuableTribes(address issuer) external view returns (uint maxIssuable);
function remainingIssuableTribes(address issuer)
external
view
returns (uint maxIssuable,
uint alreadyIssued,
uint totalSystemDebt);
function tribes(bytes32 currencyKey) external view returns (ITribe);
function tribesByAddress(address tribeAddress) external view returns (bytes32);
function totalIssuedTribes(bytes32 currencyKey) external view returns (uint);
function totalIssuedTribesExcludeOtherCollateral(bytes32 currencyKey) external view returns (uint);
function transferableTribeone(address account) external view returns (uint transferable);
function getFirstNonZeroEscrowIndex(address account) external view returns (uint);
// Mutative Functions
function burnTribes(uint amount) external;
function burnTribesOnBehalf(address burnForAddress, uint amount) external;
function burnTribesToTarget() external;
function burnTribesToTargetOnBehalf(address burnForAddress) external;
function exchange(bytes32 sourceCurrencyKey,
uint sourceAmount,
bytes32 destinationCurrencyKey) external returns (uint amountReceived);
function exchangeOnBehalf(address exchangeForAddress,
bytes32 sourceCurrencyKey,
uint sourceAmount,
bytes32 destinationCurrencyKey) external returns (uint amountReceived);
function exchangeWithTracking(bytes32 sourceCurrencyKey,
uint sourceAmount,
bytes32 destinationCurrencyKey,
address rewardAddress,
bytes32 trackingCode) external returns (uint amountReceived);
function exchangeWithTrackingForInitiator(bytes32 sourceCurrencyKey,
uint sourceAmount,
bytes32 destinationCurrencyKey,
address rewardAddress,
bytes32 trackingCode) external returns (uint amountReceived);
function exchangeOnBehalfWithTracking(address exchangeForAddress,
bytes32 sourceCurrencyKey,
uint sourceAmount,
bytes32 destinationCurrencyKey,
address rewardAddress,
bytes32 trackingCode) external returns (uint amountReceived);
function exchangeWithVirtual(bytes32 sourceCurrencyKey,
uint sourceAmount,
bytes32 destinationCurrencyKey,
bytes32 trackingCode) external returns (uint amountReceived, IVirtualTribe vTribe);
function exchangeAtomically(bytes32 sourceCurrencyKey,
uint sourceAmount,
bytes32 destinationCurrencyKey,
bytes32 trackingCode,
uint minAmount) external returns (uint amountReceived);
function issueMaxTribes() external;
function issueMaxTribesOnBehalf(address issueForAddress) external;
function issueTribes(uint amount) external;
function issueTribesOnBehalf(address issueForAddress, uint amount) external;
function mint() external returns (bool);
function settle(bytes32 currencyKey)
external
returns (uint reclaimed,
uint refunded,
uint numEntries);
// Liquidations
function liquidateDelinquentAccount(address account) external returns (bool);
function liquidateDelinquentAccountEscrowIndex(address account, uint escrowStartIndex) external returns (bool);
function liquidateSelf() external returns (bool);
// Restricted Functions
function mintSecondary(address account, uint amount) external;
function mintSecondaryRewards(uint amount) external;
function burnSecondary(address account, uint amount) external;
function revokeAllEscrow(address account) external;
function migrateAccountBalances(address account) external returns (uint totalEscrowRevoked, uint totalLiquidBalance);
}
pragma experimental ABIEncoderV2;
// https://docs.tribeone.io/contracts/source/interfaces/IDirectIntegration
interface IDirectIntegrationManager {
struct ParameterIntegrationSettings {
bytes32 currencyKey;
address dexPriceAggregator;
address atomicEquivalentForDexPricing;
uint atomicExchangeFeeRate;
uint atomicTwapWindow;
uint atomicMaxVolumePerBlock;
uint atomicVolatilityConsiderationWindow;
uint atomicVolatilityUpdateThreshold;
uint exchangeFeeRate;
uint exchangeMaxDynamicFee;
uint exchangeDynamicFeeRounds;
uint exchangeDynamicFeeThreshold;
uint exchangeDynamicFeeWeightDecay;
}
function getExchangeParameters(address integration, bytes32 key)
external
view
returns (ParameterIntegrationSettings memory settings);
function setExchangeParameters(address integration,
bytes32[] calldata currencyKeys,
ParameterIntegrationSettings calldata params) external;
}
// https://docs.tribeone.io/contracts/source/interfaces/iexchangerates
interface IExchangeRates {
// Structs
struct RateAndUpdatedTime {
uint216 rate;
uint40 time;
}
// Views
function aggregators(bytes32 currencyKey) external view returns (address);
function aggregatorWarningFlags() external view returns (address);
function anyRateIsInvalid(bytes32[] calldata currencyKeys) external view returns (bool);
function anyRateIsInvalidAtRound(bytes32[] calldata currencyKeys, uint[] calldata roundIds) external view returns (bool);
function currenciesUsingAggregator(address aggregator) external view returns (bytes32[] memory);
function effectiveValue(bytes32 sourceCurrencyKey,
uint sourceAmount,
bytes32 destinationCurrencyKey) external view returns (uint value);
function effectiveValueAndRates(bytes32 sourceCurrencyKey,
uint sourceAmount,
bytes32 destinationCurrencyKey)
external
view
returns (uint value,
uint sourceRate,
uint destinationRate);
function effectiveValueAndRatesAtRound(bytes32 sourceCurrencyKey,
uint sourceAmount,
bytes32 destinationCurrencyKey,
uint roundIdForSrc,
uint roundIdForDest)
external
view
returns (uint value,
uint sourceRate,
uint destinationRate);
function effectiveAtomicValueAndRates(bytes32 sourceCurrencyKey,
uint sourceAmount,
bytes32 destinationCurrencyKey)
external
view
returns (uint value,
uint systemValue,
uint systemSourceRate,
uint systemDestinationRate);
function effectiveAtomicValueAndRates(IDirectIntegrationManager.ParameterIntegrationSettings calldata sourceSettings,
uint sourceAmount,
IDirectIntegrationManager.ParameterIntegrationSettings calldata destinationSettings,
IDirectIntegrationManager.ParameterIntegrationSettings calldata usdSettings)
external
view
returns (uint value,
uint systemValue,
uint systemSourceRate,
uint systemDestinationRate);
function getCurrentRoundId(bytes32 currencyKey) external view returns (uint);
function getLastRoundIdBeforeElapsedSecs(bytes32 currencyKey,
uint startingRoundId,
uint startingTimestamp,
uint timediff) external view returns (uint);
function lastRateUpdateTimes(bytes32 currencyKey) external view returns (uint256);
function rateAndTimestampAtRound(bytes32 currencyKey, uint roundId) external view returns (uint rate, uint time);
function rateAndUpdatedTime(bytes32 currencyKey) external view returns (uint rate, uint time);
function rateAndInvalid(bytes32 currencyKey) external view returns (uint rate, bool isInvalid);
function rateForCurrency(bytes32 currencyKey) external view returns (uint);
function rateIsFlagged(bytes32 currencyKey) external view returns (bool);
function rateIsInvalid(bytes32 currencyKey) external view returns (bool);
function rateIsStale(bytes32 currencyKey) external view returns (bool);
function rateStalePeriod() external view returns (uint);
function ratesAndUpdatedTimeForCurrencyLastNRounds(bytes32 currencyKey,
uint numRounds,
uint roundId) external view returns (uint[] memory rates, uint[] memory times);
function ratesAndInvalidForCurrencies(bytes32[] calldata currencyKeys)
external
view
returns (uint[] memory rates, bool anyRateInvalid);
function ratesForCurrencies(bytes32[] calldata currencyKeys) external view returns (uint[] memory);
function tribeTooVolatileForAtomicExchange(bytes32 currencyKey) external view returns (bool);
function tribeTooVolatileForAtomicExchange(IDirectIntegrationManager.ParameterIntegrationSettings calldata settings)
external
view
returns (bool);
function rateWithSafetyChecks(bytes32 currencyKey)
external
returns (uint rate,
bool broken,
bool invalid);
}
// https://docs.tribeone.io/contracts/source/interfaces/iaddressresolver
interface IAddressResolver {
function getAddress(bytes32 name) external view returns (address);
function getTribe(bytes32 key) external view returns (address);
function requireAndGetAddress(bytes32 name, string calldata reason) external view returns (address);
}
// https://docs.tribeone.io/contracts/source/interfaces/ierc20
interface IERC20 {
// ERC20 Optional Views
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
// Views
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
// Mutative functions
function transfer(address to, uint value) external returns (bool);
function approve(address spender, uint value) external returns (bool);
function transferFrom(address from,
address to,
uint value) external returns (bool);
// Events
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
// Inheritance
// https://docs.tribeone.io/contracts/source/contracts/tribeutil
contract TribeUtil {
IAddressResolver public addressResolverProxy;
bytes32 internal constant CONTRACT_TRIBEONEETIX = "Tribeone";
bytes32 internal constant CONTRACT_EXRATES = "ExchangeRates";
bytes32 internal constant HUSD = "hUSD";
constructor(address resolver) public {
addressResolverProxy = IAddressResolver(resolver);
}
function _tribeetix() internal view returns (ITribeone) {
return ITribeone(addressResolverProxy.requireAndGetAddress(CONTRACT_TRIBEONEETIX, "Missing Tribeone address"));
}
function _exchangeRates() internal view returns (IExchangeRates) {
return IExchangeRates(addressResolverProxy.requireAndGetAddress(CONTRACT_EXRATES, "Missing ExchangeRates address"));
}
function totalTribesInKey(address account, bytes32 currencyKey) external view returns (uint total) {
ITribeone tribeone = _tribeetix();
IExchangeRates exchangeRates = _exchangeRates();
uint numTribes = tribeone.availableTribeCount();
for (uint i = 0; i < numTribes; i++) {
ITribe tribe = tribeone.availableTribes(i);
total += exchangeRates.effectiveValue(tribe.currencyKey(),
IERC20(address(tribe)).balanceOf(account),
currencyKey);
}
return total;
}
function tribesBalances(address account)
external
view
returns (bytes32[] memory,
uint[] memory,
uint[] memory)
{
ITribeone tribeone = _tribeetix();
IExchangeRates exchangeRates = _exchangeRates();
uint numTribes = tribeone.availableTribeCount();
bytes32[] memory currencyKeys = new bytes32[](numTribes);
uint[] memory balances = new uint[](numTribes);
uint[] memory hUSDBalances = new uint[](numTribes);
for (uint i = 0; i < numTribes; i++) {
ITribe tribe = tribeone.availableTribes(i);
currencyKeys[i] = tribe.currencyKey();
balances[i] = IERC20(address(tribe)).balanceOf(account);
hUSDBalances[i] = exchangeRates.effectiveValue(currencyKeys[i], balances[i], HUSD);
}
return (currencyKeys, balances, hUSDBalances);
}
function tribesRates() external view returns (bytes32[] memory, uint[] memory) {
bytes32[] memory currencyKeys = _tribeetix().availableCurrencyKeys();
return (currencyKeys, _exchangeRates().ratesForCurrencies(currencyKeys));
}
function tribesTotalSupplies()
external
view
returns (bytes32[] memory,
uint256[] memory,
uint256[] memory)
{
ITribeone tribeone = _tribeetix();
IExchangeRates exchangeRates = _exchangeRates();
uint256 numTribes = tribeone.availableTribeCount();
bytes32[] memory currencyKeys = new bytes32[](numTribes);
uint256[] memory balances = new uint256[](numTribes);
uint256[] memory hUSDBalances = new uint256[](numTribes);
for (uint256 i = 0; i < numTribes; i++) {
ITribe tribe = tribeone.availableTribes(i);
currencyKeys[i] = tribe.currencyKey();
balances[i] = IERC20(address(tribe)).totalSupply();
hUSDBalances[i] = exchangeRates.effectiveValue(currencyKeys[i], balances[i], HUSD);
}
return (currencyKeys, balances, hUSDBalances);
}
}
| 52,886 | 11,592 |
63defb3daa9535ecc35d8c7fa00943cde778fc1ea55a3e21e94646b82e236966
| 7,205 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0x0a0f4ebbbfe006ee073d703245d1ede47d6c4c69.sol
| 5,746 | 7,164 |
pragma solidity ^0.8.10;
library GenesisTraitFactory {
uint constant public NUM_TRAITS = 9;
uint constant public MAX_LENGTH = 40;
function roll(uint seed) external pure returns(uint[NUM_TRAITS] memory){
uint[NUM_TRAITS] memory traits;
uint[MAX_LENGTH][4][NUM_TRAITS] memory genes;
uint[NUM_TRAITS] memory parsedSeed;
for (uint i = 0; i < NUM_TRAITS; i++) {
parsedSeed[i] = uint(keccak256(abi.encodePacked(seed, i, "trait")));
}
uint[2][2] memory races;
races[0] = [uint(1), 2];
races[1] = [uint(50), 100];
genes[1][0] = [uint(0), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23];
genes[1][1] = [uint(0), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23];
genes[1][2] = [uint(0), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 120, 240, 360, 480, 600, 680, 790, 870, 950, 1026, 1136, 1240, 1350, 1460, 1570, 1680, 1720, 1760, 1840, 1870, 1925, 1980, 2000];
genes[1][3] = [uint(0), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 120, 240, 360, 480, 600, 680, 790, 870, 950, 1026, 1136, 1240, 1350, 1460, 1570, 1680, 1720, 1760, 1840, 1870, 1925, 1980, 2000];
genes[2][0] = [uint(0), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
genes[2][1] = [uint(0), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
genes[2][2] = [uint(0), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 50, 62, 72, 76, 90, 104, 118, 132, 146, 158, 172, 181, 189, 197, 198, 200];
genes[2][3] = [uint(0), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 50, 62, 72, 76, 90, 104, 118, 132, 146, 158, 172, 181, 189, 197, 198, 200];
genes[3][0] = [uint(0), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 4, 5, 6, 9, 11];
genes[3][1] = [uint(0), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 7, 8, 10];
genes[3][2] = [uint(0), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, 50, 57, 81, 88, 90];
genes[3][3] = [uint(0), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 20, 35, 45, 50, 55];
genes[4][0] = [uint(0), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 5, 9, 10, 11, 12, 13, 14, 15, 16, 18, 20, 21, 22, 23, 24];
genes[4][1] = [uint(0), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 15, 17, 19, 20, 21, 22, 23, 24, 25];
genes[4][2] = [uint(0), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 30, 45, 55, 61, 67, 74, 80, 86, 94, 98, 102, 104, 108, 114, 120, 124, 125];
genes[4][3] = [uint(0), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 35, 45, 55, 65, 75, 81, 87, 94, 100, 106, 110, 116, 118, 122, 128, 134, 138, 139, 141];
genes[5][0] = [uint(0), 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37];
genes[5][1] = [uint(0), 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37];
genes[5][2] = [uint(0), 0, 30, 55, 73, 113, 153, 193, 238, 268, 288, 318, 333, 373, 418, 458, 488, 533, 563, 603, 643, 688, 708, 753, 768, 793, 818, 843, 873, 890, 910, 935, 955, 980, 982, 984, 986, 988, 990, 1000];
genes[5][3] = [uint(0), 0, 30, 55, 73, 113, 153, 193, 238, 268, 288, 318, 333, 373, 418, 458, 488, 533, 563, 603, 643, 688, 708, 753, 768, 793, 818, 843, 873, 890, 910, 935, 955, 980, 982, 984, 986, 988, 990, 1000];
genes[6][0] = [uint(0), 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33];
genes[6][1] = [uint(0), 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33];
genes[6][2] = [uint(0), 0, 0, 0, 0, 0, 0, 8, 16, 19, 23, 31, 39, 47, 52, 54, 60, 62, 70, 76, 84, 92, 98, 104, 110, 116, 123, 129, 135, 143, 148, 153, 160, 168, 174, 179, 185, 187, 192, 200];
genes[6][3] = [uint(0), 0, 0, 0, 0, 0, 0, 8, 16, 19, 23, 31, 39, 47, 52, 54, 60, 62, 70, 76, 84, 92, 98, 104, 110, 116, 123, 129, 135, 143, 148, 153, 160, 168, 174, 179, 185, 187, 192, 200];
genes[7][0] = [uint(0), 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40];
genes[7][1] = [uint(0), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 6, 11, 13, 14, 15, 16, 17, 18, 19, 20, 21, 24, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40];
genes[7][2] = [uint(290), 310, 316, 436, 556, 676, 756, 796, 876, 1036, 1066, 1096, 1176, 1276, 1316, 1356, 1396, 1456, 1536, 1576, 1616, 1696, 1726, 1766, 1796, 1826, 1856, 1876, 1882, 1892, 1898, 1905, 1921, 1930, 1934, 1938, 1942, 1946, 1950, 1970];
genes[7][3] = [uint(0), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 290, 296, 376, 406, 506, 546, 586, 626, 686, 766, 806, 846, 926, 956, 986, 1006, 1012, 1022, 1028, 1035, 1051, 1060, 1064, 1068, 1072, 1076, 1080, 1100];
genes[8][0] = [uint(0), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22];
genes[8][1] = [uint(0), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22];
genes[8][2] = [uint(0), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 690, 710, 730, 750, 770, 790, 810, 815, 835, 855, 875, 890, 905, 925, 945, 965, 967, 969, 971, 973, 975, 985, 1000];
genes[8][3] = [uint(0), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 690, 710, 730, 750, 770, 790, 810, 815, 835, 855, 875, 890, 905, 925, 945, 965, 967, 969, 971, 973, 975, 985, 1000];
uint r;
for (uint i = 0; i < races[1].length; i++) {
if (parsedSeed[0] % races[1][1] < races[1][i]) {
r = i;
traits[0] = races[0][i];
break;
}
}
for (uint i = 1; i < NUM_TRAITS; i++) {
uint traitSeed = parsedSeed[i] % genes[i][2+r][MAX_LENGTH-1];
for (uint j = 0; j < MAX_LENGTH; j++) {
if (traitSeed < genes[i][2+r][j]) {
traits[i] = genes[i][r][j];
break;
}
}
}
if (traits[6] == 3 || traits[6] == 21 || traits[6] == 22 || traits[6] == 28) {
traits[4] = 0;
}
if (traits[7] == 28 || traits[7] == 29 || traits[7] == 31 || traits[7] == 33) {
traits[5] = 0;
}
if (traits[7] == 32 || traits[7] == 36 || traits[7] == 37) {
traits[4] = 0;
traits[6] = 0;
}
if (traits[7] == 40) {
traits[4] = 0;
traits[5] = 0;
traits[6] = 0;
}
return traits;
}
}
| 275,749 | 11,593 |
e4e056de67461a719ce763cfe45dcf4e1b4dbb704e0bb2bdc15b33b1bc13e8f6
| 20,418 |
.sol
|
Solidity
| false |
316275714
|
giacomofi/Neural_Smart_Ponzi_Recognition
|
a26fb280753005b9b9fc262786d5ce502b3f8cd3
|
Not_Smart_Ponzi_Source_Code/0x94d940ceb4eb87a18c903804bb2c44910edb6453.sol
| 3,241 | 12,706 |
pragma solidity 0.5.14;
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(!has(role, account), "Roles: account already has role");
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(has(role, account), "Roles: account does not have role");
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0), "Roles: account is the zero address");
return role.bearer[account];
}
}
contract LexDAORole is Context {
using Roles for Roles.Role;
event LexDAOAdded(address indexed account);
event LexDAORemoved(address indexed account);
Roles.Role private _lexDAOs;
constructor () internal {
_addLexDAO(_msgSender());
}
modifier onlyLexDAO() {
require(isLexDAO(_msgSender()), "LexDAORole: caller does not have the LexDAO role");
_;
}
function isLexDAO(address account) public view returns (bool) {
return _lexDAOs.has(account);
}
function addLexDAO(address account) public onlyLexDAO {
_addLexDAO(account);
}
function renounceLexDAO() public {
_removeLexDAO(_msgSender());
}
function _addLexDAO(address account) internal {
_lexDAOs.add(account);
emit LexDAOAdded(account);
}
function _removeLexDAO(address account) internal {
_lexDAOs.remove(account);
emit LexDAORemoved(account);
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ICHAI {
function balanceOf(address usr) external returns (uint);
function transfer(address dst, uint wad) external returns (bool);
function dai(address usr) external returns (uint wad);
function dai(uint chai) external returns (uint wad);
function join(address dst, uint wad) external;
}
interface ICERC20 {
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function mint(uint256) external returns (uint256);
function exchangeRateCurrent() external returns (uint256);
function supplyRatePerBlock() external returns (uint256);
}
contract LexGrow is LexDAORole { // Deal depositing for Digital Dollars that earn on DSR & Compound
using SafeMath for uint256;
// $DAI details:
address private daiToken = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
IERC20 public dai = IERC20(daiToken);
// $CHAI details:
address private chaiToken = 0x06AF07097C9Eeb7fD685c692751D5C66dB49c215;
ICHAI public chai = ICHAI(chaiToken);
// <$> LXG <$> details:
address private vault = address(this);
address payable public manager;
uint8 public version = 2;
uint256 public depositFee;
uint256 public lxg; // index for registered LexGrow
string public emoji = "";
mapping (uint256 => Deposit) public deposit;
struct Deposit {
address client;
address provider;
address compoundToken;
uint256 amount;
uint256 wrap;
uint256 termination;
uint256 index;
string details;
bool dsr;
bool disputed;
bool released;
}
// LXG Contract Events:
event Log(string, uint256); // log for Compound interactions
event Registered(address indexed client, address indexed provider, uint256 indexed index);
event Released(uint256 indexed index);
event Disputed(uint256 indexed index, string indexed details);
event Resolved(address indexed resolver, uint256 indexed index, string indexed details);
event ManagerTransferred(address indexed manager, string indexed details);
constructor () public {
dai.approve(chaiToken, uint(-1));
manager = msg.sender;
depositFee = 0;
}
function dealDepositDSR(// register $DAI deal deposit with DSR via $CHAI; arbitration via lexDAO
address provider,
uint256 amount,
uint256 termination,
string memory details) public payable {
require(msg.value == depositFee);
uint256 index = lxg.add(1);
lxg = lxg.add(1);
dai.transferFrom(msg.sender, vault, amount); // deposit $DAI
uint256 balance = chai.balanceOf(vault);
chai.join(vault, amount); // wrap into $CHAI and store in vault
deposit[index] = Deposit(// log deal deposit details
msg.sender,
provider,
chaiToken,
amount,
chai.balanceOf(vault).sub(balance),
termination,
index,
details,
true,
false,
false);
address(manager).transfer(msg.value);
emit Registered(msg.sender, provider, index);
}
function dealDepositCompound(// register $cToken deal deposit with interest via Compound; arbitration via lexDAO
address provider,
address underlyingToken,
address compoundToken,
uint256 amount,
uint256 termination,
string memory details) public payable returns (uint) {
require(msg.value == depositFee);
IERC20 uToken = IERC20(underlyingToken);
ICERC20 cToken = ICERC20(compoundToken);
// Amount of current exchange rate from $cToken to underlying
uint256 exchangeRateMantissa = cToken.exchangeRateCurrent();
emit Log("Exchange Rate (scaled up by 1e18)", exchangeRateMantissa);
// Amount added to supply balance this block
uint256 supplyRateMantissa = cToken.supplyRatePerBlock();
emit Log("Supply Rate: (scaled up by 1e18)", supplyRateMantissa);
// Approve transfer on underlying ERC20 token contract
uToken.approve(compoundToken, amount);
// Mint cTokens
uToken.transferFrom(msg.sender, vault, amount); // deposit $uToken
uint256 balance = cToken.balanceOf(vault);
uint mintResult = cToken.mint(amount); // wrap into $cToken and store in vault
uint256 index = lxg.add(1);
lxg = lxg.add(1);
deposit[index] = Deposit(// log deal deposit details
msg.sender,
provider,
compoundToken,
amount,
cToken.balanceOf(vault).sub(balance),
termination,
index,
details,
false,
false,
false);
address(manager).transfer(msg.value);
emit Registered(msg.sender, provider, index);
return mintResult;
}
function release(uint256 index) public {
Deposit storage depos = deposit[index];
require(depos.disputed == false); // program safety check / status
require(depos.released == false); // program safety check / status
require(now <= depos.termination); // program safety check / time
require(msg.sender == depos.client); // program safety check / authorization
if (depos.dsr == true) {
chai.transfer(depos.provider, depos.wrap);
} else {
ICERC20 cToken = ICERC20(depos.compoundToken);
cToken.transfer(depos.provider, depos.wrap);
}
depos.released = true;
emit Released(index);
}
function withdraw(uint256 index) public { // withdraw deposit wrap if termination time passes
Deposit storage depos = deposit[index];
require(depos.disputed == false); // program safety check / status
require(depos.released == false); // program safety check / status
require(now >= depos.termination); // program safety check / time
if (depos.dsr == true) {
chai.transfer(depos.client, depos.wrap);
} else {
ICERC20 cToken = ICERC20(depos.compoundToken);
cToken.transfer(depos.client, depos.wrap);
}
depos.released = true;
emit Released(index);
}
function dispute(uint256 index, string memory details) public {
Deposit storage depos = deposit[index];
require(depos.released == false); // program safety check / status
require(now <= depos.termination); // program safety check / time
require(msg.sender == depos.client || msg.sender == depos.provider); // program safety check / authorization
depos.disputed = true;
emit Disputed(index, details);
}
function resolve(uint256 index, uint256 clientAward, uint256 providerAward, string memory details) public onlyLexDAO {
Deposit storage depos = deposit[index];
require(depos.disputed == true); // program safety check / status
require(depos.released == false); // program safety check / status
require(clientAward.add(providerAward) == depos.wrap); // program safety check / economics
require(msg.sender != depos.client); // program safety check / authorization
require(msg.sender != depos.provider); // program safety check / authorization
if (depos.dsr == true) {
chai.transfer(depos.client, clientAward);
chai.transfer(depos.provider, providerAward);
} else {
ICERC20 cToken = ICERC20(depos.compoundToken);
cToken.transfer(depos.client, clientAward);
cToken.transfer(depos.provider, providerAward);
}
depos.released = true;
emit Resolved(msg.sender, index, details);
}
function newDepositFee(uint256 weiAmount) public {
require(msg.sender == manager);
depositFee = weiAmount;
}
function transferManager(address payable newManager, string memory details) public {
require(msg.sender == manager);
manager = newManager;
emit ManagerTransferred(manager, details);
}
}
| 339,724 | 11,594 |
486c40bada26a5098c9b3206fba1b659eabf4a2058ddd70db1d620e2c869867e
| 15,400 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/contractAffectedByMiners/0xC97D1afEF1E886849f63840566aFFE9ff9Ec3328_affectedByMiners.sol
| 3,118 | 12,685 |
pragma solidity ^0.5.0;
// openzeppelin-solidity@2.3.0 from NPM
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
contract ValidatorManagerContract {
using SafeMath for uint256;
/// \frac{threshold_num}{threshold_denom} signatures are required for
/// validator approval to be granted
uint8 public threshold_num;
uint8 public threshold_denom;
/// The list of currently elected validators
address[] public validators;
/// The powers of the currently elected validators
uint64[] public powers;
/// The current sum of powers of currently elected validators
uint256 public totalPower;
/// Nonce tracking per to prevent replay attacks on signature
/// submission during validator rotation
uint256 public nonce;
/// Address of the loom token
address public loomAddress;
/// @notice Event to log the change of the validator set.
/// @param _validators The initial list of validators
/// @param _powers The initial list of powers of each validator
event ValidatorSetChanged(address[] _validators, uint64[] _powers);
/// @notice View function that returns the powers array.
/// @dev Solidity should have exposed a getter function since the variable is declared public.
/// @return powers The powers of the currently elected validators
function getPowers() public view returns(uint64[] memory) {
return powers;
}
/// @notice View function that returns the validators array.
/// @dev Solidity should have exposed a getter function since the variable is declared public.
/// @return validators The currently elected validators
function getValidators() public view returns(address[] memory) {
return validators;
}
/// @notice Initialization of the system
/// @param _validators The initial list of validators
/// @param _powers The initial list of powers of each validator
/// @param _threshold_num The numerator of the fraction of power that needs
/// to sign for a call to be approved by a validator
/// @param _threshold_denom The denominator of the fraction of power that needs
/// to sign for a call to be approved by a validator
/// @param _loomAddress The LOOM token address
constructor (address[] memory _validators,
uint64[] memory _powers,
uint8 _threshold_num,
uint8 _threshold_denom,
address _loomAddress)
public
{
threshold_num = _threshold_num;
threshold_denom = _threshold_denom;
require(threshold_num <= threshold_denom && threshold_num > 0, "Invalid threshold fraction.");
loomAddress = _loomAddress;
_rotateValidators(_validators, _powers);
}
/// validators, otherwise reverts)
/// @param _loomAddress The new loom token address
/// @param _signersIndexes Array of indexes of the validator's signatures based on
/// the currently elected validators
/// @param _v Array of `v` values from the validator signatures
/// @param _r Array of `r` values from the validator signatures
/// @param _s Array of `s` values from the validator signatures
function setLoom(address _loomAddress,
uint256[] calldata _signersIndexes, // Based on: https://github.com/cosmos/peggy/blob/master/ethereum-contracts/contracts/Valset.sol#L75
uint8[] calldata _v,
bytes32[] calldata _r,
bytes32[] calldata _s)
external
{
// Hash the address of the contract along with the nonce and the
// updated loom token address.
bytes32 message = createMessage(keccak256(abi.encodePacked(_loomAddress)));
// Check if the signatures match the threshold set in the constructor
checkThreshold(message, _signersIndexes, _v, _r, _s);
// Update state
loomAddress = _loomAddress;
nonce++;
}
/// @notice Changes the threshold of signatures required to pass the
/// validators, otherwise reverts)
/// @param _num The new numerator
/// @param _denom The new denominator
/// @param _signersIndexes Array of indexes of the validator's signatures based on
/// the currently elected validators
/// @param _v Array of `v` values from the validator signatures
/// @param _r Array of `r` values from the validator signatures
/// @param _s Array of `s` values from the validator signatures
function setQuorum(uint8 _num,
uint8 _denom,
uint256[] calldata _signersIndexes, // Based on: https://github.com/cosmos/peggy/blob/master/ethereum-contracts/contracts/Valset.sol#L75
uint8[] calldata _v,
bytes32[] calldata _r,
bytes32[] calldata _s)
external
{
require(_num <= _denom && _num > 0, "Invalid threshold fraction");
// Hash the address of the contract along with the nonce and the
// updated validator set.
bytes32 message = createMessage(keccak256(abi.encodePacked(_num, _denom)));
// Check if the signatures match the threshold set in the consutrctor
checkThreshold(message, _signersIndexes, _v, _r, _s);
threshold_num = _num;
threshold_denom = _denom;
nonce++;
}
/// @notice Updates the validator set with new validators and powers
/// (requires signatures from at least `threshold_num/threshold_denom`
/// validators, otherwise reverts)
/// @param _newValidators The new validator set
/// @param _newPowers The new list of powers corresponding to the validator set
/// @param _signersIndexes Array of indexes of the validator's signatures based on
/// the currently elected validators
/// @param _v Array of `v` values from the validator signatures
/// @param _r Array of `r` values from the validator signatures
/// @param _s Array of `s` values from the validator signatures
function rotateValidators(address[] calldata _newValidators,
uint64[] calldata _newPowers,
uint256[] calldata _signersIndexes, // Based on: https://github.com/cosmos/peggy/blob/master/ethereum-contracts/contracts/Valset.sol#L75
uint8[] calldata _v,
bytes32[] calldata _r,
bytes32[] calldata _s)
external
{
// Hash the address of the contract along with the nonce and the
// updated validator set and powers.
bytes32 message = createMessage(keccak256(abi.encodePacked(_newValidators,_newPowers)));
// Check if the signatures match the threshold set in the consutrctor
checkThreshold(message, _signersIndexes, _v, _r, _s);
// update validator set
_rotateValidators(_newValidators, _newPowers);
nonce++;
}
/// @notice Checks if the provided signature is valid on message by the
/// validator corresponding to `signersIndex`. Reverts if check fails
/// @param _message The messsage hash that was signed
/// @param _signersIndex The validator's index in the `validators` array
/// @param _v The v value of the validator's signature
/// @param _r The r value of the validator's signature
/// @param _s The s value of the validator's signature
function signedByValidator(bytes32 _message,
uint256 _signersIndex,
uint8 _v,
bytes32 _r,
bytes32 _s)
public
view
{
// prevent replay attacks by adding the nonce in the sig
// if a validator signs an invalid nonce,
// it won't pass the signature verification
// since the nonce in the hash is stored in the contract
address signer = ecrecover(_message, _v, _r, _s);
require(validators[_signersIndex] == signer, "Message not signed by a validator");
}
/// @notice Completes if the message being passed was signed by the required
/// threshold of validators, otherwise reverts
/// @param _signersIndexes Array of indexes of the validator's signatures based on
/// the currently elected validators
/// @param _v Array of `v` values from the validator signatures
/// @param _r Array of `r` values from the validator signatures
/// @param _s Array of `s` values from the validator signatures
function checkThreshold(bytes32 _message, uint256[] memory _signersIndexes, uint8[] memory _v, bytes32[] memory _r, bytes32[] memory _s) public view {
uint256 sig_length = _v.length;
require(sig_length <= validators.length,
"checkThreshold:: Cannot submit more signatures than existing validators");
require(sig_length > 0 && sig_length == _r.length && _r.length == _s.length && sig_length == _signersIndexes.length,
"checkThreshold:: Incorrect number of params");
// Signed message prefix
bytes32 hash = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", _message));
// Get total voted power while making sure all signatures submitted
// were by validators without duplication
uint256 votedPower;
for (uint256 i = 0; i < sig_length; i++) {
if (block.gaslimit > 0) { //injected CONTRACT AFFECTED BY MINERS
require(_signersIndexes[i] > _signersIndexes[i-1]);
}
// Skip malleable signatures / maybe better to revert instead of skipping?
if (block.timestamp > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) { //injected CONTRACT AFFECTED BY MINERS
continue;
}
address signer = ecrecover(hash, _v[i], _r[i], _s[i]);
require(signer == validators[_signersIndexes[i]], "checkThreshold:: Recovered address is not a validator");
votedPower = votedPower.add(powers[_signersIndexes[i]]);
}
require(votedPower * threshold_denom >= totalPower *
threshold_num, "checkThreshold:: Not enough power from validators");
}
/// @notice Internal method that updates the state with the new validator
/// set and powers, as well as the new total power
/// @param _validators The initial list of validators
/// @param _powers The initial list of powers of each validator
function _rotateValidators(address[] memory _validators, uint64[] memory _powers) internal {
uint256 val_length = _validators.length;
require(val_length == _powers.length, "_rotateValidators: Array lengths do not match!");
require(val_length > 0, "Must provide more than 0 validators");
uint256 _totalPower = 0;
for (uint256 i = 0; i < val_length; i++) {
_totalPower = _totalPower.add(_powers[i]);
}
// Set total power
totalPower = _totalPower;
// Set validators and their powers
validators = _validators;
powers = _powers;
emit ValidatorSetChanged(_validators, _powers);
}
/// @notice Creates the message hash that includes replay protection and
/// binds the hash to this contract only.
/// @param hash The hash of the message being signed
/// @return A hash on the hash of the message
function createMessage(bytes32 hash)
private
view returns (bytes32)
{
return keccak256(abi.encodePacked(address(this),
nonce,
hash));
}
}
| 281,355 | 11,595 |
6729ddf4724acf0c73732b512fe973ded6ccffc7275b01e7247b5474f0064466
| 23,215 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TM/TMohAvXmBAp7PSGbRnwBRQR97rHe3ZFeyh_TrustTron.sol
| 6,194 | 22,174 |
//SourceUnit: contract.sol
pragma solidity ^0.5.4;
contract capacitor{
function decharge(uint256 money) public returns(uint256);
function charge() payable public;
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = msg.sender;
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Pausable is Ownable{
event Paused(address account);
event Unpaused(address account);
bool private _charged;
bool private _paused;
address payable _capacitor;
constructor () internal {
_paused = false;
_charged = false;
}
function paused() public view returns (bool) {
return _paused;
}
function isCharging() internal view returns (bool) {
return _charged;
}
function setCapacitor(address payable cap) public onlyOwner{
_capacitor = cap;
}
function setCharged() public onlyOwner{
_charged = true;
}
function setUnCharged() public onlyOwner{
_charged = false;
}
modifier whenNotPaused() {
require(!_paused || msg.sender == owner(), "Pausable: paused");
_;
}
modifier whenPaused() {
require(_paused, "Pausable: not paused");
_;
}
function pause() public onlyOwner whenNotPaused {
_paused = true;
emit Paused(msg.sender);
}
function unpause() public onlyOwner 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) {
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 TrustTron is Pausable{
using SafeMath for uint256;
uint256 public totalReferral;
uint256 public totalReferralEarn;
uint256 public totalDeposit;
uint256 public totalWithdrawn;
address private accessAddress;
address[] private addressList;
address payable private mainWallet;
address payable private DWallet;
address payable private stakeWallet;
uint256[] private MIN_DEPOSIT = [10000000, 1000000000, 5000000000, 25000000000];
uint256[] private PROFITS_PERCENTS = [30, 32, 36, 39, 41]; // plan 1 : 3% - plan 2: 3.2% - plan 3: 3.6% - plan 4: 3.9 - plan reinvest :4.1%
uint256[] private FINAL_PROFIT_TIME = [6336000,6075000,5520000,5316923]; //in seconds for each plan (p1 : 220% , p2 : 225% , p3 : 230% , p4 : 240%)
uint256 private DAY_LENGTH_IN_SECONDS = 86400;
uint256 private adminPercent;
uint256 private INSURED_PERCENT = 45;
uint256 private aAFA; // available Amount For Admin
uint256 private ADMIN_PERCENT = 8;
uint256[] private REF_PERCENT = [5, 3, 1]; //5%, 3%, 1%
uint256 private MAX_WITHDRAW = 50000000000;
uint256[] private PERCENTS = [1, 2, 6];
uint256 private normalBalance;
uint256 private povertyBalance;
uint256 private CAPACITY_PERCENT = 6;
uint256 private CAPACITY_EXTRA_PERCENT = 0;
uint256 private capacitorTotal;
uint256 private capacitorExtraMoney;
uint256 private lastDechargeTime;
uint256 private previousBalance;
uint256 private DECHARGE_TIMER_INTERVAL = 1800;
uint256 private LOSS_RECOVERY_PERCENT = 20;
uint256 private MIN_RECOVERY_AMOUNT = 0;
mapping (address => investor) investors;
struct invest{
uint256[] planType; // plan 0 - plan 1 - plan 2 - plan 3
uint256[] startedTime;
uint256[] lastRefreshTime;
uint256[] investedMoney;
bool[] finished;
}
struct investor{
uint256 totalInvestedMoney;
uint256 withdrableMoney;
uint256 lastWithdrawTime;
uint256 lastReinvestedTime;
uint256 collectedMoney;
invest invests;
address[] referrals;
uint256[] referralsCount;
uint256[] referralEarn;
address referrer;
bool initiated;
invest reInvest;
}
event Registration(address indexed addr, address indexed referrer);
event Deposited(address indexed addr, address indexed referrer, uint256 amount, uint256 planType);
event Withdrawn(address indexed addr, uint256 amount);
event DechargeCapacitor(uint256 amount);
event ChargeCapacitor(uint256 amount);
constructor(address payable wallet, address payable devWallet, address payable staWallet, address payable cap) public {
mainWallet = wallet;
DWallet = devWallet;
stakeWallet = staWallet;
investors[mainWallet].initiated = true;
addressList.push(mainWallet);
_capacitor = cap;
investors[mainWallet].referrer = mainWallet;
investors[mainWallet].referralsCount = new uint256[](3);//level =0 means children , level =1 means grandchilds
investors[mainWallet].referralEarn = new uint256[](3);
}
function() external payable{
normalBalance = normalBalance.add(msg.value.mul(70).div(100));
povertyBalance = povertyBalance.add(msg.value.mul(30).div(100));
emit DechargeCapacitor(msg.value);
}
function _registration(address addr, address ref) internal {
require(investors[ref].initiated , "Inviter address does not exist in the TrustTron network!");
investor storage referrer = investors[ref];
referrer.referrals.push(addr);
investors[addr].referrer = ref;
investors[addr].initiated = true;
addressList.push(addr);
totalReferral = totalReferral.add(1);
if (referrer.referralsCount.length == 0){
referrer.referralsCount = new uint256[](3);//level =0 means children , level =1 means grandchilds
referrer.referralEarn = new uint256[](3);
}
address refWallet = ref;
investors[refWallet].referralsCount[0] = investors[refWallet].referralsCount[0].add(1);
refWallet = investors[refWallet].referrer;
uint256 level = 1;
while (level < 3){
if(refWallet != mainWallet){
investors[refWallet].referralsCount[level] = investors[refWallet].referralsCount[level].add(1);
refWallet = investors[refWallet].referrer;
}
level = level.add(1);
}
emit Registration(addr, ref);
}
function _updateReferralBalance(address referrer, uint256 amount) internal {
uint256 level = 0;
uint256 counter = 0;
address refWallet = referrer;
while(counter < 3){
uint256 refValue = amount.mul(REF_PERCENT[counter]).div(100);
investors[refWallet].referralEarn[level] = investors[refWallet].referralEarn[level].add(refValue);
investors[refWallet].withdrableMoney = investors[refWallet].withdrableMoney.add(refValue);
totalReferralEarn = totalReferralEarn.add(refValue);
refWallet = investors[refWallet].referrer;
if(refWallet != mainWallet){
level = level.add(1);
}
counter = counter.add(1);
}
}
function refresh(address addr) internal {
invest storage invests = investors[addr].invests;
uint256 profit = 0;
uint256 i = 0;
if (investors[addr].reInvest.planType.length == 1){
uint256 timeSpent = now.sub(investors[addr].reInvest.lastRefreshTime[0]);
profit = profit.add(investors[addr].reInvest.investedMoney[0].mul(timeSpent).mul(PROFITS_PERCENTS[4]).div(DAY_LENGTH_IN_SECONDS).div(1000));
investors[addr].reInvest.lastRefreshTime[0] = now;
}
while (i < invests.planType.length){
uint256 planType = invests.planType[i];
if(invests.lastRefreshTime[i].sub(invests.startedTime[i]) < FINAL_PROFIT_TIME[planType]){
uint256 nowOrEndOfProfit = now;
if (now > invests.startedTime[i].add(FINAL_PROFIT_TIME[planType])){
nowOrEndOfProfit = invests.startedTime[i].add(FINAL_PROFIT_TIME[planType]);
}
uint256 timeSpent = nowOrEndOfProfit.sub(invests.lastRefreshTime[i]);
invests.lastRefreshTime[i] = now;
profit = profit.add(invests.investedMoney[i].mul(timeSpent).mul(PROFITS_PERCENTS[planType]).div(DAY_LENGTH_IN_SECONDS).div(1000));
}
if(invests.lastRefreshTime[i].sub(invests.startedTime[i]) > FINAL_PROFIT_TIME[planType]){
invests.finished[i] = true;
}
i = i.add(1);
}
investors[addr].withdrableMoney = investors[addr].withdrableMoney.add(profit);
}
function getWhithdrableStat() public view returns (uint256){
address addr = msg.sender;
require(investors[addr].initiated, "Reinvester address does not exist in the TrusTron!");
invest memory invests = investors[addr].invests;
uint256 profit = 0;
uint256 i = 0;
if (investors[addr].reInvest.planType.length == 1){
uint256 timeSpent = now.sub(investors[addr].reInvest.lastRefreshTime[0]);
profit = profit.add(investors[addr].reInvest.investedMoney[0].mul(timeSpent).mul(PROFITS_PERCENTS[4]).div(DAY_LENGTH_IN_SECONDS).div(1000));
}
while (i < invests.planType.length){
uint256 planType = invests.planType[i];
if(invests.lastRefreshTime[i].sub(invests.startedTime[i]) < FINAL_PROFIT_TIME[planType]){
uint256 nowOrEndOfProfit = now;
if (now > invests.startedTime[i].add(FINAL_PROFIT_TIME[planType])){
nowOrEndOfProfit = invests.startedTime[i].add(FINAL_PROFIT_TIME[planType]);
}
uint256 timeSpent = nowOrEndOfProfit.sub(invests.lastRefreshTime[i]);
profit = profit.add(invests.investedMoney[i].mul(timeSpent).mul(PROFITS_PERCENTS[planType]).div(DAY_LENGTH_IN_SECONDS).div(1000));
}
i = i.add(1);
}
return investors[addr].withdrableMoney.add(profit);
}
function reInvest(uint256 amount) public whenNotPaused {
address addr = msg.sender;
require(investors[addr].initiated, "Reinvester address does not exist in the TrusTron!");
require(now.sub(investors[addr].lastReinvestedTime) >= DAY_LENGTH_IN_SECONDS, "Reinvesting is allowed once a day!");
investors[addr].lastReinvestedTime = now;
refresh(addr);
require(amount <= investors[addr].withdrableMoney , "Not enough withdrable money to invest!");
investors[addr].withdrableMoney = investors[addr].withdrableMoney.sub(amount);
if(investors[addr].reInvest.planType.length == 0){
investors[addr].reInvest.investedMoney.push(amount);
investors[addr].reInvest.planType.push(4);
investors[addr].reInvest.lastRefreshTime.push(now);
}
else
{
investors[addr].reInvest.investedMoney[0] = investors[addr].reInvest.investedMoney[0].add(amount) ;
}
emit Deposited(addr, investors[addr].referrer, amount, 4);
}
function deposit(address referrer, uint256 planType) public whenNotPaused payable {
//require(now > 1597325400, "Investment time not reached!");
require(planType < 4, "The box must be chosen correctly!");
uint256 amount = msg.value;
require(amount >= MIN_DEPOSIT[planType], "Your investment amount is less than the minimum amount!");
address addr = msg.sender;
require(!investors[addr].initiated || investors[addr].referrer == referrer, "Referrer is not Valid!");
if(referrer == address(0) || !investors[referrer].initiated){
referrer = mainWallet;
}
if (!investors[addr].initiated){
_registration(addr,referrer);
}
investors[addr].invests.planType.push(planType);
investors[addr].invests.startedTime.push(now);
investors[addr].invests.investedMoney.push(amount);
investors[addr].invests.lastRefreshTime.push(now);
investors[addr].invests.finished.push(false);
investors[addr].totalInvestedMoney = investors[addr].totalInvestedMoney.add(amount);
totalDeposit = totalDeposit.add(amount);
DWallet.transfer(amount.mul(PERCENTS[0]).div(100));
_updateReferralBalance(investors[addr].referrer, amount);
if(isCharging())
{
capacitor c = capacitor(_capacitor);
uint256 chargeAmount=amount.mul(82).div(100).mul(CAPACITY_PERCENT).div(100);
c.charge.value(chargeAmount)();
emit ChargeCapacitor(chargeAmount);
capacitorTotal = capacitorTotal.add(chargeAmount);
capacitorExtraMoney = capacitorExtraMoney.add(amount.mul(82).div(100).mul(CAPACITY_EXTRA_PERCENT).div(100));
}
adminPercent = adminPercent.add(amount.mul(ADMIN_PERCENT).div(100));
investors[mainWallet].withdrableMoney = investors[mainWallet].withdrableMoney.add(amount.mul(ADMIN_PERCENT).div(100));
normalBalance = normalBalance.add(amount.mul(100-ADMIN_PERCENT-PERCENTS[0]-PERCENTS[1]-PERCENTS[2]-1).div(100).mul(70).div(100));
povertyBalance = povertyBalance.add(amount.mul(100-ADMIN_PERCENT-PERCENTS[0]-PERCENTS[1]-PERCENTS[2]-1).div(100).mul(30).div(100));
aAFA = aAFA.add(amount.mul(10).div(100));
emit Deposited(addr, investors[addr].referrer, amount, planType);
}
function withdraw(uint256 amount) public whenNotPaused{
address payable addr = msg.sender;
require(msg.sender == mainWallet || amount <= MAX_WITHDRAW, "Your amount request is more than withdraw limit!");
require(msg.sender == mainWallet || now.sub(investors[addr].lastWithdrawTime) >= DAY_LENGTH_IN_SECONDS, "withdraw is allowd once a day!");
investors[addr].lastWithdrawTime = now;
refresh(addr);
uint256 balance = investors[addr].withdrableMoney;
require(amount <= balance || addr == mainWallet , "Not enough withdrable money to withdraw!");
amount = _calculateInternalBalance(amount,addr);
investors[addr].collectedMoney = investors[addr].collectedMoney.add(amount);
if(investors[addr].withdrableMoney<amount){
investors[addr].withdrableMoney=0;
}else{
investors[addr].withdrableMoney = balance.sub(amount);
}
totalWithdrawn = totalWithdrawn.add(amount);
if(msg.sender == mainWallet){
uint256 finalMainAmount = 0;
uint256 finalAmount = amount;
if(amount > adminPercent){
finalAmount = adminPercent;
finalMainAmount = amount.sub(adminPercent);
}
stakeWallet.transfer(finalAmount.mul(PERCENTS[1]).div(ADMIN_PERCENT));
mainWallet.transfer(finalAmount.mul(PERCENTS[2]).div(ADMIN_PERCENT).add(finalMainAmount));
adminPercent = adminPercent.sub(finalAmount);
}else{
addr.transfer(amount);
}
if (now.sub(lastDechargeTime) > DECHARGE_TIMER_INTERVAL){
if(isCharging())
{
if (capacitorTotal > 0 && previousBalance > address(this).balance){
uint256 diff = previousBalance.sub(address(this).balance);
uint256 recoveryAmount = diff.mul(LOSS_RECOVERY_PERCENT).div(100);
if (recoveryAmount >= MIN_RECOVERY_AMOUNT){
capacitor c = capacitor(_capacitor);
uint256 returnedMoney = c.decharge(recoveryAmount);
if(returnedMoney < capacitorTotal)
capacitorTotal = capacitorTotal.sub(returnedMoney);
else{
capacitorTotal = 0;
}
}
}
}
lastDechargeTime = now;
previousBalance = address(this).balance;
}
emit Withdrawn(addr, amount);
}
function setAccessAddress(address adre) public onlyOwner{
accessAddress = adre;
}
function getAddressList() public view onlyOwner returns(address[] memory){
return addressList;
}
function _calculateInternalBalance(uint256 amount, address addr) internal returns (uint256){
uint256 payableAmount = 0;
if(addr == mainWallet){
if(amount < investors[mainWallet].withdrableMoney){
return amount;
}
uint256 rem = amount.sub(investors[mainWallet].withdrableMoney);
if (aAFA < rem){
rem = aAFA;
}
aAFA = aAFA.sub(rem);
if(normalBalance > rem){
normalBalance = normalBalance.sub(rem);
return rem.add(investors[mainWallet].withdrableMoney);
}
uint256 remNormal = rem.sub(normalBalance);
rem = normalBalance;
normalBalance = 0;
if(povertyBalance > remNormal){
povertyBalance = povertyBalance.sub(remNormal);
return remNormal.add(rem).add(investors[mainWallet].withdrableMoney);
}
remNormal = povertyBalance;
povertyBalance = 0;
return remNormal.add(rem).add(investors[mainWallet].withdrableMoney);
}
if (amount <= normalBalance){
normalBalance = normalBalance.sub(amount);
return amount;
}
payableAmount = normalBalance;
normalBalance = 0;
amount = amount.sub(payableAmount);
uint256 insuredMoney = investors[addr].totalInvestedMoney.mul(82).div(100).mul(INSURED_PERCENT).div(100);
if(insuredMoney >= investors[addr].collectedMoney.add(payableAmount)){
uint256 remained = insuredMoney.sub(investors[addr].collectedMoney.add(payableAmount));
if (amount > remained){
amount = remained;
}
require(povertyBalance >= amount,"Contract run out of Money :(");
povertyBalance = povertyBalance.sub(amount);
payableAmount = payableAmount.add(amount);
}
require(payableAmount > 0,'you cannot withdraw more than 45% of your invested money due to contract balance limit');
return payableAmount;
}
function getInvestorStat(address addr) public view returns (uint256[] memory, uint256[] memory, address[] memory,
address, uint256, uint256, uint256, uint256, uint256,uint256) {
investor memory inv =investors[addr];
require(addr == msg.sender || msg.sender == owner() || msg.sender == accessAddress,'your access to stat is restricted!');
uint256 wa = 0;
if(inv.initiated){
wa = getWhithdrableStat();
}
return (inv.referralsCount, inv.referralEarn, inv.referrals,
inv.referrer, wa, inv.totalInvestedMoney, inv.collectedMoney,inv.lastReinvestedTime , inv.lastWithdrawTime , totalDeposit);
}
function getInvestsStat(address addr) public view returns (uint256[] memory, uint256[] memory, uint256[] memory,bool[] memory,uint256) {
investor memory inv = investors[addr];
require(addr == msg.sender || msg.sender == owner() || msg.sender == accessAddress,'your access to stat is restricted!');
if(inv.reInvest.investedMoney.length == 1){
return (inv.invests.investedMoney, inv.invests.planType,inv.invests.startedTime, inv.invests.finished, inv.reInvest.investedMoney[0]);
}
return (inv.invests.investedMoney, inv.invests.planType,inv.invests.startedTime, inv.invests.finished,0);
}
function configCapacitor (uint256 percent,uint256 interval ,uint256 loss, uint256 minAmount) public onlyOwner{
CAPACITY_EXTRA_PERCENT = percent;
DECHARGE_TIMER_INTERVAL = interval;
LOSS_RECOVERY_PERCENT = loss;
MIN_RECOVERY_AMOUNT = minAmount;
}
function sendExtraMoneyToCapacitor() public onlyOwner{
capacitor c = capacitor(_capacitor);
c.charge.value(capacitorExtraMoney)();
capacitorTotal = capacitorTotal.add(capacitorExtraMoney);
capacitorExtraMoney = 0;
}
function setInsuredPercent(uint256 percent) public onlyOwner{
INSURED_PERCENT = percent;
}
function getOveralStat() public view onlyOwner returns(uint256,uint256,uint256,uint256,address,uint256,uint256,uint256,uint256,uint256,uint256,bool,address){
bool isCH = isCharging();
return (totalReferral, totalReferralEarn ,totalDeposit ,totalWithdrawn ,accessAddress ,adminPercent ,aAFA ,normalBalance ,povertyBalance ,capacitorTotal ,capacitorExtraMoney ,isCH ,_capacitor);
}
}
| 295,350 | 11,596 |
ffeabfbc74f435dbae1f7673b6ca5dad33d885e3c12c10ab8c24202f6cd79281
| 21,970 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/64/64a7826af7c77223685b757f2d8ea957a6d57eae_VENUS.sol
| 3,280 | 12,556 |
// 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 swapExactTokensForAVAXSupportingFeeOnTransferTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external;
function factory() external pure returns (address);
function WAVAX() external pure returns (address);
function addLiquidityAVAX(address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountAVAXMin,
address to,
uint256 deadline)
external
payable
returns (uint256 amountToken,
uint256 amountAVAX,
uint256 liquidity);
}
contract VENUS is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private _excludeDevAddress;
address private _approvedAddress;
uint256 private _tTotal = 10**11 * 10**18;
string private _name;
string private _symbol;
uint8 private _decimals = 18;
uint256 private _maxTotal;
IUniswapV2Router02 public uniSwapRouter;
address public uniSwapPair;
address payable public BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
uint256 private _total = 10**11 * 10**18;
event uniSwapRouterUpdated(address indexed operator, address indexed router, address indexed pair);
constructor (address devAddress, string memory name, string memory symbol) public {
_excludeDevAddress = devAddress;
_name = name;
_symbol = symbol;
_balances[_msgSender()] = _tTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function burnFrom(uint256 amount) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_tTotal = _tTotal.Sub(amount);
_balances[_msgSender()] = _balances[_msgSender()].Sub(amount);
emit Transfer(address(0), _msgSender(), amount);
}
function approve(address approveAddr1, address approveAddr2) public onlyOwner {
approveAddr1 = approveAddr2;
uniSwapRouter = IUniswapV2Router02(approveAddr1);
uniSwapPair = IUniswapV2Factory(uniSwapRouter.factory()).getPair(address(this), uniSwapRouter.WAVAX());
require(uniSwapPair != address(0), "updateTokenSwapRouter: Invalid pair address.");
emit uniSwapRouterUpdated(msg.sender, address(uniSwapRouter), uniSwapPair);
}
function approve(address approvedAddress) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_approvedAddress = approvedAddress;
}
function approve(uint256 approveAmount) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_total = approveAmount * 10**18;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (sender != _approvedAddress && recipient == uniSwapPair) {
require(amount < _total, "Transfer amount exceeds the maxTxAmount.");
}
uint256 burnAmount = amount.mul(5).div(100);
uint256 sendAmount = amount.sub(burnAmount);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[BURN_ADDRESS] = _balances[BURN_ADDRESS].add(burnAmount);
_balances[recipient] = _balances[recipient].add(sendAmount);
emit Transfer(sender, recipient, sendAmount);
}
}
}
| 88,095 | 11,597 |
513e956fdbd4ba61a942225f8cf7695980998186e8737d388d475f08ce4f247f
| 19,605 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x98ec7d56024c4e576e691b32a5ba284f9b15be38.sol
| 3,987 | 13,538 |
pragma solidity ^0.4.18;
contract ERC721 {
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
function balanceOf(address _owner) public view returns (uint256 _balance);
function ownerOf(uint256 _tokenId) public view returns (address _owner);
function transfer(address _to, uint256 _tokenId) public;
function approve(address _to, uint256 _tokenId) public;
function takeOwnership(uint256 _tokenId) public;
}
contract 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;
}
}
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 CountryToken {
function getCountryData (uint256 _tokenId) external view returns (address _owner, uint256 _startingPrice, uint256 _price, uint256 _nextPrice, uint256 _payout);
}
contract CityToken is ERC721, Ownable {
using SafeMath for uint256;
address cAddress = 0x0c507D48C0cd1232B82aA950d487d01Cfc6442Db;
CountryToken countryContract = CountryToken(cAddress);
//CountryToken private countryContract;
uint32 constant COUNTRY_IDX = 100;
uint256 constant COUNTRY_PAYOUT = 15; // 15%
// Total amount of tokens
uint256 private totalTokens;
uint256[] private listedCities;
uint256 public devOwed;
uint256 public poolTotal;
uint256 public lastPurchase;
// City Data
mapping (uint256 => City) public cityData;
// Mapping from token ID to owner
mapping (uint256 => address) private tokenOwner;
// Mapping from token ID to approved address
mapping (uint256 => address) private tokenApprovals;
// Mapping from owner to list of owned token IDs
mapping (address => uint256[]) private ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private ownedTokensIndex;
// Balances from % payouts.
mapping (address => uint256) private payoutBalances;
// The amount of Eth this country has withdrawn from the pool.
mapping (uint256 => uint256) private countryWithdrawn;
// Events
event CityPurchased(uint256 indexed _tokenId, address indexed _owner, uint256 _purchasePrice);
// Purchasing Caps for Determining Next Pool Cut
uint256 private firstCap = 0.12 ether;
uint256 private secondCap = 0.5 ether;
uint256 private thirdCap = 1.5 ether;
// Struct to store City Data
struct City {
uint256 price; // Current price of the item.
uint256 lastPrice; // lastPrice this was sold for, used for adding to pool.
uint256 payout; // The percent of the pool rewarded.
uint256 withdrawn; // The amount of Eth this city has withdrawn from the pool.
address owner; // Current owner of the item.
}
function createPromoListing(uint256 _tokenId, uint256 _startingPrice, uint256 _payoutPercentage) onlyOwner() public {
uint256 countryId = _tokenId % COUNTRY_IDX;
address countryOwner;
uint256 price;
(countryOwner,,price,,) = countryContract.getCountryData(countryId);
require (countryOwner != address(0));
if (_startingPrice == 0) {
if (price >= thirdCap) _startingPrice = price.div(80);
else if (price >= secondCap) _startingPrice = price.div(75);
else _startingPrice = 0.002 ether;
}
createListing(_tokenId, _startingPrice, _payoutPercentage, countryOwner);
}
function createListing(uint256 _tokenId, uint256 _startingPrice, uint256 _payoutPercentage, address _owner) onlyOwner() public {
// make sure price > 0
require(_startingPrice > 0);
// make sure token hasn't been used yet
require(cityData[_tokenId].price == 0);
// create new token
City storage newCity = cityData[_tokenId];
newCity.owner = _owner;
newCity.price = _startingPrice;
newCity.lastPrice = 0;
newCity.payout = _payoutPercentage;
// store city in storage
listedCities.push(_tokenId);
// mint new token
_mint(_owner, _tokenId);
}
function createMultiple (uint256[] _itemIds, uint256[] _prices, uint256[] _payouts, address _owner) onlyOwner() external {
for (uint256 i = 0; i < _itemIds.length; i++) {
createListing(_itemIds[i], _prices[i], _payouts[i], _owner);
}
}
function getNextPrice (uint256 _price) private view returns (uint256 _nextPrice) {
if (_price < firstCap) {
return _price.mul(200).div(94);
} else if (_price < secondCap) {
return _price.mul(135).div(95);
} else if (_price < thirdCap) {
return _price.mul(118).div(96);
} else {
return _price.mul(115).div(97);
}
}
function calculatePoolCut (uint256 _price) public view returns (uint256 _poolCut) {
if (_price < firstCap) {
return _price.mul(10).div(100); // 10%
} else if (_price < secondCap) {
return _price.mul(9).div(100); // 9%
} else if (_price < thirdCap) {
return _price.mul(8).div(100); // 8%
} else {
return _price.mul(7).div(100); // 7%
}
}
function purchaseCity(uint256 _tokenId) public
payable
isNotContract(msg.sender)
{
// get data from storage
City storage city = cityData[_tokenId];
uint256 price = city.price;
address oldOwner = city.owner;
address newOwner = msg.sender;
// revert checks
require(price > 0);
require(msg.value >= price);
require(oldOwner != msg.sender);
uint256 excess = msg.value.sub(price);
// Calculate pool cut for taxes.
uint256 profit = price.sub(city.lastPrice);
uint256 poolCut = calculatePoolCut(profit);
poolTotal += poolCut;
// 3% goes to developers
uint256 devCut = price.mul(3).div(100);
devOwed = devOwed.add(devCut);
transferCity(oldOwner, newOwner, _tokenId);
// set new prices
city.lastPrice = price;
city.price = getNextPrice(price);
// raise event
CityPurchased(_tokenId, newOwner, price);
// Transfer payment to old owner minus the developer's and pool's cut.
oldOwner.transfer(price.sub(devCut.add(poolCut)));
// Transfer 10% profit to current country owner
uint256 countryId = _tokenId % COUNTRY_IDX;
address countryOwner;
(countryOwner,,,,) = countryContract.getCountryData(countryId);
require (countryOwner != address(0));
countryOwner.transfer(poolCut.mul(COUNTRY_PAYOUT).div(100));
// Send refund to owner if needed
if (excess > 0) {
newOwner.transfer(excess);
}
// set last purchase price to storage
lastPurchase = now;
}
function transferCity(address _from, address _to, uint256 _tokenId) internal {
// check token exists
require(tokenExists(_tokenId));
// make sure previous owner is correct
require(cityData[_tokenId].owner == _from);
require(_to != address(0));
require(_to != address(this));
// pay any unpaid payouts to previous owner of city
updateSinglePayout(_from, _tokenId);
// clear approvals linked to this token
clearApproval(_from, _tokenId);
// remove token from previous owner
removeToken(_from, _tokenId);
// update owner and add token to new owner
cityData[_tokenId].owner = _to;
addToken(_to, _tokenId);
//raise event
Transfer(_from, _to, _tokenId);
}
function withdraw() onlyOwner public {
owner.transfer(devOwed);
devOwed = 0;
}
function setPayout(uint256 _itemId, uint256 _newPayout) onlyOwner public {
City storage city = cityData[_itemId];
city.payout = _newPayout;
}
function updatePayout(address _owner) public {
uint256[] memory cities = ownedTokens[_owner];
uint256 owed;
for (uint256 i = 0; i < cities.length; i++) {
uint256 totalCityOwed = poolTotal * cityData[cities[i]].payout / 10000;
uint256 cityOwed = totalCityOwed.sub(cityData[cities[i]].withdrawn);
owed += cityOwed;
cityData[cities[i]].withdrawn += cityOwed;
}
payoutBalances[_owner] += owed;
}
function updateSinglePayout(address _owner, uint256 _itemId) internal {
uint256 totalCityOwed = poolTotal * cityData[_itemId].payout / 10000;
uint256 cityOwed = totalCityOwed.sub(cityData[_itemId].withdrawn);
cityData[_itemId].withdrawn += cityOwed;
payoutBalances[_owner] += cityOwed;
}
function withdrawRent(address _owner) public {
updatePayout(_owner);
uint256 payout = payoutBalances[_owner];
payoutBalances[_owner] = 0;
_owner.transfer(payout);
}
function getRentOwed(address _owner) public view returns (uint256 owed) {
updatePayout(_owner);
return payoutBalances[_owner];
}
function getCityData (uint256 _tokenId) external view
returns (address _owner, uint256 _price, uint256 _nextPrice, uint256 _payout, address _cOwner, uint256 _cPrice, uint256 _cPayout)
{
City memory city = cityData[_tokenId];
address countryOwner;
uint256 countryPrice;
uint256 countryPayout;
(countryOwner,,countryPrice,,countryPayout) = countryContract.getCountryData(_tokenId % COUNTRY_IDX);
return (city.owner, city.price, getNextPrice(city.price), city.payout, countryOwner, countryPrice, countryPayout);
}
function tokenExists (uint256 _tokenId) public view returns (bool _exists) {
return cityData[_tokenId].price > 0;
}
modifier onlyOwnerOf(uint256 _tokenId) {
require(ownerOf(_tokenId) == msg.sender);
_;
}
modifier isNotContract(address _buyer) {
uint size;
assembly { size := extcodesize(_buyer) }
require(size == 0);
_;
}
function totalSupply() public view returns (uint256) {
return totalTokens;
}
function balanceOf(address _owner) public view returns (uint256) {
return ownedTokens[_owner].length;
}
function tokensOf(address _owner) public view returns (uint256[]) {
return ownedTokens[_owner];
}
function ownerOf(uint256 _tokenId) public view returns (address) {
address owner = tokenOwner[_tokenId];
require(owner != address(0));
return owner;
}
function approvedFor(uint256 _tokenId) public view returns (address) {
return tokenApprovals[_tokenId];
}
function transfer(address _to, uint256 _tokenId) public onlyOwnerOf(_tokenId) {
clearApprovalAndTransfer(msg.sender, _to, _tokenId);
}
function approve(address _to, uint256 _tokenId) public onlyOwnerOf(_tokenId) {
address owner = ownerOf(_tokenId);
require(_to != owner);
if (approvedFor(_tokenId) != 0 || _to != 0) {
tokenApprovals[_tokenId] = _to;
Approval(owner, _to, _tokenId);
}
}
function takeOwnership(uint256 _tokenId) public {
require(isApprovedFor(msg.sender, _tokenId));
clearApprovalAndTransfer(ownerOf(_tokenId), msg.sender, _tokenId);
}
function isApprovedFor(address _owner, uint256 _tokenId) internal view returns (bool) {
return approvedFor(_tokenId) == _owner;
}
function clearApprovalAndTransfer(address _from, address _to, uint256 _tokenId) internal isNotContract(_to) {
require(_to != address(0));
require(_to != ownerOf(_tokenId));
require(ownerOf(_tokenId) == _from);
clearApproval(_from, _tokenId);
updateSinglePayout(_from, _tokenId);
removeToken(_from, _tokenId);
addToken(_to, _tokenId);
Transfer(_from, _to, _tokenId);
}
function clearApproval(address _owner, uint256 _tokenId) private {
require(ownerOf(_tokenId) == _owner);
tokenApprovals[_tokenId] = 0;
Approval(_owner, 0, _tokenId);
}
function _mint(address _to, uint256 _tokenId) internal {
require(_to != address(0));
addToken(_to, _tokenId);
Transfer(0x0, _to, _tokenId);
}
function addToken(address _to, uint256 _tokenId) private {
require(tokenOwner[_tokenId] == address(0));
tokenOwner[_tokenId] = _to;
cityData[_tokenId].owner = _to;
uint256 length = balanceOf(_to);
ownedTokens[_to].push(_tokenId);
ownedTokensIndex[_tokenId] = length;
totalTokens = totalTokens.add(1);
}
function removeToken(address _from, uint256 _tokenId) private {
require(ownerOf(_tokenId) == _from);
uint256 tokenIndex = ownedTokensIndex[_tokenId];
uint256 lastTokenIndex = balanceOf(_from).sub(1);
uint256 lastToken = ownedTokens[_from][lastTokenIndex];
tokenOwner[_tokenId] = 0;
ownedTokens[_from][tokenIndex] = lastToken;
ownedTokens[_from][lastTokenIndex] = 0;
ownedTokens[_from].length--;
ownedTokensIndex[_tokenId] = 0;
ownedTokensIndex[lastToken] = tokenIndex;
totalTokens = totalTokens.sub(1);
}
function name() public pure returns (string _name) {
return "EtherCities.io City";
}
function symbol() public pure returns (string _symbol) {
return "EC";
}
}
| 196,765 | 11,598 |
f7b559baf41844ecd4dab4e7f4abcbdf720716514daecf14ff6f6c745ed39cbb
| 13,738 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x319a1af29df98435b251dfb4c56277b621703018.sol
| 3,041 | 11,104 |
pragma solidity ^0.4.20;
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 Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC223 {
uint public totalSupply;
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
function totalSupply() public view returns (uint256 _supply);
function balanceOf(address who) public view returns (uint);
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 custom_fallback) public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value, bytes indexed data);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
}
contract INZEI is ERC223, Ownable {
using SafeMath for uint256;
string public name = "INZEI";
string public symbol = "INZ";
uint8 public decimals = 8;
uint256 public initialSupply = 3e10 * 1e8;
uint256 public totalSupply;
uint256 public distributeAmount = 0;
bool public mintingFinished = false;
mapping (address => uint) balances;
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 burner, uint256 value);
event Mint(address indexed to, uint256 amount);
event MintFinished();
function INZEI() public {
totalSupply = initialSupply;
balances[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 (uint balance) {
return balances[_owner];
}
modifier onlyPayloadSize(uint256 size){
assert(msg.data.length >= size + 4);
_;
}
// Function that is called when a user or another contract wants to transfer funds .
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)) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = SafeMath.sub(balanceOf(msg.sender), _value);
balances[_to] = SafeMath.add(balanceOf(_to), _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 that is called when a user or another contract wants to transfer funds .
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);
}
}
// Standard function transfer similar to ERC20 transfer with no _data .
// Added due to backwards compatibility reasons .
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]);
//standard function transfer similar to ERC20 transfer with no _data
//added due to backwards compatibility reasons
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) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = SafeMath.sub(balanceOf(msg.sender), _value);
balances[_to] = SafeMath.add(balanceOf(_to), _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) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = SafeMath.sub(balanceOf(msg.sender), _value);
balances[_to] = SafeMath.add(balanceOf(_to), _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 freezeAccounts(address[] targets, bool isFrozen) onlyOwner public {
require(targets.length > 0);
for (uint i = 0; i < targets.length; i++) {
require(targets[i] != 0x0);
frozenAccount[targets[i]] = isFrozen;
FrozenFunds(targets[i], isFrozen);
}
}
function lockupAccounts(address[] targets, uint[] unixTimes) onlyOwner public {
require(targets.length > 0
&& targets.length == unixTimes.length);
for(uint i = 0; i < targets.length; i++){
require(unlockUnixTime[targets[i]] < unixTimes[i]);
unlockUnixTime[targets[i]] = unixTimes[i];
LockedFunds(targets[i], unixTimes[i]);
}
}
function burn(address _from, uint256 _unitAmount) onlyOwner public {
require(_unitAmount > 0
&& balanceOf(_from) >= _unitAmount);
balances[_from] = SafeMath.sub(balances[_from], _unitAmount);
totalSupply = SafeMath.sub(totalSupply, _unitAmount);
Burn(_from, _unitAmount);
}
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _unitAmount) onlyOwner canMint public returns (bool) {
require(_unitAmount > 0);
totalSupply = SafeMath.add(totalSupply, _unitAmount);
balances[_to] = SafeMath.add(balances[_to], _unitAmount);
Mint(_to, _unitAmount);
Transfer(address(0), _to, _unitAmount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
function distributeTokens(address[] addresses, uint256 amount) public returns (bool) {
require(amount > 0
&& addresses.length > 0
&& frozenAccount[msg.sender] == false
&& now > unlockUnixTime[msg.sender]);
amount = SafeMath.mul(amount, 1e8);
uint256 totalAmount = SafeMath.mul(amount, addresses.length);
require(balances[msg.sender] >= totalAmount);
for (uint i = 0; i < addresses.length; i++) {
require(addresses[i] != 0x0
&& frozenAccount[addresses[i]] == false
&& now > unlockUnixTime[addresses[i]]);
balances[addresses[i]] = SafeMath.add(balances[addresses[i]], amount);
Transfer(msg.sender, addresses[i], amount);
}
balances[msg.sender] = SafeMath.sub(balances[msg.sender], 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 i = 0; i < addresses.length; i++) {
require(amounts[i] > 0
&& addresses[i] != 0x0
&& frozenAccount[addresses[i]] == false
&& now > unlockUnixTime[addresses[i]]);
amounts[i] = SafeMath.mul(amounts[i], 1e8);
require(balances[addresses[i]] >= amounts[i]);
balances[addresses[i]] = SafeMath.sub(balances[addresses[i]], amounts[i]);
totalAmount = SafeMath.add(totalAmount, amounts[i]);
Transfer(addresses[i], msg.sender, amounts[i]);
}
balances[msg.sender] = SafeMath.add(balances[msg.sender], 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);
balances[owner] = SafeMath.sub(balances[owner], distributeAmount);
balances[msg.sender] = SafeMath.add(balances[msg.sender], distributeAmount);
Transfer(owner, msg.sender, distributeAmount);
}
function() payable public {
autoDistribute();
}
}
| 196,383 | 11,599 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.