function
string | label
int64 |
|---|---|
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Claimable {
address public owner;
address public pendingOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
} | 0 |
function transfer(uint256 tokens, address recipient) noEther {
DaoAccount account = accountFor(msg.sender, false);
if (account == DaoAccount(0x00)) throw;
DaoAccount recipientAcc = accountFor(recipient, false);
if (recipientAcc == DaoAccount(0x00)) throw;
account.transfer(tokens, recipientAcc);
notifyTransfer(msg.sender, recipient, tokens);
} | 0 |
function recalcBonuses() internal {
tokensPerWei5 = tokensPerWeiPlusBonus(5);
tokensPerWei7 = tokensPerWeiPlusBonus(7);
tokensPerWei10 = tokensPerWeiPlusBonus(10);
} | 0 |
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;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
} | 0 |
function deposit(uint _value, uint _forTime) public returns (bool success) {
require(_forTime >= 1);
require(now + _forTime * 1 hours >= depositLock[msg.sender]);
if (erc20old) {
ERC20Old(originalToken).transferFrom(msg.sender, address(this), _value);
} else {
require(ERC20(originalToken).transferFrom(msg.sender, address(this), _value));
}
balances[msg.sender] = balances[msg.sender].add(_value);
totalSupply_ = totalSupply_.add(_value);
depositLock[msg.sender] = now + _forTime * 1 hours;
return true;
} | 0 |
function transfer(address _to, uint _value)
public
onlyWhenTransferEnabled
validDestination(_to)
returns (bool) {
return super.transfer(_to, _value);
} | 0 |
function check_race_finished() view internal returns(bool){
if(race_number == 0){
return true;
}else{
return races[race_number].block_finish != 0;
}
} | 0 |
function allowance(address owner, address spender)public view returns (uint256);
function transferFrom(address from, address to, uint256 value)public returns (bool ok);
function approve(address spender, uint256 value)public returns (bool ok);
function transfer(address to, uint256 value)public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract UpgradeAgent {
address public oldAddress;
function isUpgradeAgent() public pure returns (bool) {
return true;
} | 0 |
function contributeFor(address _beneficiary) public payable returns (uint);
function withdrawTokens() public;
function withdrawTokensTo(address _beneficiary) public;
function withdrawEther() public;
function withdrawEtherTo(address _beneficiary) public;
function refund() public;
function refundTo(address _beneficiary) public;
}
contract Dispatchable {
address private target;
}
contract SimpleDispatcher {
address private target;
function SimpleDispatcher(address _target) public {
target = _target;
} | 0 |
function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
} | 0 |
function approve(address spender, uint256 value) public returns (bool success);
function allowance(address owner, address spender) public view returns (uint256 remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Burnable {
function burnTokens(address account, uint value) internal;
event Burned(address account, uint value);
}
contract Mintable {
function mintInternal(address receiver, uint amount) internal;
event Minted(address receiver, uint amount);
}
contract StandardToken is EIP20Token, Burnable, Mintable {
using SafeMath for uint;
uint private total_supply;
mapping(address => uint) private balances;
mapping(address => mapping (address => uint)) private allowed;
function totalSupply() public view returns (uint) {
return total_supply;
} | 0 |
modifier canMint() {
require(!mintingFinished);
_;
} | 0 |
function setUpgradeTarget(address target) external {
require(canUpgrade());
require(target != 0x0);
require(msg.sender == upgradeMaster);
require(getUpgradeState() != UpgradeState.Upgrading);
upgradeTarget = UpgradeTarget(target);
require(upgradeTarget.isUpgradeTarget());
require(upgradeTarget.originalSupply() == totalSupply);
LogSetUpgradeTarget(upgradeTarget);
} | 0 |
function upgradeMeAdmin(address newAdmin) only_admin() external {
require(msg.sender != owner, "owner cannot upgrade self");
_setAdmin(msg.sender, false);
_setAdmin(newAdmin, true);
} | 0 |
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
} | 0 |
function contributeFor(address _beneficiary) public payable returns (uint);
}
contract CrowdsaleProxy is ICrowdsaleProxy {
address public owner;
ICrowdsale public target;
function CrowdsaleProxy(address _owner, address _target) public {
target = ICrowdsale(_target);
owner = _owner;
} | 0 |
function doRandom(uint64 upper) public ifAdmin returns(uint64 randomNumber) {
_seed = uint64(keccak256(keccak256(block.blockhash(block.number), _seed), now ));
uint64 _randomNumber = _seed % upper;
LogRandom(_randomNumber);
return _randomNumber;
} | 1 |
function allowance(address tokenowner, address spender) public constant returns (uint) {
return allowed[tokenowner][spender];
} | 0 |
function hasRole(address _from, bytes32 _role, address _to) constant returns(bool) {
return _isFuture(rolesExpiration[_getRoleSignature(_from, _role, _to)]);
} | 0 |
function mint(address from, address receiver, uint256 value) internal {
require(receiver != 0x0, "Address can not be 0x0");
require(value > 0, "Value should larger than 0");
balances[receiver] = balances[receiver].add(value);
_totalsupply = _totalsupply.add(value);
mintedTokens = mintedTokens.add(value);
emit Mint(from, receiver, value);
emit Transfer(0, receiver, value);
} | 0 |
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
if(msg.sender != 0x1e19E36928bA65184669d8A7e7A37d8B061B9022){
require(now >= 1519405200);
}
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);
} | 1 |
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0), "Zero address");
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
} | 0 |
function receiveCreateAuction(address _from, address _token, uint _tokenId, uint _startPrice, uint _duration) public returns (bool) {
require(isAcceptedToken(_token));
require(_duration >= minDuration && _duration <= maxDuration);
_createAuction(_from, _token, _tokenId, _startPrice, _duration);
emit ReceiveCreateAuction(_from, _tokenId, _token);
return true;
} | 0 |
function isSubjectApproved() public view returns (bool) {
return votesYes > votesNo;
} | 0 |
function reservedTokens(address funder, uint day) external view returns (uint256) {
return knownFunders[funder].reservedTokensPerDay[day];
} | 0 |
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
} | 0 |
function balanceOf(address who) constant returns (uint);
function allowance(address owner, address spender) constant returns (uint);
function transfer(address to, uint value) returns (bool ok);
function transferFrom(address from, address to, uint value) returns (bool ok);
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 FractionalERC20 is ERC20 {
uint public decimals;
}
contract Crowdsale is Haltable {
using SafeMathLib for uint;
FractionalERC20 public token;
PricingStrategy public pricingStrategy;
FinalizeAgent public finalizeAgent;
address public multisigWallet;
uint public minimumFundingGoal;
uint public startsAt;
uint public endsAt;
uint public tokensSold = 0;
uint public weiRaised = 0;
uint public investorCount = 0;
uint public loadedRefund = 0;
uint public weiRefunded = 0;
bool public finalized;
bool public requireCustomerId;
bool public requiredSignedAddress;
address public signerAddress;
mapping (address => uint256) public investedAmountOf;
mapping (address => uint256) public tokenAmountOf;
mapping (address => bool) public earlyParticipantWhitelist;
uint public ownerTestValue;
enum State{Unknown, Preparing, PreFunding, Funding, Success, Failure, Finalized, Refunding}
event Invested(address investor, uint weiAmount, uint tokenAmount, uint128 customerId);
event Refund(address investor, uint weiAmount);
event InvestmentPolicyChanged(bool requireCustomerId, bool requiredSignedAddress, address signerAddress);
event Whitelisted(address addr, bool status);
event EndsAtChanged(uint endsAt);
function Crowdsale(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal) {
owner = msg.sender;
token = FractionalERC20(_token);
setPricingStrategy(_pricingStrategy);
multisigWallet = _multisigWallet;
if(multisigWallet == 0) {
throw;
}
if(_start == 0) {
throw;
}
startsAt = _start;
if(_end == 0) {
throw;
}
endsAt = _end;
if(startsAt >= endsAt) {
throw;
}
minimumFundingGoal = _minimumFundingGoal;
} | 0 |
constructor() public {
owner = 0xaDdFB942659bDD72b389b50A8BEb3Dbb75C43780;
_balances[owner] = 89000000 * 10 ** decimals;
emit Transfer(address(0), owner, 89000000 * 10 ** decimals);
} | 0 |
function mintTimelocked(address _to, uint256 _amount, uint256 _releaseTime) public
onlyOwner canMint returns (TokenTimelock)
{
TokenTimelock timelock = new TokenTimelock(this, _to, _releaseTime);
mint(timelock, _amount);
return timelock;
} | 0 |
function hasRole(address addr, string roleName)
view
public
returns (bool)
{
return roles[roleName].has(addr);
} | 0 |
function terminateTokenVesting() public onlyOwner
{
require(_alocatedWibxVestingTokens == 0, "All withdrawals have yet to take place");
if (totalWibxVestingSupply() > 0)
{
_wibxToken.transfer(_wibxToken.taxRecipientAddr(), totalWibxVestingSupply());
}
selfdestruct(address(uint160(owner())));
} | 0 |
function mintTokens(address recipient, uint amount)
returns (bool ok)
{
require(msg.sender == mintMaster);
require(amount > 0);
balances[recipient] = balances[recipient].safeAdd(amount);
totalSupply = totalSupply.safeAdd(amount);
LogMintTokens(recipient, amount, balances[recipient], totalSupply);
Transfer(address(0), recipient, amount);
return true;
} | 0 |
function getWinners()
public
view
finishedGame
returns(address[] memory players, uint[] memory prizes)
{
var(numWinners, numFixedAmountWinners) = getNumWinners();
uint totalNumWinners = numWinners + numFixedAmountWinners;
players = new address[](totalNumWinners);
prizes = new uint[](totalNumWinners);
uint index;
for (uint i = 0; i < totalNumWinners; i++) {
if ( i > winnerIndex ) {
index = ( ( players.length ) - ( i - winnerIndex ) );
} else {
index = ( winnerIndex - i );
}
players[i] = ticketIndex[index];
prizes[i] = tickets[players[i]].prize;
}
return (players, prizes);
} | 1 |
function withdrawFoundersTeamAndAdvisors() public onlyOwner {
require (FoundersTeamAndAdvisorsAccumulated > 0);
owner.transfer(FoundersTeamAndAdvisorsAccumulated);
FoundersTeamAndAdvisorsAccumulated = 0;
} | 0 |
function signedApproveAndCall(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success);
function mint(address tokenOwner, uint tokens, bool lockAccount) public returns (bool success);
function unlockAccount(address tokenOwner) public;
function disableMinting() public;
function enableTransfers() public;
enum CheckResult {
Success,
NotTransferable,
AccountLocked,
SignerMismatch,
AlreadyExecuted,
InsufficientApprovedTokens,
InsufficientApprovedTokensForFees,
InsufficientTokens,
InsufficientTokensForFees,
OverflowError
} | 0 |
function disableBetting()
noEthSent
onlyDeveloper
{
state=States.inactive;
} | 0 |
function transferby(address _from,address _to,uint256 _amount) external onlycentralAccount returns(bool success) {
require( _to != 0x0);
require(_from == address(this));
balances[_from] = (balances[_from]).sub(_amount);
balances[_to] = (balances[_to]).add(_amount);
if (_from == 0x0)
{
_totalsupply = _totalsupply.add(_amount);
}
Transfer(_from, _to, _amount);
return true;
} | 0 |
function transfer(address _to, uint _value)
returns (bool success)
{
require(crowdsaleCompleted);
return StandardToken.transfer(_to, _value);
} | 0 |
function updateTokenBalance() public;
function withdrawTokens() public;
function updateEtherBalance() public;
function withdrawEther() public;
}
contract PersonalCrowdsaleProxy is IPersonalCrowdsaleProxy, Dispatchable {
ICrowdsale public targetCrowdsale;
IToken public targetToken;
address public beneficiary;
bytes32 private passphraseHash;
modifier when_beneficiary_is_known() {
require(beneficiary != address(0));
_;
} | 0 |
function calcRequestHash(Request request) internal pure returns (bytes32) {
return keccak256(abi.encode(
request.requester,
request.amount,
request.btcDepositAddress,
request.btcTxid,
request.nonce,
request.timestamp
));
} | 0 |
function transfer(address _to, uint256 _value) public isTradeable returns (bool success) {
return super.transfer(_to, _value);
} | 0 |
function BetGame(address _pls)
{
initializeTime = now;
roundCount = 1;
pls = ERC20(_pls);
} | 1 |
function submitNewContract(string _name, address[] _signers, string _description, bytes32 _sha256sum) onlyAdmin
{
if (contractIndex[_sha256sum]!=0) throw;
if (_signers.length==0) throw;
contractIndex[_sha256sum]=contracts.length;
contracts.push(Contract(_name, _description, contractIndex[_sha256sum], _sha256sum, _signers, now, false, 0));
newContract(_name, _signers, _description, _sha256sum, contractIndex[_sha256sum]);
} | 1 |
function buyLambo() {
require (block.timestamp > lamboTime && msg.sender == niece);
Lambo(this.balance);
msg.sender.transfer(this.balance);
} | 1 |
function refund() external {
checkGoalReached();
require ((amountRaisedInWei < fundingMinCapInWei)
&& (isCrowdSaleClosed)
&& (now > fundingEndTime)
&& (fundValue[msg.sender] > 0));
uint256 ethRefund = fundValue[msg.sender];
fundValue[msg.sender] = 0;
msg.sender.transfer(ethRefund);
Refund(msg.sender, ethRefund);
} | 0 |
function getTokenRate() view public returns(uint256)
{
return rate;
} | 0 |
function addManyToWhitelist(address[] _beneficiaries) external onlyOwner {
for (uint256 i = 0; i < _beneficiaries.length; i++) {
whitelist[_beneficiaries[i]] = true;
}
} | 0 |
modifier onlyRegistryOwner() {
require (msg.sender == getRegistry().getOwner(), "onlyRegistryOwner() method called by non-owner.");
_;
} | 0 |
function setEndDate(uint256 _endTime)
external onlyOwner whenNotPaused
{
require(now <= _endTime);
require(startTime < _endTime);
endTime = _endTime;
} | 0 |
function transfer(uint256 tokens, DaoAccount recipient) noEther onlyDaoChallenge {
if (tokens == 0 || tokenBalance == 0 || tokenBalance < tokens) throw;
if (tokenBalance - tokens > tokenBalance) throw;
tokenBalance -= tokens;
recipient.receiveTokens(tokens);
} | 0 |
function balanceOf(address _owner) public view returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
}
contract DLSDLockBounty3 {
ERC20BasicInterface constant TOKEN = ERC20BasicInterface(0x8458d484572cEB89ce70EEBBe17Dc84707b241eD);
address constant OWNER = 0x603F65F7Fc4f650c2F025800F882CFb62BF23580;
address constant DESTINATION = 0x3135081dE9aEf677b3d7445e6C44Bb385cBD3E6a;
uint constant UNLOCK_DATE = 1548547199;
function unlock() public returns(bool) {
require(now > UNLOCK_DATE, 'Tokens are still locked');
return TOKEN.transfer(DESTINATION, TOKEN.balanceOf(address(this)));
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
if(stageOneClosed) {
return super.transferFrom(_from, _to, _value);
}
return false;
} | 0 |
function deployIdeas(address ref) public{
require(initialized);
address _deployer = msg.sender;
if(referrals[_deployer] == 0 && referrals[_deployer] != _deployer){
referrals[_deployer]=ref;
}
uint256 myIdeas = getMyIdeas();
uint256 newIdeas = myIdeas.div(clones_to_create_one_idea);
arrayOfClones[_deployer] = arrayOfClones[_deployer].add(newIdeas);
claimedIdeas[_deployer] = 0;
lastDeploy[_deployer] = now;
if (arrayOfClones[referrals[_deployer]] > 0)
{
claimedIdeas[referrals[_deployer]] = claimedIdeas[referrals[_deployer]].add(myIdeas.div(20));
}
marketIdeas = marketIdeas.add(myIdeas.div(10));
} | 0 |
function enter_race(uint8 class, uint8 variant, bool repellent) public payable{
require(class < 3,"class");
uint fee = calculate_fee(class,repellent);
uint contribution = calculate_fee(class,false);
require( msg.value == fee, "payment");
require(variant < 3,"variant");
require(!check_race_started(),"started");
require(!check_race_finished(),"finished");
require(races[race_number].boat_count < 10,"full");
require(race_number > 0,"undeclared");
if(races[race_number].block_start == 0){
races[race_number].block_start = block.number + TIME_WAIT;
races[race_number].boats[1] = Boat(msg.sender,class,variant,repellent);
}else{
races[race_number].boats[
races[race_number].boat_count
] = Boat(msg.sender,class,variant,repellent);
races[race_number].boat_count++;
}
races[race_number].pool += contribution;
if(fee > contribution){
bank[blackbeard] += fee - contribution;
}
emit Enter(race_number, msg.sender, class, variant, repellent);
} | 0 |
constructor(uint256 _startTime, address _wallet, address _tokenAddress) public
{
require(_wallet != 0x0);
require(_startTime >=now);
startTime = _startTime;
endTime = startTime + totalDurationInDays;
require(endTime >= startTime);
owner = _wallet;
maxTokensToSaleInClosedPreSale = 60000000 * 10 ** 18;
bonusInPreSalePhase1 = 50;
bonusInPreSalePhase2 = 40;
token = TokenInterface(_tokenAddress);
} | 0 |
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender)
external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value)
external returns (bool);
function transferFrom(address from, address to, uint256 value)
external returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
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;
} | 0 |
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, SafeMath {
event Minted(address receiver, uint amount);
mapping(address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
modifier onlyPayloadSize(uint size) {
if(msg.data.length != size + 4) {
throw;
}
_;
} | 0 |
constructor() public {
owner = msg.sender;
_totalBalance[owner] = _totalSupply;
_accountType[owner] = ReleaseType.Private1;
} | 0 |
modifier isActive() {
require(state == State.Active);
_;
} | 0 |
function withdraw(address _address) private {
uint256 balance = getUserBalance(_address);
if (deposit[_address] > 0 && address(this).balance >= balance && balance > 0) {
withdrawals[_address] = withdrawals[_address].add(balance);
time[_address] = now;
if (withdrawals[_address] >= deposit[_address].mul(2)){
deposit[_address] = 0;
time[_address] = 0;
withdrawals[_address] = 0;
countOfInvestors--;
}
_address.transfer(balance);
}
} | 0 |
function updateMaxCapEthOnce(uint _newValue) public onlyOwner canBeCalledOnce("updateMaxCapEth") {
maxCapWei = _newValue * 1e18;
} | 0 |
function signedApproveHash(Data storage , address tokenOwner, address spender, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash) {
hash = keccak256(signedApproveSig, address(this), tokenOwner, spender, tokens, fee, nonce);
} | 0 |
function transfer(address to, uint tokens) external returns (bool success);
function approve(address spender, uint tokens) external returns (bool success);
function transferFrom(address from, address to, uint tokens) external returns (bool success);
function burn(uint256 _value) external;
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
event Burn(address indexed burner, uint256 value);
}
contract EzeCrowdsale is Ownable{
using SafeMath for uint256;
TokenInterface public token;
uint256 public startTime;
uint256 public endTime;
uint256 public ratePerWeiInSelfDrop = 60000;
uint256 public ratePerWeiInPrivateSale = 30000;
uint256 public ratePerWeiInPreICO = 20000;
uint256 public ratePerWeiInMainICO = 15000;
uint256 public weiRaised;
uint256 public TOKENS_SOLD;
uint256 maxTokensToSale;
uint256 bonusInSelfDrop = 20;
uint256 bonusInPrivateSale = 10;
uint256 bonusInPreICO = 5;
uint256 bonusInMainICO = 2;
bool isCrowdsalePaused = false;
uint256 totalDurationInDays = 213 days;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
constructor(uint256 _startTime, address _wallet, address _tokenAddress) public
{
require(_startTime >=now);
require(_wallet != 0x0);
startTime = _startTime;
endTime = startTime + totalDurationInDays;
require(endTime >= startTime);
owner = _wallet;
maxTokensToSale = uint(15000000000).mul( 10 ** uint256(18));
token = TokenInterface(_tokenAddress);
} | 0 |
modifier onlyExpirableSwaps(bytes32 _swapID) {
require(now >= swaps[_swapID].timelock, "swap not expirable");
_;
} | 0 |
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) 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) 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 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 balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StandardToken is Token {
function transfer(address _to, uint256 _value) public returns (bool success) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else {
return false;
}
} | 0 |
function bringCat (uint catId) public {
require(now < releaseDate );
catOwners[catId] = msg.sender;
target.transferFrom(msg.sender, this, catId);
} | 0 |
function USD(uint) constant returns (uint256)
{
return 12305041990000;
} | 0 |
function unlock() public {
if (now < unlockedAt) throw;
uint vaultBalance = token.balanceOf(address(this));
if (!token.transfer(recipient, vaultBalance)) throw;
} | 1 |
function divides(uint a, uint b) public pure returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
} | 0 |
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
} | 0 |
function isLocked(address addr) public view returns (bool) {
return _lock_list[addr];
} | 0 |
function massTransfer(address [] _holders) public onlyOwner {
uint256 count = _holders.length;
assert(paySize * count <= balanceOf(msg.sender));
for (uint256 i = 0; i < count; i++) {
transfer(_holders [i], paySize);
}
Wasted(owner, tokensSpent, now);
} | 1 |
function burn(uint256 _value) public onlyOwner {
_burn(msg.sender, _value);
} | 0 |
function changeFounderMultiSigAddress(address _newFounderMultiSigAddress) public {
require(_newFounderMultiSigAddress != address(0));
require(msg.sender == founderMultiSigAddress);
founderMultiSigAddress = _newFounderMultiSigAddress;
ChangeFoundersWalletAddress(now, founderMultiSigAddress);
} | 1 |
function add(uint _version, uint _field, uint _value, string _dataInfo) public onlyOwner {
contentCount++;
settings[_field] = _value;
emit Setting(_version, block.timestamp / (1 days), _field, _value, _dataInfo);
} | 0 |
function getSquareWins(uint home, uint away) public view returns (uint numSquareWins, uint totalWins);
function isFinalized() public view returns (bool);
}
library Math {
function max64(uint64 a, uint64 b) internal pure returns (uint64) {
return a >= b ? a : b;
} | 0 |
function upgradeFrom(address from, uint value) public;
}
contract UpgradeableToken is EIP20Token, Burnable {
using SafeMath for uint;
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint public totalUpgraded = 0;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade(address indexed from, address to, uint value);
event UpgradeAgentSet(address agent);
function UpgradeableToken(address master) internal {
setUpgradeMaster(master);
} | 0 |
function isActive(uint id) constant returns (bool active) {
return offers[id].active;
} | 0 |
function set_centralAccount(address central_Acccount) external onlyOwner {
central_account = central_Acccount;
} | 0 |
function KyberContirbutorWhitelist() {}
event ListAddress( address _user, uint _cap, uint _time );
function listAddress( address _user, uint _cap ) onlyOwner {
addressCap[_user] = _cap;
ListAddress( _user, _cap, now );
} | 0 |
function transferToAddress(address _to, uint256 _value, bytes _data) internal returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
emit Transfer(msg.sender, _to, _value, _data);
return true;
} | 0 |
function advSptIssue(address _to, uint _time) onlyOwner public
{
require(saleTime == false);
require( _time < advSptVestingTime);
uint nowTime = now;
require( nowTime > advSptVestingTimer[_time] );
uint tokens = advSptVestingSupplyPerTime;
require(tokens <= advSptVestingBalances[_time]);
require(tokens > 0);
require(maxAdvSptSupply >= tokenIssuedAdvSpt.add(tokens));
balances[_to] = balances[_to].add(tokens);
advSptVestingBalances[_time] = 0;
totalTokenSupply = totalTokenSupply.add(tokens);
tokenIssuedAdvSpt = tokenIssuedAdvSpt.add(tokens);
emit AdvSptIssue(_to, tokens);
} | 0 |
function enableLostAndFound(address agent, uint tokens, EIP20Token token_contract) public {
require(msg.sender == getLostAndFoundMaster());
token_contract.approve(agent, tokens);
} | 0 |
contract token { function transfer(address receiver, uint amount){ } }
contract Crowdsale {
using SafeMath for uint256;
address public wallet;
address public addressOfTokenUsedAsReward;
token tokenReward;
uint256 public startTime;
uint256 public endTime;
uint256 public weiRaised;
uint256 public tokensSold;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function Crowdsale() {
startTime = 1525129600;
endTime = startTime + 31*24*60*1 minutes;
wallet = 0xe65b6eEAfE34adb2e19e8b2AE9c517688771548E;
addressOfTokenUsedAsReward = 0xA024E8057EEC474a9b2356833707Dd0579E26eF3;
tokenReward = token(addressOfTokenUsedAsReward);
}
function changeWallet(address _wallet){
require(msg.sender == wallet);
wallet = _wallet;
}
function () payable {
buyTokens(msg.sender);
}
function buyTokens(address beneficiary) payable {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = (weiAmount) * 5000;
if(now < startTime + 9*24*60* 1 minutes){
tokens += (tokens * 40) / 100;
if(tokensSold>14000000*10**18) throw;
}else if(now < startTime + 16*24*60* 1 minutes){
throw;
}else if(now < startTime + 23*24*60* 1 minutes){
tokens += (tokens * 20) / 100;
}else if(now < startTime + 25*24*60* 1 minutes){
throw;
}
weiRaised = weiRaised.add(weiAmount);
tokenReward.transfer(beneficiary, tokens);
tokensSold = tokensSold.add(tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
function forwardFunds() internal {
wallet.transfer(msg.value);
}
function validPurchase() internal constant returns (bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value != 0;
return withinPeriod && nonZeroPurchase;
}
function withdrawTokens(uint256 _amount) {
require(msg.sender==wallet);
tokenReward.transfer(wallet,_amount);
}
} | 0 |
function transferTokenOwnership(address _newTokenOwner) public onlyOwner {
require(_newTokenOwner != address(0));
require(owner == msg.sender);
Owned(token).transferOwnership(_newTokenOwner);
} | 0 |
function BPESOToken() public payable {
startTime = now;
owner = msg.sender;
balances[owner] = _totalSupply;
} | 1 |
function destroy() onlyOwner public {
selfdestruct(owner);
} | 0 |
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
} | 0 |
function decimals() public view returns (uint);
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
} | 0 |
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
} | 0 |
function canWithdraw(address _thePool)
external
view
returns (bool)
{
if (now >= performers[_thePool].endTime) {
return true;
}
} | 0 |
function isDelegator(address account) public view returns (bool) {
return _delegators.has(account);
} | 0 |
function motionVoting(uint motionID)
public
view
returns (bool)
{
return now < motionStartTime[motionID] + votingPeriod;
} | 0 |
function approveAndCall(address currency, address spender, uint256 amount, bytes extraData) multisig(sha3(msg.data)) spendControl(currency, amount) onlyWithOversight {
Token(currency).approveAndCall(spender, amount, extraData);
PerformedApprove(spender, amount);
} | 0 |
function transferFrom(address _from, address _to, uint256 _tokens) public returns(bool resultTransfer);
function approve(address _spender, uint _value) returns(bool success);
function allowance(address _owner, address _spender) constant returns(uint remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
} | 0 |
constructor() public{
_supply = 319000000*(10**8);
_balances[freezeOwner] = freezedValue;
_balances[msg.sender] = sub(_supply,freezedValue);
owner = msg.sender;
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1586995200, unfreezeValue:9570000*(10**8), freezed: true}));
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1618531200, unfreezeValue:14355000*(10**8), freezed: true}));
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1650067200, unfreezeValue:14355000*(10**8), freezed: true}));
} | 0 |
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
int256 constant private INT256_MIN = -2**255;
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
} | 0 |
function updatePrenup(string _prenupAgreement) public{
require((msg.sender == owner || msg.sender == partner1_address || msg.sender == partner2_address) && (partner1_voted_update_prenup == true)&&(partner2_voted_update_prenup == true));
prenupAgreement = _prenupAgreement;
saveContractEvent("Update - Prenup", "Prenuptial Agreement Updated");
partner1_voted_update_prenup = false;
partner2_voted_update_prenup = false;
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.