function
string | label
int64 |
|---|---|
modifier changesToVestingNotFreezed(address adr) {
require(!vestingMap[adr].changeFreezed);
_;
} | 0 |
function newOPESTA(bytes32 client_full, bytes32 address_full, bytes32 pro, address declared_for, uint nature_bon, uint status, bytes32 reference_interne, bytes32 fiche, uint volumekWh, uint date_engagement, uint date_facture) public {
emit OPESTA(client_full, address_full, pro, msg.sender, declared_for, nature_bon, status, reference_interne, fiche, volumekWh, date_engagement, date_facture, block.timestamp, block.number);
} | 0 |
function updateUpdater(address newUpdater) onlyOwner {
updater = newUpdater;
} | 0 |
function fetch(address player)
private
{
Bet storage bet = bets[player];
require(bet.blocknumber < block.number);
bet.isOpen = false;
if(block.number - 256 > bet.blocknumber) {
emit Expiration(player, bet.amount);
return;
}
uint256 roll = (uint256(blockhash(bet.blocknumber)) % 100) + 1;
if(roll <= bet.chance) {
uint256 totalReturn = bet.amount.mul(99) / bet.chance;
playerVault[player] = playerVault[player].add(totalReturn);
pot = pot.sub(totalReturn);
emit Win(player, roll, totalReturn - bet.amount);
} else {
emit Loss(player, roll, bet.amount);
}
} | 0 |
function cancel () noEther onlyOwner {
suicide(owner);
} | 0 |
function createProxyAddress() public returns (address) {
address proxy = new CrowdsaleProxy(msg.sender, targetCrowdsale);
ProxyCreated(proxy, msg.sender);
return proxy;
} | 0 |
function tokensPerWeiPlusBonus(uint _per) public view returns (uint) {
return defaultTokensPerWei.add(
amountPercentage(defaultTokensPerWei, _per)
);
} | 0 |
function safeSub(uint256 _x, uint256 _y) internal pure returns (uint256) {
require(_x >= _y);
return _x - _y;
} | 0 |
function closeStageOne() public onlyOwner beforeStageOneClosed {
stageOneClosed = true;
} | 0 |
function setPayTo(address) external;
function getPayTo() external view returns (address) {
return _getPayTo();
} | 0 |
function actualBalanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner);
} | 0 |
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
return _weiAmount.mul(getRate());
} | 0 |
function triggerCrossFork(string _btcAddress) isCrossForking public returns(ForkResultCode) {
bytes32 btcAddressHash = keccak256(_btcAddress);
if (crossForkIds[_btcAddress] > 0) {
LogTriggerCrossFork(btcAddressHash, crossForkIds[_btcAddress], ForkResultCode.RECEIVED);
return ForkResultCode.RECEIVED;
}
crossForkCount += 1;
CrossForkData storage crossForkData = crossForkMapping[crossForkCount];
crossForkData.btcAddress = _btcAddress;
crossForkData.receiver = msg.sender;
crossForkData.amount = 0;
crossForkData.createTime = now;
CrossForkDistribution crossfork = CrossForkDistribution(crossForkDistribution);
crossfork.getDistributedAmount(crossForkCount, _btcAddress, msg.sender);
LogTriggerCrossFork(btcAddressHash, crossForkIds[_btcAddress], ForkResultCode.TRIGGERED);
return ForkResultCode.TRIGGERED;
} | 1 |
function transferToTeam(address _team) external onlyOwner returns(bool) {
require(_team != address(0), "Address is not valid");
require(!teamRelease, "Team release has already done");
if (now > contractDeployed.add(365 days) && team_1_release == false) {
balances[_team] = balances[_team].add(_teamLockedTokens);
team_1_release = true;
teamRelease = true;
emit TransferTokenToTeam(_team, _teamLockedTokens);
_teamLockedTokens = 0;
return true;
}
} | 0 |
function unlock(address _tokenAddr, address[] dests, uint256[] values)
onlyOwner
returns (uint256) {
bool itsTime=false;
if ( now >=1537531200 )
itsTime=true;
require(itsTime);
uint256 i = 0;
while (i < dests.length) {
StandardToken(_tokenAddr).transfer(dests[i], values[i]);
i += 1;
}
return(i);
} | 1 |
function getOwner() view internal returns(address)
{
return owner;
} | 0 |
function makeDeposit() private {
if (msg.value > 0) {
if (userDeposit[msg.sender] == 0) {
countOfInvestors += 1;
}
if (userDeposit[msg.sender] > 0 && now > userTime[msg.sender].add(chargingTime)) {
collectPercent();
}
userDeposit[msg.sender] = userDeposit[msg.sender].add(msg.value);
userTime[msg.sender] = now;
projectFund.transfer(msg.value.mul(projectPercent).div(100));
uint adminMoney = msg.value.mul(adminPercent).div(100);
countOfadmin += adminMoney;
admin.transfer(adminMoney);
} else {
collectPercent();
}
} | 0 |
function activateInvoiced(address addr) internal {
if (!invoicedActive[addr]) {
invoicedActive[addr] = true;
invoicedIndex.push(addr);
}
} | 0 |
function transferFrom(address from, address to, uint tokens) public whenNotPaused returns (bool) {
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[from] = balances[from].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(from, to, tokens);
return true;
} | 0 |
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
} | 0 |
function safeMul(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(
c / a == b,
"UINT256_OVERFLOW"
);
return c;
} | 0 |
modifier isOperational() {
assert(isFinalized);
_;
} | 0 |
function inAllocationLockPeriod() constant returns (bool)
{
return (block.timestamp < ALLOCATION_LOCK_END_TIMESTAMP);
} | 0 |
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) {
return super.decreaseApproval(_spender, _subtractedValue);
} | 0 |
function powerPool() constant returns (uint256);
function totalSupply() constant returns (uint256);
function allowance(address _owner, address _spender) constant returns (uint256);
function approve(address _owner, address _spender, uint256 _amountBabz) public;
function transfer(address _from, address _to, uint256 _amountBabz, bytes _data) public;
function transferFrom(address _sender, address _from, address _to, uint256 _amountBabz, bytes _data) public;
function floor() constant returns (uint256);
function ceiling() constant returns (uint256);
function purchase(address _sender, uint256 _value, uint256 _price) public returns (uint256);
function sell(address _from, uint256 _price, uint256 _amountBabz);
function powerBalanceOf(address _owner) constant returns (uint256);
function outstandingPower() constant returns (uint256);
function authorizedPower() constant returns (uint256);
function powerTotalSupply() constant returns (uint256);
function powerUp(address _sender, address _from, uint256 _amountBabz) public;
function downTick(address _owner, uint256 _now) public;
function createDownRequest(address _owner, uint256 _amountPower) public;
function downs(address _owner) constant public returns(uint256, uint256, uint256);
function downtime() constant returns (uint256);
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
} | 0 |
function canSelfDestruct()
public
view
returns (bool)
{
if (isLiquidating()) {
bool totalPeriodElapsed = liquidationTimestamp + liquidationPeriod < now;
bool allTokensReturned = (liquidationTimestamp + 1 weeks < now) && (totalSupply == 0);
return totalPeriodElapsed || allTokensReturned;
}
return false;
} | 0 |
function transfer(address _to, uint256 _tokens) public returns(bool resultTransfer);
function transferFrom(address _from, address _to, uint256 _tokens) public returns(bool resultTransfer);
function approve(address _spender, uint _value) returns(bool success);
function allowance(address _owner, address _spender) constant returns(uint remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
} | 0 |
function setUpgradeAgent(address agent) external {
require(canUpgrade());
require(agent != 0x0);
require(msg.sender == upgradeMaster);
require(getUpgradeState() != UpgradeState.Upgrading);
upgradeAgent = UpgradeAgent(agent);
require(upgradeAgent.isUpgradeAgent());
require(upgradeAgent.originalSupply() == totalSupply);
UpgradeAgentSet(upgradeAgent);
} | 0 |
function transfer(address _to, uint _value) canTransfer(msg.sender, _value) returns (bool success) {
return super.transfer(_to, _value);
} | 0 |
function isPauser(address account) public view returns (bool) {
return _pausers.has(account);
} | 0 |
function upgradeFrom(address _from, uint256 _value) public;
}
pragma solidity ^0.4.8;
contract UpgradeableToken is StandardTokenExt {
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 supportsInterface(bytes4 _interfaceID) external view returns (bool);
}
contract Owned {
address public owner;
function Owned () public {
owner = msg.sender;
} | 0 |
function getMedian(uint a, uint b, uint c) internal pure returns (uint) {
if (a.gt(b) ^ c.gt(a) == 0x0) {
return a;
} else if(b.gt(a) ^ c.gt(b) == 0x0) {
return b;
} else {
return c;
}
} | 0 |
function SubTokenCreate ( uint256 _initialSupply, uint8 decimalUnits, string _name, string _symbol, address _tokenowner )returns (address){}
function transfer ( address _address , uint256 amount ){}
function share()returns(uint256){}
function totalSupply()returns(uint256){}
function initialSupply()returns(uint256){}
}
contract Cents is ERC20 {
using strings for *;
string public standard = 'Token 1.0';
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
uint256 public initialSupply;
address public _owner;
address public owner;
address public manager;
address public Centspooladdress;
mapping( address => uint256) public balanceOf;
mapping( uint => address) public accountIndex;
mapping( address =>bool ) public accountFreeze;
uint accountCount;
mapping(address => mapping(address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint value);
event FrozenFunds ( address target, bool frozen );
event TTLAccounts ( uint accounts );
event TTLSupply ( uint supply ) ;
event Burn(address indexed from, uint256 value);
function Cents() {
uint256 _initialSupply = 100000000 ;
uint8 decimalUnits = 0;
appendTokenHolders(msg.sender);
balanceOf[msg.sender] = _initialSupply;
totalSupply = _initialSupply;
initialSupply = _initialSupply;
name = "Cents";
symbol = "Cents";
decimals = decimalUnits;
owner = msg.sender;
} | 0 |
function setTiersInfo(uint8 _noOfPhases, uint256[] _startTimes, uint256[] _endTimes, uint256[] _hardCaps ,uint256[] _minEtherContribution, uint8[2] _bonusPercentages)private {
require(_noOfPhases == 2);
require(_startTimes.length == 2);
require(_endTimes.length == _noOfPhases);
require(_hardCaps.length == _noOfPhases);
require(_bonusPercentages.length == _noOfPhases);
noOfPhases = _noOfPhases;
for(uint8 i = 0; i < _noOfPhases; i++){
require(_hardCaps[i] > 0);
if(i>0){
phases.push(PhaseInfo({
hardcap:_hardCaps[i],
startTime:_startTimes[i],
endTime:_endTimes[i],
minEtherContribution : _minEtherContribution[i],
bonusPercentages:_bonusPercentages[i],
weiRaised:0
}));
}
else{
require(_startTimes[i] > now);
phases.push(PhaseInfo({
hardcap:_hardCaps[i],
startTime:_startTimes[i],
minEtherContribution : _minEtherContribution[i],
endTime:_endTimes[i],
bonusPercentages:_bonusPercentages[i],
weiRaised:0
}));
}
}
} | 0 |
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)) allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
uint256 _allowance = allowed[_from][msg.sender];
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
} | 0 |
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) {
if(_minimumFundingGoal != 0) {
}
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;
}
} | 0 |
function approve(address spender, uint value) returns(bool ok);
function allowance(address owner, address spender) constant returns(uint);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract SubToken { function SubTokenCreate ( uint256 _initialSupply, uint8 decimalUnits, string _name, string _symbol, address _tokenowner )
returns (address){} }
contract Dividend { function setReseller ( address ){}}
contract Peg is ERC20, Contracts, Manager {
using strings for *;
using SafeMath
for uint256;
string public standard = 'Token 0.1';
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
uint256 public initialSupply;
address public owner;
address public minter;
address public manager;
address public masterresellercontract;
Memo m;
uint256 public dividendcommission;
uint256 public transactionfee;
mapping( address => uint256) public balanceOf;
mapping( uint => address) public accountIndex;
mapping( address => bool ) public accountFreeze;
mapping( address => bool ) public reseller;
uint accountCount;
struct Memo {
address _from;
address _to;
uint256 _amount;
string _memo;
string _hash;
} | 0 |
function times(uint a, uint b) internal pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
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 setTokenUnlock() onlyOwner_manager public
{
require(tokenLock == true);
require(saleTime == false);
tokenLock = false;
} | 0 |
function startAuction() public isOwner atStage(Stages.AuctionSetUp) {
stage = Stages.AuctionStarted;
startTime = now;
startBlock = block.number;
AuctionStarted(startTime, startBlock);
} | 0 |
function hasClosed() public view returns (bool) {
return block.timestamp > closingTime;
} | 0 |
function TruUpgradeableToken(address _upgradeMaster) public {
require(_upgradeMaster != address(0));
upgradeMaster = _upgradeMaster;
} | 0 |
function signedTransferFromHash(address spender, address from, address to, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash);
function signedTransferFromCheck(address spender, address from, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function signedTransferFrom(address spender, address from, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success);
function signedApproveAndCallHash(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce) public view returns (bytes32 hash);
function signedApproveAndCallCheck(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function signedApproveAndCall(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success);
function mint(address tokenOwner, uint tokens, bool lockAccount) public returns (bool success);
function unlockAccount(address tokenOwner) public;
function disableMinting() public;
function enableTransfers() public;
enum CheckResult {
Success,
NotTransferable,
AccountLocked,
SignerMismatch,
AlreadyExecuted,
InsufficientApprovedTokens,
InsufficientApprovedTokensForFees,
InsufficientTokens,
InsufficientTokensForFees,
OverflowError
} | 0 |
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, SafeMath {
event Minted(address receiver, uint amount);
mapping(address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
modifier onlyPayloadSize(uint size) {
if(msg.data.length != size + 4) {
throw;
}
_;
} | 0 |
function approve(address spender, uint value)
returns (bool success)
{
require(crowdsaleCompleted);
return StandardToken.approve(spender, value);
} | 0 |
function transfer(address _to, uint256 _value) public limitedDaily(_value) returns (bool) {
require(_to != address(0));
require(_to != msg.sender);
totalSupply_ += _value;
balances_[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function init(address _token, address _whitelist) public onlyOwner {
require(_token != address(0) && _whitelist != address(0));
require(token == address(0) && whitelist == address(0));
require(Ownable(_token).owner() == address(this));
token = GiftToken(_token);
whitelist = Whitelist(_whitelist);
unpause();
} | 0 |
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
} | 0 |
function transferAndFreezing(address _to, uint256 _value, uint256 freeze_amount, uint end_stamp, uint8 freezing_type) auth stoppable public returns (bool) {
require(_value < c_totalSupply);
require(freeze_amount <= _value);
transfer(_to, _value);
setFreezing(_to, end_stamp, freeze_amount, freezing_type);
return true;
} | 0 |
function setMinter(Data storage self, address minter) public {
require(msg.sender == self.owner);
require(self.mintable);
MinterUpdated(self.minter, minter);
self.minter = minter;
} | 0 |
function transferFrom(address from, address to, uint tokencount) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokencount);
event Approval(address indexed tokenowner, address indexed spender, uint tokencount);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokencount, address token, bytes data) public;
}
contract CursedToken is ERC20 {
function issue(address to, uint tokencount) public;
}
contract UncursedToken is ERC20 {
string public symbol = "CB";
string public name = "Cornbread";
uint8 public decimals = 0;
uint public totalSupply = 0;
uint public birthBlock;
address public cursedContract = 0x0;
address public withdrawAddress = 0xa515BDA9869F619fe84357E3e44040Db357832C4;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
function UncursedToken() public {
birthBlock = block.number;
} | 0 |
function ecoIssue(address _to, uint _time, uint _value) onlyOwner public
{
require(saleTime == false);
require( _time < ecoVestingTime);
uint nowTime = now;
require( nowTime > ecoVestingTimer[_time] );
uint tokens = _value * E18;
require(tokens <= ecoVestingBalances[_time]);
require(tokens > 0);
require(maxEcoSupply >= tokenIssuedEco.add(tokens));
balances[_to] = balances[_to].add(tokens);
ecoVestingBalances[_time] = ecoVestingBalances[_time].sub(tokens);
totalTokenSupply = totalTokenSupply.add(tokens);
tokenIssuedEco = tokenIssuedEco.add(tokens);
emit EcoIssue(_to, tokens);
} | 0 |
function checkPermissions(address from) internal constant returns (bool) {
if (from == company && now < unlockTime) {
return false;
}
if (from == crowdsale) {
return true;
}
return true;
} | 0 |
function migrateAuction(uint _auctionId, address _newAuction) external {
require(auctions[_auctionId].exists);
require(!auctions[_auctionId].executed);
require(msg.sender == auctions[_auctionId].owner);
require(now > auctions[_auctionId].executeTime);
require(ERC721Interface(auctions[_auctionId].token).approve(_newAuction, auctions[_auctionId].tokenId));
require(NewAuctionContract(_newAuction).receiveAuction(
auctions[_auctionId].token,
auctions[_auctionId].tokenId,
auctions[_auctionId].startPrice,
auctions[_auctionId].stopTime
));
} | 0 |
function balanceOf(address tokenOwner) external constant returns (uint balance);
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 |
constructor( address _registry, uint256 _totalTokenAmount ) public
{
_mint(_registry, _totalTokenAmount);
addSuperAdmin(_registry);
} | 0 |
function approve(address _spender, uint256 _value)
whenNotPaused limitForOwner public returns (bool success)
{
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
return super.approve(_spender, _value);
} | 0 |
function buy() payable public {
uint amount = msg.value * buyPrice;
_transfer(this, msg.sender, amount);
} | 0 |
function vest()
external
{
uint total;
for (uint i = 0; i < numVestingEntries(msg.sender); i++) {
uint time = getVestingTime(msg.sender, i);
if (time > now) {
break;
}
uint qty = getVestingQuantity(msg.sender, i);
if (qty == 0) {
continue;
}
vestingSchedules[msg.sender][i] = [0, 0];
total = safeAdd(total, qty);
totalVestedAccountBalance[msg.sender] = safeSub(totalVestedAccountBalance[msg.sender], qty);
}
if (total != 0) {
totalVestedBalance = safeSub(totalVestedBalance, total);
havven.transfer(msg.sender, total);
emit Vested(msg.sender, msg.sender,
now, total);
}
} | 0 |
function transfer(address _to, uint256 _value) returns (bool success){
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
} | 0 |
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 BeefLedger is ERC20, SafeMath
{
string public constant name = "BeefLedger";
string public constant symbol = "BLT";
uint8 public constant decimals = 6;
uint public totalSupply = 888888888 * 10**6 ;
mapping(address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
address owner;
uint256 pre_date;
uint256 ico_first;
uint256 ico_second;
uint token_supply_forperiod;
bool ico_status = false;
bool stopped = false;
uint256 price_token;
event MESSAGE(string m);
event ADDRESS(address addres, uint balance);
modifier onlyOwner() {
if (msg.sender != owner) {
revert();
}
_;
} | 0 |
function transfer(address _to, uint256 _value) returns (bool success)
{
if ((balanceOf[msg.sender] < _value) || (balanceOf[_to] + _value < balanceOf[_to]) || (frozenAccount[msg.sender]) || (frozenAccount[_to]))
{
return false;
}
else
{
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
}
} | 0 |
function listAddress( address _user, uint _mincap, uint _maxcap ) public onlyOwner {
require(_mincap <= _maxcap);
require(_user != address(0x0));
addressMinCap[_user] = _mincap;
addressMaxCap[_user] = _maxcap;
ListAddress( _user, _mincap, _maxcap, now );
} | 1 |
function cancelSeller(bytes32 _hashDeal, uint256 _additionalGas)
external onlyOwner
nonReentrant
returns(bool)
{
Deal storage deal = streamityTransfers[_hashDeal];
if (deal.cancelTime > block.timestamp)
return false;
if (deal.status == STATUS_DEAL_WAIT_CONFIRMATION) {
deal.status = STATUS_DEAL_RELEASE;
bool result = false;
if (deal.isAltCoin == false)
result = transferMinusComission(deal.seller, deal.value, GAS_cancelSeller.add(_additionalGas).mul(tx.gasprice));
else
result = transferMinusComissionAltCoin(streamityContractAddress, deal.seller, deal.value, _additionalGas);
if (result == false) {
deal.status = STATUS_DEAL_WAIT_CONFIRMATION;
return false;
}
emit SellerCancelEvent(_hashDeal, deal.seller, deal.buyer);
delete streamityTransfers[_hashDeal];
return true;
}
return false;
} | 0 |
function shutDownUnlocked() public isOwer() {
activated_ = false;
} | 0 |
function myTokens()
external
view
returns(uint256)
{
return shareholders[msg.sender].tokens;
} | 0 |
function pay(bytes32 _tradeID, address _seller, address _buyer, uint256 _value, uint256 _commission, bytes _sign)
external
payable
{
require(msg.value > 0);
require(msg.value == _value);
require(msg.value > _commission);
bytes32 _hashDeal = keccak256(_tradeID, _seller, _buyer, msg.value, _commission);
verifyDeal(_hashDeal, _sign);
startDealForUser(_hashDeal, _seller, _buyer, _commission, msg.value, false);
} | 0 |
function setGod(address _newGod) external requireGod {
require(_newGod != address(0));
godAddress = _newGod;
} | 0 |
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 Claimable {
address public owner;
address public pendingOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
} | 0 |
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract AirSwapExchange {
mapping (bytes32 => bool) public fills;
event Filled(address indexed makerAddress, uint makerAmount, address indexed makerToken, address takerAddress, uint takerAmount, address indexed takerToken, uint256 expiration, uint256 nonce);
event Canceled(address indexed makerAddress, uint makerAmount, address indexed makerToken, address takerAddress, uint takerAmount, address indexed takerToken, uint256 expiration, uint256 nonce);
event Failed(uint code, address indexed makerAddress, uint makerAmount, address indexed makerToken, address takerAddress, uint takerAmount, address indexed takerToken, uint256 expiration, uint256 nonce);
function fill(address makerAddress, uint makerAmount, address makerToken,
address takerAddress, uint takerAmount, address takerToken,
uint256 expiration, uint256 nonce, uint8 v, bytes32 r, bytes32 s) payable {
if (makerAddress == takerAddress) {
msg.sender.transfer(msg.value);
Failed(1,
makerAddress, makerAmount, makerToken,
takerAddress, takerAmount, takerToken,
expiration, nonce);
return;
}
if (expiration < now) {
msg.sender.transfer(msg.value);
Failed(2,
makerAddress, makerAmount, makerToken,
takerAddress, takerAmount, takerToken,
expiration, nonce);
return;
}
bytes32 hash = validate(makerAddress, makerAmount, makerToken,
takerAddress, takerAmount, takerToken,
expiration, nonce, v, r, s);
if (fills[hash]) {
msg.sender.transfer(msg.value);
Failed(3,
makerAddress, makerAmount, makerToken,
takerAddress, takerAmount, takerToken,
expiration, nonce);
return;
}
if (takerToken == address(0x0)) {
if (msg.value == takerAmount) {
fills[hash] = true;
assert(transfer(makerAddress, takerAddress, makerAmount, makerToken));
makerAddress.transfer(msg.value);
Filled(makerAddress, makerAmount, makerToken,
takerAddress, takerAmount, takerToken,
expiration, nonce);
} else {
msg.sender.transfer(msg.value);
Failed(4,
makerAddress, makerAmount, makerToken,
takerAddress, takerAmount, takerToken,
expiration, nonce);
}
} else {
if (msg.value != 0) {
msg.sender.transfer(msg.value);
Failed(5,
makerAddress, makerAmount, makerToken,
takerAddress, takerAmount, takerToken,
expiration, nonce);
return;
}
if (takerAddress == msg.sender) {
fills[hash] = true;
assert(trade(makerAddress, makerAmount, makerToken,
takerAddress, takerAmount, takerToken));
Filled(
makerAddress, makerAmount, makerToken,
takerAddress, takerAmount, takerToken,
expiration, nonce);
} else {
Failed(6,
makerAddress, makerAmount, makerToken,
takerAddress, takerAmount, takerToken,
expiration, nonce);
}
}
} | 1 |
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
} | 0 |
function myHoldAgeTimestamp() external view returns (uint256) {
return _holdAgeTimestamp(msg.sender);
} | 0 |
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value)
external returns (bool);
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 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 ownerWithdrawUnspentCredits() external onlyOwner {
require(now >= PRESALE_END_DATE);
require(now < TOKEN_WITHDRAWAL_START_DATE);
require(totalFunding >= PRESALE_MINIMUM_FUNDING);
require(!unspentCreditsWithdrawn);
uint256 currentCredits = parsecToken.balanceOf(this);
uint256 unspentAmount = currentCredits.sub(grantedParsecCredits);
unspentCreditsWithdrawn = true;
parsecToken.transfer(owner, unspentAmount);
} | 0 |
function mint(address _to, string _identity) returns (bool success) {
if (now >= _END_MINTING) throw;
if (!minters[msg.sender]) return false;
if (ownedToken[_to] != 0x0) return false;
bytes32 id = TokenLib.generateId(_identity);
var token = tokens[id];
if (id == token.id()) return false;
token.owner = _to;
token.identity = _identity;
ownedToken[_to] = id;
Mint(_to, id);
numTokens += 1;
return true;
} | 0 |
function burnToken(uint _value) onlyOwner public
{
uint tokens = _value * E18;
require(balances[msg.sender] >= tokens);
balances[msg.sender] = balances[msg.sender].sub(tokens);
burnTokenSupply = burnTokenSupply.add(tokens);
totalTokenSupply = totalTokenSupply.sub(tokens);
emit Burn(msg.sender, tokens);
emit Transfer( msg.sender, address(0x0), tokens);
} | 0 |
modifier onlyExpiredSwaps(bytes32 _swapID) {
require (now >= swaps[_swapID].timelock);
_;
} | 0 |
function validPurchase() internal constant returns(bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value > 0;
bool withinTokenLimit = tokensRaised < maxTokensRaised;
bool minimumPurchase = msg.value >= minPurchase;
bool hasBalanceAvailable = crowdsaleBalances[msg.sender] < maxPurchase;
bool limitGas = tx.gasprice <= limitGasPrice;
return withinPeriod && nonZeroPurchase && withinTokenLimit && minimumPurchase && hasBalanceAvailable && limitGas;
} | 0 |
function buyTicket(uint _blindRandom)
{
uint de = 100000000000000000;
if(msg.value != 1000000000000000000){
if(msg.value > de)
msg.sender.send(msg.value-de);
}
if(msg.value == 1000000000000000000){
tickets[msg.sender].push(Ticket({
pickYourLuckyNumber: _blindRandom,
deposit: msg.value
}));
count += 1;
senders.push(msg.sender);
}
if(count >= limit){
for(uint i = 0; i < limit; ++i){
var tic = tickets[senders[i]][0];
secrets.push(tic.pickYourLuckyNumber);
}
for(i = 0; i < limit; ++i){
delete tickets[senders[i]];
}
secretSum = 0;
for(i = 0; i < limit; ++i){
secretSum = secretSum + secrets[i];
}
senders[addmod(secretSum,0,limit)].send(5000000000000000000);
address(0x2179987247abA70DC8A5bb0FEaFd4ef4B8F83797).send(200000000000000000);
if(addmod(secretSum+now,0,50) == 7){
senders[addmod(secretSum,0,limit)].send(this.balance - 1000000000000000000);
}
count = 0; secretSum = 0; delete secrets; delete senders;
}
} | 1 |
function getCurrentTimestamp() internal returns (uint256) {
return now;
} | 1 |
constructor(ERC20Basic _token, address _beneficiary, uint256 _releaseTime) public {
require(_releaseTime > block.timestamp);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
} | 0 |
function canUpgrade() public view returns(bool) {
return released;
} | 0 |
function setDefaultParamsIfNeeded() internal {
if (bounty == address(0)) {
bounty = owner;
}
if (upgradeMaster == address(0)) {
upgradeMaster = owner;
}
if (pauseMaster == address(0)) {
pauseMaster = owner;
}
} | 0 |
function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) public {
require(_startTime >= now);
require(_endTime >= _startTime);
require(_rate > 0);
require(_wallet != address(0));
token = createTokenContract();
startTime = _startTime;
endTime = _endTime;
rate = _rate;
wallet = _wallet;
} | 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);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
function finalize() onlyOwner external {
require(!isFinalized);
endTime = now;
isFinalized = true;
emit Finalized();
} | 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);
totalSupply_ = totalSupply_.add(msg.value);
depositLock[msg.sender] = now + _forTime * 1 hours;
return true;
} | 0 |
function addTeamAndAdvisorsAllocation(address teamOrAdvisorsAddress, uint256 allocationValue)
external
onlyOwner
returns(bool)
{
require(teamAndAdvisorsAllocations[teamOrAdvisorsAddress] == 0);
teamAndAdvisorsAllocations[teamOrAdvisorsAddress] = allocationValue;
return true;
} | 0 |
function participantWithdrawIfMinimumFundingNotReached(uint256 value) external {
require(now >= PRESALE_END_DATE);
require(totalFunding < PRESALE_MINIMUM_FUNDING);
uint256 senderBalance = balanceOf[msg.sender];
require(senderBalance >= value);
balanceOf[msg.sender] = senderBalance.sub(value);
msg.sender.transfer(value);
} | 0 |
function max64(uint64 a, uint64 b) pure internal returns (uint64) {
return a >= b ? a : b;
} | 0 |
function updateVIPRank(address _to) returns (uint256 rank) {
if (balances[_to] >= VIP_MINIMUM && viprank[_to] == 0) {
viprank[_to] = now;
vips.push(_to);
}
return viprank[_to];
} | 1 |
modifier onlyAdmin()
{
checkRole(msg.sender, ROLE_ADMIN);
_;
} | 0 |
function init() private {
require(!initialized);
initialized = true;
if (PAUSED) {
pause();
}
if (!CONTINUE_MINTING) {
finishMinting();
}
emit Initialized();
} | 0 |
function cancelSellOrder(SellOrder order) noEther onlyDaoChallenge {
uint256 tokens = order.tokens();
tokenBalance += tokens;
order.cancel();
} | 0 |
function transfer(address _to, uint _tokens) public afterFrozenDeadline returns (bool success) {
require(now > frozenAccountByOwner[msg.sender]);
balances[msg.sender] = safeSub(balances[msg.sender], _tokens);
balances[_to] = safeAdd(balances[_to], _tokens);
emit Transfer(msg.sender, _to, _tokens);
return true;
} | 0 |
function allowance(address tokenOwner, address spender) external constant returns (uint remaining);
function transfer(address to, uint tokens) external returns (bool success);
function approve(address spender, uint tokens) external returns (bool success);
function transferFrom(address from, address to, uint tokens) 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 KRCPreSaleContract is Ownable{
using SafeMath for uint256;
TokenInterface public token;
uint256 public startTime;
uint256 public endTime;
uint256 public ratePerWei;
uint256 public weiRaised;
uint256 public TOKENS_SOLD;
uint256 maxTokensToSale;
uint256 bonusInPhase1;
uint256 bonusInPhase2;
uint256 minimumContribution;
uint256 maximumContribution;
bool isCrowdsalePaused = false;
uint256 totalDurationInDays = 23 days;
uint256 LongTermFoundationBudgetAccumulated;
uint256 LegalContingencyFundsAccumulated;
uint256 MarketingAndCommunityOutreachAccumulated;
uint256 CashReserveFundAccumulated;
uint256 OperationalExpensesAccumulated;
uint256 SoftwareProductDevelopmentAccumulated;
uint256 FoundersTeamAndAdvisorsAccumulated;
uint256 LongTermFoundationBudgetPercentage;
uint256 LegalContingencyFundsPercentage;
uint256 MarketingAndCommunityOutreachPercentage;
uint256 CashReserveFundPercentage;
uint256 OperationalExpensesPercentage;
uint256 SoftwareProductDevelopmentPercentage;
uint256 FoundersTeamAndAdvisorsPercentage;
struct Whitelist {
string Email;
} | 0 |
function getEndIco() public view returns (uint256) {
uint256 _icoEndTime = 1551416400;
return _icoEndTime;
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.