function string | label int64 |
|---|---|
function transfer(address _to, uint256 _value) public {
if (TransferActive){_transfer(msg.sender, _to, _value);}
} | 0 |
function advisorIssueVesting(address _to, uint _time) onlyIssuer public
{
require(saleTime == false);
require(advisorVestingTime >= _time);
uint time = now;
require( ( ( endSaleTime + (_time * advisorVestingDate) ) < time ) && ( advisorVestingTimeAtSupply[_time] > 0 ) );
uint tokens = advisorVestingTimeAtSupply[_... | 0 |
function allowance(address tokenOwner, address spender) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (boo... | 0 |
function end_ICO() external onlyOwner atStage(Stages.ICO) {
require(now > ico_fourth);
stage = Stages.ENDED;
} | 0 |
function verify(address tokenContract) public view returns (
bool valid,
address owner,
uint decimals,
bool mintable,
bool transferable
) {
valid = _verify[tokenContract];
if (valid) {
BTTSToken t = BTTSToken(tokenContract);
owner = t.owner();
decimals = t.decimals();
mintable = t.mintable();
transferable ... | 0 |
function changeBridge(address _bridge) public onlyOwner {
require(_bridge != address(0x0));
bridge = Bridge(_bridge);
} | 0 |
function unlockFund () public onlyOwner {
require(releaseTimeFund <= block.timestamp);
require(ReserveFundAmount > 0);
uint tokenBalance = token.balanceOf(this);
require(tokenBalance >= ReserveFundAmount);
if (token.transfer(ReserveFund, ReserveFundAmount)) {
ReserveFundAmount = 0;
}
} | 0 |
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) ... | 0 |
function doPurchaseFor(address _sender) payable {
doPurchase(_sender);
} | 0 |
function _getTokenAmount(uint256 _weiAmount)
internal
view
returns (uint256){
super._getTokenAmount(_weiAmount);
uint256 tokens = _weiAmount.mul(rate);
return tokens.add(tokens.mul(10).div(100));
} | 0 |
function createAuction(address _token, uint _tokenId, uint _startPrice, uint _duration) external returns (bool) {
require(isAcceptedToken(_token));
require(_duration >= minDuration && _duration <= maxDuration);
_createAuction(msg.sender, _token, _tokenId, _startPrice, _duration);
return true;
} | 0 |
function times(uint a, uint b) public pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
function kill() public onlyOwner {
require(now < 1522566000);
selfdestruct(owner);
} | 1 |
function unpauseWithdrawal(address _address) onlyOwner external returns (bool) {
withdrawalPaused[_address] = false;
return true;
} | 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 |
function transfer(address _to, uint256 _value) public returns (bool);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
function allowance(address _owner, address _spender) public constant returns (uint25... | 0 |
modifier can_buy(uint id) {
assert(isActive(id));
_
} | 0 |
function register(address key) {
if (records[key].time == 0) {
records[key].time = now;
records[key].owner = msg.sender;
records[key].keysIndex = keys.length;
keys.length++;
keys[keys.length - 1] = key;
numRecords++;
} else {
returnValue();
}
} | 1 |
function getTokenCap() view public returns(uint256)
{
return cap;
} | 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 kill() public onlyOwner {
selfdestruct(owner);
} | 0 |
function unlockAccount(address tokenOwner) public {
data.unlockAccount(tokenOwner);
} | 0 |
function floor() constant returns (uint256);
function ceiling() constant returns (uint256);
function purchase(address _sender, uint256 _value, uint256 _price) public returns (uint256);
function sell(address _from, uint256 _price, uint256 _amountBabz);
function powerBalanceOf(address _owner) constant returns (uint25... | 0 |
constructor() owned() hasAdmins() public {
} | 0 |
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 ... | 0 |
function pullFunds()
external
onlyOwner
returns (bool)
{
IBrickblockToken bbk = IBrickblockToken(
registry.getContractAddress("BrickblockToken")
);
uint256 _companyFunds = bbk.balanceOf(address(bbk));
return bbk.transferFrom(address(bbk), address(this), _companyFunds);
} | 0 |
function approve(address spender, uint value) returns(bool ok);
function allowance(address owner, address spender) constant returns(uint);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract SubToken {
function ... | 0 |
function max256(uint256 a, uint256 b) internal constant returns (uint256)
{
return a >= b ? a : b;
} | 0 |
function transferAdmin(address newAdmin) onlyOwner public {
require(newAdmin != address(0));
emit OwnershipTransferred(admin, newAdmin);
admin = newAdmin;
} | 0 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20OldBasic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(add... | 0 |
function setRequireCustomerId(bool value) public onlyOwner stopInEmergency {
requireCustomerId = value;
InvestmentPolicyChanged(requireCustomerId);
} | 0 |
function getNumber(bytes32 hash) onlyuser internal returns (uint8) {
nonce++;
seed = keccak256(block.timestamp, nonce);
return uint8(keccak256(hash, seed))%(0+9)-0;
} | 1 |
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ApproveAndCallFallBack {
function receiveApproval(address fro... | 0 |
constructor() public{
blackbeard = msg.sender;
} | 0 |
function transfer(address _to, uint256 _value) onlyPayloadSize(2) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
} | 0 |
modifier whenCrowdsaleSuccessful() {
require(isSuccessful());
_;
} | 0 |
modifier onlyMinter() {
require(isMinter(msg.sender), "Minter: caller is not the minter");
_;
} | 0 |
function removeClaim(address issuer, address subject, bytes32 key) public {
require(msg.sender == issuer || msg.sender == subject);
require(registry[issuer][subject][key] != 0);
delete registry[issuer][subject][key];
ClaimRemoved(msg.sender, subject, key, now);
} | 0 |
function SellOrder (uint256 _tokens, uint256 _price, address _challengeOwner) noEther {
owner = msg.sender;
tokens = _tokens;
price = _price;
challengeOwner = _challengeOwner;
} | 0 |
function servicePayment(uint _value) public returns (bool, uint256, uint256) {
require(_value >= currentCost);
require(balanceOf[msg.sender] >= currentCost);
ignPayments[msg.sender].unlockedTime = block.timestamp;
ignPayments[msg.sender].unlockedBlockNumber = block.number;
inrSessions++;
balanceOf[msg.sender] -= ... | 1 |
function registerNameXID(string _nameString, uint256 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all... | 0 |
modifier ReleaseTimeTransfer(address _sender) {
require(now >= timelockAccounts[_sender]);
_;
} | 0 |
function startCrowdsale() public onlyOwner
{
crowdsaleRunning = true;
crowdsaleStartTimestamp = now;
} | 0 |
function approve(address spender, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
} | 0 |
function refund() public;
function updateTokenBalance() public;
function withdrawTokens() public;
function updateEtherBalance() public;
function withdrawEther() public;
}
contract PersonalCrowdsaleProxy is IPersonalCrowdsaleProxy, Dispatchable {
ICrowdsale public targetCrowdsale;
IToken public targetToken;
addre... | 0 |
function areTokensBuyable(uint _roundIndex, uint256 _tokens) internal constant returns (bool)
{
uint256 current_time = block.timestamp;
Round storage round = rounds[_roundIndex];
return (
_tokens > 0 &&
round.availableTokens >= _tokens &&
current_time >= round.startTime &&
current_time <= round.endTime
);
} | 1 |
function pressButton() public onlyWhenStarted payable {
require(msg.value == 10000000000000000 && block.number <= targetBlock);
lastPresser = msg.sender;
targetBlock = targetBlock + 240;
pressCount++;
Pressed(msg.sender, now);
} | 1 |
function safeTransfer(address _oldOwner, uint256 _amount) internal {
assembly {
let x := mload(0x40)
let success := call(
5000,
_oldOwner,
_amount,
x,
0x0,
x,
0x20)
mstore(0x40,add(x,0x20))
}
} | 0 |
function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal {
assert(token.transferFrom(from, to, value));
} | 0 |
function add(uint256 a, uint256 b) pure internal returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
} | 0 |
function start_ICO() public onlyOwner atStage(Stages.NOTSTARTED) {
stage = Stages.ICO;
stopped = false;
startdate = now;
ico_first = now + 5 minutes;
ico_second = ico_first + 5 minutes;
ico_third = ico_second + 5 minutes;
ico_fourth = ico_third + 5 minutes;
} | 0 |
function addAuditor(address _auditor) external onlyOwner {
require(auditors[_auditor].addr == address(0));
auditors[_auditor].banned = false;
auditors[_auditor].addr = _auditor;
auditors[_auditor].completedAudits = 0;
auditors[_auditor].totalEarned = 0;
emit AddedAuditor(_auditor);
} | 0 |
function receiveApproval(address _from, uint256 _value, address _inContract, bytes _extraData) public returns (bool);
}
contract tokenRecipient {
function tokenFallback(address _from, uint256 _value, bytes _extraData) public returns (bool);
}
contract LuckyStrikeTokens {
using SafeMath for uint256;
string public nam... | 0 |
modifier backEnd() {
require(msg.sender == backEndOperator || msg.sender == owner);
_;
} | 0 |
function totalSupply() public view returns (uint) {
return data.totalSupply - data.balances[address(0)];
} | 0 |
function drain() onlyOwner public {
require(depositStartTime > 0 && now >= depositStartTime + DRAIN_DELAY);
uint balance = lrcBalance();
require(balance > 0);
require(Token(lrcTokenAddress).transfer(owner, balance));
emit Drained(balance);
} | 0 |
function popLastByte(bytes memory b)
internal
pure
returns (bytes1 result)
{
require(
b.length > 0,
"GREATER_THAN_ZERO_LENGTH_REQUIRED"
);
result = b[b.length - 1];
assembly {
let newLen := sub(mload(b), 1)
mstore(b, newLen)
}
return result;
} | 0 |
function transferWithReference(address _to, uint _value, string _reference) returns(bool);
function totalSupply() constant returns(uint);
function approve(address _spender, uint _value) returns(bool);
}
contract VestingInterface {
function createVesting(address _receiver, AssetProxyInterface _AssetProxy, uint _amoun... | 0 |
function saveLifeEvent(string name, string description, string mesg) private {
lifeEvents.push(Event(block.timestamp, name, description, mesg));
LifeEvent(name, description, mesg);
eventcount++;
} | 0 |
function transfer(address _to, uint256 _amount)public returns (bool success) {
require( _to != 0x0);
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
Transfer(msg.sender, _to, _amount);
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(numDeposit... | 1 |
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
... | 0 |
function max64(uint64 a, uint64 b) internal pure returns (uint64) {
return a >= b ? a : b;
} | 0 |
function makeKebabs(address ref) public
{
require(initialized);
if(referrals[msg.sender]==0 && referrals[msg.sender]!=msg.sender)
{
referrals[msg.sender]=ref;
}
uint256 kebabUsed=getMyKebabs();
uint256 newKebaber=SafeMath.div(kebabUsed,KEBABER_TO_MAKE_1KEBAB);
workingKebaber[msg.sender]=SafeMath.add(workingKeb... | 0 |
function withdrawEther() public when_beneficiary_is_known {
beneficiary.transfer(this.balance);
} | 0 |
function setup (uint256 _fundingStartTime, uint256 _fundingEndTime, address _token) onlyOwner external {
require (isActive == false);
require (isFinalized == false);
require (msg.sender == owner);
require(_fundingStartTime > 0);
require(_fundingEndTime > 0 && _fundingEndTime > _fundingStartTime);
require(_token !... | 0 |
function delAcceptedToken(address _token) onlyAdmin external {
require(acceptedTokens[_token]);
acceptedTokens[_token] = false;
emit DelAcceptedToken(_token);
} | 0 |
function get_boats() public view returns (
address[10] memory owner,
uint8[10] memory class,
uint8[10] memory variant,
bool[10] memory repellent
){
for(uint boat = 0; boat < 10; boat++){
owner[boat] = races[race_number].boats[boat].owner;
class[boat] = races[race_number].boats[boat].class;
variant[boat] = race... | 0 |
function read() external view returns(bytes32);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
} | 0 |
function 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 authCall(address from, bytes32 hash) external returns (uint8 code) {
if (!masterKeys[from] || !trustedClients[msg.sender]) {
Unauthorized(from);
return 0;
}
if (functionCalling[from] == 0) {
if (functionCalls[uint256(hash)] == 0x0) {
functionCalls[uint256(hash)] = from;
functionCalling[from] = uint256(... | 0 |
function allowance( address _owner, address _spender ) public view returns (uint _allowance);
function transferFrom( address _from, address _to, uint _value) public returns (bool _success);
}
contract VantaToken is ERC20Interface, OwnerHelper
{
using SafeMath for uint;
address private creator;
string public name;
... | 0 |
function release() public {
require(uint64(block.timestamp) >= releaseTime);
uint256 amount = token.balanceOf(this);
require(amount > 0);
token.safeTransfer(beneficiary, amount);
} | 0 |
function CrowdsaleToken(string _name, string _symbol, uint _initialSupply, uint8 _decimals, address _multisig, bool _mintable)
UpgradeableToken(_multisig) MintableToken(_initialSupply, _multisig, _mintable) {
name = _name;
symbol = _symbol;
decimals = _decimals;
} | 0 |
function unlock (uint256 _id) public {
TokenTimeLockInfo memory lockInfo = locks [_id];
delete locks [_id];
require (lockInfo.amount > 0);
require (lockInfo.unlockTime <= block.timestamp);
Unlock (_id);
require (
lockInfo.token.transfer (
lockInfo.beneficiary, lockInfo.amount));
} | 1 |
modifier onlyDepositor() {
require(msg.sender == depositor, "Only the depositor may call this function.");
_;
} | 0 |
function getNorsefirePrice() public view returns(uint256){
return norsefirePrice;
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) onlyPayloadSize(3) public returns (bool success) {
require(_to != address(0));
require(balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0);
balances[_from] = safeSub(balances[_from], _value);
balances[_to] = safeAdd(balan... | 0 |
function _transfer(address _from, address _to, uint _value) internal {
require(_to != address(0x0));
balanceOf[_from] = balanceOf[_from].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
emit Transfer(_from, _to, _value);
} | 0 |
function setSymbol(bytes32 sym) onlyOwnerUnlocked setter {
symbol = sym;
} | 0 |
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 KRCPreSaleContract is Ownable{
using SafeMath for uint256;
... | 0 |
function setUpgradeAgent(address agent) external {
if(!canUpgrade()) {
throw;
}
if (agent == 0x0) throw;
if (msg.sender != upgradeMaster) throw;
if (getUpgradeState() == UpgradeState.Upgrading) throw;
upgradeAgent = UpgradeAgent(agent);
if(!upgradeAgent.isUpgradeAgent()) throw;
if (upgradeAgent.originalSupply(... | 0 |
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 ... | 0 |
function authorize(address _trustee) returns (bool success) {
authorized[msg.sender][_trustee] = true;
Authorization(msg.sender, _trustee);
return true;
} | 0 |
modifier limitedDaily(uint256 _value) {
require(underLimit(_value));
_;
} | 0 |
modifier onlyWhenTransferEnabled() {
if (now <= allowTransferTime) {
require(
msg.sender == tracetoMultiSigContract ||
msg.sender == exchangeIEO
);
}
_;
} | 0 |
function _burnFrom(address account, uint256 amount) internal {
require(amount <= _allowed[account][msg.sender]);
_allowed[account][msg.sender] = _allowed[account][msg.sender].sub(
amount);
_burn(account, amount);
} | 0 |
function createIdentity(address owner, address recoveryKey) public validAddress(recoveryKey) {
Proxy identity = new Proxy();
owners[identity][owner] = now - adminTimeLock;
recoveryKeys[identity] = recoveryKey;
LogIdentityCreated(identity, msg.sender, owner, recoveryKey);
} | 0 |
function _transfer(address _from, address _to, uint _value) internal {
require(balanceOf[_from] >= _value);
uint256 remain = balanceOf[_from].sub(_value);
uint256 length = lockedAddresses[_from].length;
for (uint256 i = 0; i < length; i++) {
LockMeta storage meta = lockedAddresses[_from][i];
if(block.timestamp < ... | 0 |
function lockedPeriod(address addr) public view returns (uint256) {
return _lock_list_period[addr];
} | 0 |
function socialIdentityToCardId(uint256 _socialNetworkType, uint256 _socialId) public view returns (uint256 cardId) {
uint8 _socialNetworkType8 = uint8(_socialNetworkType);
require(_socialNetworkType == uint256(_socialNetworkType8));
uint64 _socialId64 = uint64(_socialId);
require(_socialId == uint256(_socialId64))... | 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 addWallet(address _wallet, string _data) public onlyPrivilegedAddresses {
require(_wallet != address(0));
require(!isWhitelisted(_wallet));
whitelist[_wallet].data = _data;
whitelist[_wallet].whitelisted = true;
whitelist[_wallet].createdTimestamp = now;
whitelistLength++;
} | 0 |
function mint(address _to, string _identity) returns (bool success);
function destroy(bytes32 _id) returns (bool success);
function addMinter(address who) returns (bool);
function removeMinter(address who) returns (bool);
function totalSupply() returns (uint supply);
function transfer(address _to, uint256 _value) ... | 0 |
function investETH(address referral) public payable {
require(now >= launchtime);
require(msg.value >= 0.4 ether);
uint256 timelimit = SafeMath.sub(now, launchtime);
if(timelimit < 1296000 && getProfit(msg.sender) > 0){
reinvestProfit();
}
if(timelimit > 1296000 && getProfit(msg.sender) > 0){
uint256 profit = g... | 0 |
function hold(address who, uint256 quantity) public onlyIssuer {
require(who != address(0x0), "The null address cannot own tokens.");
require(quantity != 0, "Quantity must be greater than zero.");
require(!isExistingHolding(who), "Cannot overwrite an existing holding, use a new wallet.");
Holding memory holding = H... | 0 |
function withdraw_ether() returns (bool) {
uint amount = pending_returns[msg.sender];
if (amount > 0) {
pending_returns[msg.sender] = 0;
if (!msg.sender.send(amount)) {
pending_returns[msg.sender] = amount;
return false;
}
}
return true;
} | 0 |
function getMintRequest(uint nonce)
external
view
returns (
uint requestNonce,
address requester,
uint amount,
string btcDepositAddress,
string btcTxid,
uint timestamp,
string status,
bytes32 requestHash
)
{
Request memory request = mintRequests[nonce];
string memory statusString = getStatusString(reques... | 0 |
function addApproval(address spender, uint addedValue) public returns (bool success) {
uint oldValue = allowed[msg.sender][spender];
allowed[msg.sender][spender] = oldValue.add(addedValue);
Approval(msg.sender, spender, allowed[msg.sender][spender]);
return true;
} | 0 |
function Crowdsale(address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal) internal {
setMultisig(_multisigWallet);
require(_start != 0 && _end != 0);
require(block.number < _start && _start < _end);
startsAt = _start;
endsAt = _end;
minimumFundingGoal = _minimumFundingGoal;
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.