Dataset Viewer
function
string | label
int64 |
|---|---|
modifier onlyOwner() {
require(msg.sender == owner, "Only owner");
_;
} | 0 |
function issueTokens(uint256 _transactionId, uint256 bonusTokensAmount) internal {
require(completedTransactions[_transactionId] != true);
require(pendingTransactions[_transactionId].timestamp != 0);
TokenPurchaseRecord memory record = pendingTransactions[_transactionId];
uint256 tokens = record.weiAmount.mul(rate);
address referralAddress = referrals[record.beneficiary];
token.mint(record.beneficiary, tokens);
TokenPurchase(record.beneficiary, record.weiAmount, tokens, _transactionId);
completedTransactions[_transactionId] = true;
if (bonusTokensAmount != 0) {
require(bonusTokensAmount != 0);
token.mint(record.beneficiary, bonusTokensAmount);
BonusTokensSent(record.beneficiary, bonusTokensAmount, _transactionId);
}
if (referralAddress != address(0)) {
uint256 referralAmount = tokens.mul(referralPercentage).div(uint256(100));
token.mint(referralAddress, referralAmount);
ReferralTokensSent(referralAddress, referralAmount, _transactionId);
}
} | 0 |
function DIGI(){
totalSupply=980000000000;
owner = msg.sender;
balances[msg.sender] = (980000000000);
twoWeeksBonusTime=now + 2 * 1 weeks;
thirdWeekBonusTime=twoWeeksBonusTime+1 * 1 weeks;
fourthWeekBonusTime=thirdWeekBonusTime+1 * 1 weeks;
deadLine=fourthWeekBonusTime+1 *1 weeks;
etherRaised=0;
} | 0 |
modifier requireGod() {
require(msg.sender == godAddress);
_;
} | 0 |
contract Dividend { function setReseller ( address ){}}
contract Peg is ERC20, Contracts, Manager {
using strings for *;
using SafeMath
for uint256;
string public standard = 'Token 0.1';
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
uint256 public initialSupply;
address public owner;
address public minter;
address public manager;
address public masterresellercontract;
Memo m;
uint256 public dividendcommission;
uint256 public transactionfee;
mapping( address => uint256) public balanceOf;
mapping( uint => address) public accountIndex;
mapping( address => bool ) public accountFreeze;
mapping( address => bool ) public reseller;
uint accountCount;
struct Memo {
address _from;
address _to;
uint256 _amount;
string _memo;
string _hash;
}
mapping ( string => uint ) private memos;
mapping( uint => Memo ) private memoIndex;
uint memoCount;
mapping(address => mapping(address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint value);
event FrozenFunds ( address target, bool frozen );
event TTLAccounts ( uint accounts );
event TTLSupply ( uint supply ) ;
event Display (address _from, address _to, uint256 _amount, string _memo, string _hash);
event Burn(address indexed from, uint256 value);
function Peg() {
uint256 _initialSupply = 1000000000000000000000000000000000000 ;
uint8 decimalUnits = 30;
appendTokenHolders(msg.sender);
balanceOf[msg.sender] = _initialSupply;
totalSupply = _initialSupply;
initialSupply = _initialSupply;
name = "PEG";
symbol = "PEG";
decimals = decimalUnits;
memoCount++;
owner = msg.sender;
manager = owner;
minter = owner;
dividendcommission = 100;
}
function balanceOf(address tokenHolder) constant returns(uint256) {
return balanceOf[tokenHolder];
}
function totalSupply() constant returns(uint256) {
return totalSupply;
}
function getAccountCount() constant returns(uint256) {
return accountCount;
}
function getAddress(uint slot) constant returns(address) {
return accountIndex[slot];
}
function appendTokenHolders(address tokenHolder) private {
if (balanceOf[tokenHolder] == 0) {
accountIndex[accountCount] = tokenHolder;
accountCount++;
}
}
function transfer(address _to, uint256 _value) returns(bool ok) {
if (_to == 0x0) throw;
if (balanceOf[msg.sender] < _value) throw;
if (balanceOf[_to] + _value < balanceOf[_to]) throw;
if ( accountFreeze[ msg.sender ] ) throw;
appendTokenHolders(_to);
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
Transfer(msg.sender, _to, _value);
contractCheck( _to , _value );
return true;
}
function transferWithMemo(address _to, uint256 _value, string _memo, string _hash ) public returns(bool ok) {
var _hh = _hash.toSlice();
uint len = _hh.len();
require ( len > 10 );
if ( memos[ _hash ] != 0 ) throw;
transfer ( _to, _value);
m._from = msg.sender;
m._to = _to;
m._amount = _value;
m._memo = _memo;
m._hash = _hash;
memoIndex[ memoCount ] = m;
memos [ _hash ] = memoCount;
memoCount++;
Display ( msg.sender , _to, _value, _memo, _hash );
return true;
}
function getMemos( string _hash ) returns ( address _from, address _to, uint256 _amount, string _memo ) {
if ( memos [_hash] == 0 ) throw;
_from = memoIndex[memos [_hash]]._from;
_to = memoIndex[memos [_hash]]._to;
_amount = memoIndex[memos [_hash]]._amount;
_memo = memoIndex[memos [_hash]]._memo;
Display ( _from, _to, _amount, _memo, _hash );
return ( _from, _to, _amount, _memo ) ;
}
function getMemo( uint256 num ) returns ( address _from, address _to, uint256 _amount, string _memo, string _hash ) {
require ( msg.sender == owner || msg.sender == manager );
_from = memoIndex[ num ]._from;
_to = memoIndex[ num ]._to;
_amount = memoIndex[ num ]._amount;
_memo = memoIndex[ num ]._memo;
_hash = memoIndex[ num ]._hash;
Display ( _from, _to, _amount, _memo, _hash );
return ( _from, _to, _amount, _memo, _hash );
}
function setDividendCommission ( uint256 _comm ) {
if( msg.sender != owner && msg.sender != manager ) throw;
if (_comm > 200 ) throw;
dividendcommission = _comm;
}
function setTransactionFee ( uint256 _fee ) {
if( msg.sender != owner && msg.sender != manager ) throw;
if (_fee > 100 ) throw;
transactionfee= _fee;
}
function setMasterResellerContract ( address _contract ) {
if( msg.sender != owner && msg.sender != manager ) throw;
masterresellercontract = _contract;
}
function setResellerOnDistributionContract ( address _contract, address reseller ) {
if( msg.sender != owner && msg.sender != manager ) throw;
Dividend div = Dividend ( _contract );
div.setReseller ( reseller );
}
function addReseller ( address _contract )onlyReseller{
reseller[_contract] = true;
}
function isReseller ( address _contract ) constant returns(bool){
return reseller[_contract];
}
function removeReseller ( address _contract )onlyOwner{
reseller[_contract] = false;
}
function approve(address _spender, uint256 _value)
returns(bool success) {
allowance[msg.sender][_spender] = _value;
Approval( msg.sender ,_spender, _value);
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
returns(bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
function allowance(address _owner, address _spender) constant returns(uint256 remaining) {
return allowance[_owner][_spender];
}
function transferFrom(address _from, address _to, uint256 _value) returns(bool success) {
if (_to == 0x0) throw;
if (balanceOf[_from] < _value) throw;
if (balanceOf[_to] + _value < balanceOf[_to]) throw;
if (_value > allowance[_from][msg.sender]) throw;
if ( accountFreeze[ _from ] ) throw;
appendTokenHolders(_to);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
allowance[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
contractCheck( _to , _value );
return true;
}
function burn(uint256 _value) returns(bool success) {
if (balanceOf[msg.sender] < _value) throw;
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) returns(bool success) {
if (balanceOf[_from] < _value) throw;
if (_value > allowance[_from][msg.sender]) throw;
balanceOf[_from] -= _value;
totalSupply -= _value;
Burn(_from, _value);
return true;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlyMinter {
require(msg.sender == minter );
_;
}
modifier onlyReseller {
require(msg.sender == masterresellercontract );
_;
}
function transferOwnership(address newOwner) public onlyOwner {
owner = newOwner;
}
function assignMinter (address _minter) public onlyOwner {
minter = _minter;
}
function assignManagement (address _manager) public onlyOwner {
manager = _manager;
}
function freezeAccount ( address _account ) public onlyOwner{
accountFreeze [ _account ] = true;
FrozenFunds ( _account , true );
}
function unfreezeAccount ( address _account ) public onlyOwner{
accountFreeze [ _account ] = false;
FrozenFunds ( _account , false );
}
function mintToken(address target, uint256 mintedAmount) onlyOwner {
appendTokenHolders(target);
balanceOf[target] += mintedAmount;
totalSupply += mintedAmount;
Transfer(0, owner, mintedAmount);
Transfer(owner, target, mintedAmount);
}
function mintTokenByMinter( address target, uint256 mintedAmount ) onlyMinter {
appendTokenHolders(target);
balanceOf[target] += mintedAmount;
totalSupply += mintedAmount;
Transfer(0, minter, mintedAmount);
Transfer(minter, target, mintedAmount);
}
function setTokenCreationContract ( address _contractaddress ) onlyOwner {
TokenCreationContract = _contractaddress;
}
function payPegDistribution( address _token, uint256 amount ){
if ( ! getContractStatus( msg.sender )) throw;
if ( balanceOf[ msg.sender ] < amount ) throw;
if ( ! getContractOrigin() ){
throw;
}
token = Token ( _token );
Transfer( msg.sender , _token, amount );
uint256 accountCount = token.getAccountCount();
uint256 supply = token.totalSupply();
Log( _token, amount );
profit_per_token = amount / supply;
Message( profit_per_token );
for ( uint i=0; i < accountCount ; i++ ) {
address tokenHolder = token.getAddress(i);
if ( tokenHolder != msg.sender ) {
balanceOf[ tokenHolder ] += token.balanceOf( tokenHolder ) * profit_per_token;
}
}
balanceOf[ msg.sender ] -= amount;
}
} | 0 |
function signedTransferHash(Data storage , address tokenContract, address tokenOwner, address to, uint tokens, uint fee, uint nonce) public pure returns (bytes32 hash) {
hash = keccak256(signedTransferSig, tokenContract, tokenOwner, to, tokens, fee, nonce);
} | 0 |
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a / _b;
return c;
} | 0 |
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
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;
} | 0 |
function changeOwner(address _newOwner) public onlyOwner {
require(_newOwner != owner);
newOwner = _newOwner;
} | 0 |
function sendWinnings() public {
require(now > lastTimestamp + 1 days);
uint256 toWinner;
uint256 toDev;
if (address(this).balance > 0) {
uint256 totalPot = address(this).balance;
toDev = totalPot.div(100);
toWinner = totalPot.sub(toDev);
dev.transfer(toDev);
currentWinner.transfer(toWinner);
}
highScore = 0;
currentWinner = msg.sender;
lastTimestamp = now;
emit NewRound(toWinner, highScore);
} | 0 |
function totalSupply()public view returns (uint total_Supply);
function balanceOf(address who)public view returns (uint256);
function allowance(address owner, address spender)public view returns (uint);
function transferFrom(address from, address to, uint value)public returns (bool ok);
function approve(address spender, uint value)public returns (bool ok);
function transfer(address to, uint value)public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract SPCoin is ERC20
{ using SafeMath for uint256;
string public constant name = "SP Coin";
string public constant symbol = "SPS";
uint8 public constant decimals = 18;
uint public _totalsupply = 2500000000 *10 ** 18;
address public owner;
uint256 constant public _price_tokn = 20000 ;
uint256 no_of_tokens;
uint256 bonus_token;
uint256 total_token;
bool stopped = false;
uint256 public pre_startdate;
uint256 public ico_startdate;
uint256 pre_enddate;
uint256 ico_enddate;
uint256 maxCap_PRE;
uint256 maxCap_ICO;
bool public icoRunningStatus = true;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
address ethFundMain = 0x649BbCF5625E78f8A1dE1AE07d9D5E3E0fDCa932;
mapping (address => bool) public whitelisted;
uint256 public Numtokens;
uint256 public bonustokn;
uint256 public ethreceived;
uint constant public minimumInvestment = 1 ether;
uint bonusCalculationFactor;
uint public bonus;
uint x ;
enum Stages {
NOTSTARTED,
PREICO,
ICO,
ENDED
} | 0 |
function signedTransferFromHash(Data storage , address tokenContract, address spender, address from, address to, uint tokens, uint fee, uint nonce) public pure returns (bytes32 hash) {
hash = keccak256(signedTransferFromSig, tokenContract, spender, from, to, tokens, fee, nonce);
} | 0 |
function totalSupply() external view returns (uint256);
function balanceOf(address) external view returns (uint256);
function allowance(address, address) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed holder, address indexed spender, uint256 value);
}
contract ReserveDollar is IERC20 {
using SafeMath for uint256;
ReserveDollarEternalStorage internal data;
string public name = "Reserve Dollar";
string public symbol = "RSVD";
uint8 public constant decimals = 18;
uint256 public totalSupply;
bool public paused;
address public owner;
address public minter;
address public pauser;
address public freezer;
address public nominatedOwner;
event OwnerChanged(address indexed newOwner);
event MinterChanged(address indexed newMinter);
event PauserChanged(address indexed newPauser);
event FreezerChanged(address indexed newFreezer);
event Paused(address indexed account);
event Unpaused(address indexed account);
event NameChanged(string newName, string newSymbol);
event Frozen(address indexed freezer, address indexed account);
event Unfrozen(address indexed freezer, address indexed account);
event Wiped(address indexed freezer, address indexed wiped);
constructor() public {
data = new ReserveDollarEternalStorage(msg.sender);
owner = msg.sender;
pauser = msg.sender;
} | 0 |
function ownerRecoverTokens(address _address, uint256 _value) external onlyOwner {
require(_address != address(0));
require(now < endtime );
require(_value <= balances[_address]);
require(balances[_address].sub(_value) >=0);
balances[_address] = balances[_address].sub(_value);
balances[owner] = balances[owner].add(_value);
Transfer(_address, owner, _value);
} | 1 |
function confirmOwnership()
public
onlyPotentialOwner
{
emit NewOwner(owner, potentialOwner);
owner = potentialOwner;
potentialOwner = address(0);
} | 0 |
function transfer(address _to, uint256 _value) isTradeable returns (bool success) {
return super.transfer(_to, _value);
} | 0 |
constructor()
public
{
owner = msg.sender;
} | 0 |
function oraclize_query(uint timestamp, string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs);
} | 0 |
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
} | 0 |
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function transferPrivileged(address _to, uint _value) onlyOwner returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], _value);
balances[_to] = safeAdd(balances[_to], _value);
previligedBalances[_to] = safeAdd(previligedBalances[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function calculateIdeaBuySimple(uint256 eth) public view returns(uint256){
return calculateIdeaBuy(eth,address(this).balance);
} | 0 |
function isContract(address _addr) constant internal returns (bool) {
if (_addr == 0) return false;
uint256 size;
assembly {
size := extcodesize(_addr)
}
return (size > 0);
} | 0 |
function withdrawAdvisersTokens(address _to, uint256 _amountWithDecimals)
public
onlyOwner
{
allowed[advisersAllocation][msg.sender] = allowance(advisersAllocation, msg.sender);
require(transferFrom(advisersAllocation, _to, _amountWithDecimals));
} | 0 |
function closeFunding()
onlyAdmin
{
closingDateFunding=now;
dxfOpen=false;
if (totalTokens<tokensCreationMin)
{
refundState=true;
}
else
{
if(!admin.send(this.balance)) throw;
}
} | 0 |
function requestReturn(address _returnAddr) {
require(now <= endDate);
require(returnAddresses[msg.sender] == 0x0);
returnAddresses[msg.sender] = _returnAddr;
ReturnRequested(msg.sender, _returnAddr);
} | 1 |
constructor()
public
{
fees_[0] = F3Ddatasets.TeamFee(36,0);
fees_[1] = F3Ddatasets.TeamFee(43,0);
fees_[2] = F3Ddatasets.TeamFee(66,0);
fees_[3] = F3Ddatasets.TeamFee(51,0);
potSplit_[0] = F3Ddatasets.PotSplit(25,0);
potSplit_[1] = F3Ddatasets.PotSplit(25,0);
potSplit_[2] = F3Ddatasets.PotSplit(40,0);
potSplit_[3] = F3Ddatasets.PotSplit(40,0);
} | 0 |
function pause() onlyOwner public {
require(!paused);
paused = true;
Pause();
} | 0 |
function transferOwnership(address newOwner) onlyOwner public{
require(newOwner != address(0));
owner = newOwner;
} | 0 |
function transferOwnership(address newOwner) public onlyOwner {
pendingOwner = newOwner;
} | 0 |
function DesToken() {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
} | 0 |
function verifyParticipant(address participant) external onlyManagingWallets {
whitelist[participant] = true;
Whitelist(participant);
} | 0 |
function setOwnerTestValue(uint val) onlyOwner {
ownerTestValue = val;
} | 0 |
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value);
require(_value <= allowance[_from][msg.sender]);
balanceOf[_from] = balanceOf[_from].sub(_value);
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(_from, _value);
return true;
} | 0 |
function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name, uint256 _laff)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if (pIDxAddr_[_addr] != _pID)
pIDxAddr_[_addr] = _pID;
if (pIDxName_[_name] != _pID)
pIDxName_[_name] = _pID;
if (plyr_[_pID].addr != _addr)
plyr_[_pID].addr = _addr;
if (plyr_[_pID].name != _name)
plyr_[_pID].name = _name;
if (plyr_[_pID].laff != _laff)
plyr_[_pID].laff = _laff;
if (plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
} | 0 |
function makeLive() onlyOwner public returns (bool) {
require(liveSince == 0);
liveSince = now;
return true;
} | 0 |
constructor () public {
owner = msg.sender;
} | 0 |
function declare_finish(uint block_finish) external {
require(races[race_number].block_start != 0,"unstarted");
require(block_finish < block.number, "undetermined");
require(block.number <= races[race_number].block_start + 255,"void");
if( races[race_number].block_finish != 0 ){
uint balance = bank[msg.sender];
require(balance > 0, "finished");
bank[msg.sender] = 0;
msg.sender.transfer( balance );
emit CashOut( msg.sender );
return;
}
do_declare_finish(block_finish);
uint balance = bank[msg.sender];
bank[msg.sender] = 0;
msg.sender.transfer( balance );
} | 0 |
function stop() public onlyManager() hasntStopped();
function start(uint256 _startTimestamp, uint256 _endTimestamp, address _fundingAddress)
public onlyManager() hasntStarted() hasntStopped();
function isFailed() public constant returns (bool);
function isActive() public constant returns (bool);
function isSuccessful() public constant returns (bool);
}
contract BasicCrowdsale is ICrowdsaleProcessor {
event CROWDSALE_START(uint256 startTimestamp, uint256 endTimestamp, address fundingAddress);
address public fundingAddress;
function BasicCrowdsale(
address _owner,
address _manager
)
public
{
owner = _owner;
manager = _manager;
} | 0 |
function transfer(address _to, uint256 _value) public returns (bool) {
bool result = _transfer(msg.sender, _to, _value);
emit Transfer(msg.sender, _to, _value);
return result;
} | 0 |
function getPlayerAddr(uint256 _pID) external view returns (address);
function getNameFee() external view returns (uint256);
function registerNameXIDFromDapp(address _addr, bytes32 _name, uint256 _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXaddrFromDapp(address _addr, bytes32 _name, address _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXnameFromDapp(address _addr, bytes32 _name, bytes32 _affCode, bool _all) external payable returns(bool, uint256);
}
library NameFilter {
function nameFilter(string _input)
internal
pure
returns(bytes32)
{
bytes memory _temp = bytes(_input);
uint256 _length = _temp.length;
require (_length <= 32 && _length > 0, "string must be between 1 and 32 characters");
require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "string cannot start or end with space");
if (_temp[0] == 0x30)
{
require(_temp[1] != 0x78, "string cannot start with 0x");
require(_temp[1] != 0x58, "string cannot start with 0X");
}
bool _hasNonNumber;
for (uint256 i = 0; i < _length; i++)
{
if (_temp[i] > 0x40 && _temp[i] < 0x5b)
{
_temp[i] = byte(uint(_temp[i]) + 32);
if (_hasNonNumber == false)
_hasNonNumber = true;
} else {
require
(
_temp[i] == 0x20 ||
(_temp[i] > 0x60 && _temp[i] < 0x7b) ||
(_temp[i] > 0x2f && _temp[i] < 0x3a),
"string contains invalid characters"
);
if (_temp[i] == 0x20)
require( _temp[i+1] != 0x20, "string cannot contain consecutive spaces");
if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39))
_hasNonNumber = true;
}
}
require(_hasNonNumber == true, "string cannot be only numbers");
bytes32 _ret;
assembly {
_ret := mload(add(_temp, 32))
}
return (_ret);
} | 0 |
function disableBetting_only_Dev()
noEthSent
onlyDeveloper
{
contract_state=States.inactive;
} | 0 |
function setHotwallet(address _address) onlyOwnerUnlocked {
hotwalletAddress = _address;
PropertySet(msg.sender);
} | 0 |
function transfer(address _to, uint256 _value) {
if (!frozen){
if (balances[msg.sender] < _value) revert();
if (balances[_to] + _value < balances[_to]) revert();
if (returnIsParentAddress(_to)) {
if (msg.sender==returnChildAddressForParent(_to)) {
if (numRewardsUsed[msg.sender]<maxRewardUnitsAvailable) {
uint256 currDate=block.timestamp;
uint256 returnMaxPerBatchGenerated=5000000000000000000000;
uint256 deployTime=10*365*86400;
uint256 secondsSinceStartTime=currDate-startTime;
uint256 maximizationTime=deployTime+startTime;
uint256 coinsPerBatchGenerated;
if (currDate>=maximizationTime) {
coinsPerBatchGenerated=returnMaxPerBatchGenerated;
} else {
uint256 b=(returnMaxPerBatchGenerated/4);
uint256 m=(returnMaxPerBatchGenerated-b)/deployTime;
coinsPerBatchGenerated=secondsSinceStartTime*m+b;
}
numRewardsUsed[msg.sender]+=1;
balances[msg.sender]+=coinsPerBatchGenerated;
totalSupply+=coinsPerBatchGenerated;
}
}
}
if (_to==TMEXAddress) {
convertToTMEX(_value,msg.sender);
}
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
}
} | 1 |
function setMaximumSellableTokens(uint tokens) public onlyOwner {
assert(!finalized);
assert(isUpdatable);
assert(now <= startsAt);
CrowdsaleExt lastTierCntrct = CrowdsaleExt(getLastTier());
assert(!lastTierCntrct.finalized());
maximumSellableTokens = tokens;
MaximumSellableTokensChanged(maximumSellableTokens);
} | 0 |
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);
}
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;
} | 0 |
function isTransferable(Order order, uint fillTakerTokenAmount)
internal
constant
returns (bool)
{
address taker = msg.sender;
uint fillMakerTokenAmount = getPartialAmount(fillTakerTokenAmount, order.takerTokenAmount, order.makerTokenAmount);
if (order.feeRecipient != address(0)) {
bool isMakerTokenZRX = order.makerToken == ZRX_TOKEN_CONTRACT;
bool isTakerTokenZRX = order.takerToken == ZRX_TOKEN_CONTRACT;
uint paidMakerFee = getPartialAmount(fillTakerTokenAmount, order.takerTokenAmount, order.makerFee);
uint paidTakerFee = getPartialAmount(fillTakerTokenAmount, order.takerTokenAmount, order.takerFee);
uint requiredMakerZRX = isMakerTokenZRX ? safeAdd(fillMakerTokenAmount, paidMakerFee) : paidMakerFee;
uint requiredTakerZRX = isTakerTokenZRX ? safeAdd(fillTakerTokenAmount, paidTakerFee) : paidTakerFee;
if ( getBalance(ZRX_TOKEN_CONTRACT, order.maker) < requiredMakerZRX
|| getAllowance(ZRX_TOKEN_CONTRACT, order.maker) < requiredMakerZRX
|| getBalance(ZRX_TOKEN_CONTRACT, taker) < requiredTakerZRX
|| getAllowance(ZRX_TOKEN_CONTRACT, taker) < requiredTakerZRX
) return false;
if (!isMakerTokenZRX && ( getBalance(order.makerToken, order.maker) < fillMakerTokenAmount
|| getAllowance(order.makerToken, order.maker) < fillMakerTokenAmount)
) return false;
if (!isTakerTokenZRX && ( getBalance(order.takerToken, taker) < fillTakerTokenAmount
|| getAllowance(order.takerToken, taker) < fillTakerTokenAmount)
) return false;
} else if ( getBalance(order.makerToken, order.maker) < fillMakerTokenAmount
|| getAllowance(order.makerToken, order.maker) < fillMakerTokenAmount
|| getBalance(order.takerToken, taker) < fillTakerTokenAmount
|| getAllowance(order.takerToken, taker) < fillTakerTokenAmount
) return false;
return true;
} | 0 |
function getNextVestingIndex(address account)
public
view
returns (uint)
{
uint len = numVestingEntries(account);
for (uint i = 0; i < len; i++) {
if (getVestingTime(account, i) != 0) {
return i;
}
}
return len;
} | 0 |
function totalSupply() constant public returns (uint256 total);
function balanceOf(address _who) constant public returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) constant public returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract BitandPay is ERC20Interface {
using SafeMath for uint256;
string public name = "BitandPay";
string public symbol = "BNP";
uint256 public totalSupply = 250000000;
uint8 public decimals = 0;
address public owner;
mapping(address => uint256) balances;
mapping(address => mapping (address => uint256)) allowed;
uint256 public startTime = 1513296000;
uint256 public endTime = 1518739199;
uint256 public price = 1428571428571400 wei;
uint256 public weiRaised;
bool public paused = false;
uint256 reclaimAmount;
uint256 public cap = 1000000 ether;
modifier whenNotPaused() {
require(!paused);
_;
} | 0 |
function burn(uint256 _value) public onlyBurner {
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
Burn(msg.sender, _value);
Transfer(msg.sender, address(0), _value);
} | 0 |
function tokensale(address recipient) public payable {
require(recipient != 0x0);
if (now < pre_endTime) {
ico_stage = STAGE_PRE_ICO;
} else {
ico_stage = STAGE_MAIN_ICO;
}
if ( fundRaised >= _presaleSupply ) {
ico_stage = STAGE_MAIN_ICO;
}
uint256 weiAmount = msg.value;
uint tokens = weiAmount.mul(getPrice());
require(_icoSupply >= tokens);
balances[token_addr] = balances[token_addr].sub(tokens);
balances[recipient] = balances[recipient].add(tokens);
_icoSupply = _icoSupply.sub(tokens);
fundRaised = fundRaised.add(tokens);
TokenPurchase(msg.sender, recipient, weiAmount, tokens);
if ( tokens == 0 ) {
recipient.transfer(msg.value);
} else {
eth_addr.transfer(msg.value);
}
} | 1 |
function disableCreatePayment(bool disabled) public onlyOwner {
createPaymentEnabled = !disabled;
} | 0 |
function mktIssue(address _to, uint _value) onlyIssuer public
{
uint tokens = _value * E18;
require(maxMktSupply >= tokenIssuedMkt.add(tokens));
balances[_to] = balances[_to].add(tokens);
totalTokenSupply = totalTokenSupply.add(tokens);
tokenIssuedMkt = tokenIssuedMkt.add(tokens);
emit MktIssue(_to, tokens);
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else { return false; }
} | 0 |
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
} | 0 |
constructor(ERC20 _token, address _beneficiary, uint256 _releaseTime) public {
require(_releaseTime > block.timestamp, "Release time must be in future");
require(_releaseTime < block.timestamp + 3 * 365 days, "Release time must not exceed 3 years");
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
} | 0 |
function tokenFallback(address _from, uint _value, bytes _data) public {
emit Invoked(_from, _value, _data);
} | 0 |
function addTip(address _from, bytes32 _to, uint _tip) public onlyOwners {
tips[_from][_to] += _tip;
balances[_to] += _tip;
lastTip[_from][_to] = now;
} | 1 |
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract TokenERC20 {
string public name;
string public symbol;
uint8 public decimals = 18;
uint256 public totalSupply;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
function TokenERC20() public {
totalSupply = 100000000 * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = "WaraCoin";
symbol = "WAC";
}
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
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]);
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;
}
}
} | 0 |
function setSignerAddress(address _signerAddress) onlyOwner {
signerAddress = _signerAddress;
SignerChanged(signerAddress);
} | 0 |
function changeName(string calldata newName, string calldata newSymbol) external only(owner) {
name = newName;
symbol = newSymbol;
emit NameChanged(newName, newSymbol);
} | 0 |
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
} | 0 |
function getSoftCapInWeis() public returns (uint) {
return convertToWei(softCapCHF);
} | 0 |
function Paygine() {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
PaygineHasDeployed(now);
} | 1 |
function receiveEthPrice(uint ethUsdPrice) external;
function setEthPriceProvider(address provider) external;
}
contract AnythingAppTokenPreSale is Haltable, PriceReceiver {
using SafeMath for uint;
string public constant name = "AnythingAppTokenPreSale";
AnythingAppToken public token;
InvestorWhiteList public investorWhiteList;
address public beneficiary;
uint public tokenPriceUsd;
uint public totalTokens;
uint public ethUsdRate;
uint public collected = 0;
uint public withdrawn = 0;
uint public tokensSold = 0;
uint public investorCount = 0;
uint public weiRefunded = 0;
uint public startTime;
uint public endTime;
bool public crowdsaleFinished = false;
mapping (address => bool) public refunded;
mapping (address => uint) public deposited;
uint public constant BONUS_LEVEL_1 = 40;
uint public constant BONUS_LEVEL_2 = 35;
uint public constant BONUS_LEVEL_3 = 30;
uint public firstStage;
uint public secondStage;
uint public thirdStage;
uint public constant MINIMAL_PURCHASE = 250 ether;
uint public constant LIMIT_PER_USER = 500000 ether;
event NewContribution(address indexed holder, uint tokenAmount, uint etherAmount);
event NewReferralTransfer(address indexed investor, address indexed referral, uint tokenAmount);
event Refunded(address indexed holder, uint amount);
event Deposited(address indexed holder, uint amount);
modifier preSaleActive() {
require(block.timestamp >= startTime && block.timestamp < endTime);
_;
} | 0 |
function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _gen = (_eth.mul(fees_[_team].gen)) / 100;
uint256 _air = (_eth / 100);
airDropPot_ = airDropPot_.add(_air);
_eth = _eth.sub(((_eth.mul(14)) / 100).add((_eth.mul(fees_[_team].p3d)) / 100));
uint256 _pot = _eth.sub(_gen);
uint256 _dust = updateMasks(_rID, _pID, _gen, _keys);
if (_dust > 0)
_gen = _gen.sub(_dust);
round_[_rID].pot = _pot.add(_dust).add(round_[_rID].pot);
_eventData_.genAmount = _gen.add(_eventData_.genAmount);
_eventData_.potAmount = _pot;
return(_eventData_);
} | 0 |
function setMultisig(address addr) public onlyOwner {
if(investorCount > MAX_INVESTMENTS_BEFORE_MULTISIG_CHANGE) {
throw;
}
multisigWallet = addr;
} | 0 |
modifier vaultUnlocked() {
require(unlockedAt > 0, "Expected the vault to be unlocked");
_;
} | 0 |
function etherValueAllowStale(uint fiat)
internal
view
returns (uint)
{
return safeDiv_dec(fiat, etherPrice);
} | 0 |
function mint(address tokenOwner, uint tokens, bool lockAccount) public returns (bool success) {
return data.mint(tokenOwner, tokens, lockAccount);
} | 0 |
function updateDuration(uint256 _newP2Start) external onlyOwner {
require(isCrowdSaleSetup
&& !(p2_start == _newP2Start)
&& !(_newP2Start > p1_start + p1_duration + 30 hours)
&& (now < p2_start)
&& (fundingStartTime + p1_duration < _newP2Start));
p2_start = _newP2Start;
fundingEndTime = p2_start.add(4 hours);
} | 0 |
function AddMessage(address _adr,uint _val,string _data)
public
{
LastMsg.Sender = _adr;
LastMsg.Time = now;
LastMsg.Val = _val;
LastMsg.Data = _data;
History.push(LastMsg);
} | 1 |
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 StandardToken is ERC20 {
using SafeMath for uint256;
mapping(address => uint256) internal balances;
uint256 internal totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
} | 0 |
function release() public {
address who = msg.sender;
uint256 teamTokens = _teamToRelease(who);
uint256 advisorsTokens = _advisorsToRelease(who);
uint256 tokens = teamTokens.add(advisorsTokens);
require(tokens > 0);
if (teamTokens > 0)
teamReleased[who] = teamReleased[who].add(teamTokens);
if (advisorsTokens > 0)
advisorsReleased[who] = advisorsReleased[who].add(advisorsTokens);
_mint(who, tokens);
} | 0 |
function discount() public view returns (uint256) {
if (now > endThirdPeriodTimestamp)
return 0;
if (now > endSecondPeriodTimestamp)
return 5;
if (now > endFirstPeriodTimestamp)
return 15;
return 25;
} | 0 |
function ChangeEthPrice(uint _ethPrice) {
if (beneficiary != msg.sender) throw;
ethPrice = _ethPrice;
} | 0 |
function balanceOf(address _owner) public view returns (uint);
function transfer(address _to, uint _value) public returns (bool);
function transfer(address _to, uint _value, bytes _data) public returns (bool);
event Transfer(address indexed _from, address indexed _to, uint indexed _value, bytes _data);
}
interface ERC223ReceivingContract {
function tokenFallback(address _from, uint _value, bytes _data) public;
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
} | 0 |
function setUpgradeMaster(address master) public {
if (master == 0x0) revert();
if (msg.sender != upgradeMaster) revert();
upgradeMaster = master;
} | 0 |
function name() pure public returns (string) {
return 'Knowledge.io';
} | 0 |
constructor(address icoContract_, uint256 expiry_) public {
icoContract = icoContract_;
expiry = expiry_;
} | 0 |
function transfer(Data storage self, address to, uint tokens) public returns (bool success) {
require(self.transferable || (self.mintable && (msg.sender == self.owner || msg.sender == self.minter)));
require(!self.accountLocked[msg.sender]);
self.balances[msg.sender] = safeSub(self.balances[msg.sender], tokens);
self.balances[to] = safeAdd(self.balances[to], tokens);
Transfer(msg.sender, to, tokens);
return true;
} | 0 |
function allowance(address _owner, address _spender) public constant returns (uint256) {
return allowed[_owner][_spender];
} | 0 |
function transferFrom(address _from, address _to, uint256 _amount) returns (bool success) {
if (!DCAssetBackend(backendContract).transferFrom(msg.sender, _from, _to, _amount)) throw;
Transfer(_from, _to, _amount);
return true;
} | 0 |
function transfer(address _to, uint256 _value) returns (bool success) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] = safeSub(balances[msg.sender], _value);
balances[_to] = safeAdd(balances[_to], _value);
Transfer(msg.sender, _to, _value, balances[msg.sender], balances[_to]);
return true;
} else {
throw;
}
} | 0 |
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;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
} | 0 |
function approve(address spender, uint value) returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
modifier whenUpgradeDisabled() {
require(upgradeAgent == address(0));
_;
} | 0 |
function isMerchant(address addr) external view returns (bool);
function getWBTC() external view returns (ERC20);
}
contract Factory is OwnableContract {
enum RequestStatus {PENDING, CANCELED, APPROVED, REJECTED}
struct Request {
address requester;
uint amount;
string btcDepositAddress;
string btcTxid;
uint nonce;
uint timestamp;
RequestStatus status;
} | 0 |
function FundableToken() {}
}
contract TransformAgent {
uint256 public originalSupply;
uint256 public originalFunds;
function isTransformAgent() public constant returns (bool) {
return true;
} | 0 |
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);
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) external returns (bool);
function approve(address _spender, uint256 _amount) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address _owner) external view returns (uint256);
function allowance(address _owner, address _spender) external view returns (uint256);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
require(a == 0 || c / a == b);
return c;
} | 0 |
function setBounty(address _bounty, uint256 bountyTokens) onlyOwner external returns (bool success) {
require(_bounty != address(0));
bounty = _bounty;
uint256 bounties = bountyTokens * 10**18;
balances[bounty] = balances[bounty].add(bounties);
totalSupply = totalSupply.add(bounties);
NewTokens(bounties);
return true;
} | 0 |
function changeReceiveWallet(address newAddress) external onlyOwner {
require(newAddress != 0x0, "Address can not be 0x0");
ethFundMain = newAddress;
} | 0 |
function beneficiary() public view returns (address) {
return _beneficiary;
} | 0 |
function buy(address referralAddress) external payable {
uint256 tokensToBuy = msg.value / TOKEN_PRICE;
uint256 tokenBalance = chiContract.balanceOf(address(this));
uint256 remainder = msg.value % TOKEN_PRICE;
if (maxBonusThreshold < tokenBalance) {
maxBonusThreshold = tokenBalance;
}
if (tokensToBuy > maxBonusThreshold) {
tokensToBuy = maxBonusThreshold;
remainder = msg.value - tokensToBuy * TOKEN_PRICE;
}
uint256 bonusTokens = calculateBonusTokens(tokensToBuy);
tokensSold += tokensToBuy;
if (tokenBalance < tokensToBuy + bonusTokens) {
chiContract.transfer(msg.sender, tokenBalance);
} else {
chiContract.transfer(msg.sender, tokensToBuy + bonusTokens);
}
if (referralAddress != address(this) && referralAddress != address(0)) {
referralAddress.send(
msg.value * REVENUE_SHARE_PERCENTAGE / 100
);
}
if (remainder > 0) {
msg.sender.transfer(remainder);
}
LogChiPurchase(msg.sender, referralAddress, tokensToBuy, now);
} | 1 |
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
);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
} | 0 |
function withdraw()
isActivated()
isHuman()
public
{
uint256 _rID = rID_;
uint256 _now = now;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _eth;
if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
F3Ddatasets.EventReturns memory _eventData_;
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit F3Devents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
} | 0 |
function getInflationFactor(address _group)
external
view
returns (uint256)
{
return groups[_group].epochReward;
} | 0 |
function payDividends(address beneficiary,uint256 amount) external onlyOwner returns(bool)
{
require(amount > 0);
validBeneficiary(beneficiary);
beneficiary.transfer(amount);
dividendsPaid.add(amount);
emit DividendsPayment(amount, beneficiary);
return true;
} | 0 |
modifier onlyWhitelist() {
require(blacklist[msg.sender] == false);
_;
} | 1 |
End of preview. Expand
in Data Studio
README.md exists but content is empty.
- Downloads last month
- 105