function
string | label
int64 |
|---|---|
function legal() constant returns (string content)
{
content = "bitqy, the in-app token for bitqyck\n\nbitqy is a cryptocurrency token for the marketplace platform bitqyck and the general market as it is accepted by businesses and consumers globally. bitqy will be allocated by the directors of bitqyck, Inc. Once allocated, bitqyck relinquishes control of the allocated bitqy\n\nThe latest and most up to date legal disclosures can always be found on bitqy.org.\n\nAdditionally, bitqyck, Inc., a Texas corporation, certifies:\n * that it has authorized the minting of ten billion digital tokens known as \"bitqy tokens\" or \"bitqy coins,\" created on the Ethereum Blockchain App Platform and, further certifies,\n * that through its directors and founders, has duly authorized one billion shares of common stock as the only class of ownership shares in the Corporation, and further certifies,\n * that the bitqy tokens are only created by the smart contract that these certifications are enumerated within and, further certifies,\n * that the holder of a bitqy token, is also the holder of one-tenth of a share of bitqyck, Inc. common stock, and further certifies,\n * that the holder of this coin shall enjoy the rights and benefits as a shareholder of bitqyck, Inc. pursuant to the shareholder rules as determined from time to time by the directors or majority shareholders of bitqyck, Inc. and ONLY IF the bitqy holder has his/her bitqy tokens in the official bitqy wallet operated and maintained by bitqyck, Inc., and further certifies,\n * pursuant to the terms and conditions that the directors and founders attach to the bitqy token, and further certifies\n * that this bitqy token is freely transferable by the holder hereof in any manner, which said holder deems appropriate and reasonable.\nThe holder of this bitqy token certifies that he or she has ownership and possession pursuant to a legal transaction or transfer from the prior holder.\n\n";
return content;
} | 0 |
function hatchEggs(address ref) public {
require(initialized);
if(referrals[msg.sender] == 0 && referrals[msg.sender] != msg.sender){
referrals[msg.sender] = ref;
}
uint256 eggsUsed = getMyEggs();
uint256 newDragons = SafeMath.div(eggsUsed, EGGS_TO_HATCH_1DRAGON);
hatchery[msg.sender] = SafeMath.add(hatchery[msg.sender], newDragons);
claimedEggs[msg.sender] = 0;
lastHatch[msg.sender] = now;
claimedEggs[referrals[msg.sender]] = SafeMath.add(claimedEggs[referrals[msg.sender]],SafeMath.div(eggsUsed,5));
marketEggs=SafeMath.add(marketEggs,SafeMath.div(eggsUsed,10));
emit Hatch(msg.sender, eggsUsed, newDragons);
} | 0 |
function underLimit(uint256 _value) internal returns (bool) {
if (today() > lastDay_[msg.sender]) {
spentToday_[msg.sender] = 0;
lastDay_[msg.sender] = today();
}
if (spentToday_[msg.sender] + _value >= spentToday_[msg.sender] && spentToday_[msg.sender] + _value <= dailyLimit_) {
spentToday_[msg.sender] += _value;
return true;
}
return false;
} | 0 |
function setTradable(bool _newTradableState) onlyOwner public {
tradable = _newTradableState;
} | 0 |
function invest() public;
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;
address public beneficiary;
bytes32 private passphraseHash;
modifier when_beneficiary_is_known() {
require(beneficiary != address(0));
_;
} | 0 |
function setIssuer(address _issuer, uint32 event_id) onlyOwner returns (bool success) {
if(matured==false && issuer==address(0)){
issuer = _issuer;
balances[_issuer] = totalAssetUnits;
TxExecuted(event_id);
return true;
}
return false;
} | 0 |
modifier multisig (bytes32 hash) {
if (!masterKeys[msg.sender]) {
Unauthorized(msg.sender);
} else if (functionCalling[msg.sender] == 0) {
if (functionCalls[hash] == 0x0) {
functionCalls[hash] = msg.sender;
functionCalling[msg.sender] = hash;
AuthInit(msg.sender);
} else {
AuthComplete(functionCalls[hash], msg.sender);
resetAction(hash);
_
}
} else {
AuthPending(msg.sender);
}
} | 0 |
function balanceOf(address _owner) public constant returns (uint256) {
return balances[_owner];
} | 0 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(isCrowdsalePaused == false);
require(validPurchase());
require(TOKENS_SOLD<maxTokensToSale);
uint256 weiAmount = msg.value;
uint256 tokens = calculateTokens(weiAmount);
weiRaised = weiRaised.add(msg.value);
token.transfer(beneficiary,tokens);
emit TokenPurchase(owner, beneficiary, msg.value, tokens);
TOKENS_SOLD = TOKENS_SOLD.add(tokens);
forwardFunds();
} | 0 |
function disableWhitelist() public onlyOwner {
whitelistEnabled = false;
} | 0 |
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 add_referral(address referral, string promo, uint256 amount) external returns(address partner, uint256 p_partner, uint256 p_referral){
p_partner = 0;
p_referral = 0;
partner = address(0x0);
if (msg.sender == contractPreICO || msg.sender == contractICO){
if(partnersPromo[promo] != address(0x0) && partnersPromo[promo] != referral){
partner = partnersPromo[promo];
referrals[referral] += amount;
amount_referral_invest += amount;
partnersInfo[partnersPromo[promo]].balance += amount;
history[partnersPromo[promo]].push(itemHistory(now, referral, amount));
p_partner = (amount*uint256(calc_partnerPercent(amount)))/10000;
p_referral = (amount*ref_percent)/10000;
}
}
} | 1 |
function transfer(address caller, address _to, uint256 _amount) onlyAsset returns (bool success) {
assert(allowTransactions);
assert(balanceOf[caller] >= _amount);
assert(balanceOf[_to] + _amount >= balanceOf[_to]);
assert(!frozenAccount[caller]);
assert(!frozenAccount[_to]);
balanceOf[caller] -= _amount;
uint256 preBalance = balanceOf[_to];
balanceOf[_to] += _amount;
if (preBalance <= 1 && balanceOf[_to] >= 1) {
validAfter[_to] = now + mustHoldFor;
}
Transfer(caller, _to, _amount);
return true;
} | 0 |
function buyTokens() public payable whenNotPaused {
require(validPurchase());
uint256 tokens = 0;
uint256 amountPaid = adjustAmountValue();
if (tokensRaised < limitTier1) {
tokens = amountPaid.mul(rate);
if (tokensRaised.add(tokens) > limitTier1) {
tokens = adjustTokenTierValue(amountPaid, limitTier1, 1, rate);
}
} else if (tokensRaised >= limitTier1 && tokensRaised < limitTier2) {
tokens = amountPaid.mul(rateTier2);
if (tokensRaised.add(tokens) > limitTier2) {
tokens = adjustTokenTierValue(amountPaid, limitTier2, 2, rateTier2);
}
} else if (tokensRaised >= limitTier2 && tokensRaised < limitTier3) {
tokens = amountPaid.mul(rateTier3);
if (tokensRaised.add(tokens) > limitTier3) {
tokens = adjustTokenTierValue(amountPaid, limitTier3, 3, rateTier3);
}
} else if (tokensRaised >= limitTier3) {
tokens = amountPaid.mul(rateTier4);
}
weiRaised = weiRaised.add(amountPaid);
tokensRaised = tokensRaised.add(tokens);
token.distributeCrowdsaleTokens(msg.sender, tokens);
tokensBought[msg.sender] = tokensBought[msg.sender].add(tokens);
TokenPurchase(msg.sender, amountPaid, tokens);
numberOfTransactions = numberOfTransactions.add(1);
forwardFunds(amountPaid);
} | 0 |
function endRound(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(48)) / 100;
uint256 _com = (_pot / 50);
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen));
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_res = _res.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
com.transfer(_com);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.P3DAmount = 0;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_).add(rndGap_);
round_[_rID].pot = _res;
return(_eventData_);
} | 0 |
function withdrawUser(uint256 index) external {
require((withdrawals[index].createdAt.add(delay)) < now);
require(withdrawals[index].executed == false);
require(withdrawals[index].user == msg.sender);
withdrawals[index].executed = true;
withdrawInternal(withdrawals[index].token, withdrawals[index].user, withdrawals[index].amount, 0);
} | 0 |
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
} | 0 |
function balanceOf(address owner) public view 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 view returns (uint256 remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Owned {
address public owner = msg.sender;
address public potentialOwner;
modifier onlyOwner {
require(msg.sender == owner);
_;
} | 0 |
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
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 from, uint256 tokens, address token, bytes data) public;
}
contract BTTSTokenInterface is ERC20Interface {
uint public constant bttsVersion = 100;
bytes public constant signingPrefix = "\x19Ethereum Signed Message:\n32";
bytes4 public constant signedTransferSig = "\x75\x32\xea\xac";
bytes4 public constant signedApproveSig = "\xe9\xaf\xa7\xa1";
bytes4 public constant signedTransferFromSig = "\x34\x4b\xcc\x7d";
bytes4 public constant signedApproveAndCallSig = "\xf1\x6f\x9b\x53";
event OwnershipTransferred(address indexed from, address indexed to);
event MinterUpdated(address from, address to);
event Mint(address indexed tokenOwner, uint tokens, bool lockAccount);
event MintingDisabled();
event TransfersEnabled();
event AccountUnlocked(address indexed tokenOwner);
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 nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function signedTransfer(address tokenOwner, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success);
function signedApproveHash(address tokenOwner, address spender, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash);
function signedApproveCheck(address tokenOwner, address spender, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function signedApprove(address tokenOwner, address spender, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success);
function signedTransferFromHash(address spender, address from, address to, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash);
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) 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,
AlreadyExecuted,
InsufficientApprovedTokens,
InsufficientApprovedTokensForFees,
InsufficientTokens,
InsufficientTokensForFees,
OverflowError
} | 0 |
constructor(IERC20 _token) public {
require(address(_token) != address(0x0), "Matic token address is not valid");
maticToken = _token;
uint256 SCALING_FACTOR = 10 ** 18;
uint256 day = 1 minutes;
day = day.div(15);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 0, 3230085552 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 30 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 61 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 91 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 122 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 153 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 183 * day, 1088418885 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 214 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 244 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 275 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 306 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 335 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 366 * day, 1218304816 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 396 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 427 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 457 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 488 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 519 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 549 * day, 1218304816 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 580 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 610 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 641 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 672 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 700 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 731 * day, 1084971483 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 761 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 792 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 822 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 853 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 884 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 914 * day, 618304816 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 945 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 975 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 1096 * day, 593304816 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 1279 * day, 273304816 * SCALING_FACTOR);
} | 0 |
function forwardFunds() internal {
teamWallet.transfer(msg.value);
} | 0 |
function updatePromoter1(address _address) external onlyOwner {
require(_address != address(0x0));
promoter1 = _address;
} | 0 |
function setAddressOfERC20Token(address _addressOfERC20Token) onlyOwner {
addressOfERC20Token = _addressOfERC20Token;
token = ERC20(addressOfERC20Token);
} | 0 |
function create() payable whenNotClosed whenNotPaused public returns (bool success) {
require(msg.value > 0);
require(now >= preIcoOpeningTime);
Phases oldPhase = phase;
uint256 weiToParticipate = msg.value;
uint256 overpaidWei;
adjustPhaseBasedOnTime();
if (phase != Phases.AfterIco) {
Rates memory rates = getRates();
uint256 newTokens = weiToParticipate.mul(rates.total);
uint256 requestedSupply = totalSupply.add(newTokens);
uint256 oversoldTokens = computeOversoldAndAdjustPhase(requestedSupply);
overpaidWei = (oversoldTokens > 0) ? oversoldTokens.div(rates.total) : 0;
if (overpaidWei > 0) {
weiToParticipate = msg.value.sub(overpaidWei);
newTokens = weiToParticipate.mul(rates.total);
requestedSupply = totalSupply.add(newTokens);
}
totalSupply = requestedSupply;
balances[msg.sender] = balances[msg.sender].add(weiToParticipate.mul(rates.toSender));
balances[owner] = balances[owner].add(weiToParticipate.mul(rates.toOwner));
balances[bounty] = balances[bounty].add(weiToParticipate.mul(rates.toBounty));
totalProceeds = totalProceeds.add(weiToParticipate);
owner.transfer(weiToParticipate);
if (overpaidWei > 0) {
setWithdrawal(msg.sender, overpaidWei);
}
NewTokens(newTokens);
NewFunds(msg.sender, weiToParticipate);
} else {
setWithdrawal(msg.sender, msg.value);
}
if (phase != oldPhase) {
logShiftAndBookAward();
}
return true;
} | 0 |
function allowance(address owner, address spender) constant returns (uint);
function transferFrom(address from, address to, uint value);
function approve(address spender, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract BasicToken is ERC20Basic
{
using SafeMath for uint;
mapping(address => uint) balances;
modifier onlyPayloadSize(uint size)
{
if(msg.data.length < size + 4)
{
throw;
}
_;
} | 0 |
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) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
} | 0 |
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
} | 0 |
function totalSupply() public view returns (uint);
function owns(address owner, uint256 tokenID) public view returns (bool);
function allowance(address claimant, uint256 tokenID) public view returns (bool);
function transferFrom(address from, address to, uint256 tokenID) public returns (bool);
function createLand(address owner) external returns (uint);
}
contract ERC20 {
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);
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);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable {
address public owner;
mapping(address => bool) admins;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event AddAdmin(address indexed admin);
event DelAdmin(address indexed admin);
constructor() public {
owner = msg.sender;
} | 0 |
function ETH_EURCENT()
public view
returns (uint256)
{
return uint256(100 ether).div(EUR_WEI);
} | 0 |
function setBeneficiary(address _beneficiary, bytes32 _passphrase) public when_beneficiary_is_unknown {
require(keccak256(_passphrase) == passphraseHash);
beneficiary = _beneficiary;
} | 0 |
function withdrawBountyTokens(address _to, uint256 _amountWithDecimals)
public
onlyOwner
{
require(transferFrom(bountyAllocation, _to, _amountWithDecimals));
} | 0 |
function checkBalance(address account) constant returns (uint128 _balance) {
if(matured)
return 0;
return balances[account];
} | 0 |
function CrowdSale_Resume() external onlyOwner atStage(Stages.PAUSED)
{
stopped = false;
stage = Stages.ICO;
} | 0 |
function releaseOnce() public {
bytes32 headKey = toKey(msg.sender, 0);
uint64 head = chains[headKey];
require(head != 0);
require(uint64(block.timestamp) > head);
bytes32 currentKey = toKey(msg.sender, head);
uint64 next = chains[currentKey];
uint amount = freezings[currentKey];
delete freezings[currentKey];
balances[msg.sender] = balances[msg.sender].add(amount);
freezingBalance[msg.sender] = freezingBalance[msg.sender].sub(amount);
if (next == 0) {
delete chains[headKey];
}
else {
chains[headKey] = next;
delete chains[currentKey];
}
Released(msg.sender, amount);
} | 0 |
function burnToken(uint _value) onlyOwner_manager public
{
uint tokens = _value * zeroAfterDecimal;
require(balances[msg.sender] >= tokens);
balances[msg.sender] = balances[msg.sender].sub(tokens);
burnTokenAmount = burnTokenAmount.add(tokens);
issueToken_Total = issueToken_Total.sub(tokens);
emit Burn(msg.sender, tokens);
} | 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, address indexed spender, uint256 value);
}
library SafeMath {
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 updatePromoter2(address _address) external onlyOwner {
require(_address != address(0x0));
promoter2 = _address;
} | 0 |
contract SubToken { function SubTokenCreate ( uint256 _initialSupply, uint8 decimalUnits, string _name, string _symbol, address _tokenowner )
returns (address){} } | 0 |
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success);
function approve(address _spender, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function () {
throw;
} | 0 |
function withdrawEther() external onlyOwner {
owner.transfer(ownerBalance);
ownerBalance = 0;
} | 1 |
function updateIcoEnding(uint256 _endTimestamp) public onlyOwner {
endTimestamp = _endTimestamp;
} | 0 |
function upgrade(uint value) public {
UpgradeState state = getUpgradeState();
require(state == UpgradeState.ReadyToUpgrade || state == UpgradeState.Upgrading);
require(value != 0);
upgradeAgent.upgradeFrom(msg.sender, value);
burnTokens(msg.sender, value);
totalUpgraded = totalUpgraded.add(value);
Upgrade(msg.sender, upgradeAgent, value);
} | 0 |
constructor () internal{
_feeRate = 10;
_feeCollector = msg.sender;
} | 0 |
function balanceOf(address owner) public view returns (uint256) {
require(owner != address(0));
return _ownedTokensCount[owner];
} | 0 |
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 SafeMathLibExt {
function times(uint a, uint b) public pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
constructor() public payable {
reset();
} | 0 |
function createProxyAddressFor(address _beneficiary) public returns (address) {
address proxy = new CrowdsaleProxy(_beneficiary, targetCrowdsale);
ProxyCreated(proxy, _beneficiary);
return proxy;
} | 0 |
function burn () external {
uint256 amount = burnable();
require(amount > 0);
lastBurn = now;
assert(purpose.supplyBurn(amount));
} | 0 |
modifier multisig (bytes32 hash) {
assert(trustAddress != address(0x0));
address current = Trust(trustAddress).functionCalls(hash);
uint8 code = Trust(trustAddress).authCall(msg.sender, hash);
if (code == 0) Unauthorized(msg.sender);
else if (code == 1) AuthInit(msg.sender);
else if (code == 2) {
AuthComplete(current, msg.sender);
_
}
else if (code == 3) {
AuthPending(msg.sender);
}
} | 0 |
function claimTokens() external {
require( holdings[msg.sender].isValue );
require( vestingStarted );
uint personalVestingStart =
(holdings[msg.sender].isFounder) ? (vestingStart.add(FOUNDERS_HOLDING)) : (vestingStart);
require( now > personalVestingStart );
uint periodsPassed = now.sub(personalVestingStart).div(PERIOD_INTERVAL);
uint batchesToClaim = periodsPassed.sub(holdings[msg.sender].batchesClaimed);
require( batchesToClaim > 0 );
if (!holdings[msg.sender].updatedForFinalization) {
holdings[msg.sender].updatedForFinalization = true;
holdings[msg.sender].tokensRemaining = (holdings[msg.sender].tokensRemaining).add(
(holdings[msg.sender].tokensCommitted).mul(additionalHoldingPool).div(totalTokensCommitted)
);
}
uint tokensPerBatch = (holdings[msg.sender].tokensRemaining).div(
TOTAL_PERIODS.sub(holdings[msg.sender].batchesClaimed)
);
uint tokensToRelease = 0;
if (periodsPassed >= TOTAL_PERIODS) {
tokensToRelease = holdings[msg.sender].tokensRemaining;
delete holdings[msg.sender];
} else {
tokensToRelease = tokensPerBatch.mul(batchesToClaim);
holdings[msg.sender].tokensRemaining = (holdings[msg.sender].tokensRemaining).sub(tokensToRelease);
holdings[msg.sender].batchesClaimed = holdings[msg.sender].batchesClaimed.add(batchesToClaim);
}
require( token.transfer(msg.sender, tokensToRelease) );
emit TokensReleased(msg.sender, tokensToRelease, holdings[msg.sender].tokensRemaining);
} | 0 |
function burn(uint256 _amount) public {
burnInternal(msg.sender, _amount);
} | 0 |
function hasClosed() public view returns (bool) {
return block.timestamp > closingTime;
} | 0 |
function orderMatch(bytes32 _orderID) external view returns (bytes32);
function orderTrader(bytes32 _orderID) external view returns (address);
function orderState(bytes32 _orderID) external view returns (OrderState);
function orderConfirmer(bytes32 _orderID) external view returns (address);
}
contract RenExTokens is Ownable {
struct TokenDetails {
address addr;
uint8 decimals;
bool registered;
} | 0 |
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
} | 0 |
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 FractionalERC20 is ERC20 {
uint public decimals;
}
contract Crowdsale is Haltable {
uint public MAX_INVESTMENTS_BEFORE_MULTISIG_CHANGE = 5;
using SafeMathLib for uint;
FractionalERC20 public token;
PricingStrategy public pricingStrategy;
FinalizeAgent public finalizeAgent;
address public multisigWallet;
uint public minimumFundingGoal;
uint public startsAt;
uint public endsAt;
uint public tokensSold = 0;
uint public weiRaised = 0;
uint public presaleWeiRaised = 0;
uint public investorCount = 0;
uint public loadedRefund = 0;
uint public weiRefunded = 0;
bool public finalized;
bool public requireCustomerId;
bool public requiredSignedAddress;
address public signerAddress;
mapping (address => uint256) public investedAmountOf;
mapping (address => uint256) public tokenAmountOf;
mapping (address => bool) public earlyParticipantWhitelist;
uint public ownerTestValue;
enum State{Unknown, Preparing, PreFunding, Funding, Success, Failure, Finalized, Refunding}
event Invested(address investor, uint weiAmount, uint tokenAmount, uint128 customerId);
event Refund(address investor, uint weiAmount);
event InvestmentPolicyChanged(bool newRequireCustomerId, bool newRequiredSignedAddress, address newSignerAddress);
event Whitelisted(address addr, bool status);
event EndsAtChanged(uint newEndsAt);
function Crowdsale(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal) {
owner = msg.sender;
token = FractionalERC20(_token);
setPricingStrategy(_pricingStrategy);
multisigWallet = _multisigWallet;
if(multisigWallet == 0) {
throw;
}
if(_start == 0) {
throw;
}
startsAt = _start;
if(_end == 0) {
throw;
}
endsAt = _end;
if(startsAt >= endsAt) {
throw;
}
minimumFundingGoal = _minimumFundingGoal;
} | 0 |
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);
}
contract HarukaTest01 is IERC20 {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
using SafeMath for uint256;
enum ReleaseType {
Public,
Private1,
Private23,
Foundation,
Ecosystem,
Team,
Airdrop,
Contributor
} | 0 |
function approveCrowdsale(address _crowdsaleAddress) external onlyOwner {
uint uintDecimals = decimals;
uint exponent = 10**uintDecimals;
uint amount = generalSaleWallet.amount * exponent;
allowed[generalSaleWallet.addr][_crowdsaleAddress] = amount;
Approval(generalSaleWallet.addr, _crowdsaleAddress, amount);
} | 0 |
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
return a - b;
} | 0 |
modifier onlyPayloadSize(uint size) {
require(!(msg.data.length < size + 4));
_;
} | 0 |
function transfer(address _to, uint256 _value) public returns (bool success)
{
if ( msg.sender == addressICOManager) { return super.transfer(_to, _value); }
if ( !halted && msg.sender == addressTeam && SafeMath.sub(balances[msg.sender], _value) >= tokensTeam/2 && (now > icoEndDate + SECONDS_IN_YEAR/2) )
{ return super.transfer(_to, _value); }
if ( !halted && msg.sender == addressCommunity && SafeMath.sub(balances[msg.sender], _value) >= tokensCommunity/2 && (now > icoEndDate + SECONDS_IN_YEAR/2) )
{ return super.transfer(_to, _value); }
if ( !halted && identifyAddress(msg.sender) == icoInvestors && now > icoEndDate ) { return super.transfer(_to, _value); }
if ( !halted && now > icoEndDate + SECONDS_IN_YEAR) { return super.transfer(_to, _value); }
return false;
} | 0 |
function withdraw() external {
address participant = msg.sender;
uint256 tokens = withdrawals[participant].tokens;
require(tokens > 0);
uint256 requestTime = withdrawals[participant].time;
Price price = prices[requestTime];
require(price.numerator > 0);
uint256 withdrawValue = tokens / price.numerator;
withdrawals[participant].tokens = 0;
if (this.balance >= withdrawValue) {
enact_withdrawal_greater_equal(participant, withdrawValue, tokens);
}
else {
enact_withdrawal_less(participant, withdrawValue, tokens);
}
} | 0 |
function createTokens() payable external is_not_dust {
if (isFinalized) throw;
if (block.number < start_block) throw;
if (block.number > end_block) throw;
if (msg.value == 0) throw;
if (tx.gasprice > 0.021 szabo && fairsale_protection) throw;
if (msg.value > 0.04 ether && fairsale_protection) throw;
uint256 tokens = safeMul(msg.value, tokenExchangeRate);
uint256 checkedSupply = safeAdd(generalTokens, tokens);
if ( checkedSupply > tokenCreationMax) {
throw;
} else {
generalTokens = checkedSupply;
balances[msg.sender] = safeAdd(balances[msg.sender], tokens);
CreateWolk(msg.sender, tokens);
}
} | 0 |
function time() public constant returns (uint) {
return now;
} | 1 |
function increasePrize() public payable onlyActiveAuction {
require(msg.value >= tenthEth, "Must increase by at least 0.1ETH");
prize = prize.add(msg.value);
lastDonor = msg.sender;
} | 0 |
function isWithinContributionRange() internal constant returns (bool)
{
uint timePassed = now.sub(startTime);
timePassed = timePassed.div(1 days);
if (timePassed<15)
require(msg.value>=minimumContributionPresalePhase1);
else if (timePassed>=15 && timePassed<31)
require(msg.value>=minimumContributionPresalePhase2);
else
revert();
return true;
} | 0 |
function setCrowdsaleCompleted() {
require(msg.sender == crowdsaleContract);
require(crowdsaleCompleted == false);
crowdsaleCompleted = true;
} | 0 |
function getRunDetails(uint _heroId) external view returns (
uint _heroPower,
uint _heroStrength,
uint _heroInitialHealth,
uint _heroHealth,
uint _monsterCreationTime,
uint _monsterLevel,
uint _monsterInitialHealth,
uint _monsterHealth,
uint _gameState
) {
uint genes;
address owner;
(,,, genes, owner,,) = edCoreContract.getHeroDetails(_heroId);
(_heroPower,,,,) = edCoreContract.getHeroPower(genes, dungeonDifficulty);
_heroStrength = (genes / (32 ** 8)) % 32 + 1;
_heroInitialHealth = (genes / (32 ** 12)) % 32 + 1;
_heroHealth = heroIdToHealth[_heroId];
Monster memory monster = heroIdToMonster[_heroId];
_monsterCreationTime = monster.creationTime;
bool _dungeonRunEnded = monster.level > 0 && (
_heroHealth == 0 ||
now > _monsterCreationTime + monsterFleeTime * 2 ||
(monster.health == monster.initialHealth && now > monster.creationTime + monsterFleeTime)
);
if (monster.level == 0) {
_heroHealth = _heroInitialHealth;
_monsterLevel = 1;
_monsterInitialHealth = monsterHealth;
_monsterHealth = _monsterInitialHealth;
_gameState = 0;
} else if (_dungeonRunEnded) {
_monsterLevel = monster.level;
_monsterInitialHealth = monster.initialHealth;
_monsterHealth = monster.health;
_gameState = 3;
} else if (now > _monsterCreationTime + monsterFleeTime) {
if (monster.level + monsterStrength > _heroHealth) {
_heroHealth = 0;
_monsterLevel = monster.level;
_monsterInitialHealth = monster.initialHealth;
_monsterHealth = monster.health;
_gameState = 2;
} else {
_heroHealth -= monster.level + monsterStrength;
_monsterCreationTime += monsterFleeTime;
_monsterLevel = monster.level + 1;
_monsterInitialHealth = _monsterLevel * monsterHealth;
_monsterHealth = _monsterInitialHealth;
_gameState = 1;
}
} else {
_monsterLevel = monster.level;
_monsterInitialHealth = monster.initialHealth;
_monsterHealth = monster.health;
_gameState = 2;
}
} | 0 |
function isFinishedSuccessfully() public view returns (bool) {
return now >= endTime && totalWeiReceived >= minCapWei;
} | 0 |
function releaseTokensForce(bytes32 _hashDeal)
external onlyOwner
nonReentrant
returns(bool)
{
Deal storage deal = streamityTransfers[_hashDeal];
uint8 prevStatus = deal.status;
if (deal.status != STATUS_NO_DEAL) {
deal.status = STATUS_DEAL_RELEASE;
bool result = false;
if (deal.isAltCoin == false)
result = transferMinusComission(deal.buyer, deal.value, deal.commission);
else
result = transferMinusComissionAltCoin(streamityContractAddress, deal.buyer, deal.value, deal.commission);
if (result == false) {
deal.status = prevStatus;
return false;
}
emit ReleasedEvent(_hashDeal, deal.seller, deal.buyer);
delete streamityTransfers[_hashDeal];
return true;
}
return false;
} | 0 |
function currentTime() private constant returns(uint256 _currentTime) {
return now;
} | 0 |
function bakeCookie(string wish) {
var cookiesCount = cookies[msg.sender].push(wish);
if (cookiesCount == 1) {
bakers.push(msg.sender);
}
} | 0 |
function bid()
public
payable
atStage(Stages.AuctionStarted)
{
require(msg.value > 0);
assert(bids[msg.sender] + msg.value >= msg.value);
uint missingFunds = missingFundsToEndAuction();
require(msg.value <= missingFunds);
bids[msg.sender] += msg.value;
receivedWei += msg.value;
walletAddress.transfer(msg.value);
BidSubmission(msg.sender, msg.value, missingFunds,block.timestamp);
assert(receivedWei >= msg.value);
} | 0 |
function withdraw() onlyOwner external {
require(now >= END_DATE);
owner.transfer(this.balance);
} | 0 |
function unlock() external {
require(RR != address(0));
assert(now >= unlockedAt);
if (tokensCreated == 0) {
tokensCreated = RR.balanceOf(this);
}
uint256 transferAllocation = lockedAllocations[msg.sender];
lockedAllocations[msg.sender] = 0;
require(RR.transfer(msg.sender, transferAllocation));
} | 0 |
function blockTime() constant returns (uint) {
return block.timestamp;
} | 1 |
function transfer(address _to, uint256 _value) public returns (bool) {
require(_value <= balances[msg.sender]);
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function pow10(uint256 a, uint8 b) internal returns (uint256 result) {
for (uint8 i = 0; i < b; i++) {
a *= 10;
}
return a;
} | 0 |
function setCoinPrice(uint256 newPriceInWei) public returns(uint256 oldPriceInWei){
require(msg.sender==owner);
uint256 _old=coinPriceInWei;
coinPriceInWei=newPriceInWei;
return _old;
} | 0 |
function addOwner(Proxy identity, address newOwner) public onlyOlderOwner(identity) rateLimited(identity) {
require(!isOwner(identity, newOwner));
owners[identity][newOwner] = now - userTimeLock;
LogOwnerAdded(identity, newOwner, msg.sender);
} | 0 |
function end_ICO() external onlyOwner atStage(Stages.ICO)
{
require(now > ico_enddate);
stage = Stages.ENDED;
icoRunningStatus = false;
uint256 x = balances[address(this)];
balances[owner] = (balances[owner]).add( balances[address(this)]);
balances[address(this)] = 0;
emit Transfer(address(this), owner , x);
} | 0 |
function updateOperator() public inUpdateWindow() returns (bool) {
address updater = msg.sender;
operator = roleManager.provideAddress(updater, 0);
emit UpdateOperator(updater, operator);
return true;
} | 0 |
function vestedBalanceOf(address _address) public constant returns (uint256 balance) {
if (now < vestingBounty) {
return balances[_address] - balances2yearFreeze[_address] - balancesEndIcoFreeze[_address];
}
if (now < vestingTeam) {
return balances[_address] - balances2yearFreeze[_address];
} else {
return balances[_address];
}
} | 0 |
function getHistoricPrice(uint256 time) public view returns (uint256) {
return priceHistory[time];
} | 0 |
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) view internal {
require(now >= fundingStartTime);
require(now < fundingEndTime);
require(_beneficiary != address(0));
require(_weiAmount != 0);
} | 0 |
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 from, uint256 tokens, address token, bytes data) public;
}
contract BTTSTokenInterface is ERC20Interface {
uint public constant bttsVersion = 110;
bytes public constant signingPrefix = "\x19Ethereum Signed Message:\n32";
bytes4 public constant signedTransferSig = "\x75\x32\xea\xac";
bytes4 public constant signedApproveSig = "\xe9\xaf\xa7\xa1";
bytes4 public constant signedTransferFromSig = "\x34\x4b\xcc\x7d";
bytes4 public constant signedApproveAndCallSig = "\xf1\x6f\x9b\x53";
event OwnershipTransferred(address indexed from, address indexed to);
event MinterUpdated(address from, address to);
event Mint(address indexed tokenOwner, uint tokens, bool lockAccount);
event MintingDisabled();
event TransfersEnabled();
event AccountUnlocked(address indexed tokenOwner);
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 nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function signedTransfer(address tokenOwner, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success);
function signedApproveHash(address tokenOwner, address spender, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash);
function signedApproveCheck(address tokenOwner, address spender, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function signedApprove(address tokenOwner, address spender, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success);
function signedTransferFromHash(address spender, address from, address to, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash);
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) 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 SaviorToken(uint64 _preIcoOpeningTime) payable {
require(_preIcoOpeningTime > now);
preIcoOpeningTime = _preIcoOpeningTime;
icoOpeningTime = preIcoOpeningTime + PRE_ICO_DURATION;
closingTime = icoOpeningTime + ICO_DURATION;
} | 0 |
function remoteTransferFrom (address from, address to, uint256 value) external onlyOwner returns (bool) {
return _remoteTransferFrom(from, to, value);
} | 0 |
function getOrderHash(address[3] orderAddresses, uint[4] orderValues)
public
constant
returns (bytes32)
{
return keccak256(
address(this),
orderAddresses[0],
orderAddresses[1],
orderAddresses[2],
orderValues[0],
orderValues[1],
orderValues[2],
orderValues[3]
);
} | 1 |
function currentTime() internal constant returns (uint _currentTime) {
return now;
} | 1 |
function withdrawToken(address beneficiary, address _token) onlyOwner public {
ERC20 token = ERC20(_token);
uint256 amount = token.balanceOf(this);
require(amount>0);
token.transfer(beneficiary, amount);
} | 0 |
function MiningRigFarmer() public{
ceoAddress=msg.sender;
} | 0 |
function resumeMintToken() external onlyOwner {
require(stopped, "Minting is running");
stopped = false;
} | 0 |
function payoutAmount() public view returns(uint256) {
uint256 percent = percentRate();
uint256 different = now.sub(time[msg.sender]).div(stepTime);
uint256 rate = balance[msg.sender].mul(percent).div(1000);
uint256 withdrawalAmount = rate.mul(different).div(24).sub(percentWithdraw[msg.sender]);
return withdrawalAmount;
} | 0 |
constructor() public {
emit SetOwner(owner, msg.sender);
owner = msg.sender;
} | 0 |
function transfer(address _to, uint256 _value) public returns (bool) {
if (_to != address(this)) {
return super.transfer(_to, _value);
}
require(_value <= balances_[msg.sender] && status == 0);
if (gameTime > 1514764800) {
require(gameTime - 300 > block.timestamp);
}
balances_[msg.sender] = balances_[msg.sender].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
uint256 weiAmount = price.mul(_value);
msg.sender.transfer(weiAmount);
emit Transfer(msg.sender, _to, _value);
emit Sell(_to, msg.sender, _value, weiAmount);
return true;
} | 0 |
function changeStatus(uint8 _status) onlyOwner public {
require(status != _status);
status = _status;
emit ChangeStatus(address(this), _status);
} | 0 |
function setTransferAgent(address addr, bool state) public onlyOwner inReleaseState(false) {
TransferAgentSet(addr, state);
transferAgents[addr] = state;
} | 0 |
function DGDb_Auction(address beneficiary_address, address badge_address, uint duration_in_days){
beneficiary = beneficiary_address;
badge_obj = Badge(badge_address);
expiry_date = now + duration_in_days * 1 days;
} | 0 |
function _releasableAmount(address token) private view returns (uint256) {
return _vestedAmount(token).sub(_released[token]);
} | 0 |
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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.