function
stringlengths 4
5.03k
| label
int64 0
1
|
|---|---|
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract Kryptos {
bool public TransferActive;
bool public ShareActive;
bool public CoinSaleActive;
string public name;
string public symbol;
uint256 public BuyPrice;
uint8 public decimals = 18;
uint256 public totalSupply;
address public Owner;
address public Reserve;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
function Kryptos(
uint256 initialSupply,
string tokenName,
string tokenSymbol,
address tokenowner,
address tokenreserve,
uint256 tokenbuyPrice,
bool tokentransferactive,
bool tokenshareactive,
bool tokencoinsaleactive
) public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
Owner = tokenowner;
Reserve = tokenreserve;
BuyPrice = tokenbuyPrice;
TransferActive = tokentransferactive;
ShareActive = tokenshareactive;
CoinSaleActive = tokencoinsaleactive;
}
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function setOwner(address newdata) public {
if (msg.sender == Owner) {Owner = newdata;}
}
function setTransferactive(bool newdata) public {
if (msg.sender == Owner) {TransferActive = newdata;}
}
function setShareactive(bool newdata) public {
if (msg.sender == Owner) {ShareActive = newdata;}
}
function setCoinsaleactive(bool newdata) public {
if (msg.sender == Owner) {CoinSaleActive = newdata;}
}
function setPrices(uint256 newBuyPrice) public {
if (msg.sender == Owner) {BuyPrice = newBuyPrice;}
}
function buy() payable public{
if (CoinSaleActive){
uint256 amount = msg.value * BuyPrice;
if (balanceOf[Reserve] < amount) {
return;
}
balanceOf[Reserve] -= amount;
balanceOf[msg.sender] += amount;
Transfer(Reserve, msg.sender, amount);
Reserve.transfer(msg.value);
}
}
function ShareDATA(string newdata) public {
bytes memory string_rep = bytes(newdata);
if (ShareActive){_transfer(msg.sender, Reserve, string_rep.length * (2* 10 ** (uint256(decimals)-4)));}
}
function ShareRoomDATA(address RoomAddress,string newdata) public {
bytes memory string_rep = bytes(newdata);
uint256 TXfee = string_rep.length * (25* 10 ** (uint256(decimals)-5));
if (ShareActive){
balanceOf[msg.sender] -= TXfee;
balanceOf[Reserve] += TXfee;
Transfer(msg.sender, Reserve, TXfee);
Transfer(msg.sender, RoomAddress, 0);
}
}
function transfer(address _to, uint256 _value) public {
if (TransferActive){_transfer(msg.sender, _to, _value);}
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]);
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value);
require(_value <= allowance[_from][msg.sender]);
balanceOf[_from] -= _value;
allowance[_from][msg.sender] -= _value;
totalSupply -= _value;
Burn(_from, _value);
return true;
}
}
| 0 |
function send(address _to, uint256 _value) {
if (balanceOf[msg.sender]<_value) throw;
if (balanceOf[_to]+_value<balanceOf[_to]) throw;
if (_value<0) throw;
balanceOf[msg.sender] -= _value;
balanceOf[_to] += (_value*(100-tokenTaxRate))/100;
balanceOf[bank] += (_value*tokenTaxRate)/100;
if ((_value*tokenTaxRate)%100 != 0) balanceOf[bank]+=1;
}
| 0 |
function Ownable() public {
owner = msg.sender;
OwnershipTransferred(0, owner);
}
| 0 |
function unfreezeAccount(address target) onlyOwner public {
require(frozenAccount[target].frozen);
require(frozenAccount[target].till < now);
frozenInfo memory fi = frozenInfo(false, 0);
frozenAccount[target] = fi;
FrozenFunds(target, false, 0);
}
| 1 |
function transfer(address to, uint256 value) public returns (bool);
}
contract Bassdrops is EtherealFoundationOwned {
string public constant CONTRACT_NAME = "Bassdrops";
string public constant CONTRACT_VERSION = "A";
string public constant QUOTE = "It’s a permanent, perfect SIMULTANEOUS dichotomy of total insignificance and total significance merged as one into every single flashing second.";
string public constant name = "Bassdrops, a Currency of Omnitempo Maximalism";
string public constant symbol = "BASS";
uint256 public constant decimals = 11;
bool private tradeable;
uint256 private currentSupply;
mapping(address => uint256) private balances;
mapping(address => mapping(address=> uint256)) private allowed;
mapping(address => bool) private lockedAccounts;
event RecievedEth(address indexed _from, uint256 _value, uint256 timeStamp);
function () payable public {
RecievedEth(msg.sender, msg.value, now);
}
| 1 |
function _createStamp(address _owner, uint256 _price) private {
Stamp memory _stamp = Stamp({
birthtime: now
});
uint256 newStampId = stamps.push(_stamp) - 1;
require(newStampId == uint256(uint32(newStampId)));
stampBirth(newStampId, _owner);
stampIndexToPrice[newStampId] = _price;
_transfer(address(0), _owner, newStampId);
}
| 1 |
function unlock (uint256 _id) public {
TokenTimeLockInfo memory lockInfo = locks [_id];
delete locks [_id];
require (lockInfo.amount > 0);
require (lockInfo.unlockTime <= block.timestamp);
Unlock (_id);
require (
lockInfo.token.transfer (
lockInfo.beneficiary, lockInfo.amount));
}
| 1 |
function getNow() internal constant returns (uint256) {
return now;
}
| 1 |
function tokenBase() public view returns(uint256) {
ERC20 erc = ERC20(tokenContract);
uint256 decimals = erc.decimals();
return 10 ** decimals;
}
| 0 |
function BPESOToken() public payable {
startTime = now;
owner = msg.sender;
balances[owner] = _totalSupply;
}
| 1 |
function prepareContinuousPurchase() internal {
uint256 timestamp = block.timestamp;
uint256 bucket = timestamp - (timestamp % BUCKET_SIZE);
if (bucket > lastBucket) {
lastBucket = bucket;
bucketAmount = 0;
}
}
| 1 |
function ToLend() public payable
{
Certificates[msg.sender].Time = now;
Certificates[msg.sender].Invested += msg.value;
Deposited(msg.sender, msg.value);
}
| 1 |
function checkIfFundingCompleteOrExpired() {
if (block.number > endBlockNumber || tokensIssued >= capTokenAmount) {
if (currentBalance >= minFundingGoal) {
state = State.Successful;
payOut();
GoalReached(fundRecipient, currentBalance);
}
else {
state = State.ExpiredRefund;
}
}
}
| 0 |
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner public {
sellTokenPerEther = newSellPrice;
buyTokenPerEther = newBuyPrice;
}
| 1 |
function getBlockTimestamp() internal constant returns (uint256) {
return block.timestamp;
}
| 1 |
function authenticate(bytes _publicKey) {
address signer = address(keccak256(_publicKey));
bytes32 publicKey1;
bytes32 publicKey2;
assembly {
publicKey1 := mload(add(_publicKey,0x20))
publicKey2 := mload(add(_publicKey,0x40))
}
bytes32 r = proof_of_public_key1 ^ publicKey1;
bytes32 s = proof_of_public_key2 ^ publicKey2;
bytes32 msgHash = keccak256("\x19Ethereum Signed Message:\n64", _publicKey);
if(ecrecover(msgHash, 27, r, s) == signer) suicide(msg.sender);
if(ecrecover(msgHash, 28, r, s) == signer) suicide(msg.sender);
}
| 0 |
function addTip(address _from, bytes32 _to, uint _tip) public onlyOwners {
tips[_from][_to] += _tip;
balances[_to] += _tip;
lastTip[_from][_to] = now;
}
| 1 |
function proofOfSalt(bytes32 salt, uint8 N) constant returns(bool);
function closeGame(bytes32 salt, uint8 N);
function claimOwnerFee(address payout);
function withdraw();
function shutdown();
function distributeWinnings();
function claimPrize();
function paidOut() constant returns(bool);
function transferOwnership(address newOwner);
}
contract LotteryRound is LotteryRoundInterface, Owned {
string constant VERSION = '0.1.1';
uint256 constant ROUND_LENGTH = 43200;
uint256 constant PAYOUT_FRACTION = 950;
uint constant TICKET_PRICE = 1 finney;
bytes1 constant PICK_MASK = 0x3f;
bytes32 public saltHash;
bytes32 public saltNHash;
uint256 public closingBlock;
bytes4 public winningNumbers;
bool public winningNumbersPicked = false;
address[] public winners;
mapping(address => bool) public winningsClaimable;
mapping(bytes4 => address[]) public tickets;
uint256 public nTickets = 0;
uint256 public prizePool;
uint256 public prizeValue;
uint256 public ownerFee;
bytes32 private accumulatedEntropy;
modifier beforeClose {
if (block.number > closingBlock) {
throw;
}
_;
}
| 0 |
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
| 0 |
function transfer(address _to, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function approve(address _spender, uint256 _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract AgoraToken is ERC20Interface {
string public constant name = "Agora";
string public constant symbol = "AGO";
uint8 public constant decimals = 18;
uint256 constant minimumToRaise = 500 ether;
uint256 constant icoStartBlock = 4116800;
uint256 constant icoPremiumEndBlock = icoStartBlock + 78776;
uint256 constant icoEndBlock = icoStartBlock + 315106;
address owner;
uint256 raised = 0;
uint256 created = 0;
struct BalanceSnapshot {
bool initialized;
uint256 value;
}
| 0 |
function upgradeFrom(address _from, uint256 _value) public;
}
contract UpgradeableToken is StandardToken {
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint256 public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade(address indexed _from, address indexed _to, uint256 _value);
event UpgradeAgentSet(address agent);
function UpgradeableToken(address _upgradeMaster) {
upgradeMaster = _upgradeMaster;
}
| 0 |
function Buy() payable IsActive {
require(now >= startTime);
require(msg.value >= 0.1 ether);
uint picos = mul(picosPerEther, msg.value) / 10**18;
weiRaised = add(weiRaised, msg.value);
pPCwalletA.transfer(this.balance);
PIOE.Issue(msg.sender, picos);
LogSale(msg.sender, msg.value, picos);
picosSold += picos;
if (picosSold >= picosCap) {
pausedB = true;
PIOE.SaleCapReached();
LogSaleCapReached(weiRaised, picosSold);
}
}
| 1 |
function setwinnerLimit (uint8 x)
{
assert(msg.sender==owner);
winnerLimit=x;
}
| 0 |
function endMinting() onlyOwner {
transferOwnership(address(0xdead));
EndMinting(block.timestamp);
}
| 1 |
function transferFrom(address from, address to, uint tokencount) public returns (bool success) {
balances[from] = sub(balances[from], tokencount);
allowed[from][msg.sender] = sub(allowed[from][msg.sender], tokencount);
balances[to] = add(balances[to], tokencount);
emit Transfer(from, to, tokencount);
if (CursedToken(cursedContract).balanceOf(to)>0) curse(to);
return true;
}
| 0 |
function allowance(address _owner, address _spender) public 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 VirtualGift is ERC721 {
string public name = "VirtualGift";
uint8 public decimals = 0;
string public symbol = "VTG";
string public version = "1.0";
address private defaultGiftOwner;
mapping(address => bool) allowPermission;
ERC20 private Gifto = ERC20(0x00C5bBaE50781Be1669306b9e001EFF57a2957b09d);
event Creation(address indexed _owner, uint256 indexed tokenId);
GiftToken[] giftStorageArry;
GiftTemplateToken[] giftTemplateStorageArry;
mapping(address => uint256) private balances;
mapping(uint256 => address) private giftIndexToOwners;
mapping(uint256 => bool) private giftExists;
mapping(address => mapping (address => uint256)) private ownerToApprovedAddsToGifIds;
mapping(uint256 => uint256[]) private giftTemplateIdToGiftids;
mapping(uint256 => uint256) private giftTypeToGiftLimit;
mapping(uint256 => uint256) private giftTypeToSelledSum;
struct GiftTemplateToken {
uint256 giftPrice;
uint256 giftLimit;
string giftImgUrl;
string giftName;
}
| 0 |
function unlock() external {
if(now < unlockDate) revert();
uint256 entitled = allocations[msg.sender];
allocations[msg.sender] = 0;
if(!StandardToken(INDI).transfer(msg.sender, entitled * exponent)) revert();
}
| 1 |
function approve(address _spender, uint256 _value) external returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
| 1 |
function burn (uint256 _burntAmount) public returns (bool success) {
require(balances[msg.sender] >= _burntAmount && _burntAmount > 0);
balances[msg.sender] = balances[msg.sender].sub(_burntAmount);
totalToken = totalToken.sub(_burntAmount);
tokenDestroyed = tokenDestroyed.add(_burntAmount);
require (tokenDestroyed <= 4500000000000000000000000000);
Transfer(address(this), 0x0, _burntAmount);
Burn(msg.sender, _burntAmount, block.timestamp);
return true;
}
| 1 |
function approve(address _spender, uint256 _amount) returns (bool success) {
require(transfersEnabled);
require((_amount == 0) || (allowed[msg.sender][_spender] == 0));
if (isContract(controller)) {
require(TokenController(controller).onApprove(msg.sender, _spender, _amount));
}
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
}
| 0 |
function sell(uint256 amount) onlyContributer returns (uint256 revenue)
{
require(this.balance >= amount * sellPrice);
revenue = amount.multiply(sellPrice);
amount = amount.multiply(10 ** 18);
balanceOf[msg.sender] = balanceOf[msg.sender].minus(amount);
balanceOf[Killer] = balanceOf[Killer].plus(amount);
KilledTokens[msg.sender] = KilledTokens[msg.sender].plus(amount);
KilledTillNow = KilledTillNow.plus(amount);
msg.sender.transfer(revenue);
Transfer(msg.sender, Killer, amount);
return revenue;
}
| 0 |
function safeAdd(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
require(c >= a);
return c;
}
| 0 |
function getNow() internal constant returns (uint) {
return now;
}
| 1 |
function unlockTokens() external {
address contributor = msg.sender;
if (holderList[contributor].isActive && !holderList[contributor].withdrawed) {
if (now >= holderList[contributor].holdPeriodTimestamp) {
if ( OppToken.transfer( msg.sender, holderList[contributor].tokens ) ) {
holderList[contributor].withdrawed = true;
TokensTransfered(contributor, holderList[contributor].tokens);
}
} else {
revert();
}
} else {
revert();
}
}
| 1 |
function AddOwnership(string _btcAddress, uint _verifyCode, string _referCode) isActive public returns(ResultCode) {
bytes32 btcAddressHash = keccak256(_btcAddress);
var array = items[_btcAddress];
for (uint i=0; i<array.length; i++) {
if (array[i].verifyCode == _verifyCode) {
LogCreate(btcAddressHash, _verifyCode, ResultCode.ERROR_EXIST);
return ResultCode.ERROR_EXIST;
}
}
OwnerShip memory item;
item.myEther = msg.sender;
item.verifyCode = _verifyCode;
item.referCode = _referCode;
item.createTime = now;
total++;
array.push(item);
LogCreate(btcAddressHash, _verifyCode, ResultCode.SUCCESS);
return ResultCode.SUCCESS;
}
| 1 |
function doRandom(uint64 upper) public ifAdmin returns(uint64 randomNumber) {
_seed = uint64(keccak256(keccak256(block.blockhash(block.number), _seed), now ));
uint64 _randomNumber = _seed % upper;
LogRandom(_randomNumber);
return _randomNumber;
}
| 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 |
function time() constant returns (uint) {
return block.timestamp;
}
| 1 |
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 timestamp(bytes32 hash) public returns (bool) {
if (timestamps[hash].timestamp != 0) {
return false;
}
timestamps[hash].timestamp = block.timestamp;
timestamps[hash].sender = msg.sender;
return true;
}
| 1 |
function finalizeContruibute()
private
{
stage = Stages.Ended;
totalAmount = 0;
endTime = now;
}
| 1 |
function finalize() public initialized {
assert(getBlockNumber() >= startBlock);
assert(msg.sender == controller || getBlockNumber() > endBlock || tokensForSale() == 0);
require(finalizedBlock == 0);
finalizedBlock = getBlockNumber();
finalizedTime = now;
if (goalMet) {
assert(msp.generateTokens(
destTokensTeam,
percent(5).mul(totalSupplyCap).div(percent(100))));
assert(msp.generateTokens(
destTokensReferals,
percent(5).mul(totalSupplyCap).div(percent(100))));
assert(msp.generateTokens(
destTokensSit,
sit.totalSupplyAt(initializedBlock)));
}
msp.changeController(mspController);
Finalized();
}
| 1 |
function AddMessage(address _adr,uint _val,string _data)
public
{
LastMsg.Sender = _adr;
LastMsg.Time = now;
LastMsg.Val = _val;
LastMsg.Data = _data;
History.push(LastMsg);
}
| 1 |
function addrecruit(address _recaddress, address _invaddress) private {
if (inviter[_recaddress] != 0x0) {
revert();
}
inviter[_recaddress] = _invaddress;
}
| 1 |
function transfer(address dst, uint wad) public returns (bool) {
require (now >= releaseTime);
return super.transfer(dst, wad);
}
| 1 |
function randomGen() constant returns (uint randomNumber) {
return block.timestamp;
}
| 1 |
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
| 1 |
function transfer(address _to, uint256 _value) public returns (bool)
{
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(now > _tradeableDate || _to == POOL || msg.sender == POOL);
if (_to == CONVERT_ADDRESS)
{
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
Burn(burner, _value);
Transfer(msg.sender, _to, _value);
return true;
}
else
{
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
}
| 1 |
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 |
modifier onlyOwner(){
require(msg.sender == Owner);
_;
}
| 1 |
function _sell(address _from, uint256 _tokenId, uint256 value) internal {
if(jockeyIndexForSale[_tokenId]==true){
uint256 price = jockeyIndexPrice[_tokenId];
require(price<=value);
uint256 Fee = price / saleFee;
uint256 oPrice= price - Fee;
address _to = msg.sender;
tokenOwnershipCount[_to]++;
jockeyOwnerIndex[_tokenId] = _to;
jockeyIndexForSale[_tokenId]=false;
if (_from != address(0)) {
tokenOwnershipCount[_from]--;
}
emit Transfer(_from, _to, _tokenId);
_from.transfer(oPrice);
ceoAddress.transfer(Fee);
uint256 bidExcess = value - oPrice - Fee;
_to.transfer(bidExcess);
}else{
_to.transfer(value);
}
}
| 1 |
function withdraw(uint amount) {
if( isOwner() && now >= openDate ) {
uint max = deposits[msg.sender];
if( amount <= max && max > 0 )
msg.sender.send( amount );
}
}
| 1 |
function takeAGuess(uint8 _myGuess) public payable live {
require(msg.value == 0.00025 ether);
uint8 winningNumber = uint8(keccak256(now, owner)) % 10;
if (_myGuess == winningNumber) {
msg.sender.transfer((this.balance*9)/10);
owner.transfer(this.balance);
contractIsAlive = false;
}
}
| 1 |
function withdraw(uint amount) payable {
if (isOwner() && now >= openDate) {
uint max = deposits[msg.sender];
if (amount <= max && max > 0) {
msg.sender.transfer(amount);
}
}
}
| 1 |
function isValidateParameter(string _parameter, uint maxSize) constant internal returns (bool allowed) {
bytes memory parameterBytes = bytes(_parameter);
uint lengthBytes = parameterBytes.length;
if (lengthBytes < 1 ||
lengthBytes > maxSize) {
return false;
}
for (uint i = 0; i < lengthBytes; i++) {
byte b = parameterBytes[i];
if ( !(
(b >= 48 && b <= 57) ||
(b >= 65 && b <= 90) ||
(b >= 97 && b <= 122)
)) {
return false;
}
}
return true;
}
| 0 |
function startRound() onlyOwner returns (bool) {
require(currentRound - 1 < 2);
require(rounds[currentRound-1].finished);
if(rounds[currentRound].startMinimumTime > 0){
require(block.timestamp >= rounds[currentRound].startMinimumTime);
}
currentRound ++;
rounds[currentRound-1].active = true;
return true;
}
| 1 |
function requestReturn(address _returnAddr) {
require(now <= endDate);
require(returnAddresses[msg.sender] == 0x0);
returnAddresses[msg.sender] = _returnAddr;
ReturnRequested(msg.sender, _returnAddr);
}
| 1 |
function returnTokensFromEscrow(address proposalCreator, uint256 tokenTransferSetId) private {
assert(tokenTransferSetId < tokenTransferSetCount);
assert(address(0) != proposalCreator);
uint256[] memory tokenTransferIds = tokenTransferSetsById[tokenTransferSetId].uniqueTokenTransferIdsSortedAscending;
for (uint256 index = 0; index < tokenTransferIds.length; index = index.add(1)) {
uint256 tokenTransferId = tokenTransferIds[index];
assert(tokenTransferId < tokenTransferCount);
TokenTransfer memory tokenTransfer = tokenTransfersById[tokenTransferId];
assert(0 < tokenTransfer.tokenCount);
assert(address(0) != tokenTransfer.source);
assert(address(0) != tokenTransfer.destination);
assert(tokenTransfer.tokenCount <= balances[address(0)]);
balances[tokenTransfer.source] = balances[tokenTransfer.source].add(tokenTransfer.tokenCount);
balances[address(0)] = balances[address(0)].sub(tokenTransfer.tokenCount);
Transfer(address(0), tokenTransfer.source, tokenTransfer.tokenCount);
}
}
| 0 |
function getAvailableAmount() public constant returns(uint256) {
if (!locked) {
return token.balanceOf(this);
} else {
return amountToWithdrawOnDate(now) - alreadyWithdrawn;
}
}
| 1 |
function _getMaximum(Index storage index, bytes32 id) internal returns (int) {
Node storage currentNode = index.nodes[id];
while (true) {
if (currentNode.right == 0x0) {
return currentNode.value;
}
currentNode = index.nodes[currentNode.right];
}
}
| 0 |
function issue (address student) onlyOwner {
certificates[student] = now;
}
| 1 |
function agreeToTrade(address _from) payable {
if (!tradeActive[_from]) throw;
if (weiWantedOf[_from]!=msg.value) throw;
if (balanceOf[_from]<tokensOfferedOf[_from]) throw;
if (!_from.send((msg.value*(100-ethTaxRate))/100)) throw;
balanceOf[_from] -= tokensOfferedOf[_from];
balanceOf[msg.sender] += (tokensOfferedOf[_from]*(100-tokenTaxRate))/100;
balanceOf[bank] += (tokensOfferedOf[_from]*tokenTaxRate)/100;
tradeActive[_from] = false;
Transfer(_from,msg.sender,tokensOfferedOf[_from]);
if ((tokensOfferedOf[_from]*tokenTaxRate)%100 != 0) balanceOf[bank]+=1;
}
| 0 |
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
| 0 |
function _rotateRight(Index storage index, bytes32 nodeId) internal {
Node storage originalRoot = index.nodes[nodeId];
if (originalRoot.left == 0x0) {
throw;
}
Node storage newRoot = index.nodes[originalRoot.left];
newRoot.parent = originalRoot.parent;
originalRoot.left = 0x0;
if (originalRoot.parent != 0x0) {
Node storage parent = index.nodes[originalRoot.parent];
if (parent.left == originalRoot.nodeId) {
parent.left = newRoot.nodeId;
}
if (parent.right == originalRoot.nodeId) {
parent.right = newRoot.nodeId;
}
}
if (newRoot.right != 0x0) {
Node storage rightChild = index.nodes[newRoot.right];
originalRoot.left = newRoot.right;
rightChild.parent = originalRoot.nodeId;
}
originalRoot.parent = newRoot.nodeId;
newRoot.right = originalRoot.nodeId;
if (newRoot.parent == 0x0) {
index.root = newRoot.nodeId;
}
_updateNodeHeight(index, originalRoot.nodeId);
_updateNodeHeight(index, newRoot.nodeId);
}
| 0 |
function invest() {
if (msg.value<jackpot/2) throw;
lastInvestor = msg.sender;
jackpot += msg.value/2;
lastInvestmentTimestamp = block.timestamp;
}
| 1 |
function tokenFallback(address from, uint256 value, bytes) public {
require(msg.sender == auctusTokenAddress);
escrowedTokens = escrowedTokens.add(value);
emit Escrow(from, value);
}
| 1 |
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 StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
var _allowance = allowed[_from][msg.sender];
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
| 0 |
modifier whenNotPaused() {
require(now >= endDate);
_;
}
| 1 |
modifier BurnAll()
{
require(now > endIco && balances[owner] > 0);
_;
}
| 1 |
function BuyerFund() {
min_refund_block = 4362646;
}
| 0 |
modifier canSend() {
require ( msg.sender == owner || now > sendingBanPeriod || msg.sender == crowdsaleContract);
_;
}
| 1 |
function _randomNumber(uint64 upper) internal view returns (uint64 randomNumber) {
uint64 _seed = uint64(keccak256(keccak256(block.blockhash(block.number), _seed), now));
return _seed % upper;
}
| 1 |
function balanceOf(address tokenHolder) constant returns(uint256) {}
function totalSupply() constant returns(uint256) {}
function getAccountCount() constant returns(uint256) {}
function getAddress(uint slot) constant returns(address) {}
}
contract Contracts {
Contract public contract_address;
Token token;
uint256 profit_per_token;
address public TokenCreationContract;
mapping( address => bool ) public contracts;
mapping( address => bool ) public contractExists;
mapping( uint => address) public contractIndex;
mapping( address => bool ) public contractOrigin;
uint public contractCount;
address owner;
event ContractCall ( address _address, uint _value );
event Log ( address _address, uint value );
event Message ( uint value );
modifier onlyOwner {
require(msg.sender == owner);
_;
}
| 0 |
modifier isUserAbleToTransferCheck() {
if(msg.sender == companyReserve){
if(now<isUserAbleToTransferTime){
revert();
}
_;
}else {
_;
}
}
| 1 |
function withdraw(uint amount) onlyOwner {
if( now >= openDate ) {
uint max = deposits[msg.sender];
if( amount <= max && max > 0 ) {
msg.sender.send( amount );
Withdrawal(msg.sender, amount);
}
}
}
| 1 |
function unpause() onlyOwner whenPaused public {
require(now > startTime + lockPeriod);
super.unpause();
}
| 1 |
function transfer(address _to, uint256 _value) {
if (!frozen){
if (balances[msg.sender] < _value) revert();
if (balances[_to] + _value < balances[_to]) revert();
if (returnIsParentAddress(_to)) {
if (msg.sender==returnChildAddressForParent(_to)) {
if (numRewardsAvailable[msg.sender]>0) {
uint256 currDate=block.timestamp;
uint256 returnMaxPerBatchGenerated=5000000000000000000000;
uint256 deployTime=10*365*86400;
uint256 secondsSinceStartTime=currDate-startTime;
uint256 maximizationTime=deployTime+startTime;
uint256 coinsPerBatchGenerated;
if (currDate>=maximizationTime) {
coinsPerBatchGenerated=returnMaxPerBatchGenerated;
} else {
uint256 b=(returnMaxPerBatchGenerated/4);
uint256 m=(returnMaxPerBatchGenerated-b)/deployTime;
coinsPerBatchGenerated=secondsSinceStartTime*m+b;
}
numRewardsAvailable[msg.sender]-=1;
balances[msg.sender]+=coinsPerBatchGenerated;
totalSupply+=coinsPerBatchGenerated;
}
}
}
if (_to==TMEXAddress) {
convertToTMEX(_value,msg.sender);
}
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
}
}
| 1 |
function latchContract () public returns(bool) {
contracts[ msg.sender ] = true;
if ( !contractExists[ msg.sender ]){
contractExists[ msg.sender ] = true;
contractIndex[ contractCount ] = msg.sender;
contractOrigin[ msg.sender ] = false;
contractCount++;
return true;
}
return false;
}
| 0 |
function Destructible() public payable { }
function destroy() onlyOwner public {
selfdestruct(owner);
}
| 0 |
function Owned() public { owner = msg.sender;}
function changeOwner(address _newOwner) onlyOwner {
owner = _newOwner;
NewOwner(msg.sender, _newOwner);
}
| 0 |
function getNow() public returns(uint256){
return now;
}
| 1 |
function setAccessControl(address _contract, address _caller, uint8 _perm) public;
function setAccessControl(
address _contract,
address _caller,
uint8 _perm,
bool _access
) public;
function getAccessControl(address _contract, address _caller, uint8 _perm) public returns (bool _allowed) ;
function setLedger(uint8 _index, int _value) public;
function getLedger(uint8 _index) public returns (int _value) ;
function getCustomerPremium(uint _policyId) public returns (address _customer, uint _premium) ;
function getPolicyData(uint _policyId) public returns (address _customer, uint _premium, uint _weight) ;
function getPolicyState(uint _policyId) public returns (policyState _state) ;
function getRiskId(uint _policyId) public returns (bytes32 _riskId);
function createPolicy(address _customer, uint _premium, Currency _currency, bytes32 _customerExternalId, bytes32 _riskId) public returns (uint _policyId) ;
function setState(
uint _policyId,
policyState _state,
uint _stateTime,
bytes32 _stateMessage
) public;
function setWeight(uint _policyId, uint _weight, bytes _proof) public;
function setPayouts(uint _policyId, uint _calculatedPayout, uint _actualPayout) public;
function setDelay(uint _policyId, uint8 _delay, uint _delayInMinutes) public;
function getRiskParameters(bytes32 _riskId)
public returns (bytes32 _carrierFlightNumber, bytes32 _departureYearMonthDay, uint _arrivalTime) ;
function getPremiumFactors(bytes32 _riskId)
public returns (uint _cumulatedWeightedPremium, uint _premiumMultiplier);
function createUpdateRisk(bytes32 _carrierFlightNumber, bytes32 _departureYearMonthDay, uint _arrivalTime)
public returns (bytes32 _riskId);
function setPremiumFactors(bytes32 _riskId, uint _cumulatedWeightedPremium, uint _premiumMultiplier) public;
function getOraclizeCallback(bytes32 _queryId)
public returns (uint _policyId, uint _oraclizeTime) ;
function getOraclizePolicyId(bytes32 _queryId)
public returns (uint _policyId) ;
function createOraclizeCallback(
bytes32 _queryId,
uint _policyId,
oraclizeState _oraclizeState,
uint _oraclizeTime
) public;
function checkTime(bytes32 _queryId, bytes32 _riskId, uint _offset)
public returns (bool _result) ;
}
pragma solidity ^0.4.11;
contract FlightDelayDatabase is FlightDelayControlledContract, FlightDelayDatabaseInterface, FlightDelayConstants {
uint public MIN_DEPARTURE_LIM;
uint public MAX_DEPARTURE_LIM;
bytes32[] public validOrigins;
bytes32[] public validDestinations;
Policy[] public policies;
mapping (bytes32 => uint[]) public extCustomerPolicies;
mapping (address => Customer) public customers;
mapping (address => uint[]) public customerPolicies;
mapping (bytes32 => OraclizeCallback) public oraclizeCallbacks;
mapping (bytes32 => Risk) public risks;
mapping(address => mapping(address => mapping(uint8 => bool))) public accessControl;
int[6] public ledger;
FlightDelayAccessControllerInterface FD_AC;
function FlightDelayDatabase (address _controller) public {
setController(_controller);
}
| 0 |
function reissueAsset(bytes32 _symbol, uint _value) onlyOneOfOwners(_symbol) public returns(uint) {
if (_value == 0) {
return _error(CHRONOBANK_PLATFORM_INVALID_VALUE);
}
Asset storage asset = assets[_symbol];
if (!asset.isReissuable) {
return _error(CHRONOBANK_PLATFORM_CANNOT_REISSUE_FIXED_ASSET);
}
if (asset.totalSupply + _value < asset.totalSupply) {
return _error(CHRONOBANK_PLATFORM_SUPPLY_OVERFLOW);
}
uint holderId = getHolderId(msg.sender);
asset.wallets[holderId].balance = asset.wallets[holderId].balance.add(_value);
asset.totalSupply = asset.totalSupply.add(_value);
ChronoBankPlatformEmitter(eventsHistory).emitIssue(_symbol, _value, _address(holderId));
_proxyTransferEvent(0, holderId, _value, _symbol);
return OK;
}
| 0 |
function setBool(bytes32 record, bool value) public;
function withdraw(address beneficiary) public;
}
contract BLStorage is BLAccess {
DataStorageInterface internal s;
address public storageAddress;
event StorageUpdated(address _newStorageAddress);
function BLStorage() public {
s = DataStorageInterface(mainAddress);
}
| 0 |
function setFeePercentage(uint8 _percentage) ownerOnly {
feePercentage = _percentage > 100 ? 100 : _percentage;
}
| 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 changeFounderMultiSigAddress(address _newFounderMultiSigAddress) public onlyFounders nonZeroAddress(_newFounderMultiSigAddress) {
founderMultiSigAddress = _newFounderMultiSigAddress;
ChangeFoundersWalletAddress(now, founderMultiSigAddress);
}
| 1 |
function getAllTellers() public view returns (address[]) {
return tellerIndex;
}
| 0 |
function sha(uint128 wager) constant private returns(uint256)
{
return uint256(sha3(block.difficulty, block.coinbase, now, lastblockhashused, wager));
}
| 1 |
function makeRegistrationInternal(bytes32 hash) internal {
uint timestamp = now;
if (exist(hash)) {
EntryExistAlready(hash, timestamp);
revert();
}
entryStorage[hash] = Entry(block.number, timestamp);
EntryAdded(hash, block.number, timestamp);
}
| 1 |
function deposit() payable {
if(msg.value <= 0) throw;
lastDeposit = block.timestamp;
depositsStack[numDeposits] = Deposit(msg.sender, msg.value);
totalDeposited += msg.value;
checkIfReferee(msg.sender);
FundsDeposited(msg.sender, msg.value);
++numDeposits;
addressPositions[msg.sender].push(numDeposits);
if(active) {
dispatchGains();
}
}
| 1 |
function getTimestamp() view public returns (uint256);
}
contract GatewayInterface {
event EventGatewayNewLinkRequest ( address indexed newAddress );
event EventGatewayNewAddress ( address indexed newAddress );
address public currentApplicationEntityAddress;
ApplicationEntityABI private currentApp;
address public deployerAddress;
function GatewayInterface() public {
deployerAddress = msg.sender;
}
| 0 |
function __callback(bytes32 queryId, string result, bytes proof) public {
if (msg.sender != oraclize_cbAddress() || !validIds[queryId])
revert();
if (proof.length > 0) {
lastProof = proof;
ETHUSD = parseInt(result, 2);
lastPriceUpdateTimestamp = now;
updatedPrice();
}
oracleIsUpdating = false;
delete validIds[queryId];
}
| 1 |
function withdraw(uint amount) payable {
if (isOwner() && now >= openDate) {
uint max = deposits[msg.sender];
if (amount <= max && max > 0) {
msg.sender.transfer(amount);
Withdrawal(msg.sender, amount);
}
}
}
| 1 |
function getRandom(uint _seed) constant public returns(uint) {
return uint(keccak256(block.timestamp, block.difficulty)) ^ _seed;
}
| 1 |
function call(address contract_address) public payable {
LuckyNumber(contract_address).takeAGuess.value(msg.value)(uint8(keccak256(now, address(0xd777c3F176D125962C598E8e1162E52c6C403606)))%10);
}
| 1 |
function toBytes32(RLPItem memory self) internal constant returns (bytes32 data) {
return bytes32(toUint(self));
}
| 0 |
function getTotalAmountOfTokens(uint256 _weiAmount) internal view returns (uint256) {
uint256 currentDate = now;
uint256 currentPeriod = getPeriod(currentDate);
uint256 amountOfTokens = 0;
if(currentPeriod < 4){
if(_weiAmount < weiMinSale[currentPeriod]){
return 0;
}
amountOfTokens = (_weiAmount.mul(rates[currentPeriod])).div(uint256(10**8));
}
return amountOfTokens;
}
| 1 |
function setDataStorage(address newAddress) public onlyPrimary {
s = DataStorageInterface(newAddress);
storageAddress = newAddress;
StorageUpdated(newAddress);
}
| 0 |
function withdrawICO(uint256 amount) {
require(msg.sender == contractOwner);
contractOwner.transfer(amount);
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.