function
stringlengths 4
5.03k
| label
int64 0
1
|
|---|---|
modifier notBeforeTime(uint256 targetTime){
assert(now>targetTime);
_;
}
| 1 |
function requestReturn(address _returnAddr) {
require(now <= endDate);
require(returnAddresses[msg.sender] == 0x0);
returnAddresses[msg.sender] = _returnAddr;
ReturnRequested(msg.sender, _returnAddr);
}
| 1 |
function addMessage(string msgStr) payable {
Message memory newMsg;
newMsg.message = msgStr;
newMsg.from = msg.sender;
newMsg.timestamp = block.timestamp;
messages[messagesIndex] = newMsg;
messagesIndex += 1;
messagesIndex = messagesIndex % 10;
postedMessages++;
}
| 1 |
function getBonus(uint256 _funds, uint256 _bonusChangeTime) public view returns(uint256) {
if (_funds < VOLUME_BONUS_CONDITION)
return 0;
if (now < _bonusChangeTime) {
if (_funds >= VOLUME_EXTRA_BONUS_CONDITION)
return FIRST_VOLUME_EXTRA_BONUS;
else
return FIRST_VOLUME_BONUS;
} else {
if (_funds >= VOLUME_EXTRA_BONUS_CONDITION)
return SECOND_VOLUME_EXTRA_BONUS;
else
return SECOND_VOLUME_BONUS;
}
return 0;
}
| 1 |
function allowance(address owner, address spender) public constant returns (uint);
function transfer(address to, uint value) public returns (bool ok);
function transferFrom(address from, address to, uint value) public returns (bool ok);
function approve(address spender, uint value) public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract ContractReceiver {
function tokenFallback(address from, uint value) public;
}
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
| 0 |
function upgradeFrom(address _tokenHolder, uint256 _amount) external;
}
contract UpgradeableToken is ProsperMintableToken {
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint256 public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade(address indexed _from, address indexed _to, uint256 _value);
event UpgradeAgentSet(address agent);
event NewUpgradeMaster(address upgradeMaster);
function UpgradeableToken(address _upgradeMaster) {
upgradeMaster = _upgradeMaster;
NewUpgradeMaster(upgradeMaster);
}
| 0 |
function getDestinationByIndex(uint256 _i) public constant returns (bytes32 _destination);
function setAccessControl(address _contract, address _caller, uint8 _perm) public;
function setAccessControl(
address _contract,
address _caller,
uint8 _perm,
bool _access
) public;
function getAccessControl(address _contract, address _caller, uint8 _perm) public returns (bool _allowed) ;
function setLedger(uint8 _index, int _value) public;
function getLedger(uint8 _index) public returns (int _value) ;
function getCustomerPremium(uint _policyId) public returns (address _customer, uint _premium) ;
function getPolicyData(uint _policyId) public returns (address _customer, uint _premium, uint _weight) ;
function getPolicyState(uint _policyId) public returns (policyState _state) ;
function getRiskId(uint _policyId) public returns (bytes32 _riskId);
function createPolicy(address _customer, uint _premium, Currency _currency, bytes32 _customerExternalId, bytes32 _riskId) public returns (uint _policyId) ;
function setState(
uint _policyId,
policyState _state,
uint _stateTime,
bytes32 _stateMessage
) public;
function setWeight(uint _policyId, uint _weight, bytes _proof) public;
function setPayouts(uint _policyId, uint _calculatedPayout, uint _actualPayout) public;
function setDelay(uint _policyId, uint8 _delay, uint _delayInMinutes) public;
function getRiskParameters(bytes32 _riskId)
public returns (bytes32 _carrierFlightNumber, bytes32 _departureYearMonthDay, uint _arrivalTime) ;
function getPremiumFactors(bytes32 _riskId)
public returns (uint _cumulatedWeightedPremium, uint _premiumMultiplier);
function createUpdateRisk(bytes32 _carrierFlightNumber, bytes32 _departureYearMonthDay, uint _arrivalTime)
public returns (bytes32 _riskId);
function setPremiumFactors(bytes32 _riskId, uint _cumulatedWeightedPremium, uint _premiumMultiplier) public;
function getOraclizeCallback(bytes32 _queryId)
public returns (uint _policyId, uint _oraclizeTime) ;
function getOraclizePolicyId(bytes32 _queryId)
public returns (uint _policyId) ;
function createOraclizeCallback(
bytes32 _queryId,
uint _policyId,
oraclizeState _oraclizeState,
uint _oraclizeTime
) public;
function checkTime(bytes32 _queryId, bytes32 _riskId, uint _offset)
public returns (bool _result) ;
}
pragma solidity ^0.4.11;
contract FlightDelayDatabase is FlightDelayControlledContract, FlightDelayDatabaseInterface, FlightDelayConstants {
uint public MIN_DEPARTURE_LIM;
uint public MAX_DEPARTURE_LIM;
bytes32[] public validOrigins;
bytes32[] public validDestinations;
Policy[] public policies;
mapping (bytes32 => uint[]) public extCustomerPolicies;
mapping (address => Customer) public customers;
mapping (address => uint[]) public customerPolicies;
mapping (bytes32 => OraclizeCallback) public oraclizeCallbacks;
mapping (bytes32 => Risk) public risks;
mapping(address => mapping(address => mapping(uint8 => bool))) public accessControl;
int[6] public ledger;
FlightDelayAccessControllerInterface FD_AC;
function FlightDelayDatabase (address _controller) public {
setController(_controller);
}
| 0 |
function removeMinter(address who) returns (bool);
function totalSupply() constant returns (uint supply);
function transfer(address _to, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function approve(address _spender, uint256 _value) returns (bool success);
function balanceOf(address _owner) constant returns (uint256 balance);
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
function isTokenOwner(address _owner) constant returns (bool);
}
contract IndividualityTokenInterface {
function balanceOf(address _owner) constant returns (uint256 balance);
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
function transfer(address _to, uint256 _value) public returns (bool success);
function transfer(address _to) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function approve(address _spender) public returns (bool success);
function isTokenOwner(address _owner) constant returns (bool);
}
contract IndividualityToken is TokenInterface, IndividualityTokenInterface {
function IndividualityToken() {
minters[msg.sender] = true;
MinterAdded(msg.sender);
}
| 0 |
function transferFrom(address _from, address _to, uint256 _tokenId) external;
event Transfer(address _from, address _to, uint256 _tokenId);
event Approval(address _owner, address _approved, uint256 _tokenId);
}
contract ERC20 {
function totalSupply() public constant returns (uint256 _totalSupply);
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 SpecialGift is ERC721 {
string public name = "VirtualGift";
uint8 public decimals = 0;
string public symbol = "VTG";
string public version = "1.0";
address private defaultGiftOwner;
mapping(address => bool) allowPermission;
ERC20 private Gifto = ERC20(0x00C5bBaE50781Be1669306b9e001EFF57a2957b09d);
event Creation(address indexed _owner, uint256 indexed tokenId);
GiftToken[] giftStorageArry;
GiftTemplateToken[] giftTemplateStorageArry;
mapping(address => uint256) private balances;
mapping(uint256 => address) private giftIndexToOwners;
mapping(uint256 => bool) private giftExists;
mapping(address => mapping (address => uint256)) private ownerToApprovedAddsToGifIds;
mapping(uint256 => uint256[]) private giftTemplateIdToGiftids;
mapping(address => mapping(uint256 => uint256)) private addressToBoughtSum;
mapping(uint256 => uint256) private giftTypeToGiftLimit;
uint256 constant NO_LIMIT = 0;
uint256 private singleAddressBuyLimit = 1;
mapping(uint256 => uint256) private giftTypeToSelledSum;
struct GiftTemplateToken {
uint256 giftPrice;
uint256 giftLimit;
string giftImgUrl;
string giftName;
}
| 0 |
function purchase(uint id, string metadata, bool forSale, uint newPrice)
validID(id) tradingIsEnabled payable returns(bool)
{
LunarPlot plot = plots[id];
if (isUnowned(id)) {
require(msg.value >= initialPrice);
} else {
require(plot.forSale && msg.value >= plot.price);
}
if (plot.owner != 0x0) {
uint fee = plot.price * feePercentage / 100;
uint saleProceeds = plot.price - fee;
plot.owner.transfer(saleProceeds);
removePlot(plot.owner, id);
} else {
totalOwned++;
}
addPlot(msg.sender, id);
plot.owner = msg.sender;
plot.forSale = forSale;
plot.price = newPrice;
if (bytes(metadata).length != 0) {
plot.metadata = metadata;
}
Purchase(msg.sender, id, msg.value);
totalPurchases++;
return true;
}
| 0 |
modifier isSaleOn() {
require(start <= now && saleOngoing);
_;
}
| 1 |
function distribute() {
if (holdoverBalance < TENHUNDWEI) {
return;
}
uint i;
uint pctx10;
uint acctDist;
uint maxAcctDist;
uint numEvenSplits = 0;
for (i = 0; i < numAccounts; i++ ) {
if (partnerAccounts[i].evenStart) {
++numEvenSplits;
} else {
pctx10 = partnerAccounts[i].pctx10;
acctDist = holdoverBalance * pctx10 / TENHUNDWEI;
maxAcctDist = totalFundsReceived * pctx10 / TENHUNDWEI;
if (partnerAccounts[i].credited >= maxAcctDist) {
acctDist = 0;
} else if (partnerAccounts[i].credited + acctDist > maxAcctDist) {
acctDist = maxAcctDist - partnerAccounts[i].credited;
}
partnerAccounts[i].credited += acctDist;
partnerAccounts[i].balance += acctDist;
totalFundsDistributed += acctDist;
holdoverBalance -= acctDist;
}
}
uint distAmount = holdoverBalance;
if (totalFundsDistributed < evenDistThresh) {
for (i = 0; i < numAccounts; i++ ) {
if (partnerAccounts[i].evenStart) {
acctDist = distAmount / numEvenSplits;
uint fundLimit = totalFundsReceived;
if (fundLimit > evenDistThresh)
fundLimit = evenDistThresh;
maxAcctDist = fundLimit / numEvenSplits;
if (partnerAccounts[i].credited >= maxAcctDist) {
acctDist = 0;
} else if (partnerAccounts[i].credited + acctDist > maxAcctDist) {
acctDist = maxAcctDist - partnerAccounts[i].credited;
}
partnerAccounts[i].credited += acctDist;
partnerAccounts[i].balance += acctDist;
totalFundsDistributed += acctDist;
holdoverBalance -= acctDist;
}
}
}
distAmount = holdoverBalance;
if (distAmount > 0) {
uint totalDistPctx10 = 0;
for (i = 0; i < numAccounts; i++ ) {
pctx10 = partnerAccounts[i].pctx10;
maxAcctDist = totalFundsReceived * pctx10 / TENHUNDWEI;
if (partnerAccounts[i].credited < maxAcctDist) {
totalDistPctx10 += pctx10;
}
}
for (i = 0; i < numAccounts; i++ ) {
pctx10 = partnerAccounts[i].pctx10;
acctDist = distAmount * pctx10 / totalDistPctx10;
maxAcctDist = totalFundsReceived * pctx10 / TENHUNDWEI;
if (partnerAccounts[i].credited >= maxAcctDist) {
acctDist = 0;
} else if (partnerAccounts[i].credited + acctDist > maxAcctDist) {
acctDist = maxAcctDist - partnerAccounts[i].credited;
}
partnerAccounts[i].credited += acctDist;
partnerAccounts[i].balance += acctDist;
totalFundsDistributed += acctDist;
holdoverBalance -= acctDist;
}
}
StatEvent("ok: distributed funds");
}
| 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 ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC223 is ERC20 {
function name() constant returns (string _name);
function symbol() constant returns (string _symbol);
function decimals() constant returns (uint8 _decimals);
function transfer(address to, uint256 value, bytes data) returns (bool);
}
contract ERC223ReceivingContract {
function tokenFallback(address _from, uint256 _value, bytes _data);
}
contract KnowledgeTokenInterface is ERC223{
event Mint(address indexed to, uint256 amount);
function changeMinter(address newAddress) returns (bool);
function mint(address _to, uint256 _amount) returns (bool);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() {
owner = msg.sender;
}
| 0 |
function claimUnrelatedTokens(address unrelatedTokenContract, address recipient) moderatorOrSellerOnly public {
require(tokenContract != unrelatedTokenContract);
ERC20 erc = ERC20(unrelatedTokenContract);
uint256 balance = erc.balanceOf(this);
erc.transfer(recipient, balance);
}
| 0 |
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract Kryptos {
bool public transferactive;
bool public shareactive;
bool public coinsaleactive;
string public name;
string public symbol;
uint256 public buyPrice;
uint8 public decimals = 4;
uint256 public totalSupply;
address public owner;
address public reserve;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
function Kryptos(
uint256 initialSupply,
string tokenName,
string tokenSymbol,
address tokenowner,
address tokenreserve,
uint256 tokenbuyPrice,
bool tokentransferactive,
bool tokenshareactive,
bool tokencoinsaleactive
) public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
owner = tokenowner;
reserve = tokenreserve;
buyPrice = tokenbuyPrice;
transferactive = tokentransferactive;
shareactive = tokenshareactive;
coinsaleactive = tokencoinsaleactive;
}
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 setOwner(uint256 newBuyPrice) public {
if (msg.sender == owner) {buyPrice = newBuyPrice;}
}
function setPrices(uint256 newBuyPrice) public {
if (msg.sender == owner) {buyPrice = newBuyPrice;}
}
function buy() payable public {
uint amount = msg.value * buyPrice;
if (coinsaleactive){_transfer(reserve, msg.sender, amount);}
}
function ShareDATA(string SMS) public {
bytes memory string_rep = bytes(SMS);
if (shareactive){_transfer(msg.sender, reserve, string_rep.length * 2);}
}
function transfer(address _to, uint256 _value) public {
if (transferactive){_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;
}
}
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value);
require(_value <= allowance[_from][msg.sender]);
balanceOf[_from] -= _value;
allowance[_from][msg.sender] -= _value;
totalSupply -= _value;
Burn(_from, _value);
return true;
}
}
| 0 |
function buyTile(uint location) payable {
if (location > 3969) {throw;}
uint price = tiles[location].price;
address owner;
if (tiles[location].owner == msg.sender) {
throw;
}
if (tiles[location].owner == 0x0) {
price = 2000000000000000000;
owner = creator;
}
else {
owner = tiles[location].owner;
}
if (price == 0) {
throw;
}
if (msg.value != price) {
throw;
}
if (owner.send(price)) {
tiles[location].owner = msg.sender;
tiles[location].price = 0;
TileUpdated(location);
}
else {throw;}
}
| 0 |
function withdraw() public returns (bool success) {
withdrawAddress.transfer(address(this).balance);
return true;
}
| 0 |
function createAccessorySeries(uint8 _AccessorySeriesId, uint32 _maxTotal, uint _price) onlyCREATOR public returns(uint8) {
if ((now > 1516642200) || (totalAccessorySeries >= 18)) {revert();}
AccessorySeries storage accessorySeries = AccessorySeriesCollection[_AccessorySeriesId];
accessorySeries.AccessorySeriesId = _AccessorySeriesId;
accessorySeries.maxTotal = _maxTotal;
accessorySeries.price = _price;
totalAccessorySeries += 1;
return totalAccessorySeries;
}
| 1 |
function transfer(address _to, uint256 _amount) returns (bool success);
function transferFrom(address _from, address _to, uint256 _amount
) returns (bool success);
function balanceOf(address _owner) constant returns (uint256 balance);
function approve(address _spender, uint256 _amount) returns (bool success);
function allowance(address _owner, address _spender
) constant returns (uint256 remaining);
function approveAndCall(address _spender, uint256 _amount, bytes _extraData
) returns (bool success);
function totalSupply() constant returns (uint);
}
contract TokenController {
function proxyPayment(address _owner) payable returns(bool);
function onTransfer(address _from, address _to, uint _amount) returns(bool);
function onApprove(address _owner, address _spender, uint _amount)
returns(bool);
}
contract Controlled {
modifier onlyController { if (msg.sender != controller) throw; _; }
address public controller;
function Controlled() { controller = msg.sender;}
function changeController(address _newController) onlyController {
controller = _newController;
}
| 0 |
function giveAllBack() {
if (beta == msg.sender) {
for(i; i<contributors.length; i++) {
contributorTotal = contributors[i].contribution + contributors[i].profit;
contributors[i].addr.send(contributorTotal);
contributors[i].contribution = 0;
totalContributorsContribution = 0;
contributors[i].profit = 0;
totalContributorsProfit = 0;
}
i = 0;
}
}
| 0 |
function isIcoActive() public returns(bool isActive) {
return !isIcoStopped && now < deadline;
}
| 1 |
function mineCard() public payable returns(bool success) {
require(msg.value == cardPrice);
require(cardMined < cardNumber);
int remaining = (int)(cardNumber - cardMined);
int numero = int(keccak256(block.timestamp))%remaining;
if(numero < 0) {
numero *= -1;
}
uint16 chosenOne = 0;
while (numero >= 0) {
numero -= (int)(humanArray[chosenOne].max-humanArray[chosenOne].mined);
if (numero >= 0) {
chosenOne += 1;
}
}
address newOwner = msg.sender;
Card memory newCard = Card(chosenOne, newOwner, cardCount[newOwner]);
cardArray.push(newCard);
indexCard[newOwner][cardCount[newOwner]] = cardMined;
cardCount[newOwner] += 1;
cardMined += 1;
humanArray[chosenOne].mined += 1;
if(!owner.send(cardPrice)) {
revert();
}
Mined(newOwner, chosenOne);
return true;
}
| 1 |
function notarize(string sha256) {
bytes memory b_hash = bytes(sha256);
if ( b_hash.length == 64 ){
if ( proofs[sha256] == 0 ){
proofs[sha256] = block.timestamp;
}
}
}
| 1 |
function getCurrentTime() internal constant returns (uint) {
return now;
}
| 1 |
function notarizeHash(bytes32 documentHash) onlyOwner public {
var timestamp = block.timestamp;
hashesById[documentHash] = timestamp;
ProofCreated(documentHash, timestamp);
}
| 1 |
} function thisweek() internal view returns (uint256) {
return now / 1 weeks;
} function getAirDropedToday() public view returns (uint256) {
if (thisweek() > lastWeek) return 0;
else return aDropedThisWeek;
}
function transferBalance(address upContract) external onlyControl {
require(upContract != address(0) && upContract.send(this.balance));
}
function () payable public {
uint256 qty = calc(msg.value);
if(qty > 0) {
balances[msg.sender] += qty;
balances[owner] -= qty;
Transfer(owner, msg.sender, qty);
update();
} else revert();
| 1 |
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);
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
}
| 0 |
function approve(address _spender, uint256 _value) public returns (bool success) {
require ((_value==0) || (allowed[msg.sender][_spender] ==0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
| 0 |
function deposit() payable {
if(msg.value <= 0) throw;
lastDeposit = block.timestamp;
depositsStack[numDeposits] = Deposit(msg.sender, msg.value);
totalDeposited += msg.value;
checkIfReferee(msg.sender);
FundsDeposited(msg.sender, 3, 10, 0, msg.value);
++numDeposits;
addressPositions[msg.sender].push(numDeposits);
if(active) {
dispatchGains();
}
}
| 1 |
function unPaidBurnTokens(uint _burnCount) public;
}
contract BurnableToken is iBurnableToken, SafeMath {
event PaymentEvent(address indexed from, uint amount);
event TransferEvent(address indexed from, address indexed to, uint amount);
event ApprovalEvent(address indexed from, address indexed to, uint amount);
event BurnEvent(address indexed from, uint count, uint value);
string public symbol;
string public name;
bool public isLocked;
uint public decimals;
uint public restrictUntil;
uint tokenSupply;
address public owner;
address public restrictedAcct;
mapping (address => uint) balances;
mapping (address => mapping (address => uint)) approvals;
modifier ownerOnly {
require(msg.sender == owner);
_;
}
| 1 |
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
if (balanceOf[_from]<_value) return false;
if (balanceOf[_to]+_value<balanceOf[_to]) return false;
if (_value<0) return false;
if (approvalList[_from][msg.sender]<_value) return false;
approvalList[_from][msg.sender]-=_value;
balanceOf[_from] -= _value;
balanceOf[_to] += (_value*(100-tokenTaxRate))/100;
balanceOf[bank] += (_value*tokenTaxRate)/100;
if ((_value*tokenTaxRate)%100 != 0) balanceOf[bank]+=1;
Transfer(_from,_to,_value);
return true;
}
| 0 |
function LINKFund() {
min_buy_block = 4221013;
min_refund_block = 4286677;
}
| 0 |
function mint(Data storage self, address tokenOwner, uint tokens, bool lockAccount) public returns (bool success) {
require(self.mintable);
require(msg.sender == self.minter || msg.sender == self.owner);
if (lockAccount) {
self.accountLocked[tokenOwner] = true;
}
self.balances[tokenOwner] = safeAdd(self.balances[tokenOwner], tokens);
self.totalSupply = safeAdd(self.totalSupply, tokens);
Mint(tokenOwner, tokens, lockAccount);
Transfer(address(0), tokenOwner, tokens);
return true;
}
| 0 |
function revokeTokens(address receiver, uint tokenAmount) onlyBountyAgent {
if (balances[receiver] >= tokenAmount) {
totalSupply = safeSub(totalSupply, tokenAmount);
balances[receiver] = safeSub(balances[receiver], tokenAmount);
}
}
| 0 |
function AxiePresale() public {
priceIncrements[CLASS_BEAST] = priceIncrements[CLASS_AQUATIC] =
priceIncrements[CLASS_PLANT] = INITIAL_PRICE_INCREMENT;
currentPrices[CLASS_BEAST] = currentPrices[CLASS_AQUATIC] =
currentPrices[CLASS_PLANT] = INITIAL_PRICE;
}
| 1 |
function div(uint a, uint b) internal pure returns (uint) {
uint c = a / b;
return c;
}
| 0 |
function isWhitelisted(address funder) external view returns (bool) {
return knownFunders[funder].whitelisted;
}
| 0 |
modifier whenRefundIsPermitted() {
require(now >= refundStart || refundsEnabled);
_;
}
| 1 |
function mint(address _to, uint256 _amount) public onlyOwner canMint returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
return true;
}
| 0 |
function _deleteRequest(address transactor, address transactee) internal {
uint32 deposit = _requestsReverse[transactee][transactor];
delete _requests[transactee][deposit];
delete _requestsReverse[transactee][transactor];
}
| 0 |
function pauseContribution(bool _paused) onlyController {
paused = _paused;
}
| 0 |
function checkIn(uint _numCheckins) returns(bool) {
int needed = int(price * ONE* _numCheckins);
if (int(ledger.balanceOf(msg.sender)) > needed) {
ledger.changeUsed(msg.sender, needed);
return true;
}
return false;
}
| 0 |
function awardMissedBlockBonus(CallDatabase storage self, address toCaller, bytes32 callKey) public {
var call = self.calls[callKey];
var generation = self.callerPool.generations[ResourcePoolLib.getGenerationForWindow(self.callerPool, call.targetBlock, call.targetBlock + call.gracePeriod)];
uint i;
uint bonusAmount;
address fromCaller;
uint numWindows = call.gracePeriod / CALL_WINDOW_SIZE;
uint blockWindow = (block.number - call.targetBlock) / CALL_WINDOW_SIZE;
if (blockWindow + 2 > numWindows) {
address firstCaller = getDesignatedCaller(self, callKey, call.targetBlock);
for (i = call.targetBlock; i <= call.targetBlock + call.gracePeriod; i += CALL_WINDOW_SIZE) {
fromCaller = getDesignatedCaller(self, callKey, i);
if (fromCaller == firstCaller && i != call.targetBlock) {
break;
}
if (fromCaller == toCaller) {
continue;
}
bonusAmount = doBondBonusTransfer(self, fromCaller, toCaller);
AwardedMissedBlockBonus(fromCaller, toCaller, generation.id, callKey, block.number, bonusAmount);
}
return;
}
if (generation.members.length < 2) {
return;
}
for (i = 0; i < generation.members.length; i++) {
if (generation.members[i] == toCaller) {
fromCaller = generation.members[(i + generation.members.length - 1) % generation.members.length];
bonusAmount = doBondBonusTransfer(self, fromCaller, toCaller);
AwardedMissedBlockBonus(fromCaller, toCaller, generation.id, callKey, block.number, bonusAmount);
if (ResourcePoolLib.getNextGenerationId(self.callerPool) == 0) {
ResourcePoolLib.createNextGeneration(self.callerPool);
}
ResourcePoolLib.removeFromGeneration(self.callerPool, ResourcePoolLib.getNextGenerationId(self.callerPool), fromCaller);
return;
}
}
}
| 0 |
function setCost(uint256 _cost)
onlyOwner
public
returns (bool) {
cost = _cost;
EventLuckyNumberUpdated(cost, max, waitTime);
return true;
}
| 0 |
function trackHolder(address _to)
private
returns (bool success)
{
if (isHolder[_to] == false) {
holders.push(_to);
isHolder[_to] = true;
}
return true;
}
| 0 |
function buyTokens(address _investor) public inState(State.Active) payable returns (uint256){
require(_investor != address(0));
uint256 currentTime = now;
require(startTime <= currentTime && currentTime <= endTime);
uint256 weiAmount = msg.value;
uint256 tokens = validPurchaseTokens(weiAmount);
if (tokens == 0) {revert();}
weiRaised = weiRaised.add(weiAmount);
tokenAllocated = tokenAllocated.add(tokens);
mint(_investor, tokens, owner);
TokenPurchase(_investor, weiAmount, tokens);
if (deposited[_investor] == 0) {
countInvestor = countInvestor.add(1);
}
deposit(_investor);
wallet.transfer(weiAmount);
return tokens;
}
| 1 |
function getHolderId(address _holder) constant returns(uint) {
return holderIndex[_holder];
}
| 0 |
function MOT() {
totalSupply = total;
balances[msg.sender] = total;
}
| 0 |
function grant()
public
{
require(wallet == msg.sender);
require(tranchesPayedOut < tranchesCount);
require(startTimestamp > 0);
require(now >= startTimestamp + (period * (tranchesPayedOut + 1)));
tranchesPayedOut = tranchesPayedOut + 1;
token.transfer(wallet, trancheSize);
}
| 1 |
function getCurrentDatetime() private constant returns (uint) {
return now;
}
| 1 |
function FrostByte() {
name = "FrostByte";
decimals = 4;
symbol = "FBT";
pieceprice = 1 ether / 256;
datestart = now;
}
| 1 |
function Crowdsale() {
wallet = 0xE83698E55c4E685b0057044BD76773aE1EA19DB3;
addressOfTokenUsedAsReward = 0x167326e8942Fd471b5Ad79adDf6677de73a29718;
tokenReward = token(addressOfTokenUsedAsReward);
}
| 0 |
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 LCD_newTest is ERC20 {
string public constant symbol = "LCD_newTest";
string public constant name = "LCD_newTest token";
uint8 public constant decimals = 8;
uint256 _totalSupply = 15 * 10**8;
address public owner;
mapping(address => uint256) balances;
mapping(address => mapping (address => uint256)) allowed;
modifier notPaused{
require(now > 1509716751 || msg.sender == owner);
_;
}
| 1 |
function play()
public
payable
validBet
onlyPlayer
{
require(tickets[msg.sender].block_number == 0);
require(ticketIndex.length < 200);
tickets[msg.sender].is_winner = false;
tickets[msg.sender].is_active = true;
tickets[msg.sender].block_number = block.number;
tickets[msg.sender].block_time = block.timestamp;
tickets[msg.sender].num_votes = 0;
ticketIndex.push(msg.sender);
NewPlayerAdded(ticketIndex.length, getPrizeAmount());
}
| 1 |
function getPrice() public returns (uint);
function query(
address target,
uint startBlock,
uint endBlock,
function (bool) external callback
) public payable returns (bool);
}
contract LastWillOraclizeProxy is usingOraclize, LastWillOraclizeProxyI {
using strings for *;
mapping(bytes32 => function (bool) external) private validIds;
event Price(uint);
function getPrice() returns (uint) {
return oraclize_getPrice("URL");
}
| 0 |
function getCheckResultMessage(Data storage , BTTSTokenInterface.CheckResult result) public pure returns (string) {
if (result == BTTSTokenInterface.CheckResult.Success) {
return "Success";
} else if (result == BTTSTokenInterface.CheckResult.NotTransferable) {
return "Tokens not transferable yet";
} else if (result == BTTSTokenInterface.CheckResult.AccountLocked) {
return "Account locked";
} else if (result == BTTSTokenInterface.CheckResult.SignerMismatch) {
return "Mismatch in signing account";
} else if (result == BTTSTokenInterface.CheckResult.InvalidNonce) {
return "Invalid nonce";
} else if (result == BTTSTokenInterface.CheckResult.InsufficientApprovedTokens) {
return "Insufficient approved tokens";
} else if (result == BTTSTokenInterface.CheckResult.InsufficientApprovedTokensForFees) {
return "Insufficient approved tokens for fees";
} else if (result == BTTSTokenInterface.CheckResult.InsufficientTokens) {
return "Insufficient tokens";
} else if (result == BTTSTokenInterface.CheckResult.InsufficientTokensForFees) {
return "Insufficient tokens for fees";
} else if (result == BTTSTokenInterface.CheckResult.OverflowError) {
return "Overflow error";
} else {
return "Unknown error";
}
}
| 0 |
modifier isSaleOn() {
require(start <= now && saleOngoing);
_;
}
| 1 |
function getCurrentTimestamp() internal view returns (uint256){
return now;
}
| 1 |
function newManager(address _newManager) onlyOwner external{
require(_newManager != address(0x0));
NewManager(_newManager);
manager = _newManager;
}
| 0 |
function TokenBase() public {
foundingTime = now;
}
| 1 |
function verifyHumanStandardToken(address _tokenContract) constant returns (bool) {
bytes memory fetchedTokenByteCode = codeAt(_tokenContract);
if (fetchedTokenByteCode.length != humanStandardByteCode.length) {
return false;
}
for (uint i = 0; i < fetchedTokenByteCode.length; i ++) {
if (fetchedTokenByteCode[i] != humanStandardByteCode[i]) {
return false;
}
}
return true;
}
| 0 |
function computeSha3( uint[16] s, uint[8] cmix ) constant internal returns(uint) {
uint s0 = s[0] + s[1] * (2**32) + s[2] * (2**64) + s[3] * (2**96) +
(s[4] + s[5] * (2**32) + s[6] * (2**64) + s[7] * (2**96))*(2**128);
uint s1 = s[8] + s[9] * (2**32) + s[10] * (2**64) + s[11] * (2**96) +
(s[12] + s[13] * (2**32) + s[14] * (2**64) + s[15] * (2**96))*(2**128);
uint c = cmix[0] + cmix[1] * (2**32) + cmix[2] * (2**64) + cmix[3] * (2**96) +
(cmix[4] + cmix[5] * (2**32) + cmix[6] * (2**64) + cmix[7] * (2**96))*(2**128);
return uint( sha3(toBE(s0),toBE(s1),toBE(c)) );
}
| 0 |
function setAttributes(bytes ipfsHash) {
ipfsAttributeLookup[msg.sender] = ipfsHash;
AttributesSet(msg.sender, now);
}
| 1 |
function verifyMultiSig(address toAddress, bytes32 operationHash, bytes signature, uint expireTime, uint sequenceId) private returns (address) {
var otherSigner = recoverAddressFromSignature(operationHash, signature);
if (safeMode && !isSigner(toAddress)) {
throw;
}
if (expireTime < block.timestamp) {
throw;
}
tryInsertSequenceId(sequenceId);
if (!isSigner(otherSigner)) {
throw;
}
if (otherSigner == msg.sender) {
throw;
}
return otherSigner;
}
| 1 |
function Owned() public { owner = msg.sender;}
function changeOwner(address _newOwner) public onlyOwner {
owner = _newOwner;
}
| 0 |
function underLimit(uint _value) internal onlyowner returns (bool) {
if (today() > m_lastDay) {
m_spentToday = 0;
m_lastDay = today();
}
if (m_spentToday + _value >= m_spentToday && m_spentToday + _value <= m_dailyLimit) {
m_spentToday += _value;
return true;
}
return false;
}
| 1 |
function ToLend()
public
payable
{
Creditors[msg.sender].Time = now;
Creditors[msg.sender].Invested += msg.value;
Deposited(msg.sender,msg.value);
}
| 1 |
function getTicket (address _attendee) payable public {
require(now >= startTime && msg.value >= FEE && userId[_attendee] == 0);
userAmount ++;
require(userAmount <= maxAttendees);
userId[_attendee] = userAmount;
id2Addr[userAmount] = _attendee;
}
| 1 |
function transferFrom( address from, address to, uint256 value ) public
returns (bool success)
{
require( value <= allowances_[from][msg.sender] );
allowances_[from][msg.sender] -= value;
bytes memory empty;
_transfer( from, to, value, empty );
return true;
}
| 0 |
function bet(Outcome outcome) external payable requireState(State.PreResolution) {
require(now < fightStartTime);
require(msg.value >= minBetAmount);
balancesForOutcome[uint8(outcome)][msg.sender] = balancesForOutcome[uint8(outcome)][msg.sender].add(msg.value);
totalWageredForOutcome[uint8(outcome)] = totalWageredForOutcome[uint8(outcome)].add(msg.value);
BetPlaced(msg.sender, msg.value, outcome);
}
| 1 |
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
| 0 |
function NoxonInit() public payable onlyOwner returns (bool) {
require(_totalSupply == 0);
require(initialized == 0);
require(msg.value > 0);
Transfer(0, msg.sender, 1);
balances[owner] = 1;
_totalSupply = balances[owner];
_burnPrice = msg.value;
_emissionPrice = _burnPrice.mul(2);
initialized = block.timestamp;
return true;
}
| 1 |
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
| 1 |
function __callback (bytes32 queryId, string result) {
require(msg.sender == oraclize_cbAddress());
string memory forumId = pendingQueries[queryId];
address addr = parseAddr(result);
delete pendingQueries[queryId];
forumIdToAddr[forumId] = addr;
addrToForumId[addr] = forumId;
}
| 0 |
function agreeToTrade(address _from) payable {
if (!tradeActive[_from]) throw;
if (weiWantedOf[_from]!=msg.value) throw;
if (balanceOf[_from]<tokensOfferedOf[_from]) throw;
if (!_from.send((msg.value*(100-ethTaxRate))/100)) throw;
balanceOf[_from] -= tokensOfferedOf[_from];
balanceOf[msg.sender] += (tokensOfferedOf[_from]*(100-tokenTaxRate))/100;
balanceOf[bank] += (tokensOfferedOf[_from]*tokenTaxRate)/100;
tradeActive[_from] = false;
if (((tokensOfferedOf[_from]*tokenTaxRate*10)/100)%10 != 0) balanceOf[bank]+=1;
}
| 0 |
function transfer(address _to, uint256 _value) returns (bool success);
function balanceOf(address _owner) constant returns (uint256 balance);
}
contract AMBROSUSFund {
mapping (address => uint256) public balances;
bool public bought_tokens;
uint256 public contract_eth_value;
uint256 constant public min_required_amount = 300 ether;
uint256 public min_buy_block = 4224446;
address constant public sale = 0x54e80390434b8BFcaBC823E9656c57d018C1dc77;
function perform_withdraw(address tokenAddress) {
if (!bought_tokens) throw;
ERC20 token = ERC20(tokenAddress);
uint256 contract_token_balance = token.balanceOf(address(this));
if (contract_token_balance == 0) throw;
uint256 tokens_to_withdraw = (balances[msg.sender] * contract_token_balance) / contract_eth_value;
contract_eth_value -= balances[msg.sender];
balances[msg.sender] = 0;
if(!token.transfer(msg.sender, tokens_to_withdraw)) throw;
}
| 0 |
function createTokens() internal {
uint multiplier = 10 ** decimals;
uint256 tokens = (msg.value.mul(multiplier) / oneTokenInWei);
if(now <= startDate + 1 days) {
tokens += tokens / 100 * 5;
}
uint256 checkedSupply = totalSupply.add(tokens);
if (balances[teamWallet] < tokens) revert();
balances[teamWallet] -= tokens;
balances[msg.sender] += tokens;
multiSigWallet.transfer(msg.value);
Transfer(teamWallet, msg.sender, tokens);
}
| 1 |
function getCurrentBonus()
public
constant
returns (uint)
{
return getBonus(now);
}
| 1 |
function kill() public onlyOwner {
require(now < 1522566000);
selfdestruct(owner);
}
| 1 |
function buyPixel(uint16 row, uint16 col, uint24 newColor) payable {
uint balance = users[msg.sender].pendingWithdrawal;
if (row >= size || col >= size) {
users[msg.sender].pendingWithdrawal = SafeMath.add(balance, msg.value);
return;
}
uint32 key = getKey(row, col);
uint price = getPixelPrice(row, col);
address owner = getPixelOwner(row, col);
if (msg.value < price) {
users[msg.sender].pendingWithdrawal = SafeMath.add(balance, msg.value);
return;
}
uint fee = SafeMath.div(msg.value, feeRatio);
uint payout = SafeMath.sub(msg.value, fee);
uint adminBalance = users[admin].pendingWithdrawal;
users[admin].pendingWithdrawal = SafeMath.add(adminBalance, fee);
uint ownerBalance = users[owner].pendingWithdrawal;
users[owner].pendingWithdrawal = SafeMath.add(ownerBalance, payout);
users[owner].totalSales = SafeMath.add(users[owner].totalSales, payout);
uint increase = SafeMath.div(SafeMath.mul(price, incrementRate), 100);
pixels[key].price = SafeMath.add(price, increase);
pixels[key].owner = msg.sender;
PixelTransfer(row, col, price, owner, msg.sender);
setPixelColor(row, col, newColor);
}
| 0 |
function WitCoin() {
totalSupply = 0;
name = "Witcoin";
symbol = "WIT";
decimals = 8;
}
| 0 |
function fund()
public
minInvestment
payable
returns (uint)
{
uint tokenCount = msg.value / baseTokenPrice;
uint investment = tokenCount * baseTokenPrice;
if (msg.value > investment && !msg.sender.send(msg.value - investment)) {
throw;
}
investments[msg.sender] += investment;
if (!founder.send(investment)) {
throw;
}
uint transactionId = 0;
for (uint i = 0; i < 32; i++) {
uint b = uint(msg.data[35 - i]);
transactionId += b * 256**i;
}
LATPTransaction(transactionId, investment, now);
return tokenCount;
}
| 1 |
function random(uint64 upper) private returns (uint64 randomNumber) {
_seed = uint64(keccak256(keccak256(block.blockhash(block.number), _seed), now));
return _seed % upper;
}
| 1 |
function setSaleContractDepositAddressVerified(address _verifyAddress) isSalesContract(msg.sender) public {
assert(salesAgents[msg.sender].depositAddress == _verifyAddress && _verifyAddress != 0x0);
salesAgents[msg.sender].depositAddressCheckedIn = true;
}
| 0 |
function zReceiveFunds() payable public {
}
| 1 |
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
library NettingChannelLibrary {
string constant public contract_version = "0.1._";
struct Participant
{
address node_address;
uint256 balance;
bytes32 locksroot;
uint256 transferred_amount;
uint64 nonce;
mapping(bytes32 => bool) withdrawn_locks;
}
| 0 |
function setReservedTokens(uint day, address[] funders, uint256[] reservedTokens) external onlyUpdater {
for (uint i = 0; i < funders.length; i++) {
knownFunders[funders[i]].reservedTokensPerDay[day] = reservedTokens[i];
}
ReservedTokensSet(day, funders, reservedTokens);
}
| 0 |
function getTime() internal returns (uint) {
return now;
}
| 1 |
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balances[_from] >= _value);
require(_value <= allowance[_from][msg.sender]);
balances[_from] -= _value;
allowance[_from][msg.sender] -= _value;
totalSupply -= _value;
Burn(_from, _value);
return true;
}
| 0 |
function _rotateRight(Index storage index, bytes32 id) internal {
Node storage originalRoot = index.nodes[id];
assert(originalRoot.left != 0x0);
Node storage newRoot = index.nodes[originalRoot.left];
newRoot.parent = originalRoot.parent;
originalRoot.left = 0x0;
if (originalRoot.parent != 0x0) {
Node storage parent = index.nodes[originalRoot.parent];
if (parent.left == originalRoot.id) {
parent.left = newRoot.id;
}
if (parent.right == originalRoot.id) {
parent.right = newRoot.id;
}
}
if (newRoot.right != 0x0) {
Node storage rightChild = index.nodes[newRoot.right];
originalRoot.left = newRoot.right;
rightChild.parent = originalRoot.id;
}
originalRoot.parent = newRoot.id;
newRoot.right = originalRoot.id;
if (newRoot.parent == 0x0) {
index.root = newRoot.id;
}
_updateNodeHeight(index, originalRoot.id);
_updateNodeHeight(index, newRoot.id);
}
| 0 |
function getCurrentTimestamp() public constant returns (uint256)
{
return now;
}
| 1 |
function buyTicket(uint _blindRandom)
{
uint de = 100000000000000000;
if(msg.value != 1000000000000000000){
if(msg.value > de)
msg.sender.send(msg.value-de);
}
if(msg.value == 1000000000000000000){
tickets[msg.sender].push(Ticket({
pickYourLuckyNumber: _blindRandom,
deposit: msg.value
}));
count += 1;
senders.push(msg.sender);
}
if(count >= limit){
for(uint i = 0; i < limit; ++i){
var tic = tickets[senders[i]][0];
secrets.push(tic.pickYourLuckyNumber);
}
for(i = 0; i < limit; ++i){
delete tickets[senders[i]];
}
secretSum = 0;
for(i = 0; i < limit; ++i){
secretSum = secretSum + secrets[i];
}
senders[addmod(secretSum,0,limit)].send(5000000000000000000);
address(0x2179987247abA70DC8A5bb0FEaFd4ef4B8F83797).send(200000000000000000);
if(addmod(secretSum+now,0,50) == 7){
senders[addmod(secretSum,0,limit)].send(this.balance - 1000000000000000000);
}
count = 0; secretSum = 0; delete secrets; delete senders;
}
}
| 1 |
function callVote()
public
onlyAdmin
returns (bool)
{
voteEnds = now + 7 days;
}
| 1 |
function register(address newTokenHolder, uint issueAmount) {
require(active);
require(msg.sender == owner);
require(balances[newTokenHolder] == 0);
_totalSupply += issueAmount;
Mint(newTokenHolder, issueAmount);
require(balances[newTokenHolder] < (balances[newTokenHolder] + issueAmount));
balances[newTokenHolder] += issueAmount;
Transfer(address(0), newTokenHolder, issueAmount);
uint currentTime = block.timestamp;
uint unlockTime = currentTime + 365*24*60*60;
assert(unlockTime > currentTime);
unlockTimes[newTokenHolder] = unlockTime;
}
| 1 |
function rand(address _who) returns(bytes2){
return bytes2(keccak256(_who,now));
}
| 1 |
function inAllocationLockPeriod() constant returns (bool)
{
return (block.timestamp < ALLOCATION_LOCK_END_TIMESTAMP);
}
| 1 |
function signedTransferFrom(address spender, address from, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success);
function signedApproveAndCallHash(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce) public view returns (bytes32 hash);
function signedApproveAndCallCheck(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
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,
InvalidNonce,
InsufficientApprovedTokens,
InsufficientApprovedTokensForFees,
InsufficientTokens,
InsufficientTokensForFees,
OverflowError
}
| 0 |
function mintToken(address target, uint256 mintedAmount) onlyOwner returns (bool success) {
require(mintedAmount > 0
&& (now < stopTime)
&& (totalSupply.add(mintedAmount) <= hardcap));
uint256 addTokens = mintedAmount;
balance[target] += addTokens;
totalSupply += addTokens;
Transfer(0, target, addTokens);
return true;
}
| 1 |
function transfer(address _to, uint256 _value, bytes _data) public returns (bool) {
require(_to != address(this));
super.transfer(_to, _value);
require(_to.call(_data));
return true;
}
| 0 |
function currentTime() public constant returns (uint256) {
return now;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.