function
string | label
int64 |
|---|---|
function decreaseApproval (address _spender, uint _subtractedValue) public
returns (bool success)
{
uint oldValue = allowance[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowance[msg.sender][_spender] = 0;
} else {
allowance[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowance[msg.sender][_spender]);
return true;
} | 0 |
function next_id() internal returns (uint) {
last_offer_id++; return last_offer_id;
} | 0 |
function ownerClawback() external onlyOwner {
require(totalFunding < PRESALE_MINIMUM_FUNDING);
require(now >= OWNER_CLAWBACK_DATE);
owner.transfer(this.balance);
} | 0 |
function declineKyc(address participant) external onlyOwnerOrAuditor {
kycStatus[participant] = KycState.Declined;
LogKycDecline(participant, pendingAmountOfEth, now);
uint256 pendingAmountOfEth = pendingContributionOf[participant];
if (pendingAmountOfEth > 0) {
resetPendingContribution(participant);
participant.transfer(pendingAmountOfEth);
}
} | 0 |
function setContract(string intervener1, string intervener2){
date = now;
name1 = intervener1;
name2 = intervener2;
} | 0 |
function transferFrom(address from, address to, uint value) returns (bool ok);
function approve(address spender, uint value) returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract FallbackFailer {
function () {
throw;
} | 0 |
function calculateTokensPerTier(uint256 weiPaid, uint256 tierSelected)
internal constant returns(uint256 calculatedTokens)
{
require(weiPaid > 0);
require(tierSelected >= 1 && tierSelected <= 4);
if (tierSelected == 1) {
calculatedTokens = weiPaid.mul(rate);
} else if (tierSelected == 2) {
calculatedTokens = weiPaid.mul(rateTier2);
} else if (tierSelected == 3) {
calculatedTokens = weiPaid.mul(rateTier3);
} else {
calculatedTokens = weiPaid.mul(rateTier4);
}
} | 0 |
function emergencyClawbackEther(uint256 value) external onlyOwnerOrMultisig {
require(contractFailed);
require(contractRefundStarted);
require(contractRefundFinished);
require(value > 0);
require(value <= address(this).balance);
msg.sender.transfer(value);
} | 0 |
function ownerOf(uint256 assetId) public view returns (address);
function safeTransferFrom(address from, address to, uint256 assetId) public;
function isAuthorized(address operator, uint256 assetId) public view returns (bool);
}
contract Marketplace is Ownable {
using SafeMath for uint256;
ERC20Interface public acceptedToken;
ERC721Interface public nonFungibleRegistry;
struct Auction {
bytes32 id;
address seller;
uint256 price;
uint256 expiresAt;
} | 0 |
function StreamityEscrow(address streamityContract) public {
owner = msg.sender;
requestCancelationTime = 2 hours;
streamityContractAddress = TokenERC20(streamityContract);
} | 0 |
function transferFrom(address from, address to, uint256 value)
external returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
} | 0 |
function transfer(address _to, uint256 _value) returns (bool success) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else {
return false;
}
} | 0 |
function addOversight(address addr) external multisig(sha3(msg.data)) {
activateOversightAddress(addr);
oversightAddresses[addr] = true;
} | 0 |
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) internal balances;
uint256 internal totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
} | 0 |
function CatHODL () public {
releaseDate = now + 1 years;
} | 0 |
function contractApprovedBoth(address traderAddr1, address traderAddr2) external view returns (bool);
function acceptNextExchangeContract() external;
}
contract AccessModifiers is FixedAddress {
modifier onlyRegistryOwner() {
require (msg.sender == getRegistry().getOwner(), "onlyRegistryOwner() method called by non-owner.");
_;
} | 0 |
function create() payable whenNotClosed whenNotPaused public returns (bool success) {
require(msg.value > 0);
require(now >= preIcoOpeningTime);
uint256 weiToParticipate = msg.value;
adjustPhaseBasedOnTime();
if (phase != Phases.AfterIco || weiToParticipate < (0.01 * 10**18)) {
Rates memory rates = getRates();
uint256 newTokens = weiToParticipate.mul(rates.total);
uint256 requestedSupply = totalSupply.add(newTokens);
totalSupply = requestedSupply;
balances[msg.sender] = balances[msg.sender].add(weiToParticipate.mul(rates.toSender));
balances[owner] = balances[owner].add(weiToParticipate.mul(rates.toOwner));
balances[bounty] = balances[bounty].add(weiToParticipate.mul(rates.toBounty));
totalProceeds = totalProceeds.add(weiToParticipate);
NewTokens(newTokens);
NewFunds(msg.sender, weiToParticipate);
} else {
setWithdrawal(owner, weiToParticipate);
}
return true;
} | 0 |
function finalize() external {
if (!funding) throw;
if ((block.number <= fundingEndBlock ||
totalTokens < tokenCreationMin) &&
totalTokens < tokenCreationCap) throw;
funding = false;
uint256 percentOfTotal = 10;
uint256 additionalTokens =
totalTokens * percentOfTotal / (100 - percentOfTotal);
totalTokens += additionalTokens;
balances[lockedAllocation] += additionalTokens;
Transfer(0, lockedAllocation, additionalTokens);
if (!prospectors_team.send(this.balance)) throw;
} | 0 |
function getTime() constant returns (uint) {
return block.timestamp;
} | 0 |
function endMinting() onlyOwner {
transferOwnership(address(0xdead));
EndMinting(block.timestamp);
} | 1 |
function NihilistCoin() {
balances[msg.sender] = 100000000000000000000000000;
totalSupply = 100000000000000000000000000;
name = "NihilistCoin";
decimals = 18;
symbol = "NULL";
unitsOneEthCanBuy = 10000;
fundsWallet = msg.sender;
saleEnd = 1522540800;
} | 1 |
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) public balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function approve(address spender, uint tokens) public returns (bool success) {
return data.approve(spender, tokens);
} | 0 |
function safeAdd(uint a, uint b) pure internal returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
} | 0 |
function burn(uint amount) external onlyMerchant returns (bool) {
string memory btcDepositAddress = merchantBtcDepositAddress[msg.sender];
require(!isEmptyString(btcDepositAddress), "merchant btc deposit address was not set");
uint nonce = burnRequests.length;
uint timestamp = getTimestamp();
string memory btcTxid = "";
Request memory request = Request({
requester: msg.sender,
amount: amount,
btcDepositAddress: btcDepositAddress,
btcTxid: btcTxid,
nonce: nonce,
timestamp: timestamp,
status: RequestStatus.PENDING
});
bytes32 requestHash = calcRequestHash(request);
burnRequestNonce[requestHash] = nonce;
burnRequests.push(request);
require(controller.getWBTC().transferFrom(msg.sender, controller, amount), "trasnfer tokens to burn failed");
require(controller.burn(amount), "burn failed");
emit Burned(nonce, msg.sender, amount, btcDepositAddress, timestamp, requestHash);
return true;
} | 0 |
function confirmMintRequest(bytes32 requestHash) external onlyCustodian returns (bool) {
uint nonce;
Request memory request;
(nonce, request) = getPendingMintRequest(requestHash);
mintRequests[nonce].status = RequestStatus.APPROVED;
require(controller.mint(request.requester, request.amount), "mint failed");
emit MintConfirmed(
request.nonce,
request.requester,
request.amount,
request.btcDepositAddress,
request.btcTxid,
request.timestamp,
requestHash
);
return true;
} | 0 |
function plus(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
assert(c>=a);
return c;
} | 0 |
function transfer(address _to, uint _value) public returns (bool success);
function transferFrom(address _from, address _to, uint _value) public returns (bool success);
function approve(address _spender, uint _value) public returns (bool success);
}
contract StreamityEscrow is Ownable, ReentrancyGuard {
using SafeMath for uint256;
using ECRecovery for bytes32;
uint8 constant public STATUS_NO_DEAL = 0x0;
uint8 constant public STATUS_DEAL_WAIT_CONFIRMATION = 0x01;
uint8 constant public STATUS_DEAL_APPROVE = 0x02;
uint8 constant public STATUS_DEAL_RELEASE = 0x03;
TokenERC20 public streamityContractAddress;
uint256 public availableForWithdrawal;
uint32 public requestCancelationTime;
mapping(bytes32 => Deal) public streamityTransfers;
function StreamityEscrow(address streamityContract) public {
owner = msg.sender;
requestCancelationTime = 2 hours;
streamityContractAddress = TokenERC20(streamityContract);
} | 0 |
function getState() public constant returns (State) {
if (now < startsAt) return State.PreFunding;
else if (now <= endsAt) return State.Funding;
else if (now > endsAt) return State.Closed;
} | 0 |
function unlockAccount(address tokenOwner) public;
function disableMinting() public;
function enableTransfers() public;
enum CheckResult {
Success,
NotTransferable,
AccountLocked,
SignerMismatch,
AlreadyExecuted,
InsufficientApprovedTokens,
InsufficientApprovedTokensForFees,
InsufficientTokens,
InsufficientTokensForFees,
OverflowError
} | 0 |
function sellKebabs() public{
require(initialized);
uint256 hasKebabs=getMyKebabs();
uint256 kebabValue=calculateKebabSell(hasKebabs);
uint256 fee=calculatePercentage(kebabValue,10);
workingKebaber[msg.sender] = SafeMath.div(workingKebaber[msg.sender],2);
claimedKebabs[msg.sender]=0;
lastKebab[msg.sender]=now;
marketKebabs=SafeMath.add(marketKebabs,hasKebabs);
ceoEtherBalance+=fee;
msg.sender.transfer(SafeMath.sub(kebabValue,fee));
} | 0 |
function finalization() internal {
} | 0 |
function ownerDeclareRefundFinish() external onlyOwner {
require(contractFailed);
require(contractRefundStarted);
require(!contractRefundFinished);
contractRefundFinished = true;
} | 0 |
function createAgreement(IERC20 token, address recipient, uint256 totalAmount, uint48 duration, uint48 start) external {
require(duration > 0, "Duration must be greater than zero");
require(totalAmount > 0, "Total Amount must be greater than zero");
require(start > 0, "Start must be greater than zero");
require(token != IERC20(0x0), "Token must be a valid Ethereum address");
require(recipient != address(0x0), "Recipient must be a valid Ethereum address");
uint256 agreementId = ++lastAgreementId;
agreements[agreementId] = Agreement({
meta: encodeMeta(start, duration, uint256(address(token))),
recipient: recipient,
totalAmount: totalAmount,
sender: msg.sender,
releasedAmount: 0
});
token.transferFrom(agreements[agreementId].sender, address(this), agreements[agreementId].totalAmount);
emit AgreementCreated(
agreementId,
address(token),
recipient,
msg.sender,
start,
duration,
totalAmount,
block.timestamp
);
} | 0 |
function decreaseAllowance(address _spender, uint256 _subtractedValue) public validateAddress(_spender) isNotFrozen(_spender) isNotTimeLocked() returns (bool)
{
return super.decreaseAllowance(_spender, _subtractedValue);
} | 0 |
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
super._preValidatePurchase(_beneficiary, _weiAmount);
require(weiRaised.add(_weiAmount) <= cap);
} | 0 |
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface InvestorToken {
function transferInvestorTokens(address, uint256);
}
contract Exchange is RBAC {
using SafeMath for uint256;
using BytesDeserializer for bytes;
string public constant ROLE_FORCED = "forced";
string public constant ROLE_TRANSFER_TOKENS = "transfer tokens";
string public constant ROLE_TRANSFER_INVESTOR_TOKENS = "transfer investor tokens";
string public constant ROLE_CLAIM = "claim";
string public constant ROLE_WITHDRAW = "withdraw";
string public constant ROLE_TRADE = "trade";
string public constant ROLE_CHANGE_DELAY = "change delay";
string public constant ROLE_SET_FEEACCOUNT = "set feeaccount";
string public constant ROLE_TOKEN_WHITELIST = "token whitelist user";
mapping(bytes32 => bool) public withdrawn;
mapping(bytes32 => bool) public transferred;
mapping(address => bool) public tokenWhitelist;
mapping(address => uint256) public tokensTotal;
mapping(address => mapping(address => uint256)) public balanceOf;
mapping (bytes32 => uint256) public orderFilled;
address public feeAccount;
uint256 public delay;
event TokenWhitelistUpdated(address token, bool status);
event FeeAccountChanged(address newFeeAccocunt);
event DelayChanged(uint256 newDelay);
event Deposited(address token, address who, uint256 amount, uint256 balance);
event Forced(address token, address who, uint256 amount);
event Withdrawn(address token, address who, uint256 amount, uint256 balance);
event Requested(address token, address who, uint256 amount, uint256 index);
event TransferredInvestorTokens(address, address, address, uint256);
event TransferredTokens(address, address, address, uint256, uint256, uint256);
event OrderExecuted(
bytes32 orderHash,
address maker,
address baseToken,
address quoteToken,
address feeToken,
uint256 baseAmountFilled,
uint256 quoteAmountFilled,
uint256 feePaid,
uint256 baseTokenBalance,
uint256 quoteTokenBalance,
uint256 feeTokenBalance
);
struct Withdrawal {
address user;
address token;
uint256 amount;
uint256 createdAt;
bool executed;
} | 0 |
function DinosaurFarmer2() public{
ceoAddress=msg.sender;
} | 0 |
function proxyClaimTokens(address receiverAddress)
public
atStage(Stages.AuctionEnded)
returns (bool)
{
require(now > finalizedTime + TOKEN_CLAIM_WAITING_PERIOD);
require(receiverAddress != 0x0);
if (bids[receiverAddress] == 0) {
return false;
}
uint num = (tokenMultiplier * bids[receiverAddress]) / finalPrice;
uint auctionTokensBalance = token.balanceOf(address(this));
if (num > auctionTokensBalance) {
num = auctionTokensBalance;
}
fundsClaimed += bids[receiverAddress];
bids[receiverAddress] = 0;
require(token.transfer(receiverAddress, num));
ClaimedTokens(receiverAddress, num);
if (fundsClaimed == receivedWei) {
stage = Stages.TokensDistributed;
TokensDistributed();
}
assert(token.balanceOf(receiverAddress) >= num);
assert(bids[receiverAddress] == 0);
return true;
} | 0 |
function getMessage () constant returns (string retVal) {
return message;
} | 1 |
function TimeNow() public constant returns(uint256)
{
return now;
} | 1 |
function burnFrom(address from, uint256 value) public returns (bool) {
_burnFrom(from, value);
return true;
} | 0 |
function getTime() internal view returns(uint256) {
return now;
} | 1 |
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
require(_beneficiary != address(0));
require(_weiAmount != 0);
} | 0 |
function setMintMaster(address newMintMaster)
returns (bool ok)
{
require(msg.sender == mintMaster);
address oldMintMaster = mintMaster;
mintMaster = newMintMaster;
LogSetMintMaster(oldMintMaster, mintMaster);
return true;
} | 0 |
function batchCancelOrders(LibOrder.Order[] memory orders)
public
nonReentrant
{
uint256 ordersLength = orders.length;
for (uint256 i = 0; i != ordersLength; i++) {
cancelOrderInternal(orders[i]);
}
} | 0 |
function release(uint256 timestamp, uint256 sysAmount) public onlyOperator returns(uint256 _actualRelease) {
require(timestamp >= createTime && timestamp <= block.timestamp);
require(!checkIsReleaseRecordExist(timestamp));
updateReleaseAmount(timestamp);
require(sysAmount <= releaseAmountPerDay.mul(4).div(5));
require(totalSupply_ >= releasedSupply.add(releaseAmountPerDay));
balances[owner] = balances[owner].add(releaseAmountPerDay);
releasedSupply = releasedSupply.add(releaseAmountPerDay);
uint256 _releaseIndex = uint256(timestamp.parseTimestamp().year) * 10000 + uint256(timestamp.parseTimestamp().month) * 100 + uint256(timestamp.parseTimestamp().day);
releaseRecords[_releaseIndex] = ReleaseRecord(releaseAmountPerDay, _releaseIndex);
emit Release(owner, releaseAmountPerDay, sysAmount, timestamp);
systemFreeze(sysAmount.div(5), timestamp.add(180 days));
systemFreeze(sysAmount.mul(6).div(10), timestamp.add(200 years));
return releaseAmountPerDay;
} | 0 |
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 |
function getLockedAmount_contributors(address _contributor)
public
constant
returns (uint256)
{
uint256 countdownDate = contributors_countdownDate[_contributor];
uint256 lockedAmt = contributors_locked[_contributor];
if (now <= countdownDate + 1 hours) {return lockedAmt;}
if (now <= countdownDate + 2 hours) {return lockedAmt.mul(7).div(8);}
if (now <= countdownDate + 3 hours) {return lockedAmt.mul(6).div(8);}
if (now <= countdownDate + 4 hours) {return lockedAmt.mul(5).div(8);}
if (now <= countdownDate + 5 hours) {return lockedAmt.mul(4).div(8);}
if (now <= countdownDate + 6 hours) {return lockedAmt.mul(3).div(8);}
if (now <= countdownDate + 7 hours) {return lockedAmt.mul(2).div(8);}
if (now <= countdownDate + 8 hours) {return lockedAmt.mul(1).div(8);}
return 0;
} | 0 |
function addApproval(address _spender, uint _addedValue) public
returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
allowed[msg.sender][_spender] = oldValue.add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
} | 0 |
function getBlockTimestamp() returns (uint256) {
return block.timestamp;
} | 1 |
function increaseApproval (address _spender, uint _addedValue) public whenNotPaused
returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
} | 0 |
function transfer(address _to, uint256 _value) public canTransfer(msg.sender) returns (bool success) {
return super.transfer(_to, _value);
} | 0 |
function pause() public onlyOwner {
require(!paused(), "Pausable: Already paused.");
super._pause();
} | 0 |
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract MplusCrowdsaleA {
using SafeMath for uint256;
uint256 internal constant NUM_STAGES = 4;
uint256 internal constant ICO_START1 = 1519056000;
uint256 internal constant ICO_START2 = 1521216000;
uint256 internal constant ICO_START3 = 1522598400;
uint256 internal constant ICO_START4 = 1523894400;
uint256 internal constant ICO_END = 1525190399;
uint256 internal constant ICO_RATE1 = 20000;
uint256 internal constant ICO_RATE2 = 18000;
uint256 internal constant ICO_RATE3 = 17000;
uint256 internal constant ICO_RATE4 = 16000;
uint256 internal constant ICO_CAP1 = 14000 * (10 ** 18);
uint256 internal constant ICO_CAP2 = 21000 * (10 ** 18);
uint256 internal constant ICO_CAP3 = 28000 * (10 ** 18);
uint256 internal constant ICO_CAP4 = 35000 * (10 ** 18);
uint256 internal constant MIN_CAP = (10 ** 17);
uint256 internal constant MAX_CAP = 1000 * (10 ** 18);
address internal owner;
ERC20 public tokenReward;
address internal tokenOwner;
address internal wallet;
uint256 public stage = 0;
uint256 public tokensSold = 0;
uint256 public weiRaised = 0;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
event IcoStageStarted(uint256 stage);
event IcoEnded();
modifier onlyOwner() {
require(msg.sender == owner);
_;
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) ifUnlocked public returns (bool) {
return super.transferFrom(_from, _to, _value);
} | 0 |
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
} | 0 |
modifier notLessThan2Eth() {
require(investedAmountOf[msg.sender].add(msg.value) >= 2 * (10**18));
_;
} | 0 |
function mintInflation(address _thePool, uint256 _reward)
external
onlyProofOfPerformance
minimumRigo(_thePool)
timeAtLeast(_thePool)
returns (bool)
{
performers[_thePool].startTime = now;
performers[_thePool].endTime = now + period;
++performers[_thePool].epoch;
uint256 reward = _reward * 95 / 100;
uint256 rigoblockReward = safeSub(_reward, reward);
RigoToken rigoToken = RigoToken(RIGOTOKENADDRESS);
rigoToken.mintToken(getPoolOwner(_thePool), reward);
rigoToken.mintToken(rigoblockDao, rigoblockReward);
return true;
} | 0 |
function updateWallet(address _wallet, string _data) public onlyPrivilegedAddresses {
require(_wallet != address(0));
require(isWhitelisted(_wallet));
whitelist[_wallet].data = _data;
} | 0 |
function approve(address _spender, uint256 _value) public erc20Allowed returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
} | 0 |
function start(uint endAt_) public onlyOwner {
require(endAt_ > block.timestamp && state == State.Inactive);
endAt = endAt_;
startAt = block.timestamp;
state = State.Active;
emit ICOStarted(endAt, lowCapWei, hardCapWei, lowCapTxWei, hardCapTxWei);
} | 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 |
modifier onlyAfter(uint _time) {
require(now >= _time);
_;
} | 0 |
function endSale() {
require(owner == msg.sender);
require(!locked);
snapshotTimestamp = block.timestamp;
balanceAtSnapshot = Token(dvipAddress).balanceOf(saleAddress);
locked = true;
} | 1 |
function getWhitelist() view public returns (address[]) {
return WhitelistsAccts;
} | 0 |
function transferAllAndCall(address _to, bytes _extraData) public returns (bool success){
return transferAndCall(_to, balanceOf[msg.sender], _extraData);
} | 0 |
function buyCore(uint256 _pID, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
core(_rID, _pID, msg.value, _affID, _team, _eventData_);
} else {
if (_now > round_[_rID].end && round_[_rID].ended == false)
{
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onBuyAndDistribute
(
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
} | 0 |
function _transfer(address _to, uint256 _value, bytes _data) private returns (bool success) {
if(isContract(_to)) {
return transferToContract(_to, _value, _data);
}
else {
return transferToAddress(_to, _value, _data);
}
} | 0 |
function _mint(address account, uint256 amount) internal {
require(account != 0);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
} | 0 |
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
} | 0 |
function getStats() constant returns (uint256, uint256, uint256, bool) {
return (totalContribution, totalSupply, totalBonusTokensIssued, purchasingAllowed);
} | 1 |
function hasEnded() public constant returns (bool) {
return now > endTime;
} | 0 |
function atNow() constant returns (uint) {
return now;
} | 1 |
function setLockup_jiedians(address _jiedian, uint256 _value, uint256 _jiedianDate)
public
onlyOwner
{
require(_jiedian != address(0));
jiedians_locked[_jiedian] = _value;
jiedians_jiedianDate[_jiedian] = _jiedianDate;
UpdatedLockingState("jiedian", _jiedian, _value, _jiedianDate);
} | 0 |
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
return transferFrom(_from, _to, bytes32(_value));
} | 0 |
function Marketplace(address _acceptedToken, address _nonFungibleRegistry) public {
acceptedToken = ERC20Interface(_acceptedToken);
nonFungibleRegistry = ERC721Interface(_nonFungibleRegistry);
} | 0 |
function updateDuration(uint256 _newP2Start) external onlyOwner {
require(isCrowdSaleSetup
&& !(p2_start == _newP2Start)
&& !(_newP2Start > p1_start + p1_duration + 30 hours)
&& (now < p2_start)
&& (fundingStartTime + p1_duration < _newP2Start));
p2_start = _newP2Start;
fundingEndTime = p2_start.add(4 hours);
} | 0 |
function purchase(uint id, string metadata, bool forSale, uint newPrice)
validID(id) tradingIsEnabled payable returns(bool)
{
LunarPlot plot = plots[id];
if (isUnowned(id)) {
require(msg.value >= initialPrice);
} else {
require(plot.forSale && msg.value >= plot.price);
}
if (plot.owner != 0x0) {
uint fee = plot.price * feePercentage / 100;
uint saleProceeds = plot.price - fee;
plot.owner.transfer(saleProceeds);
removePlot(plot.owner, id);
} else {
totalOwned++;
}
addPlot(msg.sender, id);
plot.owner = msg.sender;
plot.forSale = forSale;
plot.price = newPrice;
if (bytes(metadata).length != 0) {
plot.metadata = metadata;
}
Purchase(msg.sender, id, msg.value);
totalPurchases++;
return true;
} | 0 |
function PreSaleToken() public {
owner = msg.sender;
} | 0 |
function allowance(address _owner, address _spender) view public returns (uint) {
return approvals[_owner][_spender];} | 0 |
function notifySale(uint256 _ethAmount, uint256 _tokensAmount) public
hasBeenStarted()
hasntStopped()
whenCrowdsaleAlive()
onlyCrowdsale()
{
totalCollected = totalCollected.add(_ethAmount);
totalSold = totalSold.add(_tokensAmount);
} | 0 |
function hasClosed() public view returns (bool) {
for(uint i = 0; i < MAX_FUND_SIZE; ++i)
{
if(openingTimeArray[i] <= now && now <= closingTimeArray[i])
{
return false;
}
}
return true;
} | 0 |
function transfer(address _to, uint256 _amount) public returns (bool success) {
if (speedBump)
{
require (_amount <= transferMaxAmount, "Speed bump activated, amount exceeded");
require (now > (lastTransfer + transferWait), "Speed bump activated, frequency exceeded");
lastTransfer = now;
}
uint256 fee = calcTransferFee (_amount);
uint256 toValue = _amount.sub(fee);
_transfer(transferFeeReceiver, fee);
_transfer(_to, toValue);
return true;
} | 0 |
function addMessage(string msgStr) payable {
Message memory newMsg;
newMsg.message = msgStr;
newMsg.from = msg.sender;
newMsg.timestamp = block.timestamp;
messages[messagesIndex] = newMsg;
messagesIndex += 1;
messagesIndex = messagesIndex % 10;
postedMessages++;
} | 1 |
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) external returns (bool success);
function burn(uint256 _value) external;
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
event Burn(address indexed burner, uint256 value);
}
contract EzeCrowdsale is Ownable{
using SafeMath for uint256;
TokenInterface public token;
uint256 public startTime;
uint256 public endTime;
uint256 public ratePerWeiInSelfDrop = 60000;
uint256 public ratePerWeiInPrivateSale = 30000;
uint256 public ratePerWeiInPreICO = 20000;
uint256 public ratePerWeiInMainICO = 15000;
uint256 public weiRaised;
uint256 public TOKENS_SOLD;
uint256 maxTokensToSale;
uint256 bonusInSelfDrop = 20;
uint256 bonusInPrivateSale = 10;
uint256 bonusInPreICO = 5;
uint256 bonusInMainICO = 2;
bool isCrowdsalePaused = false;
uint256 totalDurationInDays = 213 days;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
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));
token = TokenInterface(_tokenAddress);
} | 0 |
function addOwner(address sender, Proxy identity, address newOwner) public
onlyAuthorized
onlyOlderOwner(identity, sender)
rateLimited(identity, sender)
{
require(!isOwner(identity, newOwner));
owners[identity][newOwner] = now - userTimeLock;
LogOwnerAdded(identity, newOwner, sender);
} | 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) public {
upgradeMaster = _upgradeMaster;
} | 0 |
function getCooldown(uint16 speed) external view returns (uint64){
return uint64(now + cooldowns[speed - 1]);
} | 1 |
function releaseReserveTokens() public {
reserveTimelock.release();
} | 0 |
function weiAllowedToReceive(uint tentativeAmount, uint weiRaised, uint weiInvestedBySender, uint weiFundingCap) public constant returns (uint) {
uint totalOfSender = tentativeAmount.add(weiInvestedBySender);
if (totalOfSender > weiLimitPerAddress) tentativeAmount = weiLimitPerAddress.sub(weiInvestedBySender);
if (weiFundingCap == 0) return tentativeAmount;
uint total = tentativeAmount.add(weiRaised);
if (total < weiFundingCap) return tentativeAmount;
else return weiFundingCap.sub(weiRaised);
} | 0 |
function apLockUp(address _to) onlyOwner public
{
require(tokenLock == false);
require(saleTime == false);
uint time = now;
uint unlockTokens = 0;
if( (time >= apLock_1) && (ap1[_to] > 0) )
{
balances[_to] = balances[_to].add(ap1[_to]);
unlockTokens = unlockTokens.add(ap1[_to]);
ap1[_to] = 0;
}
if( (time >= apLock_2) && (ap2[_to] > 0) )
{
balances[_to] = balances[_to].add(ap2[_to]);
unlockTokens = unlockTokens.add(ap2[_to]);
ap2[_to] = 0;
}
if( (time >= apLock_3) && (ap3[_to] > 0) )
{
balances[_to] = balances[_to].add(ap3[_to]);
unlockTokens = unlockTokens.add(ap3[_to]);
ap3[_to] = 0;
}
emit TokenUnLock(_to, unlockTokens);
} | 0 |
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address 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) internal _balances;
mapping (address => mapping (address => uint256)) internal _allowances;
uint256 internal _totalSupply;
constructor() internal {
} | 0 |
function getClaim(address issuer, address subject, bytes32 key) public constant returns(bytes32) {
return registry[issuer][subject][key];
} | 0 |
function transfer(address _to, uint256 _value) public returns (bool) {
require(frozenAccounts[msg.sender] < now);
return super.transfer(_to, _value);
} | 0 |
function minus(uint a, uint b) public pure returns (uint) {
assert(b <= a);
return a - b;
} | 0 |
function getFreeShrimp() public{
require(initialized);
require(hatcheryShrimp[msg.sender]==0);
lastHatch[msg.sender]=now;
hatcheryShrimp[msg.sender]=STARTING_SHRIMP;
} | 0 |
function getCurrentMilestone() private constant returns (Milestone) {
uint i;
uint price;
for(i=0; i<milestones.length; i++) {
if(now < milestones[i].time) {
return milestones[i-1];
}
}
} | 1 |
function getTicket (address _attendee) payable public {
require(now >= startTime && msg.value >= FEE && userId[_attendee] == 0);
userAmount ++;
require(userAmount <= maxAttendees);
userId[_attendee] = userAmount;
id2Addr[userAmount] = _attendee;
} | 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.