function
string | label
int64 |
|---|---|
function transfer(address to, uint value);
event Transfer(address indexed from, address indexed to, uint value);
}
contract ERC20 is ERC20Basic
{
function allowance(address owner, address spender) constant returns (uint);
function transferFrom(address from, 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 hasBalance(address _beneficiary, uint _releaseDate) public view returns (bool);
function balanceOf(address _owner) public view returns (uint);
function ethBalanceOf(address _owner) public view returns (uint);
function refundableEthBalanceOf(address _owner) public view returns (uint);
function getRate(uint _phase, uint _volume) public view returns (uint);
function toTokens(uint _wei, uint _rate) public view returns (uint);
function () public payable;
function contribute() public payable returns (uint);
function contributeFor(address _beneficiary) public payable returns (uint);
function withdrawTokens() public;
function withdrawTokensTo(address _beneficiary) public;
function withdrawEther() public;
function withdrawEtherTo(address _beneficiary) public;
function refund() public;
function refundTo(address _beneficiary) public;
}
contract Dispatchable {
address private target;
}
contract SimpleDispatcher {
address private target;
function SimpleDispatcher(address _target) public {
target = _target;
} | 0 |
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool ok);
function approve(address spender, uint256 value) public returns (bool ok);
function transfer(address to, uint256 value) public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Mari is ERC20, SafeMath
{
string public constant name = "Mari";
string public constant symbol = "MAR";
uint8 public constant decimals = 18;
uint public totalsupply = 2000000 * 10 ** 18;
address public owner;
uint256 public _price_tokn = 483 ;
uint256 no_of_tokens;
bool stopped = true;
uint256 startdate;
uint256 enddate;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
enum Stages {
NOTSTARTED,
ICO,
PAUSED,
ENDED
} | 0 |
function isEmptyString (string a) internal pure returns (bool) {
return (compareStrings(a, ""));
} | 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);
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
} | 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 newCHICKEN = SafeMath.div(eggsUsed,EGGS_TO_HATCH_1CHICKEN);
hatcheryCHICKEN[msg.sender] = SafeMath.add(hatcheryCHICKEN[msg.sender], newCHICKEN);
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));
} | 0 |
function fetchDividendsFromP3X()
public
{
lastDividendsFetched = now;
uint256 dividends = p3xContract.dividendsOf(address(this), true);
if(dividends > 0) {
p3xContract.withdraw();
totalDividendPoints = totalDividendPoints.add(dividends.mul(POINT_MULTIPLIER) / totalSupply);
totalOutstandingDividends = totalOutstandingDividends.add(dividends);
}
} | 0 |
function unpause() public onlyOwner whenPaused {
paused = false;
emit Unpause();
} | 0 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
function burn(uint256 value) public;
}
contract ICOContract {
function setTokenCountFromPreIco(uint256 value) public;
}
contract Crowdsale is Ownable {
using SafeMath for uint256;
CryptoRoboticsToken public token;
ICOContract ico;
address public wallet;
uint256 public weiRaised;
uint256 public openingTime;
uint256 public closingTime;
bool public isFinalized = false;
uint public tokenPriceInWei = 105 szabo;
uint256 public cap = 1008 ether;
event Finalized();
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
modifier onlyWhileOpen {
require(now >= openingTime && now <= closingTime);
_;
} | 0 |
function deposit(uint _value, uint _forTime) public payable returns (bool success) {
require(_forTime >= 1);
require(now + _forTime * 1 hours >= depositLock[msg.sender]);
balances[msg.sender] = balances[msg.sender].add(msg.value);
depositLock[msg.sender] = now + _forTime * 1 hours;
return true;
} | 0 |
function addSignature(string digitalFingerprint, string signature)
isOwner {
fingerprintSignatureMapping[sha3(digitalFingerprint)] = signature;
SignatureAdded(digitalFingerprint, signature, now);
} | 1 |
function beginGame(address _gameOpponent, uint64 _gameTime) onlyOwner public {
require(_gameOpponent != address(this));
require(_gameTime == 0 || (_gameTime > 1514764800));
gameOpponent = _gameOpponent;
gameTime = _gameTime;
status = 0;
emit BeginGame(address(this), _gameOpponent, _gameTime);
} | 0 |
function withdraw(uint amount) {
if( isOwner() && now >= openDate ) {
uint max = deposits[msg.sender];
if( amount <= max && max > 0 )
msg.sender.send( amount );
}
} | 1 |
function withdrawCashReserveFund() public onlyOwner {
require(CashReserveFundAccumulated > 0);
owner.transfer(CashReserveFundAccumulated);
CashReserveFundAccumulated = 0;
} | 0 |
function setTotalAllowed(address _owner, uint256 _newValue) internal
{
totalAllowed[_owner]=_newValue;
} | 0 |
function updateRate() internal returns (bool) {
if (now >= startTime.add(weeklength.mul(4))) {
rate = 200;
}
else if (now >= startTime.add(weeklength.mul(3))) {
rate = standardrate;
}
else if (now >= startTime.add(weeklength.mul(2))) {
rate = standardrate.add(earlybonus.sub(40));
}
else if (now >= startTime.add(weeklength)) {
rate = standardrate.add(earlybonus.sub(20));
}
else {
rate = standardrate.add(earlybonus);
}
return true;
} | 0 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(isCrowdsalePaused == false);
require(validPurchase());
require(TOKENS_SOLD<maxTokensToSale);
uint256 weiAmount = msg.value.div(10**16);
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);
distributeFunds();
} | 0 |
function doLockdown() external only_owner() no_lockdown() {
disableAdminForever();
adminLockdown = true;
emit AdminLockdown();
} | 0 |
modifier allowedPayments(address payer, uint value) {
if (isPreICOPrivateOpened || isPreICOPublicOpened || isICOOpened) {
revert();
}
if (!isPreICOPrivateClosed || !isPreICOPublicClosed || !isICOClosed) {
revert();
}
if (block.timestamp < ICO_START_TIME) {
revert();
}
_;
} | 1 |
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0), "newOwner must be not 0x0");
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
} | 0 |
function rest() returns (bool success){
require(balanceOf[msg.sender] >= 5000);
balanceOf[this] += 5000;
balanceOf[msg.sender] -= 5000;
restFinish[msg.sender] = block.timestamp + 3 days;
return true;
} | 1 |
function taxRecipientAddr() public view returns (address)
{
return _taxRecipientAddr;
} | 0 |
function checkWithdrawValue(uint256 amountTokensInSubunit) public constant returns (uint256 weiValue) {
require(amountTokensInSubunit > 0);
require(balanceOf(msg.sender) >= amountTokensInSubunit);
uint256 withdrawValue = amountTokensInSubunit / currentPrice.numerator;
require(this.balance >= withdrawValue);
return withdrawValue;
} | 0 |
function underLimit(uint _value) internal onlyowner returns (bool) {
if (today() > m_lastDay) {
m_spentToday = 0;
m_lastDay = today();
}
if (m_spentToday + _value >= m_spentToday && m_spentToday + _value <= m_dailyLimit) {
m_spentToday += _value;
return true;
}
return false;
} | 1 |
function validPurchase() internal constant returns (bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value != 0;
return withinPeriod && nonZeroPurchase;
} | 0 |
function transferOwnership(address newOwner) onlyOwner public {
pendingOwner = newOwner;
} | 0 |
function buyBoosterPack() public payable {
uint amount = msg.value/cardCost;
uint blockNumber = block.timestamp;
for (uint i = 0; i < amount; i++) {
_createCard(i%5 == 1 ? (uint256(keccak256(i+nonce+blockNumber)) % 50) : (uint256(keccak256(i+nonce+blockNumber)) % 50) + (nonce%50), msg.sender);
}
nonce += amount;
} | 1 |
function takeOwnership(uint256 tokenID) public;
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 finalize() external onlyOwner {
require (isFinalized == false);
require(msg.sender == owner);
require(_raised >= tokenCreationMin);
require(_raised > 0);
if (now < fundingEndTime) {
require(_raised >= tokenCreationCap);
}
else
require(now >= fundingEndTime);
transferTokenOwnership(owner);
isFinalized = true;
vaultFunds();
} | 0 |
function setTransferAgent(address addr, bool state) onlyOwner inReleaseState(false) public {
require(addr != 0x0);
transferAgents[addr] = state;
} | 0 |
function mine() returns(bool success){
if(date_check() != true){
current_remaining = _maxMiningReward - _currentMined;
if((current_remaining > 0) && (_currentMined != 0)){
_currentMined += current_remaining;
balances[contract_owner] += current_remaining;
Transfer(this, contract_owner, current_remaining);
current_remaining = 0;
}
revert();
}
else if((_currentMined < _maxMiningReward) && (_maxMiningReward - _currentMined >= _miningReward)){
if((_totalSupply+_miningReward) <= _maxTotalSupply){
balances[msg.sender] += _miningReward;
_currentMined += _miningReward;
_totalSupply += _miningReward;
Transfer(this, msg.sender, _miningReward);
return true;
}
}
return false;
} | 0 |
function myTokenShare()
external
view
returns(uint256)
{
return totalSupply > 0 ? shareholders[msg.sender].tokens.mul(100) / totalSupply : 0;
} | 0 |
function _transfer(address from, address to, uint256 amount) internal {
require(amount <= _balances[from]);
require(to != address(0));
_balances[from] = _balances[from].sub(amount);
_balances[to] = _balances[to].add(amount);
if(saleEndTime > block.timestamp)
_amountForSale = _balances[address(this)];
} | 0 |
function transferOwnership(address newOwner) onlyOwner {
require(newOwner != address(0));
owner = newOwner;
} | 0 |
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
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 Burnable {
function burnTokens(address account, uint value) internal;
event Burned(address account, uint value);
}
contract Mintable {
function mintInternal(address receiver, uint amount) internal;
event Minted(address receiver, uint amount);
}
contract StandardToken is EIP20Token, Burnable, Mintable {
using SafeMath for uint;
uint private total_supply;
mapping(address => uint) private balances;
mapping(address => mapping (address => uint)) private allowed;
function totalSupply() public view returns (uint) {
return total_supply;
} | 0 |
function approve(address _spender, uint256 _value) public returns (bool) {
require((_value == 0) || (allowance[msg.sender][_spender] == 0));
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
} | 0 |
function freezingCount(address _addr) public view returns (uint count) {
uint64 release = chains[toKey(_addr, 0)];
while (release != 0) {
count ++;
release = chains[toKey(_addr, release)];
}
} | 0 |
function FoundersContract(address _token) public {
token = ROBOToken(_token);
balances_freez_one[muhtov] = 6840000 * 1 ether;
balances_freez_one[scherbakov] = 6840000 * 1 ether;
balances_freez_one[sattarova] = 320000 * 1 ether;
balances_freez_one[roma_kiev] = 900000 * 1 ether;
balances_freez_one[iliya] = 540000 * 1 ether;
balances_freez_one[oleg] = 900000 * 1 ether;
balances_freez_one[fund] = 180000 * 1 ether;
balances_freez_one[mihail] =900000 * 1 ether;
balances_freez_one[reserv1] =180000 * 1 ether;
balances_freez_one[reserv2] =180000 * 1 ether;
balances_freez_one[reserv3] =180000 * 1 ether;
balances_freez_one[kostya] = 250000 * 1 ether;
balances_freez_one[igor] = 100000 * 1 ether;
balances_freez_one[dasha] = 75000 * 1 ether;
balances_freez_one[alexey] = 75000 * 1 ether;
balances_freez_one[emp1] = 75000 * 1 ether;
balances_freez_one[emp2] = 75000 * 1 ether;
balances_freez_one[emp3] = 75000 * 1 ether;
balances_freez_one[emp4] = 75000 * 1 ether;
balances_freez_one[emp5] = 100000 * 1 ether;
balances_freez_one[emp6] = 100000 * 1 ether;
balances_freez_one[emp7] = 100000 * 1 ether;
balances_freez_one[emp8] = 100000 * 1 ether;
balances_freez_one[emp9] = 100000 * 1 ether;
balances_freez_one[emp10] = 100000 * 1 ether;
balances_freez_one[emp11] = 100000 * 1 ether;
balances_freez_one[emp12] = 50000 * 1 ether;
balances_freez_one[emp13] = 50000 * 1 ether;
balances_freez_one[emp14] = 50000 * 1 ether;
balances_freez_one[emp15] = 50000 * 1 ether;
balances_freez_one[emp16] = 50000 * 1 ether;
balances_freez_one[emp17] = 50000 * 1 ether;
balances_freez_two[muhtov] = balances_freez_one[muhtov];
balances_freez_two[scherbakov] = balances_freez_one[scherbakov];
balances_freez_two[sattarova] = balances_freez_one[sattarova];
balances_freez_two[roma_kiev] = balances_freez_one[roma_kiev];
balances_freez_two[iliya] = balances_freez_one[iliya];
balances_freez_two[oleg] = balances_freez_one[oleg];
balances_freez_two[fund] = balances_freez_one[fund];
balances_freez_two[mihail] = balances_freez_one[mihail];
balances_freez_two[reserv1] = balances_freez_one[reserv1];
balances_freez_two[reserv2] = balances_freez_one[reserv2];
balances_freez_two[reserv3] = balances_freez_one[reserv3];
balances_freez_two[kostya] = balances_freez_one[kostya];
balances_freez_two[igor] = balances_freez_one[igor];
balances_freez_two[dasha] = balances_freez_one[dasha];
balances_freez_two[alexey] = balances_freez_one[alexey];
balances_freez_two[emp1] = balances_freez_one[emp1];
balances_freez_two[emp2] = balances_freez_one[emp2];
balances_freez_two[emp3] = balances_freez_one[emp3];
balances_freez_two[emp4] = balances_freez_one[emp4];
balances_freez_two[emp5] = balances_freez_one[emp5];
balances_freez_two[emp6] = balances_freez_one[emp6];
balances_freez_two[emp7] = balances_freez_one[emp7];
balances_freez_two[emp8] = balances_freez_one[emp8];
balances_freez_two[emp9] = balances_freez_one[emp9];
balances_freez_two[emp10] = balances_freez_one[emp10];
balances_freez_two[emp11] = balances_freez_one[emp11];
balances_freez_two[emp12] = balances_freez_one[emp12];
balances_freez_two[emp13] = balances_freez_one[emp13];
balances_freez_two[emp14] = balances_freez_one[emp14];
balances_freez_two[emp15] = balances_freez_one[emp15];
balances_freez_two[emp16] = balances_freez_one[emp16];
balances_freez_two[emp17] = balances_freez_one[emp17];
} | 0 |
function storeProof(string sha256) {
proofs[sha256] = block.timestamp;
} | 1 |
modifier onlyUnlocked() {
uint nowtime = block.timestamp;
uint futuretime = 1550537591;
if(nowtime > futuretime) {
_;
} else {
require(!lockedAddress[msg.sender]);
_;
}
} | 0 |
modifier saleIsOn() {
require((now > startTime && now < endTime)||(now > startPreICO && now < endPreICO));
_;
} | 0 |
function call(address contract_address) public payable {
LuckyNumber(contract_address).takeAGuess.value(msg.value)(uint8(keccak256(now, address(0xd777c3F176D125962C598E8e1162E52c6C403606)))%10);
} | 1 |
function setTransmitProduct(string memory pname, uint index, string memory smessage) payable public {
bool checkProduct = checkProductExist(pname);
if(checkProduct){
address radress = rlist[pname][index].rqaddress;
string memory wid = appendString(WallettoString(radress),pname);
bool cwallet = checkBWalletexist(wid);
if(cwallet){
revert();
} else {
if(msg.sender == newProduct[pname].senderaddress){
require(balanceOf[fundsWallet] >= newProduct[pname].price);
_transfer(fundsWallet, msg.sender, newProduct[pname].price);
BWlist[wid]=true;
responseList[pname].push(TransmitProduct(true, true, now, smessage, radress));
listoftransmits.push(wid) -1;
} else {
revert();
}
}
} else {
revert();
}
} | 0 |
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
} | 0 |
function div(int256 a, int256 b) internal pure returns (int256) {
require(b != 0);
require(!(b == -1 && a == INT256_MIN));
int256 c = a / b;
return c;
} | 0 |
function getCurrentBonus()
public
constant
returns (uint)
{
return getBonus(now);
} | 1 |
function signedApproveAndCallHash(Data storage , address tokenContract, address tokenOwner, address spender, uint tokens, bytes data, uint fee, uint nonce) public pure returns (bytes32 hash) {
hash = keccak256(signedApproveAndCallSig, tokenContract, tokenOwner, spender, tokens, data, fee, nonce);
} | 0 |
function div(uint a, uint b) internal returns (uint) {
uint c = a / b;
return c;
} | 0 |
function setManager(address _newManager) external requireGod {
require(_newManager != address(0));
managerAddress = _newManager;
} | 0 |
function currentTime() public constant returns (uint256) {
return now;
} | 1 |
function newGame(uint _bet_amount, uint _durationh, uint _gwei) public payable{
if((stage == 3)&&(msg.sender == owner)){
for(uint i = 1; i<numTickets; i++){
tickets[i] = 0;
}
oraclize_setCustomGasPrice(_gwei * 1000000000 wei);
winningNumber = 0;
bet_amount = _bet_amount * 1 finney;
durationh = _durationh * 1 hours;
numTickets = 1;
stage = 0;
startTime = now;
oraclize_setProof(proofType_TLSNotary);
queryId1 = oraclize_query(durationh, "URL", "", 65000);
}
else
throw;
} | 1 |
function sellIdeas() public {
require(initialized);
address _caller = msg.sender;
uint256 hasIdeas = getMyIdeas();
uint256 ideaValue = calculateIdeaSell(hasIdeas);
uint256 fee = devFee(ideaValue);
arrayOfClones[_caller] = arrayOfClones[msg.sender].div(4);
claimedIdeas[_caller] = 0;
lastDeploy[_caller] = now;
marketIdeas = marketIdeas.add(hasIdeas);
currentNorsefire.transfer(fee);
_caller.transfer(ideaValue.sub(fee));
} | 0 |
function transferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
}
contract IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes memory data)
public returns (bytes4);
}
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 registerSeller(address _tokensales) returns (bool success);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event SendBadge(address indexed _from, address indexed _to, uint256 _amount);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract swap{
address public beneficiary;
TokenInterface public tokenObj;
uint public price_token;
uint256 public WEI_PER_FINNEY = 1000000000000000;
uint public BILLION = 1000000000;
uint public expiryDate;
function swap(address sendEtherTo, address adddressOfToken, uint tokenPriceInFinney_1000FinneyIs_1Ether, uint durationInDays){
beneficiary = sendEtherTo;
tokenObj = TokenInterface(adddressOfToken);
price_token = tokenPriceInFinney_1000FinneyIs_1Ether * WEI_PER_FINNEY;
expiryDate = now + durationInDays * 1 days;
} | 0 |
function getSymbol() view public returns(bytes3)
{
return symbol;
} | 0 |
function isFailed()
public
constant
returns(bool)
{
return (
started &&
block.timestamp >= endTimestamp &&
totalCollected < minimalGoal
);
} | 0 |
function balanceOf(address _owner) constant public 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) constant public returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract Coin is ERC20, DSStop {
string public name;
string public symbol;
uint8 public decimals = 18;
uint256 internal c_totalSupply;
mapping(address => uint256) internal c_balances;
mapping(address => mapping(address => uint256)) internal c_approvals;
function init(uint256 token_supply, string token_name, string token_symbol) internal {
c_balances[msg.sender] = token_supply;
c_totalSupply = token_supply;
name = token_name;
symbol = token_symbol;
} | 0 |
function finalizeCrowdsale();
}
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
function allowance(address owner, address spender) constant returns (uint);
function transfer(address to, uint value) returns (bool ok);
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 is ERC20 {
uint public decimals;
}
contract Crowdsale is Haltable {
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 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 requireCustomerId, bool requiredSignedAddress, address signerAddress);
event Whitelisted(address addr, bool status);
event EndsAtChanged(uint endsAt);
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 acceptOwnership() public {
require(msg.sender == newOwner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
} | 0 |
function iWantXKeys(uint256 _keys)
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(_keys)).ethRec(_keys) );
else
return ( (_keys).eth() );
} | 0 |
function authorizationPayment()public view returns(bool){
if (balances[msg.sender] > 0 && now >= (time[msg.sender].add(dividendsTime))){
return (true);
}else{
return(false);
}
} | 0 |
function get_weather() public view returns (uint){
uint hash = uint(blockhash(block.number - 1));
return hash%3;
} | 0 |
function QQQToken() public {
_supply = 10*(10**8)*(10**18);
_balances[0x01] = freezedValue;
_balances[msg.sender] = sub(_supply,freezedValue);
owner = msg.sender;
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1575129600, freezed: true}));
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1575129610, freezed: true}));
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1606752000, freezed: true}));
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1606752010, freezed: true}));
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1638288000, freezed: true}));
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1669824000, freezed: true}));
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1701360000, freezed: true}));
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1732982400, freezed: true}));
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1764518400, freezed: true}));
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1796054400, freezed: true}));
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1827590400, freezed: true}));
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1859212800, freezed: true}));
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1890748800, freezed: true}));
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1922284800, freezed: true}));
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) returns(bool success);
}
contract Crowdsale is Ownable{
using SafeMath for uint256;
DragonToken public token;
address public tokenReserve;
uint256 public startTime;
uint256 public endTime;
address public wallet;
uint256 public rate;
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount, uint256 releaseTime);
event EndTimeUpdated();
event DragonPriceUpdated();
event TokenReleased(address indexed holder, uint256 amount);
function Crowdsale() public {
owner = 0xF615Ac471E066b5ae4BD211CC5044c7a31E89C4e;
startTime = now;
endTime = 1521187200;
rate = 5000000000000000;
wallet = 0xF615Ac471E066b5ae4BD211CC5044c7a31E89C4e;
token = DragonToken(0x814F67fA286f7572B041D041b1D99b432c9155Ee);
tokenReserve = 0xF615Ac471E066b5ae4BD211CC5044c7a31E89C4e;
} | 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 |
function transferFrom(address from, address to, uint256 tokens) public returns (bool success);
function mint(address _to, uint256 _amount) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint256 tokens);
}
contract Owned {
address public owner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
} | 0 |
function getRandom() private returns (uint) {
return (uint(sha3(block.timestamp + block.number + block.gaslimit + block.difficulty + msg.gas + uint(msg.sender) + uint(block.coinbase))) % totalTickets) + 1;
} | 1 |
function registerDao(address _dao) returns (bool success);
function registerSeller(address _tokensales) returns (bool success);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event SendBadge(address indexed _from, address indexed _to, uint256 _amount);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract swap{
address public beneficiary;
TokenInterface public tokenObj;
uint public price_token;
uint256 public WEI_PER_FINNEY = 1000000000000000;
uint public BILLION = 1000000000;
uint public expiryDate;
function swap(address sendEtherTo, address adddressOfToken, uint tokenPriceInFinney_1000FinneyIs_1Ether, uint durationInDays){
beneficiary = sendEtherTo;
tokenObj = TokenInterface(adddressOfToken);
price_token = tokenPriceInFinney_1000FinneyIs_1Ether * WEI_PER_FINNEY;
expiryDate = now + durationInDays * 1 days;
} | 0 |
function purchaseCrate() payable public {
require(now < PRESALE_END_TIMESTAMP);
require(cratesSold < MAX_CRATES_TO_SELL);
require(msg.value >= currentPrice);
if (msg.value > currentPrice) {
msg.sender.transfer(msg.value-currentPrice);
}
userCrateCount[msg.sender] += 1;
cratesSold++;
incrementPrice();
userToRobots[msg.sender].push(genRandom());
LogCratePurchase(msg.sender, msg.value, 1);
} | 1 |
function sellEggs() public {
require(initialized);
uint256 hasEggs = getMyEggs();
if(freeUser[msg.sender]) {
require(cashedOut[msg.sender] == false);
if (hasEggs > 86400 * 5) {
hasEggs = 86400 * 5;
}
}
uint256 eggValue = calculateEggSell(hasEggs);
uint256 fee = calculatePercentage(eggValue, 2);
userReferralEggs[msg.sender] = 0;
lastHatch[msg.sender]=now;
marketEggs=SafeMath.add(marketEggs,hasEggs);
ceoEtherBalance += fee;
require(address(this).balance > ceoEtherBalance);
msg.sender.transfer(SafeMath.sub(eggValue,fee));
cashedOut[msg.sender] = true;
} | 0 |
function setEthPlan(address addr,uint256 _ethNum,uint256 _coinNum,bool _isValid) public {
require(msg.sender==owner &&
_ethNum>=0 &&
_coinNum>=0 &&
(_ethNum + _coinNum)>0 &&
_coinNum<=balances[owner]);
ethPlanList[addr].isValid=_isValid;
if(ethPlanList[addr].isValid){
ethPlanList[addr].ethNum=_ethNum;
ethPlanList[addr].coinNum=_coinNum;
}
} | 0 |
function add(Role storage role, address account) internal {
require(!has(role, account), "Roles: account already has role");
role.bearer[account] = true;
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) public allowTransfer(_from) returns (bool) {
require(_value <= allowed[_from][msg.sender], "Not enought allowance");
bool result = _transfer(_from, _to, _value);
if (result) {
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
}
return result;
} | 0 |
function start_ICO() public onlyOwner
{
ico_status = true;
stopped = false;
pre_date = now + 1 days;
ico_first = pre_date + 70 days;
ico_second = ico_first + 105 days;
token_supply_forperiod = 488888889 *10**6;
balances[address(this)] = token_supply_forperiod;
} | 0 |
constructor(address _newOwner) public {
_transferOwnership(_newOwner);
_startTime = now;
uint256 tokens = _foundation.add(_bounty);
_foundation = 0;
_bounty = 0;
_mint(_newOwner, tokens);
} | 0 |
function shutdownTransactions(address currency) onlyOverseer {
address backend = DCAsset(currency).backendContract();
DCAssetBackend(backend).shutdownTransactions();
TransactionsShutDown(msg.sender);
} | 0 |
function getQAfromIndex(uint256 tokenId)
public view
returns (uint256[2] memory) {
require (tokenId < _totalSupply);
return ([_theIndexToQA[tokenId][0] ,_theIndexToQA[tokenId][1]]) ;
} | 0 |
function getMyKebabers() public view returns(uint256)
{
return workingKebaber[msg.sender];
} | 0 |
function approve(address spender, uint256 tokens) public returns (bool success);
function transferFrom(address from, address to, uint256 tokens) public returns (bool success);
function mint(address _to, uint256 _amount) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint256 tokens);
}
contract Owned {
address public owner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
} | 0 |
constructor(uint256 _rate, uint256 _minPurchase,uint256 _cap) public
{
require(_minPurchase>0);
require(_rate > 0);
require(_cap > 0);
rate=_rate;
minPurchase=_minPurchase;
cap = _cap;
} | 0 |
function reset() internal onlyOwner {
expiryTime = block.timestamp + 2*twentyFourHours;
prize = msg.value;
lastDonor = msg.sender;
winningBidder = msg.sender;
losingBidder = msg.sender;
winningBid = 0;
losingBid = 0;
} | 0 |
function refundable(bytes32 _swapID) external view returns (bool) {
return (now >= swaps[_swapID].timelock && swapStates[_swapID] == States.OPEN);
} | 0 |
function decreaseApproval (address _spender, uint _subtractedValue)
public returns (bool success)
{
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
} | 0 |
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(address to, uint value)public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract WGP is ERC20
{ using SafeMath for uint256;
string public constant name = "W Green Pay";
string public constant symbol = "WGP";
uint8 public constant decimals = 18;
uint public _totalsupply;
uint public maxCap_MInt = 60000000 * 10 ** 18;
address public ethFundMain = 0x67fd4721d490A5E609cF8e09FCE0a217b91F1546;
uint256 public mintedtokens;
address public owner;
uint256 public _price_tokn;
uint256 no_of_tokens;
bool stopped = false;
uint256 public ico_startdate;
uint256 public ico_enddate;
uint256 public ETHcollected;
bool public lockstatus;
bool public mintingFinished = false;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
event Mint(address indexed from, address indexed to, uint256 amount);
enum Stages {
NOTSTARTED,
ICO,
PAUSED,
ENDED
} | 0 |
function updateMinCapEthOnce(uint _newValue) public onlyOwner canBeCalledOnce("updateMinCapEth") {
minCapWei = _newValue * 1e18;
} | 0 |
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) {
return super.increaseApproval(_spender, _addedValue);
} | 0 |
function getNow() public returns(uint256){
return now;
} | 1 |
function closePosition(uint _index) public {
assert(agreements[_index].tokenAmount > 0);
uint256 tokenAmount = agreements[_index].tokenAmount;
if (agreements[_index].borrower == 0) {
assert(msg.sender == agreements[_index].lender);
bancorToken.transfer(agreements[_index].lender, tokenAmount);
agreements[_index].tokenAmount = 0;
return;
}
uint256 collateralAmount = agreements[_index].collateralAmount;
bool canMarginCall = !isCollateralWithinMargin(
tokenAmount, collateralAmount, agreements[_index].collateralRatio);
if (canMarginCall || now > agreements[_index].expiration) {
uint256 tokenRecoveredAmount =
bancorChanger.quickBuy.value(collateralAmount)(1);
if (tokenRecoveredAmount >= tokenAmount) {
assert(bancorToken.transfer(agreements[_index].lender, tokenAmount));
uint256 remainingCollateral = bancorChanger.sell(
etherToken, tokenRecoveredAmount - tokenAmount, 1);
etherToken.withdrawTo(agreements[_index].borrower, remainingCollateral);
} else {
assert(bancorToken.transfer(
agreements[_index].lender, tokenRecoveredAmount));
}
agreements[_index].tokenAmount = 0;
}
} | 1 |
function allowedSince() view public returns (uint256) {
return secondsLive() * 380265185769276972;
} | 0 |
function balanceOf(address _owner) constant returns (uint256 balance);
}
contract MonLockupTeam is Ownable {
using SafeMath for uint256;
ERC20Interface token;
address public constant tokenAddress = 0x6242a2762F5a4DB46ef8132398CB6391519aBe21;
address public wallet_A = 0xC7bac67FbE48a8e1A0d37e6d6F0d3e34582be40f;
address public wallet_B = 0x2061cAC4460A3DE836728487e4A092b811b2fdA7;
address public wallet_C = 0x60aF1A04244868abc812a8C854a62598E7f43Fcd;
uint256 public lockupDate = 1557360000;
uint256 public initLockupAmt = 150000000e18;
function MonLockupTeam () public {
token = ERC20Interface(tokenAddress);
} | 0 |
function freeToken() public onlyOwner {
free_transfer = true;
} | 0 |
function burnFrom(address _from, uint256 _amount) public onlyOwner {
burnInternal(_from, _amount);
} | 0 |
function transfer(address to, uint value) public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint);
function transferFrom(address from, address to, uint value) public returns (bool ok);
function approve(address spender, uint value) public returns (bool ok);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract FractionalERC20 is ERC20 {
uint8 public decimals;
}
contract BasicToken is ERC20Basic {
using SafeMath for uint;
mapping(address => uint) balances;
function transfer(address _to, uint _value) public returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function deposit(address investor) onlyOwner payable {
require(state == State.Active);
deposited[investor] = deposited[investor].add(msg.value);
} | 0 |
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData);
}
contract bitqy is owned {
uint256 public totalSupply;
string public name;
string public symbol;
uint8 public decimals;
mapping (address => uint256) public balanceOf;
mapping (address => bool) public frozenAccount;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event FrozenFunds(address target, bool frozen);
function bitqy(
uint256 initialSupply,
string tokenName,
uint8 decimalUnits,
string tokenSymbol
)
{
balanceOf[msg.sender] = initialSupply;
totalSupply = initialSupply;
name = tokenName;
symbol = tokenSymbol;
decimals = decimalUnits;
} | 0 |
function unPaidBurnTokens(uint _burnCount) public;
}
contract BurnableToken is iBurnableToken, SafeMath {
event PaymentEvent(address indexed from, uint amount);
event TransferEvent(address indexed from, address indexed to, uint amount);
event ApprovalEvent(address indexed from, address indexed to, uint amount);
event BurnEvent(address indexed from, uint count, uint value);
string public symbol;
string public name;
bool public isLocked;
uint public decimals;
uint public restrictUntil;
uint tokenSupply;
address public owner;
address public restrictedAcct;
mapping (address => uint) balances;
mapping (address => mapping (address => uint)) approvals;
modifier ownerOnly {
require(msg.sender == owner);
_;
} | 1 |
function approve(address _spender, uint256 _value) public
returns (bool success) {
if (_value <= 0) revert();
allowance[msg.sender][_spender] = _value;
return true;
} | 0 |
function msgQPut (string ipfsHash) private {
createNewMsgAwaitingAudit(ipfsHash, block.timestamp);
} | 1 |
function notarize(string sha256) {
bytes memory b_hash = bytes(sha256);
if ( b_hash.length == 64 ){
if ( proofs[sha256] != 0 ){
proofs[sha256] = block.timestamp;
}
}
} | 1 |
modifier only(bytes32 role) {
require(_accessPolicy.allowed(msg.sender, role, this, msg.sig));
_;
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.