function string | label int64 |
|---|---|
function setRate(uint256 _new_EUR_WEI)
public
onlyRateControl
{
lastUpdate = now;
require(_new_EUR_WEI > 0, "Please assign a valid rate.");
EUR_WEI = _new_EUR_WEI;
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) onlyPayloadSize(3 * 32) onlyIfTransfersAllowed {
var _allowance = allowed[_from][msg.sender];
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_fr... | 0 |
function submitEntry(bytes _hash, string note) public {
require(entries[_hash].timestamp == 0);
entries[_hash] = Entry(msg.sender, now, note);
} | 1 |
function currentTime() constant returns (uint _currentTime) {
return now;
} | 1 |
function approve(address spender, uint256 value) public 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 =>... | 0 |
function mintAdminApproval(address _address, uint256 _value) public onlyAdmin {
if (mintApprove[_address].amount > 0) {
require(mintApprove[_address].amount == _value, "Value is diferent");
}
else {
mintApprove[_address].amount = _value;
}
mintApprove[_address].admin = msg.sender;
if ((mintApprove[_address].aud... | 0 |
function getBalance() public view returns(uint256){
return address(this).balance;
} | 0 |
function tokenFallback(address player, uint256 amount, bytes calldata data)
external
updateDividends
{
require(msg.sender == P3X_ADDRESS);
if(data[0] == 0) {
fundPot(player, amount);
} else {
placeBet(player, amount, uint8(data[0]));
}
} | 0 |
function convert() public returns (bool) {
uint256 senderBalance = Token1st(token1stContract()).getBalanceOf(msg.sender);
require(Token1st(token1stContract()).allowance(msg.sender, this) >= senderBalance);
Token1st(token1stContract()).transferDecimalAmountFrom(msg.sender, owner, senderBalance);
return Token(tokenCo... | 0 |
function removeSuperAdmin(address _admin) public onlyOwner validateAddress(_admin){
require(superAdmins[_admin]);
superAdmins[_admin] = false;
emit RemoveSuperAdmin(_admin);
} | 0 |
function token1stContract() view internal returns (address) {
return web.getContractAddress("Token1st");
} | 0 |
function setTokenUnlock() onlyOwner public
{
require(tokenLock == true);
require(saleTime == false);
tokenLock = false;
} | 0 |
function ZYHToken() public {
balances[msg.sender] = TOTAL_SUPPLY;
totalSupply = TOTAL_SUPPLY;
transfer(WALLET_ECOSYSTEM, ALLOC_ECOSYSTEM);
} | 0 |
function balanceOf(address who) constant returns (uint);
function transfer(address to, uint value);
event Transfer(address indexed from, address indexed to, uint value);
}
contract ERC20 is ERC20Basic
{
function allowance(address owner, address spender) constant returns (uint);
function transferFrom(address from, a... | 0 |
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
function isTokenOwner(address _owner) constant returns (bool);
function identityOf(bytes32 _id) constant returns (string identity);
function ownerOf(bytes32 _id) constant returns (address owner);
}
contract Devcon2Token is Tok... | 0 |
function ownerResumeContract() external onlyOwner {
require(contractPaused);
contractPaused = false;
} | 0 |
function updateInvestorFunds(uint tokenAmount, uint weiAmount, address receiver, uint128 customerId) private {
investedAmountOf[receiver] = investedAmountOf[receiver].add(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].add(tokenAmount);
weiRaised = weiRaised.add(weiAmount);
tokensSold = tokensSold.add... | 0 |
function setPaycarnita(uint256 _newPaycarnita) onlyManager public{
toPaycarnita=_newPaycarnita;
} | 0 |
constructor() public
{
owner1 = msg.sender;
} | 0 |
function hasRole(address _from, bytes32 _role, address _to) constant returns(bool);
function isOwner(address _node, address _owner) constant returns(bool);
}
contract Ambi2Enabled {
Ambi2 ambi2;
modifier onlyRole(bytes32 _role) {
if (address(ambi2) != 0x0 && ambi2.hasRole(this, _role, msg.sender)) {
_;
}
} | 0 |
function transferFrom( address _from, address _to, uint256 _amount )public returns (bool ok) {
require( _to != 0x0);
require(balances[_from] >= _amount && allowed[_from][msg.sender] >= _amount && _amount >= 0);
balances[_from] = (balances[_from]).sub(_amount);
allowed[_from][msg.sender] = (allowed[_from][msg.sender... | 0 |
function allocateTokens(address participant, uint256 amountTokens) private {
require(vestingSet);
uint256 precision = 10**18;
uint256 allocationRatio = safeMul(amountTokens, precision) / 570000000;
uint256 developmentAllocation = safeMul(allocationRatio, 380000000) / precision;
uint256 newTokens = safeAdd(amountTo... | 0 |
function transfer(address to, uint256 value) public canTransfer(to) returns (bool) {
require(isLockedForMV[msg.sender] < now);
require(value <= _balances[msg.sender]);
_transfer(to, 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 valu... | 0 |
function subApproval(address _spender, uint _subtractedValue) public
returns (bool success) {
uint oldVal = allowed[msg.sender][_spender];
if (_subtractedValue > oldVal) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldVal.sub(_subtractedValue);
}
Approval(msg.sender, _spender, a... | 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 hasBoughtEgg(address _buyer) view external returns (bool) {
return eggOwners[_buyer] == true;
} | 0 |
function PallyCoin() {
balances[msg.sender] = initialSupply;
} | 0 |
function payFee()
external
payable
returns (bool);
}
interface IAccessToken {
function lockBBK(
uint256 _value
)
external
returns (bool);
function unlockBBK(
uint256 _value
)
external
returns (bool);
function transfer(
address _to,
uint256 _value
)
external
returns (bool);
function distribute(
uint... | 0 |
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);
}
l... | 0 |
function transfer(address _to, uint256 _value, bytes _data)public returns (bool success) {
require(hasTrade());
require(_to != address(0));
if(isContract(_to)) {
transferToContract(_to, _value, _data);
}
else {
transferToAddress(_to, _value, _data);
}
return true;
} | 0 |
function BTCPToken() public payable {
startTime = now;
owner = msg.sender;
balances[owner] = _totalSupply;
} | 1 |
function transfer(address _to, uint _value) returns(bool) {
if (now < presaleDeadline) {
require(assetProxy.transferFrom(msg.sender, address(this), _value));
require(vesting.createVesting(_to, assetProxy, _value, 1, paymentInterval, schedule));
return true;
}
return assetProxy.transferFrom(msg.sender, _to, _value... | 0 |
function burn(uint256 _value)public returns (bool success) {
if (balanceOf[msg.sender] < _value) revert();
if (_value <= 0) revert();
balanceOf[msg.sender] = SafeMath.safeSub(balanceOf[msg.sender], _value);
totalSupply = SafeMath.safeSub(totalSupply,_value);
emit Burn(msg.sender, _value);
return true;
} | 0 |
function init_claim(uint256 balance) private atStage(Stages.initClaim) {
firstRelease = now + 26 weeks;
secondRelease = firstRelease + 26 weeks;
thirdRelease = secondRelease + 26 weeks;
fourthRelease = thirdRelease + 26 weeks;
uint256 amountToTransfer = safeMul(balance, 53846153846) / 100000000000;
ERC20Token.tra... | 0 |
function NokuTokenBurner(address _wallet) public {
require(_wallet != address(0));
wallet = _wallet;
burningPercentage = 100;
LogNokuTokenBurnerCreated(msg.sender, _wallet);
} | 0 |
function vestCmdNow1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, 0, unlock100Days);
} | 0 |
function freezeTokensToInvestor(address _investorAddress, uint256 _tokenAmount, uint256 _daysToFreeze) public returns (bool) {
require(_investorAddress != address(0));
require(_tokenAmount != 0);
require(!investors[_investorAddress].isInvestor);
_daysToFreeze = _daysToFreeze.mul(1 days);
investors[_investorAddress... | 0 |
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success);
function signedTransferHash(address tokenOwner, address to, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash);
function signedTransferCheck(address tokenOwner, address to, uint tokens, uint fee, uint n... | 0 |
function withdraw() public {
uint256 currBalance = token.balanceOf(this);
uint256 currLocking = getCurrLocking();
require(currBalance > currLocking);
uint256 available = currBalance.sub(currLocking);
token.transfer(wallet_A, available.mul(60).div(100));
token.transfer(wallet_B, available.mul(30).div(100));
token... | 0 |
function calcTransferFee(uint256 _amount) public view returns (uint256) {
uint256 fee = 0;
fee = _amount.div(decimalpercent);
fee = fee.mul(transferFee.prop);
fee = fee.add(transferFee.abs);
return fee;
} | 0 |
function setClaim(address subject, bytes32 key, bytes32 value) public {
registry[msg.sender][subject][key] = value;
ClaimSet(msg.sender, subject, key, value, now);
} | 0 |
function changeState(uint256 _id, uint8 _state) public onlyEpisodeManager returns (bool) {
require(started);
require(!gameOver);
require(!gameOverByUser);
require(_id > 0 && _id <= cap);
require(_state <= 1);
require(citizens[_id].state != _state);
citizens[_id].state = _state;
TokenState(_id, _state);
timesta... | 0 |
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 ... | 0 |
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)... | 0 |
function upgradeFrom(address _from, uint256 _value) public;
}
contract UpgradeableToken is StandardTokenExt {
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint256 public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade(address index... | 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 signedTransferFromCheck(Data storage self, address tokenContract, address spender, address from, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (BTTSTokenInterface.CheckResult result) {
if (!self.transferable) return BTTSTokenInterface.CheckResult.NotTransfer... | 0 |
function authorizedPower() constant returns (uint256);
function powerTotalSupply() constant returns (uint256);
function powerUp(address _sender, address _from, uint256 _amountBabz) public;
function downTick(address _owner, uint256 _now) public;
function createDownRequest(address _owner, uint256 _amountPower) public... | 0 |
function calculateRewards() public view returns(uint256,uint256) {
uint256 tokenRewardPart = IWingsController(manager).tokenRewardPart();
uint256 ethRewardPart = IWingsController(manager).ethRewardPart();
uint256 tokenReward = totalSold.mul(tokenRewardPart) / 1000000;
bool hasEthReward = (ethRewardPart != 0);
uint... | 0 |
function isSane() public constant returns (bool);
function finalizeCrowdsale();
}
contract ERC20 {
uint public totalSupply;
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... | 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 constant returns (uint256 remaining);
event Transfer(address indexed _from, ad... | 0 |
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 pub... | 0 |
modifier isBeforeDeadline(uint _bountyId) {
require(now < bounties[_bountyId].deadline);
_;
} | 0 |
function Paygine() {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
PaygineHasDeployed(now);
} | 1 |
function setWhitelistContract(HoloWhitelist _whitelistContract) external onlyOwner {
whitelistContract = _whitelistContract;
} | 0 |
function signedTransferFromCheck(address spender, address from, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function signedTransferFrom(address spender, address from, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount... | 0 |
function deductFullBalance(uint tokenCode, address addr) private returns (uint amount) {
uint176 tokenAccount = uint176(tokenCode) << 160 | uint176(addr);
amount = tokenAmounts[tokenAccount];
tokenAmounts[tokenAccount] = 0;
} | 0 |
function burnRemainingTokens() onlyOwner external {
require(now > fundingEndTime);
uint256 tokensToBurn = tokenReward.balanceOf(this);
tokenReward.burn(tokensToBurn);
} | 0 |
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
} | 1 |
function createReserveTokensVault() external onlyOwner {
require(reserveTokensVault == address(0));
uint256 reserveTokens = 400000000;
reserveTokensVault = createTokenVaultInt(reserveTokens);
require(totalSupply_ <= HARD_CAP);
} | 0 |
constructor () public {
highScore = 0;
currentWinner = msg.sender;
lastTimestamp = now;
} | 0 |
function mintTokensFor(address beneficiaryAddress, uint256 amountOfTokens)
public
onlyOwner
{
require(beneficiaryAddress != address(0));
require(token.totalSupply().add(amountOfTokens) <= TOTAL_TOKENS_FOR_CROWDSALE);
_deliverTokens(beneficiaryAddress, amountOfTokens);
emit MintedTokensFor(beneficiaryAddress, amo... | 0 |
function safeDiv(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
require(a == b * c + a % b);
return c;
} | 0 |
function burn(uint burnAmount) {
address burner = msg.sender;
balances[burner] = balances[burner].sub(burnAmount);
totalSupply_ = totalSupply_.sub(burnAmount);
Burned(burner, burnAmount);
Transfer(burner, BURN_ADDRESS, burnAmount);
} | 0 |
function buyTokens(address beneficiary) public payable {
require(!isFinalized);
require(beneficiary == msg.sender);
require(msg.value != 0);
require(msg.value >= individualCap);
uint256 weiAmount = msg.value;
require(isWhiteListedAddress(beneficiary));
require(validPurchase(weiAmount));
weiRaised = weiRaised.ad... | 0 |
modifier onlyMerchant() {
require(controller.isMerchant(msg.sender), "sender not a merchant.");
_;
} | 0 |
function setCrowdsaleActive(bool _crowdsaleActive) public {
require(msg.sender == tokenOwner);
crowdsaleActive = _crowdsaleActive;
} | 0 |
function ZZZToken() public {
balances[msg.sender] = TOTAL_SUPPLY;
totalSupply = TOTAL_SUPPLY;
transfer(WALLET_ECOSYSTEM, ALLOC_ECOSYSTEM);
} | 0 |
function Ownable() public {
ownerOne = msg.sender;
ownerTwo = msg.sender;
} | 0 |
function isEnded() public view returns (bool);
function hasBalance(address _beneficiary, uint _releaseDate) public view returns (bool);
function balanceOf(address _owner) public view returns (uint);
function ethBalanceOf(address _owner) public view returns (uint);
function refundableEthBalanceOf(address _owner) pub... | 0 |
function _addPauser(address account) internal {
_pausers.add(account);
emit PauserAdded(account);
} | 0 |
function participantClawbackEther(uint256 value) external {
require(contractRefundStarted);
require(!contractRefundFinished);
uint256 totalContribution = contributionOf[msg.sender];
uint256 alreadyRefunded = refundOf[msg.sender];
uint256 maxWithdrawalAmount = totalContribution.sub(alreadyRefunded);
require(maxWit... | 0 |
function checkBetNumber(uint8 result) private
{
bool win;
if (result==gambles[gambleIndex[msg.sender]].input)
{
win=true;
}
solveBet(msg.sender, result,win,36);
} | 0 |
function setEndsAt(uint time) onlyOwner {
if(now > time) {
throw;
}
endsAt = time;
EndsAtChanged(endsAt);
} | 0 |
function getIdeasSinceLastDeploy(address adr) public view returns(uint256){
uint256 secondsPassed=min(clones_to_create_one_idea, now.sub(lastDeploy[adr]));
return secondsPassed.mul(arrayOfClones[adr]);
} | 0 |
function setContractAllowance(address allowedAddress, uint256 allowedAmount) onlyOwner public returns (bool success) {
require(allowedAmount <= totalSupply);
allowance[this][allowedAddress] = allowedAmount;
return true;
} | 0 |
function nextForkBlockNumber()
public
constant
returns (uint256)
{
return _nextForkBlockNumber;
} | 0 |
function burn(uint256 value) public {
_burn(msg.sender, value);
} | 0 |
function proportionalAmount(uint256 agreementId) private view returns (uint256) {
(uint256 start, uint256 duration, ) = decodeMeta(agreements[agreementId].meta);
if (block.timestamp >= start.add(duration)) {
return agreements[agreementId].totalAmount;
} else if (block.timestamp <= start) {
return 0;
} else {
ret... | 0 |
function setRate(uint256 _rate) onlyOwner public {
require(_rate > 0 && _rate < 1000000);
rate = _rate;
} | 0 |
function getIndexfromQA(uint256 questionId, uint256 textId)
public view
returns (uint256) {
require (questionId < numberOfQuestions);
require (textId < _supplyPerQ[questionId]);
return _theQAtoIndex[questionId][textId];
} | 0 |
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 Stan... | 0 |
function deposit() private {
if (msg.value > 0) {
if (balance[msg.sender] == 0) {
countOfInvestors += 1;
}
if (balance[msg.sender] > 0 && now > time[msg.sender].add(stepTime)) {
collectPercent();
percentWithdraw[msg.sender] = 0;
}
balance[msg.sender] = balance[msg.sender].add(msg.value);
time[msg.sender] = no... | 0 |
function setEndingBlock(uint endingBlock) public onlyOwner notFinished {
require(endingBlock > block.number && endingBlock > startsAt);
endsAt = endingBlock;
} | 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 ind... | 0 |
function hasStarted() public constant returns (bool) {
return now >= startTime;
} | 0 |
function Owned() public {
owner = msg.sender;
} | 0 |
function approve(address _spender, uint256 _value) public returns (bool);
function allowance(address _owner, address _spender) public constant returns (uint256);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value... | 0 |
function setIntervalSchedulePresale(uint _paymentInterval, uint _schedule, uint _presaleDeadline) onlyRole('admin') returns(bool) {
paymentInterval = _paymentInterval;
schedule = _schedule;
presaleDeadline = _presaleDeadline;
return true;
} | 0 |
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint25... | 0 |
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);
}
pragma solidit... | 0 |
function decreaseApproval (address _spender, uint _subtractedValue) public whenNotPaused
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 A... | 0 |
function verifyMatchDetails(OrderDetails memory _buy, OrderDetails memory _sell) internal pure returns (bool) {
if (!verifyTokens(_buy.tokens, _sell.tokens)) {
return false;
}
if (_buy.price < _sell.price) {
return false;
}
if (_buy.volume < _sell.minimumVolume) {
return false;
}
if (_sell.volume < _buy.minim... | 0 |
function allowance(address _owner, address _spender) external constant returns (uint remaining) {
return allowed[_owner][_spender];
} | 0 |
function releaseToken(address accountAddress) private returns (bool) {
require(accountAddress != address(0x0), "accountAddress not right");
Account memory _account = accountMapping[accountAddress];
if(_account.ownAmount == 0){
return true;
}
if(_account.releasedAmount == _account.ownAmount){
return true;
}
uin... | 0 |
function TokenTimelock(ERC20Basic _token, address _beneficiary, uint256 _releaseTime) {
require(_releaseTime > now);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
} | 0 |
function unlock() external {
if(now < unlockDate) throw;
uint256 entitled = allocations[msg.sender];
allocations[msg.sender] = 0;
if(!StandardToken(INDI).transfer(msg.sender, entitled * exponent)) throw;
} | 1 |
function transfer(address _to, uint256 _value) public ReleaseTimeTransfer(msg.sender) returns (bool success) {
return super.transfer(_to, _value);
} | 0 |
function setStartingBlock(uint startingBlock) public onlyOwner inState(State.PreFunding) {
require(startingBlock > block.number && startingBlock < endsAt);
startsAt = startingBlock;
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.