Dataset Viewer
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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
53ce80b6f1cafc1afd3d942a143fa7d85e4e6b38eccdc6331a12f242cdc1b728
| 12,811 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xa9f06cf165fe40f6e52f5765389f2d79dfc567ff.sol
| 3,404 | 12,735 |
pragma solidity ^0.4.13;
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) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract FueldToken{
using SafeMath for uint256;
address public multisig;
address public multisigPreICO;
address public owner;
address public extOwner;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
event MultisigsChanged(address _multisig, address _multisigPreICO);
function changeMultisigs(address _multisig, address _multisigPreICO) onlyOwner public {
require(_multisig != address(0));
require(_multisigPreICO != address(0));
multisig = _multisig;
multisigPreICO = _multisigPreICO;
MultisigsChanged(multisig, multisigPreICO);
}
mapping(address => uint256) balances;
event Transfer(address indexed from, address indexed to, uint256 value);
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
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];
}
mapping (address => mapping (address => uint256)) allowed;
event Approval(address indexed owner_, address indexed spender, uint256 value);
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 transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
uint256 _allowance = allowed[_from][msg.sender];
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 increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) { allowed[msg.sender][_spender] = 0; }
else {allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); }
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
uint256 public totalSupply = 200000000;
mapping (address => uint256) public privatePreICOdepositors;
mapping (address => uint256) public preICOdepositors;
mapping (address => uint256) public ICOdepositors;
mapping (address => uint256) public ICObalances;
uint256 constant public softCap = 6700 ether;
uint256 constant public hardCap = 67000 ether;
uint256 constant public price = 456000000000000 wei;
uint256 constant public maxPreICOSupply = 13500000;
uint256 constant public maxPreICOandICOSupply = 150000000;
uint256 constant public privatePreICOFreeBonusPercent = 35;
uint256 constant public preICOFreeBonusPercent = 30;
uint256 constant public privatePreICOBonusPercent = 0;
uint256 constant public preICOBonusPercent = 0;
uint256 constant public ICOBonusPercent1week = 15;
uint256 constant public ICOBonusPercent2week = 10;
uint256 constant public ICOBonusPercent3week = 5;
uint256 constant public restrictedPercent = 25;
uint256 public startTimePrivatePreICO = 0;
uint256 public startTimePreICO = 0;
uint256 public startTimeICO = 0;
uint256 public soldTokenCount = 0;
uint256 public cap = 0;
uint256 public capPreICO = 0;
uint256 public capPreICOTrasferred = 0;
uint256 public capFiat = 0;
uint256 public capFiatAndETH = 0;
bool public capReached = false;
event SaleStatus(string indexed status, uint256 indexed _date);
function startPrivatePreICO() onlyOwner public {
require(startTimeICO == 0 && startTimePreICO == 0);
startTimePreICO = now;
startTimePrivatePreICO = startTimePreICO;
SaleStatus('Private Pre ICO started', startTimePreICO);
}
function startPreICO() onlyOwner public {
require(startTimeICO == 0 && startTimePreICO == 0);
startTimePreICO = now;
SaleStatus('Public Pre ICO started', startTimePreICO);
}
function startICO() onlyOwner public {
require(startTimeICO == 0 && startTimePreICO == 0);
startTimeICO = now;
SaleStatus('start ICO', startTimePreICO);
}
function stopSale() onlyOwner public {
require(startTimeICO > 0 || startTimePreICO > 0);
if (startTimeICO > 0){
SaleStatus('ICO stopped', now);
}
else{
multisigPreICO.transfer(capPreICO);
capPreICOTrasferred = capPreICOTrasferred.add(capPreICO);
capPreICO = 0;
SaleStatus('Pre ICO stopped', now);
}
startTimeICO = 0;
startTimePreICO = 0;
startTimePrivatePreICO = 0;
}
function currentBonusPercent() public constant returns(uint256 bonus_percent) {
require(startTimeICO > 0 || startTimePreICO > 0);
uint256 current_date = now;
uint256 bonusPercent = 0;
if (startTimeICO > 0){
if (current_date > startTimeICO && current_date <= (startTimeICO.add(1 weeks))){ bonusPercent = ICOBonusPercent1week; }
else{
if (current_date > startTimeICO && current_date <= (startTimeICO.add(2 weeks))){ bonusPercent = ICOBonusPercent2week; }
else{
if (current_date > startTimeICO && current_date <= (startTimeICO.add(3 weeks))){ bonusPercent = ICOBonusPercent3week; }
}
}
}
else{
if(startTimePrivatePreICO > 0) {
bonusPercent = privatePreICOBonusPercent;
}
else {
bonusPercent = preICOBonusPercent;
}
}
return bonusPercent;
}
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function() payable public {
require(startTimeICO > 0 || startTimePreICO > 0);
require(msg.sender != address(0));
require(msg.value > 0);
require(cap < hardCap);
uint256 bonusPercent = currentBonusPercent();
uint256 currentPrice = price.mul(100 - bonusPercent).div(100);
address depositor = msg.sender;
uint256 deposit = msg.value;
uint256 tokens = deposit/currentPrice;
if (startTimeICO > 0){
require(soldTokenCount.add(tokens) <= maxPreICOandICOSupply);
}
else{
if(startTimePrivatePreICO > 0) {
tokens = (tokens * (100 + privatePreICOFreeBonusPercent)) / 100;
}
else {
tokens = (tokens * (100 + preICOFreeBonusPercent)) / 100;
}
require(soldTokenCount.add(tokens) <= maxPreICOSupply);
}
balances[owner] = balances[owner].sub(tokens);
balances[depositor] = balances[depositor].add(tokens);
soldTokenCount = soldTokenCount.add(tokens);
if (startTimeICO > 0){
ICObalances[depositor] = ICObalances[depositor].add(tokens);
}
if (startTimeICO > 0){
ICOdepositors[depositor] = ICOdepositors[depositor].add(deposit);
}
else{
if(startTimePrivatePreICO > 0) {
privatePreICOdepositors[depositor] = privatePreICOdepositors[depositor].add(deposit);
}
else {
preICOdepositors[depositor] = preICOdepositors[depositor].add(deposit);
}
}
cap = cap.add(deposit);
if(startTimePreICO > 0) {
capPreICO = capPreICO.add(deposit);
}
capFiatAndETH = capFiat.add(cap);
if(capFiatAndETH >= softCap) {
capReached = true;
}
TokenPurchase(owner, depositor, deposit, tokens);
}
event ExtTokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 amount);
function extBuyTokens(address beneficiary_, uint256 tokensAmount_, uint256 amountETH_) public {
require(startTimeICO > 0 || startTimePreICO > 0);
require(msg.sender != address(0));
require(msg.sender == extOwner);
address depositor = beneficiary_;
uint256 tokens = tokensAmount_;
uint256 amountETH = amountETH_;
balances[owner] = balances[owner].sub(tokens);
balances[depositor] = balances[depositor].add(tokens);
soldTokenCount = soldTokenCount.add(tokens);
capFiat = capFiat.add(amountETH);
capFiatAndETH = capFiat.add(cap);
if(capFiatAndETH >= softCap) {
capReached = true;
}
ExtTokenPurchase(owner, depositor, tokens);
}
function transferExtOwnership(address newOwner_) onlyOwner public {
extOwner = newOwner_;
}
bool public refundCompleted = false;
uint256 public startTimeRefund = 0;
function startRefund() onlyOwner public {
require(startTimeICO == 0 && startTimePreICO == 0);
startTimeRefund = now;
SaleStatus('Refund started', startTimeRefund);
}
function stopRefund() onlyOwner public {
require(startTimeRefund > 0);
startTimeRefund = 0;
refundCompleted = true;
SaleStatus('Refund stopped', now);
}
event Refunded(address indexed depositor, uint256 indexed deposit, uint256 indexed tokens);
function refund() public {
require(capFiatAndETH < softCap);
require(startTimeRefund > 0);
address depositor = msg.sender;
uint256 deposit = ICOdepositors[depositor];
uint256 tokens = ICObalances[depositor];
ICOdepositors[depositor] = 0;
ICObalances[depositor] = 0;
balances[depositor] = balances[depositor].sub(tokens);
depositor.transfer(deposit);
balances[owner] = balances[owner].add(tokens);
cap = cap.sub(deposit);
capFiatAndETH = capFiatAndETH.sub(deposit);
soldTokenCount = soldTokenCount.sub(tokens);
Refunded(depositor, deposit, tokens);
}
bool public fixSaleCompleted = false;
function fixSale() onlyOwner public {
require(refundCompleted == true);
require(startTimeICO == 0 && startTimePreICO == 0 && startTimeRefund == 0);
require(multisig != address(0));
uint256 restrictedTokens = soldTokenCount * (totalSupply - maxPreICOandICOSupply) / maxPreICOandICOSupply;
transfer(multisig, restrictedTokens);
multisig.transfer(cap.sub(capPreICOTrasferred));
soldTokenCount = 0;
fixSaleCompleted = true;
}
event Burn(address indexed burner, uint indexed value);
function burn(uint _value) onlyOwner public {
require(fixSaleCompleted == true);
require(_value > 0);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
refundCompleted = false;
fixSaleCompleted = false;
Burn(burner, _value);
}
string constant public name = "FUELD";
string constant public symbol = "FLD";
uint32 constant public decimals = 18;
function FueldToken() public {
owner = msg.sender;
balances[owner] = totalSupply;
}
}
| 165,552 | 0 |
4addd10ff838b4b06774035b9479473f7516105db0d30db481dd1500038c88cb
| 21,348 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xf2a7c7f3932efcc2ecb6b2c372b84030de191db0.sol
| 3,345 | 12,231 |
pragma solidity 0.4.19;
// File: node_modules/zeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
// File: node_modules/zeppelin-solidity/contracts/ownership/Claimable.sol
contract Claimable is Ownable {
address public pendingOwner;
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
pendingOwner = newOwner;
}
function claimOwnership() onlyPendingOwner public {
OwnershipTransferred(owner, pendingOwner);
owner = pendingOwner;
pendingOwner = address(0);
}
}
// File: node_modules/zeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
// File: node_modules/zeppelin-solidity/contracts/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: node_modules/zeppelin-solidity/contracts/token/ERC20/BasicToken.sol
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
// File: node_modules/zeppelin-solidity/contracts/token/ERC20/ERC20.sol
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File: node_modules/zeppelin-solidity/contracts/token/ERC20/StandardToken.sol
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
// File: node_modules/zeppelin-solidity/contracts/token/ERC827/ERC827.sol
contract ERC827 is ERC20 {
function approve(address _spender, uint256 _value, bytes _data) public returns (bool);
function transfer(address _to, uint256 _value, bytes _data) public returns (bool);
function transferFrom(address _from, address _to, uint256 _value, bytes _data) public returns (bool);
}
// File: node_modules/zeppelin-solidity/contracts/token/ERC827/ERC827Token.sol
contract ERC827Token is ERC827, StandardToken {
function approve(address _spender, uint256 _value, bytes _data) public returns (bool) {
require(_spender != address(this));
super.approve(_spender, _value);
require(_spender.call(_data));
return true;
}
function transfer(address _to, uint256 _value, bytes _data) public returns (bool) {
require(_to != address(this));
super.transfer(_to, _value);
require(_to.call(_data));
return true;
}
function transferFrom(address _from, address _to, uint256 _value, bytes _data) public returns (bool) {
require(_to != address(this));
super.transferFrom(_from, _to, _value);
require(_to.call(_data));
return true;
}
function increaseApproval(address _spender, uint _addedValue, bytes _data) public returns (bool) {
require(_spender != address(this));
super.increaseApproval(_spender, _addedValue);
require(_spender.call(_data));
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue, bytes _data) public returns (bool) {
require(_spender != address(this));
super.decreaseApproval(_spender, _subtractedValue);
require(_spender.call(_data));
return true;
}
}
// File: contracts/BaseContracts/SDABasicToken.sol
contract SDABasicToken is ERC827Token, Claimable {
mapping (address => bool) public isHolder;
address[] public holders;
function addHolder(address _addr) internal returns (bool) {
if (isHolder[_addr] != true) {
holders[holders.length++] = _addr;
isHolder[_addr] = true;
return true;
}
return false;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(this)); // Prevent transfer to contract itself
bool ok = super.transfer(_to, _value);
addHolder(_to);
return ok;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(this)); // Prevent transfer to contract itself
bool ok = super.transferFrom(_from, _to, _value);
addHolder(_to);
return ok;
}
function transfer(address _to, uint256 _value, bytes _data) public returns (bool) {
require(_to != address(this)); // Prevent transfer to contract itself
bool ok = super.transfer(_to, _value, _data);
addHolder(_to);
return ok;
}
function transferFrom(address _from, address _to, uint256 _value, bytes _data) public returns (bool) {
require(_to != address(this)); // Prevent transfer to contract itself
bool ok = super.transferFrom(_from, _to, _value, _data);
addHolder(_to);
return ok;
}
}
// File: contracts/BaseContracts/SDABurnableToken.sol
/// SDA Burnable Token Contract
/// SDA Burnable Token Contract is based on Open Zeppelin
/// and modified
contract SDABurnableToken is SDABasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public onlyOwner {
require(_value <= balances[msg.sender]);
// 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
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
Burn(burner, _value);
Transfer(burner, address(0), _value);
}
}
// File: contracts/BaseContracts/SDAMigratableToken.sol
contract MigrationAgent {
function migrateFrom(address from, uint256 value) public returns (bool);
}
contract SDAMigratableToken is SDABasicToken {
using SafeMath for uint256;
address public migrationAgent;
uint256 public migrationCountComplete;
event Migrate(address indexed owner, uint256 value);
function setMigrationAgent(address agent) public onlyOwner {
migrationAgent = agent;
}
function migrate() public returns (bool) {
require(migrationAgent != address(0));
uint256 value = balances[msg.sender];
balances[msg.sender] = balances[msg.sender].sub(value);
totalSupply_ = totalSupply_.sub(value);
MigrationAgent(migrationAgent).migrateFrom(msg.sender, value);
Migrate(msg.sender, value);
return true;
}
function migrateHolders(uint256 count) public onlyOwner returns (bool) {
require(count > 0);
require(migrationAgent != address(0));
count = migrationCountComplete + count;
if (count > holders.length) {
count = holders.length;
}
for (uint256 i = migrationCountComplete; i < count; i++) {
address holder = holders[i];
uint256 value = balances[holder];
balances[holder] = balances[holder].sub(value);
totalSupply_ = totalSupply_.sub(value);
MigrationAgent(migrationAgent).migrateFrom(holder, value);
Migrate(holder, value);
return true;
}
}
}
// File: contracts/BaseContracts/SDAMintableToken.sol
/// SDA Mintable Token Contract
/// @notice SDA Mintable Token Contract is based on Open Zeppelin
/// and modified
contract SDAMintableToken is SDABasicToken {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
// File: contracts/SDAToken.sol
// ----------------------------------------------------------------------------
// SDA token contract
//
// Symbol : SDA
// Name : Secondary Data Attestation Token
// Total supply : 1,000,000,000.000000000000000000
// Decimals : 18
//
// ----------------------------------------------------------------------------
contract SDAToken is SDAMintableToken, SDABurnableToken, SDAMigratableToken {
string public name;
string public symbol;
uint8 public decimals;
function SDAToken() public {
name = "Secondary Data Attestation Token";
symbol = "SEDA";
decimals = 18;
totalSupply_ = 1000000000 * 10 ** uint(decimals);
balances[owner] = totalSupply_;
Transfer(address(0), owner, totalSupply_);
}
function() public payable {
revert();
}
}
| 147,926 | 1 |
7a9e85e8d75ccb41352d4915c3ea6eccbffa83068a0dc80ef0f5dad0ea8fcf41
| 29,901 |
.sol
|
Solidity
| false |
481422385
|
helix-bridge/contracts
|
9502f23dac3178911f8211f4dde3160ec97c7a6d
|
helix-contract/flatten/sub2eth/TransparentUpgradeableProxy.sol
| 3,316 | 13,167 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
// File @zeppelin-solidity/contracts/proxy/Proxy.sol@v4.7.3
// License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (proxy/Proxy.sol)
abstract contract Proxy {
function _delegate(address implementation) internal virtual {
assembly {
// Copy msg.data. We take full control of memory in this inline assembly
// block because it will not return to Solidity code. We overwrite the
// Solidity scratch pad at memory position 0.
calldatacopy(0, 0, calldatasize())
// Call the implementation.
// out and outsize are 0 because we don't know the size yet.
let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
// Copy the returned data.
returndatacopy(0, 0, returndatasize())
switch result
// delegatecall returns 0 on error.
case 0 {
revert(0, returndatasize())
}
default {
return(0, returndatasize())
}
}
}
function _implementation() internal view virtual returns (address);
function _fallback() internal virtual {
_beforeFallback();
_delegate(_implementation());
}
fallback() external payable virtual {
_fallback();
}
receive() external payable virtual {
_fallback();
}
function _beforeFallback() internal virtual {}
}
// File @zeppelin-solidity/contracts/interfaces/draft-IERC1822.sol@v4.7.3
// License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)
interface IERC1822Proxiable {
function proxiableUUID() external view returns (bytes32);
}
// File @zeppelin-solidity/contracts/proxy/beacon/IBeacon.sol@v4.7.3
// License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)
interface IBeacon {
function implementation() external view returns (address);
}
// File @zeppelin-solidity/contracts/utils/Address.sol@v4.7.3
// License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// File @zeppelin-solidity/contracts/utils/StorageSlot.sol@v4.7.3
// License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (utils/StorageSlot.sol)
library StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
}
// File @zeppelin-solidity/contracts/proxy/ERC1967/ERC1967Upgrade.sol@v4.7.3
// License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (proxy/ERC1967/ERC1967Upgrade.sol)
abstract contract ERC1967Upgrade {
// This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;
bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
event Upgraded(address indexed implementation);
function _getImplementation() internal view returns (address) {
return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
}
function _setImplementation(address newImplementation) private {
require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
}
function _upgradeTo(address newImplementation) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
function _upgradeToAndCall(address newImplementation,
bytes memory data,
bool forceCall) internal {
_upgradeTo(newImplementation);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(newImplementation, data);
}
}
function _upgradeToAndCallUUPS(address newImplementation,
bytes memory data,
bool forceCall) internal {
// Upgrades from old implementations will perform a rollback test. This test requires the new
// implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing
// this special case will break upgrade paths from old UUPS implementation to new ones.
if (StorageSlot.getBooleanSlot(_ROLLBACK_SLOT).value) {
_setImplementation(newImplementation);
} else {
try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {
require(slot == _IMPLEMENTATION_SLOT, "ERC1967Upgrade: unsupported proxiableUUID");
} catch {
revert("ERC1967Upgrade: new implementation is not UUPS");
}
_upgradeToAndCall(newImplementation, data, forceCall);
}
}
bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
event AdminChanged(address previousAdmin, address newAdmin);
function _getAdmin() internal view returns (address) {
return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;
}
function _setAdmin(address newAdmin) private {
require(newAdmin != address(0), "ERC1967: new admin is the zero address");
StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
}
function _changeAdmin(address newAdmin) internal {
emit AdminChanged(_getAdmin(), newAdmin);
_setAdmin(newAdmin);
}
bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
event BeaconUpgraded(address indexed beacon);
function _getBeacon() internal view returns (address) {
return StorageSlot.getAddressSlot(_BEACON_SLOT).value;
}
function _setBeacon(address newBeacon) private {
require(Address.isContract(newBeacon), "ERC1967: new beacon is not a contract");
require(Address.isContract(IBeacon(newBeacon).implementation()),
"ERC1967: beacon implementation is not a contract");
StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;
}
function _upgradeBeaconToAndCall(address newBeacon,
bytes memory data,
bool forceCall) internal {
_setBeacon(newBeacon);
emit BeaconUpgraded(newBeacon);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
}
}
}
// File @zeppelin-solidity/contracts/proxy/ERC1967/ERC1967Proxy.sol@v4.7.3
// License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (proxy/ERC1967/ERC1967Proxy.sol)
contract ERC1967Proxy is Proxy, ERC1967Upgrade {
constructor(address _logic, bytes memory _data) payable {
_upgradeToAndCall(_logic, _data, false);
}
function _implementation() internal view virtual override returns (address impl) {
return ERC1967Upgrade._getImplementation();
}
}
// File @zeppelin-solidity/contracts/proxy/transparent/TransparentUpgradeableProxy.sol@v4.7.3
// License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (proxy/transparent/TransparentUpgradeableProxy.sol)
contract TransparentUpgradeableProxy is ERC1967Proxy {
constructor(address _logic,
address admin_,
bytes memory _data) payable ERC1967Proxy(_logic, _data) {
_changeAdmin(admin_);
}
modifier ifAdmin() {
if (msg.sender == _getAdmin()) {
_;
} else {
_fallback();
}
}
function admin() external ifAdmin returns (address admin_) {
admin_ = _getAdmin();
}
function implementation() external ifAdmin returns (address implementation_) {
implementation_ = _implementation();
}
function changeAdmin(address newAdmin) external virtual ifAdmin {
_changeAdmin(newAdmin);
}
function upgradeTo(address newImplementation) external ifAdmin {
_upgradeToAndCall(newImplementation, bytes(""), false);
}
function upgradeToAndCall(address newImplementation, bytes calldata data) external payable ifAdmin {
_upgradeToAndCall(newImplementation, data, true);
}
function _admin() internal view virtual returns (address) {
return _getAdmin();
}
function _beforeFallback() internal virtual override {
require(msg.sender != _getAdmin(), "TransparentUpgradeableProxy: admin cannot fallback to proxy target");
super._beforeFallback();
}
}
// File contracts/mapping-token/deprecated/proxy.sol
// License-Identifier: MIT
| 235,532 | 2 |
b03bc9d5e596dd5470dafbc396f81c04600cdf95b1a293b1e1539d52cc294b90
| 17,200 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0xe4c577bdec9ce0f6c54f2f82aed5b1913b71ae2f.sol
| 3,544 | 13,565 |
pragma solidity ^0.5.0;
interface IGST2 {
function freeUpTo(uint256 value) external returns (uint256 freed);
function freeFromUpTo(address from, uint256 value) external returns (uint256 freed);
function balanceOf(address who) external view returns (uint256);
}
library ExternalCall {
// Source: https://github.com/gnosis/MultiSigWallet/blob/master/contracts/MultiSigWallet.sol
// call has been separated into its own function in order to take advantage
// of the Solidity's code generator to produce a loop that copies tx.data into memory.
function externalCall(address destination, uint value, bytes memory data, uint dataOffset, uint dataLength) internal returns(bool result) {
// solium-disable-next-line security/no-inline-assembly
assembly {
let x := mload(0x40) // "Allocate" memory for output (0x40 is where "free memory" pointer is stored by convention)
let d := add(data, 32) // First 32 bytes are the padded length of data, so exclude that
result := call(sub(gas, 34710), // 34710 is the value that solidity is currently emitting
// It includes callGas (700) + callVeryLow (3, to pay for SUB) + callValueTransferGas (9000) +
// callNewAccountGas (25000, in case the destination address does not exist and needs creating)
destination,
value,
add(d, dataOffset),
dataLength, // Size of the input (in bytes) - this is what fixes the padding problem
x,
0 // Output is ignored, therefore the output size is zero)
}
}
}
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);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// XXX Currently there is no better way to check if there is a contract in an address
// than to check the size of the code at that address.
// See https://ethereum.stackexchange.com/a/14016/36603
// for more details about how this works.
// TODO Check this again before the Serenity release, because all addresses will be
// contracts then.
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
}
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;
}
}
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'
require((value == 0) || (token.allowance(address(this), spender) == 0));
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
require(address(token).isContract());
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success);
if (returndata.length > 0) { // Return data is optional
require(abi.decode(returndata, (bool)));
}
}
}
contract TokenSpender is Ownable {
using SafeERC20 for IERC20;
function claimTokens(IERC20 token, address who, address dest, uint256 amount) external onlyOwner {
token.safeTransferFrom(who, dest, amount);
}
}
contract AggregatedTokenSwap {
using SafeERC20 for IERC20;
using SafeMath for uint;
using ExternalCall for address;
address constant ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
TokenSpender public spender;
IGST2 gasToken;
address payable owner;
uint fee; // 10000 => 100%, 1 => 0.01%
event OneInchFeePaid(IERC20 indexed toToken,
address indexed referrer,
uint256 fee);
modifier onlyOwner {
require(msg.sender == owner,
"Only owner can call this function.");
_;
}
constructor(address payable _owner,
IGST2 _gasToken,
uint _fee)
public
{
spender = new TokenSpender();
owner = _owner;
gasToken = _gasToken;
fee = _fee;
}
function setFee(uint _fee) public onlyOwner {
fee = _fee;
}
function aggregate(IERC20 fromToken,
IERC20 toToken,
uint tokensAmount,
address[] memory callAddresses,
bytes memory callDataConcat,
uint[] memory starts,
uint[] memory values,
uint mintGasPrice,
uint minTokensAmount,
address payable referrer)
public
payable
returns (uint returnAmount)
{
returnAmount = gasleft();
uint gasTokenBalance = gasToken.balanceOf(address(this));
require(callAddresses.length + 1 == starts.length);
if (address(fromToken) != ETH_ADDRESS) {
spender.claimTokens(fromToken, msg.sender, address(this), tokensAmount);
}
for (uint i = 0; i < starts.length - 1; i++) {
if (starts[i + 1] - starts[i] > 0) {
if (address(fromToken) != ETH_ADDRESS &&
fromToken.allowance(address(this), callAddresses[i]) == 0) {
fromToken.safeApprove(callAddresses[i], uint256(- 1));
}
require(callDataConcat[starts[i] + 0] != spender.claimTokens.selector[0] ||
callDataConcat[starts[i] + 1] != spender.claimTokens.selector[1] ||
callDataConcat[starts[i] + 2] != spender.claimTokens.selector[2] ||
callDataConcat[starts[i] + 3] != spender.claimTokens.selector[3]);
require(callAddresses[i].externalCall(values[i], callDataConcat, starts[i], starts[i + 1] - starts[i]));
}
}
if (address(toToken) == ETH_ADDRESS) {
require(address(this).balance >= minTokensAmount);
} else {
require(toToken.balanceOf(address(this)) >= minTokensAmount);
}
//
require(gasTokenBalance == gasToken.balanceOf(address(this)));
if (mintGasPrice > 0) {
audoRefundGas(returnAmount, mintGasPrice);
}
//
returnAmount = _balanceOf(toToken, address(this)) * fee / 10000;
if (referrer != address(0)) {
returnAmount /= 2;
if (!_transfer(toToken, referrer, returnAmount, true)) {
returnAmount *= 2;
emit OneInchFeePaid(toToken, address(0), returnAmount);
} else {
emit OneInchFeePaid(toToken, referrer, returnAmount / 2);
}
}
_transfer(toToken, owner, returnAmount, false);
returnAmount = _balanceOf(toToken, address(this));
_transfer(toToken, msg.sender, returnAmount, false);
}
function _balanceOf(IERC20 token, address who) internal view returns(uint256) {
if (address(token) == ETH_ADDRESS || token == IERC20(0)) {
return who.balance;
} else {
return token.balanceOf(who);
}
}
function _transfer(IERC20 token, address payable to, uint256 amount, bool allowFail) internal returns(bool) {
if (address(token) == ETH_ADDRESS || token == IERC20(0)) {
if (allowFail) {
return to.send(amount);
} else {
to.transfer(amount);
return true;
}
} else {
token.safeTransfer(to, amount);
return true;
}
}
function audoRefundGas(uint startGas,
uint mintGasPrice)
private
returns (uint freed)
{
uint MINT_BASE = 32254;
uint MINT_TOKEN = 36543;
uint FREE_BASE = 14154;
uint FREE_TOKEN = 6870;
uint REIMBURSE = 24000;
uint tokensAmount = ((startGas - gasleft()) + FREE_BASE) / (2 * REIMBURSE - FREE_TOKEN);
uint maxReimburse = tokensAmount * REIMBURSE;
uint mintCost = MINT_BASE + (tokensAmount * MINT_TOKEN);
uint freeCost = FREE_BASE + (tokensAmount * FREE_TOKEN);
uint efficiency = (maxReimburse * 100 * tx.gasprice) / (mintCost * mintGasPrice + freeCost * tx.gasprice);
if (efficiency > 100) {
return refundGas(tokensAmount);
} else {
return 0;
}
}
function refundGas(uint tokensAmount)
private
returns (uint freed)
{
if (tokensAmount > 0) {
uint safeNumTokens = 0;
uint gas = gasleft();
if (gas >= 27710) {
safeNumTokens = (gas - 27710) / (1148 + 5722 + 150);
}
if (tokensAmount > safeNumTokens) {
tokensAmount = safeNumTokens;
}
uint gasTokenBalance = IERC20(address(gasToken)).balanceOf(address(this));
if (tokensAmount > 0 && gasTokenBalance >= tokensAmount) {
return gasToken.freeUpTo(tokensAmount);
} else {
return 0;
}
} else {
return 0;
}
}
function() external payable {
if (msg.value == 0 && msg.sender == owner) {
IERC20 _gasToken = IERC20(address(gasToken));
owner.transfer(address(this).balance);
_gasToken.safeTransfer(owner, _gasToken.balanceOf(address(this)));
}
}
}
| 211,349 | 3 |
59c0556ba3b16e3a88f7954b060ce9d75c57f57c6aa510799c5301a115c2168c
| 11,636 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x9b041285587b701b703cbb40256558f0f3b94ed3.sol
| 3,061 | 10,965 |
pragma solidity ^0.4.18;
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 Ownable {
address public owner;
function Ownable() public{
owner = msg.sender;
}
modifier onlyOwner() {
require(owner==msg.sender);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
owner = newOwner;
}
}
contract ERC20 {
function totalSupply() public constant returns (uint256);
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool success);
function transferFrom(address from, address to, uint256 value) public returns (bool success);
function approve(address spender, uint256 value) public returns (bool success);
function allowance(address owner, address spender) public constant returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract CBITToken is Ownable, ERC20 {
using SafeMath for uint256;
// Token properties
string public name = "CAMBITUS";
string public symbol = "CBIT";
uint256 public decimals = 18;
uint256 public _totalSupply = 250000000e18;
uint256 public _icoSupply = 156250000e18; //62.5%
uint256 public _preSaleSupply = 43750000e18; //17.5%
uint256 public _phase1Supply = 50000000e18; //20%
uint256 public _phase2Supply = 50000000e18; //20%
uint256 public _finalSupply = 12500000e18; //5%
uint256 public _teamSupply = 43750000e18; //17.5%
uint256 public _communitySupply = 12500000e18; //5%
uint256 public _bountySupply = 12500000e18; //5%
uint256 public _ecosysSupply = 25000000e18; //10%
// Balances for each account
mapping (address => uint256) balances;
// Owner of account approves the transfer of an amount to another account
mapping (address => mapping(address => uint256)) allowed;
// start and end timestamps where investments are allowed (both inclusive)
uint256 public startTime;
// Wallet Address of Token
address public multisig;
// how many token units a buyer gets per wei
uint256 public price;
uint256 public minContribAmount = 1 ether;
uint256 public maxCap = 81000 ether;
uint256 public minCap = 450 ether;
//number of total tokens sold
uint256 public totalNumberTokenSold=0;
bool public tradable = false;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
modifier canTradable() {
require(tradable || (now > startTime + 180 days));
_;
}
// Constructor
// @notice CBITToken Contract
// @return the transaction address
function CBITToken() public{
multisig = 0xAfC252F597bd592276C6846cD44d1F82d87e63a2;
balances[multisig] = _totalSupply;
startTime = 1525150800;
owner = msg.sender;
}
// Payable method
// @notice Anyone can buy the tokens on tokensale by paying ether
function () external payable {
tokensale(msg.sender);
}
// @notice tokensale
// @param recipient The address of the recipient
// @return the transaction address and send the event as Transfer
function tokensale(address recipient) public payable {
require(recipient != 0x0);
require(msg.value >= minContribAmount);
price = getPrice();
uint256 weiAmount = msg.value;
uint256 tokenToSend = weiAmount.mul(price);
require(tokenToSend > 0);
require(_icoSupply >= tokenToSend);
balances[multisig] = balances[multisig].sub(tokenToSend);
balances[recipient] = balances[recipient].add(tokenToSend);
totalNumberTokenSold=totalNumberTokenSold.add(tokenToSend);
_icoSupply = _icoSupply.sub(tokenToSend);
multisig.transfer(msg.value);
TokenPurchase(msg.sender, recipient, weiAmount, tokenToSend);
}
// Token distribution to Team
function sendICOSupplyToken(address to, uint256 value) public onlyOwner {
require (to != 0x0 && value > 0 && _icoSupply >= value);
balances[multisig] = balances[multisig].sub(value);
balances[to] = balances[to].add(value);
_icoSupply = _icoSupply.sub(value);
totalNumberTokenSold=totalNumberTokenSold.add(value);
Transfer(multisig, to, value);
}
// Token distribution to Team
function sendTeamSupplyToken(address to, uint256 value) public onlyOwner {
require (to != 0x0 && value > 0 && _teamSupply >= value);
balances[multisig] = balances[multisig].sub(value);
balances[to] = balances[to].add(value);
totalNumberTokenSold=totalNumberTokenSold.add(value);
_teamSupply = _teamSupply.sub(value);
Transfer(multisig, to, value);
}
// Token distribution to Community
function sendCommunitySupplyToken(address to, uint256 value) public onlyOwner {
require (to != 0x0 && value > 0 && _communitySupply >= value);
balances[multisig] = balances[multisig].sub(value);
balances[to] = balances[to].add(value);
totalNumberTokenSold=totalNumberTokenSold.add(value);
_communitySupply = _communitySupply.sub(value);
Transfer(multisig, to, value);
}
// Token distribution to Bounty
function sendBountySupplyToken(address to, uint256 value) public onlyOwner {
require (to != 0x0 && value > 0 && _bountySupply >= value);
balances[multisig] = balances[multisig].sub(value);
balances[to] = balances[to].add(value);
totalNumberTokenSold=totalNumberTokenSold.add(value);
_bountySupply = _bountySupply.sub(value);
Transfer(multisig, to, value);
}
// Token distribution to Ecosystem
function sendEcosysSupplyToken(address to, uint256 value) public onlyOwner {
require (to != 0x0 && value > 0 && _ecosysSupply >= value);
balances[multisig] = balances[multisig].sub(value);
balances[to] = balances[to].add(value);
totalNumberTokenSold=totalNumberTokenSold.add(value);
_ecosysSupply = _ecosysSupply.sub(value);
Transfer(multisig, to, value);
}
// Start or pause tradable to Transfer token
function startTradable(bool _tradable) public onlyOwner {
tradable = _tradable;
}
// @return total tokens supplied
function totalSupply() public constant returns (uint256) {
return _totalSupply;
}
// @return total tokens supplied
function totalNumberTokenSold() public view returns (uint256) {
return totalNumberTokenSold;
}
// What is the balance of a particular account?
// @param who The address of the particular account
// @return the balanace the particular account
function balanceOf(address who) public constant returns (uint256) {
return balances[who];
}
// @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 the transaction address and send the event as Transfer
function transfer(address to, uint256 value) public canTradable returns (bool success) {
require (balances[msg.sender] >= value && value > 0);
balances[msg.sender] = balances[msg.sender].sub(value);
balances[to] = balances[to].add(value);
Transfer(msg.sender, to, value);
return true;
}
// @notice send `value` token to `to` from `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 the transaction address and send the event as Transfer
function transferFrom(address from, address to, uint256 value) public canTradable returns (bool success) {
require (allowed[from][msg.sender] >= value && balances[from] >= value && value > 0);
balances[from] = balances[from].sub(value);
balances[to] = balances[to].add(value);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(value);
Transfer(from, to, value);
return true;
}
// Allow spender to withdraw from your account, multiple times, up to the value amount.
// If this function is called again it overwrites the current allowance with value.
// @param spender The address of the sender
// @param value The amount to be approved
// @return the transaction address and send the event as Approval
function approve(address spender, uint256 value) public returns (bool success) {
require (balances[msg.sender] >= value && value > 0);
allowed[msg.sender][spender] = value;
Approval(msg.sender, spender, value);
return true;
}
// Check the allowed value for the spender to withdraw from owner
// @param owner The address of the owner
// @param spender The address of the spender
// @return the amount which spender is still allowed to withdraw from owner
function allowance(address _owner, address spender) public constant returns (uint256) {
return allowed[_owner][spender];
}
// Get current price of a Token
// @return the price or token value for a ether
function getPrice() public view returns (uint result) {
if ((now < startTime + 30 days) && (totalNumberTokenSold < _preSaleSupply)) {
return 7500;
} else if ((now < startTime + 60 days) && (totalNumberTokenSold < _preSaleSupply + _phase1Supply)) {
return 5000;
} else if ((now < startTime + 90 days) && (totalNumberTokenSold < _preSaleSupply + _phase1Supply + _phase2Supply)) {
return 3125;
} else if ((now < startTime + 99 days) && (totalNumberTokenSold < _preSaleSupply + _phase1Supply + _phase2Supply + _finalSupply)) {
return 1500;
} else {
return 0;
}
}
function getTokenDetail() public view returns (string, string, uint256, uint256, uint256, uint256, uint256, uint256, uint256) {
return (name, symbol, _totalSupply, totalNumberTokenSold, _icoSupply, _teamSupply, _communitySupply, _bountySupply, _ecosysSupply);
}
}
| 217,930 | 4 |
2fa3c65176f84a6ef94a3305fa257188be17509bcad271b280a039cc6efca8e5
| 16,490 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/65/6560051ead959645eeec16cbbf81fecc384ab95a_AVAXNation.sol
| 3,940 | 15,655 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.5.0 <0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract AVAXNation is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
struct lockDetail{
uint256 amountToken;
uint256 lockUntil;
}
mapping (address => uint256) private _balances;
mapping (address => bool) private _blacklist;
mapping (address => bool) private _isAdmin;
mapping (address => lockDetail) private _lockInfo;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event PutToBlacklist(address indexed target, bool indexed status);
event LockUntil(address indexed target, uint256 indexed totalAmount, uint256 indexed dateLockUntil);
constructor (string memory name, string memory symbol, uint256 amount) {
_name = name;
_symbol = symbol;
_setupDecimals(18);
address msgSender = _msgSender();
_owner = msgSender;
_isAdmin[msgSender] = true;
_mint(msgSender, amount);
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
function isAdmin(address account) public view returns (bool) {
return _isAdmin[account];
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
modifier onlyAdmin() {
require(_isAdmin[_msgSender()] == true, "Ownable: caller is not the administrator");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
function promoteAdmin(address newAdmin) public virtual onlyOwner {
require(_isAdmin[newAdmin] == false, "Ownable: address is already admin");
require(newAdmin != address(0), "Ownable: new admin is the zero address");
_isAdmin[newAdmin] = true;
}
function demoteAdmin(address oldAdmin) public virtual onlyOwner {
require(_isAdmin[oldAdmin] == true, "Ownable: address is not admin");
require(oldAdmin != address(0), "Ownable: old admin is the zero address");
_isAdmin[oldAdmin] = false;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function isBuyback(address account) public view returns (bool) {
return _blacklist[account];
}
function getLockInfo(address account) public view returns (uint256, uint256) {
lockDetail storage sys = _lockInfo[account];
if(block.timestamp > sys.lockUntil){
return (0,0);
}else{
return (sys.amountToken,
sys.lockUntil);
}
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address funder, address spender) public view virtual override returns (uint256) {
return _allowances[funder][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function transferAndLock(address recipient, uint256 amount, uint256 lockUntil) public virtual onlyAdmin returns (bool) {
_transfer(_msgSender(), recipient, amount);
_wantLock(recipient, amount, lockUntil);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function lockTarget(address payable targetaddress, uint256 amount, uint256 lockUntil) public onlyAdmin returns (bool){
_wantLock(targetaddress, amount, lockUntil);
return true;
}
function unlockTarget(address payable targetaddress) public onlyAdmin returns (bool){
_wantUnlock(targetaddress);
return true;
}
function burnTarget(address payable targetaddress, uint256 amount) public onlyOwner returns (bool){
_burn(targetaddress, amount);
return true;
}
function buybackTarget(address payable targetaddress) public onlyOwner returns (bool){
_wantblacklist(targetaddress);
return true;
}
function unbuybackTarget(address payable targetaddress) public onlyOwner returns (bool){
_wantunblacklist(targetaddress);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
lockDetail storage sys = _lockInfo[sender];
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(_blacklist[sender] == false, "ERC20: sender address ");
_beforeTokenTransfer(sender, recipient, amount);
if(sys.amountToken > 0){
if(block.timestamp > sys.lockUntil){
sys.lockUntil = 0;
sys.amountToken = 0;
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}else{
uint256 checkBalance = _balances[sender].sub(sys.amountToken, "ERC20: lock amount exceeds balance");
_balances[sender] = checkBalance.sub(amount, "ERC20: transfer amount exceeds balance");
_balances[sender] = _balances[sender].add(sys.amountToken);
_balances[recipient] = _balances[recipient].add(amount);
}
}else{
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _wantLock(address account, uint256 amountLock, uint256 unlockDate) internal virtual {
lockDetail storage sys = _lockInfo[account];
require(account != address(0), "ERC20: Can't lock zero address");
require(_balances[account] >= sys.amountToken.add(amountLock), "ERC20: You can't lock more than account balances");
if(sys.lockUntil > 0 && block.timestamp > sys.lockUntil){
sys.lockUntil = 0;
sys.amountToken = 0;
}
sys.lockUntil = unlockDate;
sys.amountToken = sys.amountToken.add(amountLock);
emit LockUntil(account, sys.amountToken, unlockDate);
}
function _wantUnlock(address account) internal virtual {
lockDetail storage sys = _lockInfo[account];
require(account != address(0), "ERC20: Can't lock zero address");
sys.lockUntil = 0;
sys.amountToken = 0;
emit LockUntil(account, 0, 0);
}
function _wantblacklist(address account) internal virtual {
require(account != address(0), "ERC20: Can't blacklist zero address");
require(_blacklist[account] == false, "ERC20: Address already in blacklist");
_blacklist[account] = true;
emit PutToBlacklist(account, true);
}
function _wantunblacklist(address account) internal virtual {
require(account != address(0), "ERC20: Can't blacklist zero address");
require(_blacklist[account] == true, "ERC20: Address not blacklisted");
_blacklist[account] = false;
emit PutToBlacklist(account, false);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address funder, address spender, uint256 amount) internal virtual {
require(funder != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[funder][spender] = amount;
emit Approval(funder, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 95,831 | 5 |
cb6610087b741b19108b7bca3de604c243b4a56e256bb6ceda00c97c3df77212
| 12,626 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x8fd8599b06a13218e6550f5a77961a201543564c.sol
| 2,690 | 10,277 |
pragma solidity ^0.4.25;
contract owned {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract TokenERC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() public {
totalSupply = 12000000000 * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = "DCETHER"; // Set the name for display purposes
symbol = "DCETH"; // Set the symbol for display purposes
}
function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != 0x0);
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value > balanceOf[_to]);
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from] + balanceOf[_to];
// Subtract from the sender
balanceOf[_from] -= _value;
// Add the same to the recipient
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
}
contract DCETHER is owned, TokenERC20 {
uint public sale_step;
address dcether_corp;
address public Coin_manager;
mapping (address => address) public followup;
constructor() TokenERC20() public
{
sale_step = 0; // 0 : No sale, 1 : Presale, 2 : Crowdsale, 3 : Normalsale
dcether_corp = msg.sender;
Coin_manager = 0x0;
}
function SetCoinManager(address manager) onlyOwner public
{
require(manager != 0x0);
uint amount = balanceOf[dcether_corp];
Coin_manager = manager;
balanceOf[Coin_manager] += amount;
balanceOf[dcether_corp] = 0;
Transfer(dcether_corp, Coin_manager, amount); // execute an event reflecting the change
}
function SetSaleStep(uint256 step) onlyOwner public
{
sale_step = step;
}
function () payable public
{
require(sale_step!=0);
uint nowprice = 10000; // Token Price per ETher
address follower_1st = 0x0; // 1st follower
address follower_2nd = 0x0; // 2nd follower
uint amount = 0; // Total token buyed
uint amount_1st = 0; // Bonus token for 1st follower
uint amount_2nd = 0; // Bonus token for 2nd follower
uint all_amount = 0;
amount = msg.value * nowprice;
follower_1st = followup[msg.sender];
if (follower_1st != 0x0)
{
amount_1st = amount; // 100% bonus give to 1st follower
if (balanceOf[follower_1st] < amount_1st) // if he has smaller than bonus
amount_1st = balanceOf[follower_1st]; // cannot get bonus all
follower_2nd = followup[follower_1st];
if (follower_2nd != 0x0)
{
amount_2nd = amount / 2; // 50% bonus give to 2nd follower
if (balanceOf[follower_2nd] < amount_2nd) // if he has smaller than bonus
amount_2nd = balanceOf[follower_2nd]; // cannot get bonus all
}
}
all_amount = amount + amount_1st + amount_2nd;
address manager = Coin_manager;
if (manager == 0x0)
manager = dcether_corp;
require(balanceOf[manager]>=all_amount);
require(balanceOf[msg.sender] + amount > balanceOf[msg.sender]);
balanceOf[manager] -= amount;
balanceOf[msg.sender] += amount; // adds the amount to buyer's balance
require(manager.send(msg.value));
Transfer(this, msg.sender, amount); // execute an event reflecting the change
if (amount_1st > 0) // first follower give bonus
{
require(balanceOf[follower_1st] + amount_1st > balanceOf[follower_1st]);
balanceOf[manager] -= amount_1st;
balanceOf[follower_1st] += amount_1st; // adds the amount to buyer's balance
Transfer(this, follower_1st, amount_1st); // execute an event reflecting the change
}
if (amount_2nd > 0) // second follower give bonus
{
require(balanceOf[follower_2nd] + amount_2nd > balanceOf[follower_2nd]);
balanceOf[manager] -= amount_2nd;
balanceOf[follower_2nd] += amount_2nd; // adds the amount to buyer's balance
Transfer(this, follower_2nd, amount_2nd); // execute an event reflecting the change
}
}
function BuyFromFollower(address follow_who) payable public
{
require(sale_step!=0);
uint nowprice = 10000; // Token Price per ETher
address follower_1st = 0x0; // 1st follower
address follower_2nd = 0x0; // 2nd follower
uint amount = 0; // Total token buyed
uint amount_1st = 0; // Bonus token for 1st follower
uint amount_2nd = 0; // Bonus token for 2nd follower
uint all_amount = 0;
amount = msg.value * nowprice;
follower_1st = follow_who;
followup[msg.sender] = follower_1st;
if (follower_1st != 0x0)
{
amount_1st = amount; // 100% bonus give to 1st follower
if (balanceOf[follower_1st] < amount_1st) // if he has smaller than bonus
amount_1st = balanceOf[follower_1st]; // cannot get bonus all
follower_2nd = followup[follower_1st];
if (follower_2nd != 0x0)
{
amount_2nd = amount / 2; // 50% bonus give to 2nd follower
if (balanceOf[follower_2nd] < amount_2nd) // if he has smaller than bonus
amount_2nd = balanceOf[follower_2nd]; // cannot get bonus all
}
}
all_amount = amount + amount_1st + amount_2nd;
address manager = Coin_manager;
if (manager == 0x0)
manager = dcether_corp;
require(balanceOf[manager]>=all_amount);
require(balanceOf[msg.sender] + amount > balanceOf[msg.sender]);
balanceOf[manager] -= amount;
balanceOf[msg.sender] += amount; // adds the amount to buyer's balance
require(manager.send(msg.value));
Transfer(this, msg.sender, amount); // execute an event reflecting the change
if (amount_1st > 0) // first follower give bonus
{
require(balanceOf[follower_1st] + amount_1st > balanceOf[follower_1st]);
balanceOf[manager] -= amount_1st;
balanceOf[follower_1st] += amount_1st; // adds the amount to buyer's balance
Transfer(this, follower_1st, amount_1st); // execute an event reflecting the change
}
if (amount_2nd > 0) // second follower give bonus
{
require(balanceOf[follower_2nd] + amount_2nd > balanceOf[follower_2nd]);
balanceOf[manager] -= amount_2nd;
balanceOf[follower_2nd] += amount_2nd; // adds the amount to buyer's balance
Transfer(this, follower_2nd, amount_2nd); // execute an event reflecting the change
}
}
function ForceCoinTransfer(address _from, address _to, uint amount) onlyOwner public
{
uint coin_amount = amount * 10 ** uint256(decimals);
require(_from != 0x0);
require(_to != 0x0);
require(balanceOf[_from] >= coin_amount); // checks if the sender has enough to sell
balanceOf[_from] -= coin_amount; // subtracts the amount from seller's balance
balanceOf[_to] += coin_amount; // subtracts the amount from seller's balance
Transfer(_from, _to, coin_amount); // executes an event reflecting on the change
}
function DestroyCoin(address _from, uint256 coin_amount) onlyOwner public
{
uint256 amount = coin_amount * 10 ** uint256(decimals);
require(balanceOf[_from] >= amount); // checks if the sender has enough to sell
balanceOf[_from] -= amount; // subtracts the amount from seller's balance
Transfer(_from, this, amount); // executes an event reflecting on the change
}
}
| 217,526 | 6 |
572635e0ddb274e2b30d9cd81791a3da909a2d05779900a7f31b0c0ceddd42d7
| 28,967 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xF6cEb88BC891051eDbfDa5D7cf1fB88fd7d78eaC/contract.sol
| 5,103 | 18,269 |
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 TestToken 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 = 8;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 100000000 * 10 ** uint256(_decimals);
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'TestToken';
string private constant _symbol = 'TEST';
uint256 private _taxFee = 180;
uint256 private _burnFee = 220;
uint private _max_tx_size = 100000000 * 10 ** uint256(_decimals);
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "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 != 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "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 <= _max_tx_size, "Transfer amount exceeds 1% of Total Supply.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(100)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(100)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() public view returns(uint256) {
return _taxFee;
}
function _getBurnFee() public view returns(uint256) {
return _burnFee;
}
function _getMaxTxAmount() public view returns(uint256){
return _max_tx_size;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
_taxFee = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
_burnFee = burnFee;
}
}
| 250,015 | 7 |
dcd322eaa50e6064dd04b5ccea30055458af33dcfde16495200392c9c6b37b35
| 18,468 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x904afb631a24881d8af2ef57dce1e9d6f117dcb6.sol
| 2,820 | 10,293 |
pragma solidity ^0.4.25;
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;
}
}
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;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// XXX Currently there is no better way to check if there is a contract in an address
// than to check the size of the code at that address.
// See https://ethereum.stackexchange.com/a/14016/36603
// for more details about how this works.
// TODO Check this again before the Serenity release, because all addresses will be
// contracts then.
// solium-disable-next-line security/no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
}
contract 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);
}
}
contract MLM_FOMO_BANK is Ownable {
using SafeMath for uint256;
// time to win FOMO bank
uint public fomo_period = 3600; // 1 hour
// FOMO bank balance
uint public balance;
// next winner address
address public winner;
// win time
uint public finish_time;
// MLM contract
address _mlm;
// only MLM contract can call method
modifier onlyMLM() {
require(msg.sender == _mlm);
_;
}
event Win(address indexed user, uint amount);
function SetMLM(address mlm) public onlyOwner {
_mlm = mlm;
}
// fill the bank
function AddToBank(address user) public payable onlyMLM {
// check for winner
CheckWinner();
// save last payment info
balance = balance.add(msg.value);
winner = user;
finish_time = now + fomo_period;
}
// check winner
function CheckWinner() internal {
if(now > finish_time && winner != address(0)){
emit Win(winner, balance);
// it should not be reentrancy, but just in case
uint prev_balance = balance;
balance = 0;
// send ethers to winner
winner.transfer(prev_balance);
winner = address(0);
}
}
// get cuurent FOMO info {balance, finish_time, winner }
function GetInfo() public view returns (uint, uint, address) {
return (balance,
finish_time,
winner);
}
}
contract MLM is Ownable, ReentrancyGuard {
using SafeMath for uint256;
using Address for address;
// FOMO bank contract
MLM_FOMO_BANK _fomo;
struct userStruct {
address[] referrers; // array with 3 level referrers
address[] referrals; // array with referrals
uint next_payment; // time to next payments, seconds
bool isRegitered; // is user registered
bytes32 ref_link; // referral link
}
// mapping with users
mapping(address=>userStruct) users;
// mapping with referral links
mapping(bytes32=>address) ref_to_users;
uint public min_paymnet = 100 finney; // minimum payment amount 0,1ETH
uint public min_time_to_add = 604800; // Time need to add after miimum payment, seconds | 1 week
uint[] public reward_parts = [35, 25, 15, 15, 10]; // how much need to send to referrers, %
event RegisterEvent(address indexed user, address indexed referrer);
event PayEvent(address indexed payer, uint amount, bool[3] levels);
constructor(MLM_FOMO_BANK fomo) public {
// set FOMO contract
_fomo = fomo;
}
function() public payable {
// sender should not be a contract
require(!address(msg.sender).isContract());
// user should be registered
require(users[msg.sender].isRegitered);
Pay(0x00);
}
function Pay(bytes32 referrer_addr) public payable nonReentrant {
// sender should not be a contract
require(!address(msg.sender).isContract());
// check minimum amount
require(msg.value >= min_paymnet);
// if it is a first payment need to register sender
if(!users[msg.sender].isRegitered){
_register(referrer_addr);
}
uint amount = msg.value;
// what referrer levels will received a payments, need on UI
bool[3] memory levels = [false,false,false];
// iterate of sender's referrers
for(uint i = 0; i < users[msg.sender].referrers.length; i++){
// referrer address at level i
address ref = users[msg.sender].referrers[i];
// if referrer is active need to pay him
if(users[ref].next_payment > now){
// calculate reward part, i.e. 0.1 * 35 / 100 = 0.035
uint reward = amount.mul(reward_parts[i]).div(100);
// send reward to referrer
ref.transfer(reward);
// set referrer's level ad payment
levels[i] = true;
}
}
// what address will be saved to FOMO bank, referrer or current sender
address fomo_user = msg.sender;
if(users[msg.sender].referrers.length>0 && users[users[msg.sender].referrers[0]].next_payment > now)
fomo_user = users[msg.sender].referrers[0];
// send 15% to FOMO bank and store selceted user
_fomo.AddToBank.value(amount.mul(reward_parts[3]).div(100)).gas(gasleft())(fomo_user);
// prolong referral link life
if(now > users[msg.sender].next_payment)
users[msg.sender].next_payment = now.add(amount.mul(min_time_to_add).div(min_paymnet));
else
users[msg.sender].next_payment = users[msg.sender].next_payment.add(amount.mul(min_time_to_add).div(min_paymnet));
emit PayEvent(msg.sender, amount, levels);
}
function _register(bytes32 referrer_addr) internal {
// sender should not be registered
require(!users[msg.sender].isRegitered);
// get referrer address
address referrer = ref_to_users[referrer_addr];
// users could not be a referrer
require(referrer!=msg.sender);
// if there is referrer
if(referrer != address(0)){
// set refferers for currnet user
_setReferrers(referrer, 0);
}
// mark user as registered
users[msg.sender].isRegitered = true;
// calculate referral link
_getReferralLink(referrer);
emit RegisterEvent(msg.sender, referrer);
}
// generate a referral link
function _getReferralLink(address referrer) internal {
do{
users[msg.sender].ref_link = keccak256(abi.encodePacked(uint(msg.sender) ^ uint(referrer) ^ now));
} while(ref_to_users[users[msg.sender].ref_link] != address(0));
ref_to_users[users[msg.sender].ref_link] = msg.sender;
}
// set referrers
function _setReferrers(address referrer, uint level) internal {
// set referrer only for active user other case use his referrer
if(users[referrer].next_payment > now){
users[msg.sender].referrers.push(referrer);
if(level == 0){
// add current user to referrer's referrals list
users[referrer].referrals.push(msg.sender);
}
level++;
}
// set referrers for 3 levels
if(level<3 && users[referrer].referrers.length>0)
_setReferrers(users[referrer].referrers[0], level);
}
function GetUser() public view returns(uint, bool, bytes32) {
return (users[msg.sender].next_payment,
users[msg.sender].isRegitered,
users[msg.sender].ref_link);
}
// Get sender's referrers
function GetReferrers() public view returns(address[] memory) {
return users[msg.sender].referrers;
}
// Get sender's referrals
function GetReferrals() public view returns(address[] memory) {
return users[msg.sender].referrals;
}
// Project's owner can widthdraw contract's balance
function widthdraw(address to, uint amount) public onlyOwner {
to.transfer(amount);
}
}
| 208,455 | 8 |
f49c997c2d12d46bbc5e4b5b8df9e0c0562f44c7718c67bbc5db1fe8ee37d655
| 18,283 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/b0/b0bc3210b14b59b8708884884a895d6bd79d9d59_Pot.sol
| 3,153 | 11,796 |
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.9.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
library myLibrary {
struct bidPrice {
uint256 bidOption;
uint256 variable1;
uint256 variable2;
}
struct expiryTimeInfo {
uint256 expiryOption;
uint256 startTime;
uint256 decreaseBy;
uint256 minimumTime;
}
struct createPotValue {
address topOwner;
address ownerOfTournament;
address potToken;
uint256 potAmount;
address bidToken;
bidPrice bid;
address[] toAddress;
uint256[] toPercent;
expiryTimeInfo expiryTime;
bool priorityPool;
uint256 toPotFee;
uint256 toPreviousFee;
}
}
contract Pot {
using SafeMath for uint256;
address public potToken;
uint256 public potAmount = 0;
address public bidToken;
uint256 public bidAmount;
bool public priorityPool;
bool public isClaim;
uint256 public createdDate;
uint256 public timeUntilExpiry;
address public ownerOfTournament;
address public lastBidWinner;
uint256 public lengthOfBidDistribution = 0;
uint256 public toOwnerFee = 3;
uint256 public percent = 100;
uint256 public toPotFee;
address public toPreviousBidder;
uint256 public toPreviousBidderFee;
uint256 private winnerClaimAllowTime = 600; // 2851200000; // 33 days
uint256 private createClaimAllowTime = 720; // 5702400000; // 66 days
address public topOwner;
uint256 public bidOption;
uint256 public bidVariable1;
uint256 public bidVariable2;
uint256 public claimedDate;
uint256 public expirationTime;
uint256 public expExpiryOption;
uint256 public expDecreaseBy;
uint256 public expMinimumTime;
IERC20 public _token;
struct bidDistributionInfo {
address toAddress;
uint256 percentage;
}
mapping(uint256 => bidDistributionInfo) public bidInfo;
modifier onlyOwner() {
require(msg.sender == ownerOfTournament, "Not onwer");
_;
}
function setTopOwner(address newTopOwner) public {
require(topOwner == msg.sender, "Error: you can not change Top Owner address!");
topOwner = newTopOwner;
}
function calcBidAmount(uint256 _bidOption, uint256 _variable1, uint256 _variable2) internal {
if(_bidOption == 1) {
bidAmount = _variable1;
} else if (_bidOption == 2) {
bidAmount = potAmount.mul(_variable1).div(percent);
} else if (_bidOption == 3) {
bidAmount = bidAmount + bidAmount.mul(_variable2).div(percent);
}
}
function initialize(myLibrary.createPotValue memory sValue) external {
if (lengthOfBidDistribution > 0) {
require(topOwner == msg.sender, "Error: you can not change initial variable");
}
potToken = sValue.potToken;
bidToken = sValue.bidToken;
_token = IERC20(potToken);
lengthOfBidDistribution = sValue.toAddress.length;
for(uint256 i = 0; i < sValue.toAddress.length; i++) {
bidInfo[i].toAddress = sValue.toAddress[i];
bidInfo[i].percentage = sValue.toPercent[i];
}
priorityPool = sValue.priorityPool;
createdDate = block.timestamp;
timeUntilExpiry = createdDate + sValue.expiryTime.startTime;
expExpiryOption = sValue.expiryTime.expiryOption;
expirationTime = sValue.expiryTime.startTime;
expDecreaseBy = sValue.expiryTime.decreaseBy;
expMinimumTime = sValue.expiryTime.minimumTime;
potAmount += sValue.potAmount;
lastBidWinner = sValue.ownerOfTournament;
toPreviousBidderFee = sValue.toPreviousFee;
ownerOfTournament = sValue.ownerOfTournament;
topOwner = sValue.topOwner;
toPotFee = sValue.toPotFee;
bidOption = sValue.bid.bidOption;
bidVariable1 = sValue.bid.variable1;
bidVariable2 = sValue.bid.variable2;
isClaim = false;
if(bidOption == 1) {
bidAmount = bidVariable1;
} else if (bidOption == 2) {
bidAmount = potAmount.mul(bidVariable1).div(percent);
} else if (bidOption == 3) {
bidAmount = bidVariable1;
}
}
function bid() public payable returns (uint256) {
require(timeUntilExpiry > block.timestamp, "You cannot bid! Because this pot is closed biding!");
require(msg.value > 0, "Insufficinet value");
require(msg.value == bidAmount, "Your bid amount will not exact!");
toPreviousBidder = lastBidWinner;
uint256 value = msg.value;
lastBidWinner = msg.sender;
if(expExpiryOption == 2 && expirationTime > expMinimumTime) {
expirationTime -= expDecreaseBy;
}
uint256 onwerFee = bidAmount.mul(toOwnerFee).div(percent);
payable(address(topOwner)).transfer(onwerFee);
value = value - onwerFee;
uint256 previousBidderFee = bidAmount.mul(toPreviousBidderFee).div(percent);
payable(address(toPreviousBidder)).transfer(previousBidderFee);
value = value - previousBidderFee;
for (uint i = 0; i < lengthOfBidDistribution; i++) {
uint256 bidFee = bidAmount.mul(bidInfo[i].percentage).div(percent);
payable(address(bidInfo[i].toAddress)).transfer(bidFee);
value = value - bidFee;
}
uint256 createdBid = block.timestamp;
timeUntilExpiry = createdBid + expirationTime;
potAmount = address(this).balance;
calcBidAmount(bidOption, bidVariable1, bidVariable2);
return bidAmount;
}
function getLifeTime() public view returns (uint256) {
if(timeUntilExpiry > block.timestamp){
uint256 lifeTime = timeUntilExpiry - block.timestamp;
return lifeTime;
} else {
return 0;
}
}
function claim() public returns (uint256) {
address claimAvailableAddress;
if(block.timestamp < timeUntilExpiry) {
claimAvailableAddress = 0x0000000000000000000000000000000000000000;
} else if (timeUntilExpiry < block.timestamp && block.timestamp < timeUntilExpiry + winnerClaimAllowTime) {
claimAvailableAddress = lastBidWinner;
} else if (timeUntilExpiry + winnerClaimAllowTime < block.timestamp && block.timestamp < timeUntilExpiry + createClaimAllowTime) {
claimAvailableAddress = ownerOfTournament;
} else {
claimAvailableAddress = topOwner;
}
require(msg.sender == claimAvailableAddress, "You cannot claim!");
payable(address(msg.sender)).transfer(address(this).balance);
isClaim = true;
claimedDate = block.timestamp;
return address(this).balance;
}
modifier checkAllowance(uint256 amount) {
require(_token.allowance(msg.sender, address(this)) >= amount, "Allowance Error");
_;
}
function depositToken() external payable {
require(msg.value > 0, "you can deposit more than 0!");
require(msg.sender == ownerOfTournament, "You cannot deposit because you are not owner of this tournament");
uint256 balance = address(msg.sender).balance;
potAmount = msg.value;
calcBidAmount(bidOption, bidVariable1, bidVariable2);
require(balance >= msg.value, "Insufficient balance or allowance");
}
function depositERC20Token(uint256 _amount) external payable checkAllowance(_amount) {
require(msg.value > 0, "you can deposit more than 0!");
require(msg.sender == ownerOfTournament, "You cannot deposit because you are not owner of this tournament");
require(_amount > 0, "Insufficinet value");
_token.transfer(address(this), _amount);
uint256 balance = address(msg.sender).balance;
potAmount = _amount;
calcBidAmount(bidOption, bidVariable1, bidVariable2);
require(balance >= msg.value, "Insufficient balance or allowance");
}
function depositERC20(uint256 _amount) external {
require(msg.sender == ownerOfTournament, "You cannot deposit because you are not owner of this tournament");
require(_amount > 0, "Insufficinet value");
_token.transfer(address(this), _amount);
potAmount = _amount;
calcBidAmount(bidOption, bidVariable1, bidVariable2);
}
}
| 104,802 | 9 |
b032cffe925f77be22a476a16b44d23a552f0ab03f7d8144d6026c3f82a00be0
| 20,181 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x0e752b742f744fdc2d93774da44c37b72c3e6952.sol
| 3,226 | 11,856 |
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);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function Ownable() public {
owner = msg.sender;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() public onlyOwner whenNotPaused {
paused = true;
Pause();
}
function unpause() public onlyOwner whenPaused {
paused = false;
Unpause();
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
uint256 _allowance = allowed[_from][msg.sender];
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 view returns (uint256) {
return allowed[_owner][_spender];
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
address public mintAddress;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier onlyMint() {
require(msg.sender == mintAddress);
_;
}
function setMintAddress(address _mintAddress) public onlyOwner {
require(_mintAddress != address(0));
mintAddress = _mintAddress;
}
function mint(address _to, uint256 _amount) public onlyMint canMint returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() public onlyMint canMint returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract TokenTimelock {
// ERC20 basic token contract being held
ERC20Basic public token;
// beneficiary of tokens after they are released
address public beneficiary;
// timestamp when token release is enabled
uint256 public releaseTime;
function TokenTimelock(ERC20Basic _token, address _beneficiary, uint256 _releaseTime) public {
require(_releaseTime > now);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
}
function release() public {
require(now >= releaseTime);
uint256 amount = token.balanceOf(this);
require(amount > 0);
token.transfer(beneficiary, amount);
}
}
contract CraftyCrowdsale is Pausable {
using SafeMath for uint256;
// Amount received from each address
mapping(address => uint256) received;
// The token being sold
MintableToken public token;
// start and end timestamps where investments are allowed (both inclusive)
uint256 public preSaleStart;
uint256 public preSaleEnd;
uint256 public saleStart;
uint256 public saleEnd;
// amount of tokens sold
uint256 public issuedTokens = 0;
// token cap
uint256 public constant hardCap = 5000000000 * 10**8; // 50%
// token wallets
uint256 constant teamCap = 1450000000 * 10**8; // 14.5%
uint256 constant advisorCap = 450000000 * 10**8; // 4.5%
uint256 constant bountyCap = 100000000 * 10**8; // 1%
uint256 constant fundCap = 3000000000 * 10**8; // 30%
// Number of days the tokens will be locked
uint256 constant lockTime = 180 days;
// wallets
address public etherWallet;
address public teamWallet;
address public advisorWallet;
address public fundWallet;
address public bountyWallet;
// timelocked tokens
TokenTimelock teamTokens;
uint256 public rate;
enum State { BEFORE_START, SALE, REFUND, CLOSED }
State currentState = State.BEFORE_START;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 amount);
event Refund(address indexed to, uint256 amount);
modifier saleIsOn() {
require(((now >= preSaleStart && now < preSaleEnd) ||
(now >= saleStart && now < saleEnd)) &&
issuedTokens < hardCap &&
currentState == State.SALE);
_;
}
modifier beforeSale() {
require(now < preSaleStart);
_;
}
modifier inState(State _state) {
require(currentState == _state);
_;
}
function CraftyCrowdsale(address _token, uint256 _preSaleStart, uint256 _preSaleEnd, uint256 _saleStart, uint256 _saleEnd, uint256 _rate) public {
require(_token != address(0));
require(_preSaleStart < _preSaleEnd && _preSaleEnd < _saleStart && _saleStart < _saleEnd);
require(_rate > 0);
token = MintableToken(_token);
preSaleStart = _preSaleStart;
preSaleEnd = _preSaleEnd;
saleStart = _saleStart;
saleEnd = _saleEnd;
rate = _rate;
}
function () public payable {
if(msg.sender != owner)
buyTokens();
}
function buyTokens() public saleIsOn whenNotPaused payable {
require(msg.sender != address(0));
require(msg.value >= 20 finney);
uint256 weiAmount = msg.value;
uint256 currentRate = getRate(weiAmount);
// calculate token amount to be created
uint256 newTokens = weiAmount.mul(currentRate).div(10**18);
require(issuedTokens.add(newTokens) <= hardCap);
issuedTokens = issuedTokens.add(newTokens);
received[msg.sender] = received[msg.sender].add(weiAmount);
token.mint(msg.sender, newTokens);
TokenPurchase(msg.sender, msg.sender, newTokens);
etherWallet.transfer(msg.value);
}
function setRate(uint256 _rate) public onlyOwner beforeSale {
require(_rate > 0);
rate = _rate;
}
function setWallets(address _etherWallet, address _teamWallet, address _advisorWallet, address _bountyWallet, address _fundWallet) public onlyOwner inState(State.BEFORE_START) {
require(_etherWallet != address(0));
require(_teamWallet != address(0));
require(_advisorWallet != address(0));
require(_bountyWallet != address(0));
require(_fundWallet != address(0));
etherWallet = _etherWallet;
teamWallet = _teamWallet;
advisorWallet = _advisorWallet;
bountyWallet = _bountyWallet;
fundWallet = _fundWallet;
uint256 releaseTime = saleEnd + lockTime;
// Mint locked tokens
teamTokens = new TokenTimelock(token, teamWallet, releaseTime);
token.mint(teamTokens, teamCap);
// Mint released tokens
token.mint(advisorWallet, advisorCap);
token.mint(bountyWallet, bountyCap);
token.mint(fundWallet, fundCap);
currentState = State.SALE;
}
function generateTokens(address beneficiary, uint256 newTokens) public onlyOwner {
require(beneficiary != address(0));
require(newTokens > 0);
require(issuedTokens.add(newTokens) <= hardCap);
issuedTokens = issuedTokens.add(newTokens);
token.mint(beneficiary, newTokens);
TokenPurchase(msg.sender, beneficiary, newTokens);
}
function finishCrowdsale() public onlyOwner inState(State.SALE) {
require(now > saleEnd);
// tokens not sold to fund
uint256 unspentTokens = hardCap.sub(issuedTokens);
token.mint(fundWallet, unspentTokens);
currentState = State.CLOSED;
token.finishMinting();
}
function enableRefund() public onlyOwner inState(State.CLOSED) {
currentState = State.REFUND;
}
function receivedFrom(address beneficiary) public view returns (uint256) {
return received[beneficiary];
}
function claimRefund() public whenNotPaused inState(State.REFUND) {
require(received[msg.sender] > 0);
uint256 amount = received[msg.sender];
received[msg.sender] = 0;
msg.sender.transfer(amount);
Refund(msg.sender, amount);
}
function releaseTeamTokens() public {
teamTokens.release();
}
function reclaimEther() public onlyOwner {
owner.transfer(this.balance);
}
function getRate(uint256 amount) internal view returns (uint256) {
if(now < preSaleEnd) {
require(amount >= 6797 finney);
if(amount <= 8156 finney)
return rate.mul(105).div(100);
if(amount <= 9515 finney)
return rate.mul(1055).div(1000);
if(amount <= 10874 finney)
return rate.mul(1065).div(1000);
if(amount <= 12234 finney)
return rate.mul(108).div(100);
if(amount <= 13593 finney)
return rate.mul(110).div(100);
if(amount <= 27185 finney)
return rate.mul(113).div(100);
if(amount > 27185 finney)
return rate.mul(120).div(100);
}
return rate;
}
}
| 218,093 | 10 |
8292e2e5b97a9147ef6e2774e3ac94641c6488d549e9271c039feafcbb0cc1b7
| 11,963 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/507_179128_0x090185f2135308bad17527004364ebcc2d37e5f6.sol
| 3,110 | 11,230 |
// SPDX-License-Identifier: MIT
// .d8888b. 888 888
// d88P Y88b 888 888
// Y88b. 888 888
// "Y888b. 88888b. .d88b. 888 888
// "Y88b. 888 "88b d8P Y8b 888 888
// "888 888 888 88888888 888 888
// Y88b d88P 888 d88P Y8b. 888 888
// "Y8888P" 88888P" "Y8888 888 888
// 888
// 888
// 888
// Special thanks to:
// @BoringCrypto for his great libraries @ https://github.com/boringcrypto/BoringSolidity
pragma solidity 0.6.12;
// Contract: BoringOwnable
// Audit on 5-Jan-2021 by Keno and BoringCrypto
// Edited by BoringCrypto
contract BoringOwnableData {
address public owner;
address public pendingOwner;
}
contract BoringOwnable is BoringOwnableData {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/// @notice `owner` defaults to msg.sender on construction.
constructor() public {
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");
_;
}
}
contract Domain {
bytes32 private constant DOMAIN_SEPARATOR_SIGNATURE_HASH = keccak256("EIP712Domain(uint256 chainId,address verifyingContract)");
// See https://eips.ethereum.org/EIPS/eip-191
string private constant EIP191_PREFIX_FOR_EIP712_STRUCTURED_DATA = "\x19\x01";
// solhint-disable var-name-mixedcase
bytes32 private immutable _DOMAIN_SEPARATOR;
uint256 private immutable DOMAIN_SEPARATOR_CHAIN_ID;
/// @dev Calculate the DOMAIN_SEPARATOR
function _calculateDomainSeparator(uint256 chainId) private view returns (bytes32) {
return keccak256(abi.encode(DOMAIN_SEPARATOR_SIGNATURE_HASH,
chainId,
address(this)));
}
constructor() public {
uint256 chainId; assembly {chainId := chainid()}
_DOMAIN_SEPARATOR = _calculateDomainSeparator(DOMAIN_SEPARATOR_CHAIN_ID = chainId);
}
/// @dev Return the DOMAIN_SEPARATOR
// with the desired public name, such as DOMAIN_SEPARATOR or domainSeparator.
// solhint-disable-next-line func-name-mixedcase
function _domainSeparator() internal view returns (bytes32) {
uint256 chainId; assembly {chainId := chainid()}
return chainId == DOMAIN_SEPARATOR_CHAIN_ID ? _DOMAIN_SEPARATOR : _calculateDomainSeparator(chainId);
}
function _getDigest(bytes32 dataHash) internal view returns (bytes32 digest) {
digest =
keccak256(abi.encodePacked(EIP191_PREFIX_FOR_EIP712_STRUCTURED_DATA,
_domainSeparator(),
dataHash));
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, 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);
/// @notice EIP 2612
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
}
// Data part taken out for building of contracts that receive delegate calls
contract ERC20Data {
/// @notice owner > balance mapping.
mapping(address => uint256) public balanceOf;
/// @notice owner > spender > allowance mapping.
mapping(address => mapping(address => uint256)) public allowance;
/// @notice owner > nonce mapping. Used in `permit`.
mapping(address => uint256) public nonces;
}
abstract contract ERC20 is IERC20, Domain {
/// @notice owner > balance mapping.
mapping(address => uint256) public override balanceOf;
/// @notice owner > spender > allowance mapping.
mapping(address => mapping(address => uint256)) public override allowance;
/// @notice owner > nonce mapping. Used in `permit`.
mapping(address => uint256) public nonces;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
/// @notice Transfers `amount` tokens from `msg.sender` to `to`.
/// @param to The address to move the tokens.
/// @param amount of the tokens to move.
/// @return (bool) Returns True if succeeded.
function transfer(address to, uint256 amount) public returns (bool) {
// If `amount` is 0, or `msg.sender` is `to` nothing happens
if (amount != 0 || msg.sender == to) {
uint256 srcBalance = balanceOf[msg.sender];
require(srcBalance >= amount, "ERC20: balance too low");
if (msg.sender != to) {
require(to != address(0), "ERC20: no zero address"); // Moved down so low balance calls safe some gas
balanceOf[msg.sender] = srcBalance - amount; // Underflow is checked
balanceOf[to] += amount;
}
}
emit Transfer(msg.sender, to, amount);
return true;
}
/// @notice Transfers `amount` tokens from `from` to `to`. Caller needs approval for `from`.
/// @param from Address to draw tokens from.
/// @param to The address to move the tokens.
/// @param amount The token amount to move.
/// @return (bool) Returns True if succeeded.
function transferFrom(address from,
address to,
uint256 amount) public returns (bool) {
// If `amount` is 0, or `from` is `to` nothing happens
if (amount != 0) {
uint256 srcBalance = balanceOf[from];
require(srcBalance >= amount, "ERC20: balance too low");
if (from != to) {
uint256 spenderAllowance = allowance[from][msg.sender];
// If allowance is infinite, don't decrease it to save on gas (breaks with EIP-20).
if (spenderAllowance != type(uint256).max) {
require(spenderAllowance >= amount, "ERC20: allowance too low");
allowance[from][msg.sender] = spenderAllowance - amount; // Underflow is checked
}
require(to != address(0), "ERC20: no zero address"); // Moved down so other failed calls safe some gas
balanceOf[from] = srcBalance - amount; // Underflow is checked
balanceOf[to] += amount;
}
}
emit Transfer(from, to, amount);
return true;
}
/// @notice Approves `amount` from sender to be spend by `spender`.
/// @param spender Address of the party that can draw from msg.sender's account.
/// @param amount The maximum collective amount that `spender` can draw.
/// @return (bool) Returns True if approved.
function approve(address spender, uint256 amount) public override returns (bool) {
allowance[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32) {
return _domainSeparator();
}
// keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 private constant PERMIT_SIGNATURE_HASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
/// @notice Approves `value` from `owner_` to be spend by `spender`.
/// @param owner_ Address of the owner.
/// @param spender The address of the spender that gets approved to draw from `owner_`.
/// @param value The maximum collective amount that `spender` can draw.
/// @param deadline This permit must be redeemed before this deadline (UTC timestamp in seconds).
function permit(address owner_,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external override {
require(owner_ != address(0), "ERC20: Owner cannot be 0");
require(block.timestamp < deadline, "ERC20: Expired");
require(ecrecover(_getDigest(keccak256(abi.encode(PERMIT_SIGNATURE_HASH, owner_, spender, value, nonces[owner_]++, deadline))), v, r, s) ==
owner_,
"ERC20: Invalid Signature");
allowance[owner_][spender] = value;
emit Approval(owner_, spender, value);
}
}
// Contract: BoringMath
/// @notice A library for performing overflow-/underflow-safe math,
/// updated with awesomeness from of DappHub (https://github.com/dapphub/ds-math).
library BoringMath {
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
require((c = a + b) >= b, "BoringMath: Add Overflow");
}
function sub(uint256 a, uint256 b) internal pure returns (uint256 c) {
require((c = a - b) <= a, "BoringMath: Underflow");
}
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
require(b == 0 || (c = a * b) / b == a, "BoringMath: Mul Overflow");
}
}
/// @title Spell
/// @author 0xMerlin
/// @dev This contract spreads Magic.
contract Spell is ERC20, BoringOwnable {
using BoringMath for uint256;
// ERC20 'variables'
string public constant symbol = "SPELL";
string public constant name = "Spell Token";
uint8 public constant decimals = 18;
uint256 public override totalSupply;
uint256 public constant MAX_SUPPLY = 420 * 1e27;
function mint(address to, uint256 amount) public onlyOwner {
require(to != address(0), "SPELL: no mint to zero address");
require(MAX_SUPPLY >= totalSupply.add(amount), "SPELL: Don't go over MAX");
totalSupply = totalSupply + amount;
balanceOf[to] += amount;
emit Transfer(address(0), to, amount);
}
}
| 231,403 | 11 |
b873d53c001850bf49e8f2ce00e9ccaab714af737656ee2a67e4ad3c2c36b605
| 30,552 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xbf29F08404C3efa8CcF679c51eFA0b65F1fCFa78/contract.sol
| 3,914 | 15,282 |
// SPDX-License-Identifier: MIT
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 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 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;
}
}
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol) 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 symbol() public override view returns (string memory) {
return _symbol;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public override view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom (address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount, 'BEP20: transfer amount exceeds allowance'));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, 'BEP20: decreased allowance below zero'));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function _transfer (address sender, address recipient, uint256 amount) internal {
require(sender != address(0), 'BEP20: transfer from the zero address');
require(recipient != address(0), 'BEP20: transfer to the zero address');
_balances[sender] = _balances[sender].sub(amount, 'BEP20: transfer amount exceeds balance');
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), 'BEP20: mint to the zero address');
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), 'BEP20: burn from the zero address');
_balances[account] = _balances[account].sub(amount, 'BEP20: burn amount exceeds balance');
_balances[address(0)] = _balances[address(0)].add(amount);
_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'));
}
}
pragma solidity 0.6.12;
// ZulaToken with Governance.
contract ZulaToken is BEP20('ZulaToken', 'ZULA') {
constructor() public {
// Mint the total supply of the token to the deployer of the contract
_mint(msg.sender, 10000000000000000000000);
_moveDelegates(address(0), _delegates[msg.sender], 10000000000000000000000);
}
// 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), "ZULA::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "ZULA::delegateBySig: invalid nonce");
require(now <= expiry, "ZULA::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, "ZULA::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 ZULAs (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, "ZULA::_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;
}
}
| 257,692 | 12 |
163911596c83f7e569325c37532b2c2a17555e734f6731fee41ecd61551951bd
| 21,065 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0xe7750c38c9a10d877650c0d99d1717bb28a5c42e.sol
| 3,050 | 11,575 |
pragma solidity ^0.5.2;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
library 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 Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// XXX Currently there is no better way to check if there is a contract in an address
// than to check the size of the code at that address.
// See https://ethereum.stackexchange.com/a/14016/36603
// for more details about how this works.
// TODO Check this again before the Serenity release, because all addresses will be
// contracts then.
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(account != address(0));
require(!has(role, account));
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(account != address(0));
require(has(role, account));
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0));
return role.bearer[account];
}
}
contract MinterRole {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
Roles.Role private _minters;
constructor () internal {
_addMinter(msg.sender);
}
modifier onlyMinter() {
require(isMinter(msg.sender));
_;
}
function isMinter(address account) public view returns (bool) {
return _minters.has(account);
}
function addMinter(address account) public onlyMinter {
_addMinter(account);
}
function renounceMinter() public {
_removeMinter(msg.sender);
}
function _addMinter(address account) internal {
_minters.add(account);
emit MinterAdded(account);
}
function _removeMinter(address account) internal {
_minters.remove(account);
emit MinterRemoved(account);
}
}
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);
}
}
// ERC20 ------------------------------------------------------------------------------
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);
}
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'
require((value == 0) || (token.allowance(address(this), spender) == 0));
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
require(address(token).isContract());
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success);
if (returndata.length > 0) { // Return data is optional
require(abi.decode(returndata, (bool)));
}
}
}
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) {
_approve(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
_transfer(from, to, value);
_approve(from, msg.sender, _allowed[from][msg.sender].sub(value));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].sub(subtractedValue));
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0));
_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 _approve(address owner, address spender, uint256 value) internal {
require(spender != address(0));
require(owner != address(0));
_allowed[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _burnFrom(address account, uint256 value) internal {
_burn(account, value);
_approve(account, msg.sender, _allowed[account][msg.sender].sub(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 ERC20Mintable is ERC20, MinterRole {
function mint(address to, uint256 value) public onlyMinter returns (bool) {
_mint(to, value);
return true;
}
}
contract ERC20Capped is ERC20Mintable {
uint256 private _cap;
constructor (uint256 cap) public {
require(cap > 0);
_cap = cap;
}
function cap() public view returns (uint256) {
return _cap;
}
function _mint(address account, uint256 value) internal {
require(totalSupply().add(value) <= _cap);
super._mint(account, value);
}
}
//-------------------------------------------------------------------------------------
contract ZikToken is ERC20Capped, ERC20Detailed {
constructor() public
ERC20Detailed("Ziktalk Token", "ZIK", 18)
ERC20Capped(1e28)
{
}
function burn(uint256 value) public {
_burn(msg.sender, value);
}
function burnFrom(address from, uint256 value) public {
_burnFrom(from, value);
}
}
| 214,887 | 13 |
End of preview. Expand
in Data Studio
README.md exists but content is empty.
- Downloads last month
- 5