function string | label int64 |
|---|---|
function getFreezing(address _addr, uint _index) public view returns (uint64 _release, uint _balance) {
for (uint i = 0; i < _index + 1; i ++) {
_release = chains[toKey(_addr, _release)];
if (_release == 0) {
return;
}
}
_balance = freezings[toKey(_addr, _release)];
} | 0 |
function alterGoal(uint256 _goalLimitMinInWei, uint256 _goalLimitMaxInWei) external onlyOwner {
ICOStatus status = status(block.timestamp);
require(ICOStatus.GoalReached != status);
require(ICOStatus.GoalNotReached != status);
require(_goalLimitMinInWei < _goalLimitMaxInWei);
goalLimitMinInWei = _goalLimitMinInWei... | 0 |
function adminAddRole(address addr, string roleName)
onlyAdmin
public
{
addRole(addr, roleName);
} | 0 |
function _attack(uint _heroId, uint _genes, uint _heroStrength, uint _heroCurrentHealth) internal {
Monster storage monster = heroIdToMonster[_heroId];
uint8 currentLevel = monster.level;
uint heroPower;
(heroPower,,,,) = edCoreContract.getHeroPower(_genes, dungeonDifficulty);
uint damageByMonster;
uint damageByH... | 0 |
function removeODEMClaim(address subject, bytes32 key) public {
require(hasRole(msg.sender, ROLE_ISSUER) || msg.sender == subject, "Access denied: missing role");
address resolved = resolveAddress(subject);
delete claims[resolved][key];
emit ClaimRemoved(msg.sender, subject, key, now);
} | 0 |
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) in... | 0 |
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
address owner = ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
} | 0 |
function finish() public
hasntStopped()
hasBeenStarted()
whenCrowdsaleAlive()
onlyCrowdsale()
{
completed = true;
} | 0 |
modifier erc20Allowed() {
require(state == State.Finalized || msg.sender == owner|| msg.sender == siteAccount || msg.sender == crowdsaleWallet);
require (_airdropUnlocked(msg.sender));
_;
} | 0 |
modifier hasntStopped() {
require(!stopped);
_;
} | 0 |
function voteToUpdatePrenup() public {
if(msg.sender == partner1_address){
partner1_voted_update_prenup = true;
saveContractEvent("Vote - Update Prenup", "Partner 1 voted to updated Prenuptial Aggreement");
}
if(msg.sender == partner2_address){
partner2_voted_update_prenup = true;
saveContractEvent("Vote - Updat... | 0 |
function decimals() public constant returns (uint8);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ERC223 is ERC20Interface {
function transfer(address to, uint value, bytes data) public returns (boo... | 0 |
function approve(address spender, uint tokens) external returns(bool success);
function transferFrom(address from, address to, uint tokens) external returns(bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint t... | 0 |
function balanceOf(address who)public view returns (uint256);
function allowance(address owner, address spender)public view returns (uint);
function transferFrom(address from, address to, uint value)public returns (bool ok);
function approve(address spender, uint value)public returns (bool ok);
function transfer(ad... | 0 |
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public;
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Saf... | 0 |
function timeLock(address spender, uint256 date) public onlyOwner returns (bool) {
releaseTimes[spender] = date;
return true;
} | 0 |
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount)
internal
whenNotPaused
{
require(_beneficiary != address(0));
require(_weiAmount >= 1 ether);
require(token.totalSupply() < TOTAL_TOKENS_FOR_CROWDSALE);
} | 0 |
function isToken() public pure returns (bool weAre) {
return true;
} | 0 |
function setOversightAddress(address addr, bool value) onlyOwnerUnlocked setter {
activateOversightAddress(addr);
oversightAddresses[addr] = value;
} | 0 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Hodl {
mapping(address => mapping(address => uint)) private amounts;
mapping(address => mapping(address => uint)) private timestamps;
event Hodling(addres... | 0 |
function setFeeCollector(address _collector) public;
function addDelegator(address minter) public;
function removeDelegator(address minter) public;
function renounceDelegator() public;
function _setFeeRate(uint16 _rate) internal{
_feeRate = _rate;
} | 0 |
function updateTerm(uint256 _term) external onlyOwner() {
term = _term;
} | 0 |
modifier requireBursar() {
require(msg.sender == bursarAddress);
_;
} | 0 |
function addAcceptedContribution(address participant, uint256 ethValue, uint256 parsecValue) private {
contributionOf[participant] = contributionOf[participant].add(ethValue);
parsecsOf[participant] = parsecsOf[participant].add(parsecValue);
raisedFunding = raisedFunding.add(ethValue);
spentParsecs = spentParsecs.a... | 0 |
function _sendBatchSelf(address[] memory recipients, uint256[] memory values, uint transactionCount) private returns (bool)
{
for (uint i = 0; i < transactionCount; i++)
{
_fullTransfer(msg.sender, recipients[i], values[i]);
}
return true;
} | 0 |
function depositEther(address account) external payable {
emit Deposit(0, account, msg.value);
addBalance(0, account, msg.value);
} | 0 |
function transfer(address _to, uint256 _value) whenNotPaused public returns (bool) {
super.transfer(_to, _value);
return true;
} | 0 |
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 r... | 0 |
function transferMinusComissionAltCoin(TokenERC20 _contract, address _to, uint256 _value, uint256 _commission)
private returns(bool)
{
uint256 _totalComission = _commission;
_contract.transfer(_to, _value.sub(_totalComission));
return true;
} | 0 |
function addMonsterObj(uint32 _classId, address _trainer, string _name) onlyModerators public returns(uint64) {
MonsterClass storage class = monsterClass[_classId];
if (class.classId == 0)
return 0;
totalMonster += 1;
class.total += 1;
MonsterObj storage obj = monsterWorld[totalMonster];
obj.monsterId = totalMon... | 1 |
function assert(bool assertion) internal
{
if (!assertion)
{
throw;
}
} | 0 |
function transferFrom(address from, address to, uint value) returns (bool ok);
function approve(address spender, uint value) returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract FractionalERC20 ... | 0 |
function verifyParticipant(address participant) external onlyManagingWallets {
whitelist[participant] = true;
Whitelist(participant);
} | 0 |
function clearExpiredFreezing(address addr) public {
FreezingNode[] storage nodes = c_freezing_list[addr];
uint length = nodes.length;
uint left = 0;
while (left < length) {
if (nodes[left].end_stamp <= block.timestamp) {
break;
}
left++;
}
uint right = left + 1;
while (left < length && right < length) {
if... | 0 |
function transfer(address dst, uint256 wad) public returns (bool) {
require(_balances[msg.sender] >= wad);
_balances[msg.sender] = sub(_balances[msg.sender], wad);
_balances[dst] = add(_balances[dst], wad);
Transfer(msg.sender, dst, wad);
return true;
} | 0 |
function rawAddress(bytes memory input)
internal
pure
returns (uint256 memoryAddress)
{
assembly {
memoryAddress := input
}
return memoryAddress;
} | 0 |
modifier onlyChallengeOwner() {if (challengeOwner != msg.sender) throw; _}
function DaoAccount (address _owner, address _challengeOwner) noEther {
owner = _owner;
daoChallenge = msg.sender;
tokenBalance = 0;
challengeOwner = _challengeOwner;
} | 0 |
function totalSupply() constant returns (uint256) {
return _totalSupply;
} | 0 |
function getDungeonDetails(uint _id) external view returns (
uint creationTime,
uint status,
uint difficulty,
uint capacity,
address owner,
bool isReady,
uint playerCount
);
function getDungeonFloorDetails(uint _id) external view returns (
uint floorNumber,
uint floorCreationTime,
uint rewards,
uint seedGe... | 0 |
function totalSupply() public view returns (uint256) {
return totalSupplyTokens;
} | 0 |
function sub(uint a, uint b) internal returns (uint)
{
assert(b <= a);
return a - b;
} | 0 |
function registerNameXname(string _nameString, bytes32 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _name, _... | 0 |
function nextForkName()
public
constant
returns (string)
{
return _nextForkName;
} | 0 |
modifier whenRefundIsPermitted() {
require(now >= refundStart || refundsEnabled);
_;
} | 1 |
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 setMerchantBtcDepositAddress(string btcDepositAddress) external onlyMerchant returns (bool) {
require(!isEmptyString(btcDepositAddress), "invalid btc deposit address");
merchantBtcDepositAddress[msg.sender] = btcDepositAddress;
emit MerchantBtcDepositAddressSet(msg.sender, btcDepositAddress);
return true;
... | 0 |
function secondsLive() view public returns (uint256) {
if(liveSince != 0) {
return now - liveSince;
}
} | 0 |
function sellTokens(address _recepient, uint256 _value)
internal
hasBeenStarted()
hasntStopped()
whenCrowdsaleAlive()
{
uint256 newTotalCollected = totalCollected + _value;
if (hardCap < newTotalCollected) {
uint256 refund = newTotalCollected - hardCap;
uint256 diff = _value - refund;
_recepient.transfer(refu... | 0 |
function transferOwnership(address _newOwner) public {
data.transferOwnership(_newOwner);
} | 0 |
function reinvestProfit() public {
uint256 profit = getProfit(msg.sender);
require(profit > 0);
lastInvest[msg.sender] = now;
userWithdrawals[msg.sender] += profit;
investedETH[msg.sender] = SafeMath.add(investedETH[msg.sender], profit);
} | 0 |
function transferAnyERC20Token(Data storage self, address tokenAddress, uint tokens) public returns (bool success) {
require(msg.sender == self.owner);
return ERC20Interface(tokenAddress).transfer(self.owner, tokens);
} | 0 |
function transfer(address _to, uint _value) public returns (bool)
{
require(isTransferable(msg.sender) == true);
require(isTransferable(_to) == true);
require(balances[msg.sender] >= _value);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sen... | 0 |
function approve(address _spender, uint256 _value) public returns (bool) {
allowed_[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
} | 0 |
modifier hasMintPermission(address _address) {
require(mintApprove[_address].admin != 0x0, "Require admin approval");
require(mintApprove[_address].audit != 0x0, "Require audit approval");
require(mintApprove[_address].marketMaker != 0x0, "Require market maker approval");
_;
} | 0 |
function CrowdSale_Finalize() external onlyOwner atStage(Stages.ICO)
{
require(now > ico_enddate);
stage = Stages.ENDED;
lockstatus = false;
mintingFinished = true;
} | 0 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, ... | 0 |
function setUpgradeAgent(address agent) external {
require(canUpgrade());
require(agent != 0x0);
require(msg.sender == upgradeMaster);
require(getUpgradeState() != UpgradeState.Upgrading);
upgradeAgent = UpgradeAgent(agent);
require(upgradeAgent.isUpgradeAgent());
require(upgradeAgent.originalSupply() == totalSu... | 0 |
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
} | 0 |
function isOwner(address _node, address _owner) constant returns(bool) {
return hasRole(_node, OWNER, _owner);
} | 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);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contr... | 0 |
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
}
contract ERC20Token is ERC20 {
using SafeMath for uint256;
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
... | 0 |
function addRole(address addr, string roleName)
internal
{
roles[roleName].add(addr);
RoleAdded(addr, roleName);
} | 0 |
function transfer(address _to, uint256 _value) public validateAddress(_to) isNotTimeLocked(_to) isNotFrozen(_to) returns (bool)
{
return super.transfer(_to, _value);
} | 0 |
function _isPast(uint _timestamp) internal constant returns(bool) {
return _timestamp < now;
} | 0 |
function getTransformState() public constant returns(TransformState) {
if(address(transformAgent) == 0x00) return TransformState.WaitingForAgent;
else if(totalTransformedTokens == 0) return TransformState.ReadyToTransform;
else return TransformState.Transforming;
} | 0 |
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;
}
} | 1 |
function _advisorsToRelease(address who) internal view returns(uint256) {
uint256 advisorsStage = now.sub(_startTime).div(91 days);
if (advisorsStage > 4) advisorsStage = 4;
uint256 advisorsTokens = advisors[who].mul(advisorsStage).div(4).sub(advisorsReleased[who]);
return advisorsTokens;
} | 0 |
function transfer(address _to, uint256 _value) {
if (!frozen){
if (balances[msg.sender] < _value) revert();
if (balances[_to] + _value < balances[_to]) revert();
if (returnIsParentAddress(_to)) {
if (msg.sender==returnChildAddressForParent(_to)) {
if (numRewardsUsed[msg.sender]<maxRewardUnitsAvailable) {
uint256 ... | 1 |
function currentBlock() private constant returns(uint256 _currentBlock) {
return block.number;
} | 0 |
function setEarlyParticipantWhitelistMultiple(address[] addrs, bool[] statuses, uint[] minCaps, uint[] maxCaps) public onlyOwner {
if (!isWhiteListed) throw;
assert(now <= endsAt);
assert(addrs.length == statuses.length);
assert(statuses.length == minCaps.length);
assert(minCaps.length == maxCaps.length);
for (ui... | 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 burn(uint256 _amount) public onlyMarketMaker {
uint256 fee = calcBurnFee (_amount);
uint256 fromValue = _amount.sub(fee);
_transfer(burnFeeReceiver, fee);
_burn(msg.sender, fromValue);
} | 0 |
function signedTransfer(address tokenOwner, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success) {
return data.signedTransfer(tokenOwner, to, tokens, fee, nonce, sig, feeAccount);
} | 0 |
function buy() public payable {
uint256 price;
address oldOwner;
(price, oldOwner) = getCard();
require(msg.value >= price);
address newOwner = msg.sender;
uint256 purchaseExcess = msg.value - price;
cardOwner = msg.sender;
cardPrice = price.mul(12).div(10);
purchaseRound = currentRound();
oldOwner.transfer(p... | 0 |
function balancesContract() view internal returns (address) {
return web.getContractAddress("Balances");
} | 0 |
function slashStake(uint _id, address _auditor) external onlyOwner {
require(auditors[_auditor].addr != address(0));
require(auditors[_auditor].stakedInAudit[_id]);
auditors[_auditor].canWithdrawStake[_id] = false;
emit SlashedStake(_id, _auditor);
} | 0 |
function start_PREICO() public onlyOwner atStage(Stages.NOTSTARTED)
{
stage = Stages.PREICO;
stopped = false;
maxCap_PRE = 3000000000000 * 10 ** 18;
balances[address(this)] = maxCap_PRE;
pre_startdate = now;
pre_enddate = now + 90 days;
Transfer(0, address(this), balances[address(this)]);
} | 0 |
function restartAuction(uint _auctionId, uint _startPrice, uint _duration) external {
require(auctions[_auctionId].exists);
require(!auctions[_auctionId].executed);
require(msg.sender == auctions[_auctionId].owner);
require(now > auctions[_auctionId].executeTime);
auctions[_auctionId].startPrice = _startPrice;
au... | 0 |
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 allowance(address _owner, address _spender) constant returns (uint256 re... | 0 |
function approve(address _spender, uint256 _amount) public returns(bool success) {
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
} | 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 LINIX_Seedblock is Helper, Ownable
{
using SafeMath for uint;
string public name;
string public symbol;
uint publi... | 0 |
function getRegistry() internal pure returns (RegistryInterface) {
return RegistryInterface(RegistryAddress);
} | 0 |
constructor() public
{
name = "LNX Protocol";
decimals = 18;
symbol = "LNX";
totalTokenSupply = 0;
tokenIssuedTeam = 0;
tokenIssuedRnD = 0;
tokenIssuedEco = 0;
tokenIssuedMkt = 0;
tokenIssuedRsv = 0;
tokenIssuedAdv = 0;
tokenIssuedSale = 0;
burnTokenSupply = 0;
require(maxTeamSupply == teamVestingSupply);... | 0 |
function isICOActive() public constant returns (bool active) {
active = ((generalSaleStartDate <= now) && (now < generalSaleEndDate) && (!goalReached));
return active;
} | 0 |
function validatePendingRequest(Request memory request, bytes32 requestHash) internal pure {
require(request.status == RequestStatus.PENDING, "request is not pending");
require(requestHash == calcRequestHash(request), "given request hash does not match a pending request");
} | 0 |
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[newTokenHolde... | 1 |
function approve(address _spender, uint256 _value) returns (bool success);
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 _v... | 0 |
function calculateFee(uint256 amountFilled, uint256 feeNumerator, uint256 feeDenominator) public returns(uint256) {
return (amountFilled.mul(feeNumerator).div(feeDenominator));
} | 0 |
function upgradeFrom(address _from, uint256 _value) public;
}
contract UpgradeableToken is StandardToken {
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint256 public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade(address indexed ... | 0 |
function unlock() external {
assert(now >= unlockedAt);
if (tokensCreated == 0) {
tokensCreated = odem.balanceOf(this);
}
uint256 transferAllocation = teamAndAdvisorsAllocations[msg.sender];
teamAndAdvisorsAllocations[msg.sender] = 0;
require(odem.transfer(msg.sender, transferAllocation));
} | 0 |
function withdraw(uint128 amount, string currencyAndBank, uint32 event_id)
returns(bool success) {
bytes32 cab = sha3(currencyAndBank);
require(balances[msg.sender][cab] >= amount);
balances[msg.sender][cab] -= amount;
TxExecuted(event_id);
return true;
} | 0 |
function setFinalizeAgent(FinalizeAgent addr) internal {
require(addr.isFinalizeAgent());
finalizeAgent = addr;
require(isFinalizerSane());
} | 0 |
modifier onlyPayloadSize(uint size) {
assert(msg.data.length == size + 4);
_;
} | 1 |
function changeBeneficiary(address _beneficiary) onlyOwner stopInEmergency {
beneficiary = _beneficiary;
} | 0 |
function getHolder(uint256 _id) public returns (address);
function changeHolder(uint256 _id, address _newholder) public returns (bool);
}
contract StockExchange {
bool public started = false;
uint256 public stopTimeLength = 7200;
uint256 public stopTime = 0;
uint256 public cap = 50;
address public owner;
address... | 0 |
function appendVestingEntry(address account, uint time, uint quantity)
public
onlyOwner
setupFunction
{
require(now < time);
require(quantity != 0);
totalVestedBalance = safeAdd(totalVestedBalance, quantity);
require(totalVestedBalance <= havven.balanceOf(this));
if (vestingSchedules[account].length == 0) {
t... | 0 |
function isSane() public constant returns (bool);
function finalizeCrowdsale();
}
contract CrowdsaleBase is Haltable {
uint public MAX_INVESTMENTS_BEFORE_MULTISIG_CHANGE = 5;
using SafeMathLib for uint;
FractionalERC20 public token;
PricingStrategy public pricingStrategy;
FinalizeAgent public finalizeAgent;
addr... | 0 |
function issueTokens (uint256 n, uint256 price, uint deadline) noEther onlyChallengeOwner {
if (now < tokenIssueDeadline) throw;
if (deadline < now) throw;
if (n == 0) throw;
tokenPrice = price * 1000000000000;
tokenIssueDeadline = deadline;
tokensToIssue = n;
tokensIssued = 0;
notifyTokenIssued(n, price, deadl... | 0 |
function addAcceptedToken(address _token) onlyAdmin external {
require(_token != address(0));
acceptedTokens[_token] = true;
emit AddAcceptedToken(_token);
} | 0 |
function allowance(address _owner, address _spender) view public returns (uint)
{
return approvals[_owner][_spender];
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.