function string | label int64 |
|---|---|
function unlock() external {
require(REB != address(0));
assert(now >= unlockedAt);
if (tokensCreated == 0) {
tokensCreated = REB.balanceOf(this);
}
uint256 transferAllocation = lockedAllocations[msg.sender];
lockedAllocations[msg.sender] = 0;
require(REB.transfer(msg.sender, transferAllocation));
} | 0 |
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);
} | 0 |
function end_ICO() external onlyOwner
{
stage = Stages.ENDED;
totalsupply = safeSub(totalsupply , balances[address(this)]);
balances[address(this)] = 0;
Transfer(address(this), 0 , balances[address(this)]);
} | 0 |
function _mintApproveClear(address _address) internal {
mintApprove[_address].amount = 0;
mintApprove[_address].admin = 0x0;
mintApprove[_address].audit = 0x0;
mintApprove[_address].marketMaker = 0x0;
} | 0 |
constructor () public {
highScore = 0;
currentWinner = msg.sender;
lastTimestamp = now;
} | 0 |
function start(uint endAt_) onlyOwner public {
uint requireTokens = hardCapWei.mul(ETH_TOKEN_EXCHANGE_RATIO).mul(ONE_TOKEN).div(1 ether);
require(token.balanceOf(tokenHolder) >= requireTokens
&& token.allowance(tokenHolder, address(this)) >= requireTokens);
personalCapEndAt = block.timestamp + 48 hours;
super.star... | 0 |
function __issueTokens(address investor, uint tokens) internal {
if (balances[investor] == 0) {
investorsCount++;
}
balances[investor] += tokens;
token.transferFrom(creator, investor, tokens * k);
} | 0 |
function _transfer(address _from, address _to, uint _value) internal {
require(_to != address(0));
require(balanceOf[_from] >= _value);
balanceOf[_from] = balanceOf[_from].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
Transfer(_from, _to, _value);
} | 0 |
function ReleaseDate() constant returns (uint) { return Date; }
function WithdrawalEnabled() internal returns (bool) { return Date > 0 && Date <= now; }
function deposit() payable {
if (msg.value >= MinimumDeposit()) {
deposits[msg.sender] += msg.value;
}
Deposit(msg.sender, msg.value);
} | 1 |
function getFirstTokens() public {
require(freezOne <= uint64(now));
token.transfer(msg.sender, balances_freez_one[msg.sender]);
} | 0 |
function start_POSTICO() public onlyOwner atStage(Stages.NOTSTARTED)
{
stage = Stages.POSTICO;
stopped = false;
maxCap_POSTICO = 20000000 * 10 **18;
balances[address(this)] = maxCap_POSTICO;
postico_startdate = now;
postico_enddate = now + 90 days;
_price_tokn = 5;
emit Transfer(0, address(this), maxCap_POSTIC... | 0 |
constructor (uint256 cap) internal {
require(cap > 0, "ERC20Capped: cap is 0");
_cap = cap;
} | 0 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract FoundersContract {
using SafeMath for uint256;
ROBOToken public token;
uint64 public freezOne = 1538352000;
uint64 public freezTwo = 1554076800;
mapping... | 0 |
function reservedTokens(address funder, uint day) external view returns (uint256) {
return knownFunders[funder].reservedTokensPerDay[day];
} | 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,... | 0 |
function transferCollectedEther(address _to) public onlyOwner
{
require(_to != 0x0);
require(!crowdsaleRunning);
_to.transfer(this.balance);
} | 0 |
function safeAdd(uint a, uint b) pure internal returns (uint) {
uint c = a + b;
assert(c >= a && c >= b);
return c;
} | 0 |
modifier onlyTokenAssignmentControl() {
require(msg.sender == tokenAssignmentControl, "tokenAssignmentControl key required for this function.");
_;
} | 0 |
function totalSupply() constant returns (uint256) {
return _totalSupply;
} | 0 |
modifier onlyWhenTransferEnabled()
{
if ( now < transferableStartTime ) {
require(msg.sender == fullTokenWallet || msg.sender == owner);
}
_;
} | 1 |
function timestamp(bytes32 hash) public returns (bool) {
if (timestamps[hash].timestamp != 0) {
return false;
}
timestamps[hash].timestamp = block.timestamp;
timestamps[hash].sender = msg.sender;
return true;
} | 1 |
modifier onlyMaster() {
require(msg.sender == upgradeMaster);
_;
} | 0 |
function Chicken() public {
totalSupply_ = 0;
dailyLimit_ = 5;
} | 0 |
function destructContract() external onlyOwner {
selfdestruct(owner());
} | 0 |
function transferFrom(address from, address to, uint256 value) public returns (bool success);
function approve(address spender, uint256 value) public returns (bool success);
function allowance(address owner, address spender) public view returns (uint256 remaining);
event Transfer(address indexed from, address indexe... | 0 |
function updateSubmissionGasPriceLimit(uint256 _newSubmissionGasPriceLimit) external onlyOwner {
emit LogSubmissionGasPriceLimitUpdated(submissionGasPriceLimit, _newSubmissionGasPriceLimit);
submissionGasPriceLimit = _newSubmissionGasPriceLimit;
} | 0 |
function balanceOf(address _owner) constant external returns (uint256 balance);
function transfer(address _to, uint256 _value) external returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
event Transfer(address indexed _from, address indexed _to,... | 0 |
function updateMarriageLicenceImageIPFShash(bytes _marriageLicenceImageIPFShash) public{
require(msg.sender == owner || msg.sender == partner1_address || msg.sender == partner2_address);
marriageLicenceImageIPFShash = _marriageLicenceImageIPFShash;
} | 0 |
function approve(address currency, uint256 amount) external multisig(sha3(msg.data)) {
activateCurrency(currency);
approved[currency] = amount;
expiry[currency] = now + timeWindow;
} | 0 |
function issue(address _to, uint256 _amount)
public
ownerOnly
validAddress(_to)
notThis(_to)
{
totalSupply = safeAdd(totalSupply, _amount);
balanceOf[_to] = safeAdd(balanceOf[_to], _amount);
Issuance(_amount);
Transfer(this, _to, _amount);
} | 0 |
function undo() public stoppable {
var wad = to.balanceOf(msg.sender);
require(now < undo_deadline);
require(from.transfer(msg.sender, wad));
to.pull(msg.sender, wad);
} | 1 |
function _transfer(address _from, address to, uint256 value) internal {
require(_from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_balances[_from] = _balances[_from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(_f... | 0 |
function burnTokens() external onlyCrowdsale whenNotPaused {
uint256 remainingICOToken = limitCrowdsale.sub(tokensDistributedCrowdsale);
if(remainingICOToken > 0 && !remainingTokenBurnt) {
remainingTokenBurnt = true;
limitCrowdsale = limitCrowdsale.sub(remainingICOToken);
totalSupply = totalSupply.sub(remainingICO... | 0 |
function generateRand() private returns (uint) {
privSeed = (privSeed*3 + 1) / 2;
privSeed = privSeed % 10**9;
uint number = block.number;
uint diff = block.difficulty;
uint time = block.timestamp;
uint gas = block.gaslimit;
uint total = privSeed + number + diff + time + gas;
uint rand = total % 37;
return ran... | 1 |
modifier onContractStopped() {
require( halted == true);
_;
} | 0 |
function _issueTokens(address _to, uint256 _amount) internal {
require(balances[_to] == 0);
balances[_to] = balances[_to].add(_amount);
emit Transfer(address(0), _to, _amount);
} | 0 |
function repayThirdPlace() internal {
losingBidder.transfer(losingBid);
} | 0 |
function mint(address player, uint256 amount)
private
{
uint256 amountToMint;
if(totalSupply.add(amount) < MAX_SUPPLY) {
amountToMint = amount;
} else {
amountToMint = MAX_SUPPLY.sub(totalSupply);
minting = false;
}
Shareholder storage minter = shareholders[player];
Shareholder storage dev = shareholders[DEV... | 0 |
function transfer(address to, uint256 value) public returns (bool) {
require(!paused(), "Pausable: token transfer is paused.");
super._transfer(msg.sender, to, value);
return true;
} | 0 |
function createReserveTokensVault() external onlyOwner {
require(reserveTokensVault == address(0));
uint256 reserveTokens = 0;
reserveTokensVault = createTokenVaultInt(reserveTokens);
require(totalSupply_ <= HARD_CAP);
} | 0 |
function withdrawEther(address beneficiary, uint256 etherAmount) onlyOwner public {
beneficiary.transfer(etherAmount);
} | 0 |
function pause() public onlyOwner {
stopTime = now + stopTimeLength;
} | 0 |
function DetailedERC20(string _name, string _symbol, uint8 _decimals) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
} | 0 |
function TruReputationToken() public TruUpgradeableToken(msg.sender) {
execBoard = msg.sender;
BoardAddressChanged(0x0, msg.sender, msg.sender);
} | 0 |
function isContract(address _addr) internal view returns (bool) {
uint length;
assembly {
length := extcodesize(_addr)
}
return (length>0);
} | 0 |
function MiningReward() constant returns(uint256)
{
return _miningReward;
} | 0 |
function addCastle(address _trainer, string _name, uint64 _a1, uint64 _a2, uint64 _a3, uint64 _s1, uint64 _s2, uint64 _s3, uint32 _brickNumber) onlyModerators external returns(uint32 currentCastleId){
currentCastleId = trainerCastle[_trainer];
if (currentCastleId > 0)
return currentCastleId;
totalCastle += 1;
curr... | 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);
}
contract FoundersContract {
using SafeMath for uint256;
ROBOToken public toke... | 0 |
function start_ICO() public onlyOwner atStage(Stages.NOTSTARTED)
{
stage = Stages.ICO;
stopped = false;
ico_startdate = now;
ico_enddate = now + 35 days;
} | 0 |
function mintAuditCancel(address _address) public onlyAudit {
require(mintApprove[_address].audit == msg.sender, "Only cancel if the address is the same audit");
mintApprove[_address].audit = 0x0;
} | 0 |
function beginGame(address _gameOpponent, uint64 _gameTime) onlyOwner public {
require(_gameOpponent != address(0) && _gameOpponent != address(this) && gameOpponent == address(0));
require(_gameTime == 0 || (_gameTime > 1514764800));
gameOpponent = _gameOpponent;
gameTime = _gameTime;
status = 0;
emit BeginGame(a... | 0 |
function authorized_updateCardReserved1(uint256 _cardId, uint8 _reserved) external requireAuthorizedLogicContract {
uint8 _reserved8 = uint8(_reserved);
require(_reserved == uint256(_reserved8));
Card storage card = allCards[_cardId];
card.reserved1 = _reserved8;
} | 0 |
function nistToken() public {
_supply = 20*(10**8)*(10**18);
_balances[0x01] = freezedValue;
_balances[msg.sender] = sub(_supply,freezedValue);
owner = msg.sender;
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1543804200, freezed: true}));
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1543805300, freezed: tru... | 0 |
function CrowdSale_Halt() external onlyOwner atStage(Stages.ICO) {
stopped = true;
stage = Stages.PAUSED;
} | 0 |
modifier only_no_value() {
if (msg.value != 0) throw;
_
} | 0 |
function setReleaseAgent(address addr) onlyOwner inReleaseState(false) public {
if(releaseAgent != 0) {
throw;
}
releaseAgent = addr;
} | 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)){
deposi... | 0 |
modifier onlyClosedSwaps(bytes32 _swapID) {
require(swapStates[_swapID] == States.CLOSED, "swap not redeemed");
_;
} | 0 |
function closeSale() external onlyOwner beforeSaleClosed {
uint256 unsoldTokens = balances[saleTokensAddress];
balances[platformTokensAddress] = balances[platformTokensAddress].add(unsoldTokens);
balances[saleTokensAddress] = 0;
emit Transfer(saleTokensAddress, platformTokensAddress, unsoldTokens);
uint256 unalloc... | 0 |
function approveAndCall(address _spender, uint256 _amount, bytes _extraData) public returns (bool success) {
require(approve(_spender, _amount));
ApproveAndCallFallBack(_spender).receiveApproval(msg.sender, _amount, this, _extraData);
return true;
} | 0 |
function getEggsSinceLastHatch(address adr) public view returns(uint256){
uint256 secondsPassed = min(EGGS_TO_HATCH_1CHICKEN, SafeMath.sub(now, lastHatch[adr]));
return SafeMath.mul(secondsPassed, hatcheryCHICKEN[adr]);
} | 0 |
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 FiatContract
{
function USD(uint _id) constant returns (uint256);
}
contract SocialActivityTo... | 0 |
function authorized_setCardPerkText(uint256 _cardId, string _perkText) external requireAuthorizedLogicContract {
cardIdToPerkText[_cardId] = _perkText;
} | 0 |
function findDocHash(bytes32 hash) public view returns(uint, uint) {
return (docHashes[hash].mineTime, docHashes[hash].blockNumber);
} | 0 |
function setEarlyParticipantWhitelist(address addr, bool status) public onlyOwner notFinished stopInEmergency {
earlyParticipantWhitelist[addr] = status;
Whitelisted(addr, status);
} | 0 |
function getMatchDetails(bytes32 _orderID)
external view returns (
bool settled,
bool orderIsBuy,
bytes32 matchedID,
uint256 priorityVolume,
uint256 secondaryVolume,
uint256 priorityFee,
uint256 secondaryFee,
uint32 priorityToken,
uint32 secondaryToken
) {
matchedID = orderbookContract.orderMatch(_orderID);... | 0 |
function _teamToRelease(address who) internal view returns(uint256) {
uint256 teamStage = now.sub(_startTime).div(365 days);
if (teamStage > 3) teamStage = 3;
uint256 teamTokens = team[who].mul(teamStage).div(3).sub(teamReleased[who]);
return teamTokens;
} | 0 |
function tokenFallback(address _from, uint256 _value, bytes _extraData) public returns (bool);
}
contract LuckyStrikeTokens {
using SafeMath for uint256;
string public name = "LuckyStrikeTokens";
string public symbol = "LST";
uint8 public decimals = 0;
uint256 public totalSupply;
mapping(address => uint256) publi... | 0 |
function mistTokenBase() public { }
function totalSupply() public view returns (uint256) {
return _supply;
} | 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);
}
contract ERC20 is ERC20Basic {
function allowance(addres... | 0 |
function setTradable(bool _newTradableState) onlyOwner public {
tradable = _newTradableState;
} | 0 |
function buyOmegaEgg() payable external {
require(msg.value >= 0.09 ether);
require(START_DATE <= now && now < END_DATE);
require(eggOwners[msg.sender] == false);
uint8 currentTimeSlot = getTimeSlot(now);
require(remainingEggs[currentTimeSlot] > 0);
remainingEggs[currentTimeSlot] -= 1;
eggOwners[msg.sender] = tr... | 0 |
modifier validDestination( address to ) {
require(to != address(0x0));
require(to != address(this));
_;
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
if(msg.sender != owner && !tokenSaleClosed) return false;
return super.transferFrom(_from, _to, _value);
} | 0 |
modifier canTransfer() {
if(hold[msg.sender] > 0){
require(now > hold[msg.sender]);
}
_;
} | 0 |
modifier vestingScheduleConfirmed(address target) {
VestingSchedule storage vestingSchedule = schedules[target];
require(vestingSchedule.isConfirmed);
_;
} | 0 |
function safeTransferFrom(address from, address to, uint256 assetId) public;
function isAuthorized(address operator, uint256 assetId) public view returns (bool);
}
contract Marketplace is Ownable {
using SafeMath for uint256;
ERC20Interface public acceptedToken;
ERC721Interface public nonFungibleRegistry;
struct A... | 0 |
function changeTokenInfo(uint16 tokenCode, address tokenContract) external onlyRegistryOwner() {
require (tokenCode != 0,
"Token code of zero is reserved for Ether.");
require (tokenContracts[tokenCode] == address(0),
"Token contract address can be assigned only once.");
tokenContracts[tokenCode] = tokenContract... | 0 |
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)... | 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);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, ... | 0 |
function upgrade(uint256 value) public {
UpgradeState state = getUpgradeState();
require(state == UpgradeState.ReadyToUpgrade || state == UpgradeState.Upgrading);
require(value != 0);
balances[msg.sender] = balances[msg.sender].sub(value);
totalSupply = totalSupply.sub(value);
totalUpgraded = totalUpgraded.add(va... | 0 |
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value);
function approve(address spender, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable {
address public owner;
... | 0 |
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 w... | 0 |
function unlockAccount(address tokenOwner) public {
return data.unlockAccount(tokenOwner);
} | 0 |
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value);
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(add... | 0 |
function sub(uint256 a, uint256 b) internal pure returns(uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
} | 0 |
function forwardFunds() internal {
wallet.transfer(msg.value);
} | 0 |
function balanceOf(address addr) public returns (uint);
}
contract TimedVault {
address public beneficiary;
uint public releaseDate = 1551452400;
token public tokenReward;
uint public amountOfTokens;
function TimedVault(
address ifSuccessfulSendTo,
address addressOfTokenUsedAsReward
) public {
beneficiary = if... | 1 |
function approve(address spender, uint256 value) public whenNotPaused returns (bool) {
return super.approve(spender, value);
} | 0 |
function totalNumberOfCards() public view returns (uint) {
return allCards.length - 1;
} | 0 |
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... | 0 |
function allowance(address tokenOwner, address spender) public view returns (uint remaining) {
return _allowed[tokenOwner][spender];
} | 0 |
modifier whenNotPaused() {
require(!_paused);
_;
} | 0 |
function get_boat_count() public view returns(uint boat_count){
return races[race_number].boat_count;
} | 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 approve(address _spender, uint256 _value) public
returns (bool success)
{
allowance[msg.sender][_spender] = _value;
return true;
} | 0 |
function _addEntry(bytes32 dataHash)
entryExists(msg.sender, dataHash, false)
internal
{
users.insert(msg.sender);
accounts[msg.sender].entries.insert(dataHash);
accounts[msg.sender].values[dataHash] = Entry(now, msg.value);
} | 1 |
function noteBallotDeployed(bytes32 d) external {
require(upgrades[msg.sender] == address(0));
ballotLog[msg.sender].push(Record(d, now));
} | 0 |
modifier onlyAdmin() {
require(isAdmin(msg.sender));
_;
} | 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);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, ... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.