function string | label int64 |
|---|---|
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) && partnersP... | 1 |
function div(uint a, uint b) internal pure returns (uint c) {
require(b > 0);
c = a / b;
} | 0 |
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 isOwner(address _node, address _owner) constant returns(bool) {
return hasRole(_node, OWNER, _owner);
} | 0 |
function refund()
public
{
} | 0 |
function GiveRocketInternal(uint16 stock_id, address target, bool buying, address referrer) internal
{
RocketTypes.StockRocket storage stock_rocket = m_InitialRockets[stock_id];
require(stock_rocket.m_IsValid);
if (buying)
{
require(msg.value == stock_rocket.m_Cost);
}
GlobalTypes.Global memory global = GlobalT... | 1 |
function burn(uint burnAmount) {
address burner = msg.sender;
balances[burner] = balances[burner].sub(burnAmount);
totalSupply = totalSupply.sub(burnAmount);
Burned(burner, burnAmount);
Transfer(burner, BURN_ADDRESS, burnAmount);
} | 0 |
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StandardToken is Token {
function transfer(address _to, u... | 0 |
function increaseApproval (address _spender, uint _addedValue)
public returns (bool success)
{
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
} | 0 |
function getCurrLocking()
public
view
returns (uint256)
{
uint256 diff = (now - lockupDate) / 2592000;
uint256 partition = 30;
if (diff >= partition)
return 0;
else
return initLockupAmt.mul(partition-diff).div(partition);
} | 0 |
function _currentDay() internal view returns(uint256) {
return now.sub(startDate).div(ONE_DAY);
} | 1 |
function activateSaleContract(address saleContractAddress) public onlyOwner {
require(saleContractAddress != address(0));
require(!saleContractActivated);
saleContract = saleContractAddress;
saleContractActivated = true;
_mint(saleContract, _tokensForSale);
_tokensForSale = 0;
emit SaleContractActivation(saleCon... | 0 |
function addMinter(address who) returns (bool) {
if (now >= _END_MINTING) throw;
if (!minters[msg.sender]) return false;
minters[who] = true;
MinterAdded(who);
return true;
} | 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 va... | 0 |
function buy() payable public {
uint amount = msg.value / buyPrice;
_transfer(this, msg.sender, amount);
} | 0 |
function transferFrom(address _from, address _to, uint _value) public returns (bool)
{
require(isTransferable() == true);
require(balances[_from] >= _value);
require(approvals[_from][msg.sender] >= _value);
approvals[_from][msg.sender] = approvals[_from][msg.sender].sub(_value);
balances[_from] = balances[_from].... | 0 |
function upgrade(uint256 _value) public {
UpgradeState state = getUpgradeState();
require((state == UpgradeState.ReadyToUpgrade) || (state == UpgradeState.Upgrading));
require(_value > 0);
require(balances[msg.sender] >= _value);
uint256 upgradedAmount = totalUpgraded.add(_value);
uint256 senderBalance = balances... | 0 |
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
} | 0 |
function allowance(address _owner, address _spender) constant returns (uint256 remaining){
return approved[_owner][_spender];
} | 0 |
function withdrawTokens() external onlyOwner {
uint256 value = balances[this];
balances[owner] = (balances[owner]).add(value);
balances[this] = 0;
emit Transfer(this, owner, value);
} | 0 |
function approve(address spender, uint256 value) 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) returns (bool) {
bal... | 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);
}
pragma solidity ^0.5.0;
contract ERC20 is IERC20 {
using SafeMath for uint256;
... | 0 |
function increaseApproval(address _spender, uint256 _addedValue) public erc20Allowed returns (bool) {
allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
} | 0 |
function halt() external onlyOwner {
halted = true;
Halted(true);
} | 0 |
function suspend() public onlyOwner isActive {
state = State.Suspended;
emit ICOSuspended();
} | 0 |
function getDungeonPower(uint _genes) public pure returns (uint);
function calculateTop5HeroesPower(address _address, uint _dungeonId) public view returns (uint);
}
contract DungeonRunBeta is Pausable, Destructible {
struct Monster {
uint64 creationTime;
uint8 level;
uint16 initialHealth;
uint16 health;
} | 0 |
constructor(uint256 _startTime, address _wallet, address _tokenAddress) public
{
require(_startTime >=now);
require(_wallet != 0x0);
startTime = _startTime;
endTime = startTime + totalDurationInDays;
require(endTime >= startTime);
owner = _wallet;
maxTokensToSale = uint(15000000000).mul( 10 ** uint256(18));
to... | 0 |
modifier notBeforeTime(uint256 targetTime){
assert(now>targetTime);
_;
} | 1 |
function plus(uint a, uint b) returns (uint) {
uint c = a + b;
assert(c>=a);
return c;
} | 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);
if (now > monster.creationTime + mons... | 0 |
function has(Role storage role, address addr)
view
internal
returns (bool)
{
return role.bearer[addr];
} | 0 |
function addSuperAdmin(address _admin) public onlyOwner validateAddress(_admin){
require(!superAdmins[_admin]);
superAdmins[_admin] = true;
emit AddSuperAdmin(_admin);
} | 0 |
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
FrozenFunds(target, freeze);
} | 0 |
function set_centralAccount(address central_Acccount) external onlyOwner
{
central_account = central_Acccount;
} | 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 (b... | 0 |
function withdrawCommisionToAddress(address _to, uint256 _amount) external onlyOwner {
require(_amount <= availableForWithdrawal);
availableForWithdrawal = availableForWithdrawal.sub(_amount);
_to.transfer(_amount);
} | 0 |
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
emit FrozenFunds(target, freeze);
} | 0 |
function transferToAddress(address _to, uint256 _value, bytes _data) internal {
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
emit Transfer(msg.sender, _to, _value, _data);
} | 0 |
function setUpgradeMaster(address master) public {
if (master == 0x0) throw;
if (msg.sender != upgradeMaster) throw;
upgradeMaster = master;
NewUpgradeMaster(upgradeMaster);
} | 0 |
function allowance(address from, address to) constant returns (uint256 res) {
return DCAssetBackend(backendContract).allowance(from, to);
} | 0 |
function transfer(address _to, uint256 _amount)public returns (bool success) {
require(!lockstatus, "Token is locked now");
require( _to != 0x0, "Receiver can not be 0x0");
require(balances[msg.sender] >= _amount, "Balance does not have enough tokens");
require(!locked[msg.sender], "Sender address is locked");
bal... | 0 |
constructor () public {
highScore = 0;
currentWinner = msg.sender;
lastTimestamp = now;
} | 0 |
function transferToICAP(bytes32 _icap, uint _value) returns(bool);
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 createVes... | 0 |
function DIGI(){
totalSupply=980000000000;
owner = msg.sender;
balances[msg.sender] = (980000000000);
twoWeeksBonusTime=now + 2 * 1 weeks;
thirdWeekBonusTime=twoWeeksBonusTime+1 * 1 weeks;
fourthWeekBonusTime=thirdWeekBonusTime+1 * 1 weeks;
deadLine=fourthWeekBonusTime+1 *1 weeks;
etherRaised=0;
} | 0 |
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract TokenERC20 {
string public name;
string public symbol;
uint8 public decimals = 18;
uint256 initialSupply=5000000000;
uint256 MAX_CAP = 5000000000;
uint256 public totalSupply;
ma... | 0 |
function ProofOfExistence(){
manager = msg.sender;
created = "cryptonomica.net";
} | 1 |
function AlfaToken(address _owner) UpgradeableToken(_owner) {
name = "AlfaToken";
symbol = "ALFA";
totalSupply = 100000000000000000;
decimals = 9;
balances[_owner] = totalSupply;
} | 0 |
function balanceOf(address _owner) public view returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
}
contract DLSDLockBounty3 {
ERC20BasicInterface constant TOKEN = ERC20BasicInterface(0x8458d484572cEB89ce70EEBBe17Dc84707b241eD);
address constant OWNER = 0x603F65F... | 0 |
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 ParetoTeamLockup()public {
token = ERC20Basic(0xea5f88E54d982Cbb0c441cde4E79bC305e5b43Bc);
beneficiary = 0x00431934746a504D3C40C20Bc8aF1607EbA9ab4f;
releaseTime = now + 300 days;
} | 0 |
function submit(bytes32 Bets, bytes32 secretKey_P, bytes32 secretKey_D_hash) payable public {
require(TicketPool[secretKey_D_hash].Time == 0);
require(msg.value >= LimitBottom && msg.value <= LimitTop);
uint bet_total_amount = 0;
for (uint i = 0; i < 29; i++) {
if(Bets[i] == 0x00) continue;
uint bet_amount_ = uin... | 0 |
function mintToken(address to, uint amount) external returns (bool success);
function balanceOf(address _owner) public view returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed... | 0 |
modifier BurnAll()
{
require(now > endIco && balances[owner] > 0);
_;
} | 1 |
function carnitaAsada(address _manager, address _bitso) public{
addressManager= _manager;
bitsoAddress= _bitso;
lastCarnita=0;
priceCarnita= 0.015 ether;
currentPeople= 8;
toPaycarnita=0.012 ether;
carnita memory temp;
temp.maxPeople=currentPeople;
temp.active=true;
temp.raised=0;
temp.min=priceCarnita;
car... | 0 |
function sellTokens() public payable whenSaleIsOpen whenWhitelisted(msg.sender) whenNotPaused {
require(msg.value > minimumInvestment);
uint256 _bonus = bonus(msg.sender);
uint256 _discount = discount();
uint256 tokensAmount = (msg.value).mul(exchangeRate).mul(_bonus.add(100)).div((100 - _discount));
token.transfe... | 0 |
function burn() public;
}
contract MonedaICO {
using SafeMath for uint256;
struct DateRate {
uint256 date;
uint256 rate;
} | 0 |
function initialize() private {
lockList[0xDfa1ebaA05b68B82475Aa737d923eCF3AA8535c5] = 200 * 10 ** 18;
lockList[0x876282c8809c300fB1ab10b451fb21F1600c27F0] = 19574 * 10 ** 18;
lockList[0xa5bC6Eca62ec7bd910753d01e2dD310D465E7a22] = 197903 * 10 ** 18;
lockList[0x71A07b9f65A9008b867584c267D545aFF5c8c68f] = 1014 * 10 *... | 0 |
function adminshipLevel(address _newAdmin, uint8 _level) public onlyAdmin(2) {
require(_newAdmin != address(0), "Address cannot be zero");
level[_newAdmin] = _level;
emit AdminshipUpdated(_newAdmin, _level);
} | 0 |
function transfer(address _to, uint _amountInWei) external onlyOwner {
require(address(this).balance > _amountInWei);
_to.transfer(_amountInWei);
} | 0 |
function transfer(address to, uint256 value) public returns (bool)
{
return _fullTransfer(msg.sender, to, value);
} | 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) && partnersP... | 1 |
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);
addVe... | 0 |
function hodl(address _beneficiary, uint256 _id, uint256 _value, uint256 _months) external {
require(_beneficiary != address(0));
require(_id > 0);
address _creator = msg.sender;
Item storage item = items[_creator][_id];
require(item.id != _id);
items[_creator][_id] = Item(_id, _creator, _beneficiary, false);
pu... | 0 |
function updateTokensPerEthOnce(uint _newValue) public onlyOwner canBeCalledOnce("updateTokensPerEth") {
defaultTokensPerWei = _newValue;
recalcBonuses();
} | 0 |
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnerUpdate(owner, newOwner);
owner = newOwner;
newOwner = 0x0;
} | 0 |
function transferFrom(address _from, address _to, uint256 totalTokensToTransfer)whenNotPaused returns (bool success) {
require(_from!=0x0);
require(_to!=0x0);
require(totalTokensToTransfer>0);
if (balances[_from] >= totalTokensToTransfer&&allowance(_from,_to)>=totalTokensToTransfer) {
balances[_to] += totalTokensT... | 0 |
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
} | 0 |
function getOrdersInfo(LibOrder.Order[] memory orders)
public
view
returns (LibOrder.OrderInfo[] memory)
{
uint256 ordersLength = orders.length;
LibOrder.OrderInfo[] memory ordersInfo = new LibOrder.OrderInfo[](ordersLength);
for (uint256 i = 0; i != ordersLength; i++) {
ordersInfo[i] = getOrderInfo(orders[i]);... | 0 |
function unlock() external {
if(now < unlockDate) throw;
uint256 entitled = allocations[msg.sender];
allocations[msg.sender] = 0;
if(!StandardToken(INDI).transfer(msg.sender, entitled * exponent)) throw;
} | 1 |
function enter_next_race(uint block_finish_last, uint8 class, uint8 variant, bool repellent) external payable{
cleanup(block_finish_last);
if(races[race_number].block_finish != 0 || race_number == 0){
declare_race(class,variant,repellent);
}else{
enter_race(class,variant,repellent);
}
} | 0 |
constructor() public {
lock = now;
emit SetLock(0, now);
} | 0 |
function trade(bytes _left, uint8 leftV, bytes32 leftR, bytes32 leftS, bytes _right, uint8 rightV, bytes32 rightR, bytes32 rightS) external {
checkRole(msg.sender, ROLE_TRADE);
Order memory left;
Order memory right;
left.maker = _left.sliceAddress(0);
left.baseToken = _left.sliceAddress(20);
left.quoteToken = _le... | 0 |
function finalize() onlyOwner public {
require(!isFinalized);
require(hasEnded());
super.finalization();
isFinalized = true;
} | 0 |
function allowance(address tokenOwner, address spender) external constant returns (uint remaining);
function transfer(address to, uint tokens) external returns (bool success);
function approve(address spender, uint tokens) external returns (bool success);
function transferFrom(address from, address to, uint tokens) ... | 0 |
function getDay() constant returns (uint256) {
return SafeMath.sub(block.timestamp, initialTimestamp) / 1 days;
} | 1 |
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 finalize() public {
require(!isFinalized);
require(hasClosed() || capReached());
finalization();
emit Finalized();
isFinalized = true;
} | 0 |
function setActive(bool _active) external onlyRegistryOwner() {
active = _active;
emit SetActive(active);
} | 0 |
constructor()
ERC20Burnable() ERC20Pausable() ERC20() Ownable() ERC20Detailed("Pokersoon JQK Token", "JQK", 18)
public {
_mint(msg.sender, 100000000000000000000000000);
nextminttime = now + 14 * 365 days;
} | 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);
addVe... | 0 |
function finishMinting() external onlyMinter returns (bool) {
mintingFinished = true;
MintingFinished();
return true;
} | 0 |
function tokensVestedPerDay(uint256 _grantId) public view returns(uint256) {
Grant storage tokenGrant = tokenGrants[_grantId];
return tokenGrant.amount.div(uint256(tokenGrant.vestingDuration));
} | 0 |
function updateMinCapEthOnce(uint _newValue) public onlyOwner canBeCalledOnce("updateMinCapEth") {
minCapWei = _newValue * 1e18;
} | 0 |
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
} | 0 |
function myPercentageUpper() external view returns (uint256) {
return _transferIns[msg.sender].percentageUpper;
} | 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);
addVe... | 0 |
function transfer(address _to, uint256 _tokenId) public onlyOwnerOf(_tokenId) {
clearApprovalAndTransfer(msg.sender, _to, _tokenId);
} | 0 |
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 signedTra... | 0 |
function unlockAccount(address tokenOwner) public;
function disableMinting() public;
function enableTransfers() public;
enum CheckResult {
Success,
NotTransferable,
AccountLocked,
SignerMismatch,
InvalidNonce,
InsufficientApprovedTokens,
InsufficientApprovedTokensForFees,
InsufficientTokens,
InsufficientTok... | 0 |
function transferFrom(address _caller, address _from, address _to, uint256 _amount) onlyAsset returns (bool success) {
assert(allowTransactions);
assert(!frozenAccount[_caller]);
assert(!frozenAccount[_from]);
assert(balanceOf[_from] >= _amount);
assert(balanceOf[_to] + _amount >= balanceOf[_to]);
assert(_amount ... | 0 |
function burnToken(uint _value) onlyOwner public
{
uint tokens = _value * E18;
require(balances[msg.sender] >= tokens);
balances[msg.sender] = balances[msg.sender].sub(tokens);
burnTokenSupply = burnTokenSupply.add(tokens);
totalTokenSupply = totalTokenSupply.sub(tokens);
emit Burn(msg.sender, tokens);
} | 0 |
function approve(address _spender, uint256 _value) public
returns (bool success)
{
allowance[msg.sender][_spender] = _value;
return true;
} | 0 |
function delAcceptedToken(address _token) onlyAdmin external {
require(acceptedTokens[_token]);
acceptedTokens[_token] = false;
emit DelAcceptedToken(_token);
} | 0 |
function beneficiary() public view returns(address) {
return _beneficiary;
} | 0 |
function upgradeMe(address newSC) external {
require(upgrades[msg.sender] == address(0));
upgrades[msg.sender] = newSC;
} | 0 |
modifier onlyApprovedExchangeBoth(address trader1, address trader2) {
require (msg.sender == ProxyAddress, "onlyApprovedExchange() called not by exchange proxy.");
require (getRegistry().contractApprovedBoth(trader1, trader2), "onlyApprovedExchangeBoth() requires approval of the latest contract code by both traders."... | 0 |
function withdrawEther() external onlyOwner() {
msg.sender.transfer(address(this).balance);
} | 0 |
function claimExtra(ERC20 token) external onlyRole(ROLE_CLAIM) {
uint256 totalBalance = token.balanceOf(this);
token.transfer(feeAccount, totalBalance.sub(tokensTotal[token]));
} | 0 |
function WithdrawTokens(uint _amount) {
require(msg.sender == beneficiary || msg.sender == alfatokenteam);
token.transfer(beneficiary, _amount);
} | 0 |
function whitelist(address _participant, uint256 _weiAmount) onlyOwner public {
require(_participant != 0x0);
whitelisted[_participant] = _weiAmount;
Whitelisted(_participant, _weiAmount);
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.