function string | label int64 |
|---|---|
function takeTokensBack() public onlyOwner
{
uint remainingTokensInTheContract = token.balanceOf(address(this));
token.transfer(owner,remainingTokensInTheContract);
} | 0 |
function transferFrom(address from, address to, uint256 value) public returns (bool success);
function approve(address spender, uint256 value) public returns (bool success);
function allowance(address owner, address spender) public view returns (uint256 remaining);
event Transfer(address indexed from, address indexe... | 0 |
function sub(uint a, uint b) internal pure returns (uint) {
assert(b <= a);
return a - b;
} | 0 |
function CentraAsiaWhiteList() {
owner = msg.sender;
operation = 0;
} | 1 |
function setRate(uint256 _value) external onlyOwner {
require (isActive == true);
require(msg.sender == owner);
require (_value >= 500 && _value <= 1500);
tokenExchangeRate = _value;
} | 0 |
function unlockTokens() public returns (bool) {
require(holderList[msg.sender].isActive);
require(!holderList[msg.sender].withdrawed);
require(now >= holderList[msg.sender].holdPeriodTimestamp);
OppToken.transfer(msg.sender, holderList[msg.sender].tokens);
holderList[msg.sender].withdrawed = true;
TokensTransfere... | 1 |
function isCustodian(address addr) external view returns (bool);
function isMerchant(address addr) external view returns (bool);
function getWBTC() external view returns (ERC20);
}
contract Factory is OwnableContract {
enum RequestStatus {PENDING, CANCELED, APPROVED, REJECTED}
struct Request {
address requester;
... | 0 |
function isSane() public constant returns (bool);
function finalizeCrowdsale();
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint2... | 0 |
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 (uint2... | 0 |
function tokenFallback(address _from, uint256 _value, bytes _data) public returns (bool) {
TKN memory tkn;
tkn.sender = _from;
tkn.value = _value;
tkn.data = _data;
uint32 u = uint32(_data[3]) + (uint32(_data[2]) << 8) + (uint32(_data[1]) << 16) + (uint32(_data[0]) << 24);
tkn.sig = bytes4(u);
fallback = tkn;
r... | 0 |
function transfer(address _to, uint256 _value) returns (bool success);
function balanceOf(address _owner) constant returns (uint256 balance);
}
contract MonLockupFund is Ownable {
using SafeMath for uint256;
ERC20Interface token;
address public constant tokenAddress = 0x6242a2762F5a4DB46ef8132398CB6391519aBe21;
ad... | 0 |
function setIcoAgent(address _icoAgent, bool _allowTransfer) onlyOwner public returns (bool) {
icoAgents[_icoAgent] = _allowTransfer;
return true;
} | 0 |
function usageFee(bytes32 _serviceName, uint256 _multiplier) public constant returns(uint fee) {
require(isValidService(_serviceName));
require(_multiplier != 0);
return 0;
} | 0 |
function releaseLockedToken() public returns (bool);
function isLocked(address addr) public view returns (bool) {
return _lock_list[addr];
} | 0 |
modifier onlyOwner() {
require(msg.sender == owner,"Ownable: caller is not owner.");
_;
} | 0 |
function vestedAmount(ERC20Basic token) public view returns (uint256) {
uint256 currentBalance = token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[token]);
if (now < cliff) {
return 0;
} else if (now >= start.add(duration) || revoked[token]) {
return totalBalance;
} else {
return totalBa... | 0 |
function emergencyReleaseERC20Token(uint16 tokenCode) external emergencyReleasePossible(msg.sender) {
uint amount = deductFullBalance(tokenCode, msg.sender);
emit EmergencyRelease(tokenCode, msg.sender, amount);
address tokenContract = tokenContracts[tokenCode];
require (tokenContract != address(0), "Registered tok... | 0 |
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
fun... | 0 |
function safeMul(uint a, uint b) internal returns (uint c) {
c = a * b;
assert(a == 0 || c / a == b);
} | 0 |
function decimals() constant returns (uint8 precision) {
return DCAssetBackend(backendContract).decimals();
} | 0 |
function ReleaseTokenForTeamAdvisersPartners () public onlyOwner {
require(now >= 1552348800);
if (transfer(reserveFund, reserveFundObligation)) {
reserveFundObligation = 0;
}
if (transfer(teamWallet2, teamObligationPart2)) {
teamObligationPart2 = 0;
}
} | 0 |
function setSecondBonus(uint256 _newBonus) onlyOwner external {
secondBonus = _newBonus;
} | 0 |
modifier greaterThanNow(uint256 _startTime) {
require(_startTime >= now);
_;
} | 1 |
function AlfaToken(address _owner) UpgradeableToken(_owner) {
name = "AlfaToken";
symbol = "ALFA";
totalSupply = 100000000000000000;
decimals = 9;
balances[_owner] = totalSupply;
} | 0 |
function burnFrom(address from, uint256 _value) public returns (bool success) {
require(balances[from] >= _value, "Source balance does not have enough tokens");
require(allowed[from][msg.sender] >= _value, "Source balance does not have enough tokens");
require(!locked[from], "Source address is locked");
balances[fr... | 0 |
function isFinalizerSane() public constant returns (bool sane) {
return address(finalizeAgent) == 0 || finalizeAgent.isSane(token);
} | 0 |
function balanceOf(address _owner) constant returns (uint256 balanceOfUser) {
return balances[_owner];
} | 0 |
constructor(IERC20 token, address beneficiary, uint256 releaseTime) public {
require(releaseTime > block.timestamp);
_token = token;
_beneficiary = beneficiary;
_releaseTime = releaseTime;
} | 0 |
function owner() public view returns(address) {
return _owner;
} | 0 |
function get_race_number() public view returns (uint){
return race_number;
} | 0 |
function withDiscount(uint256 _amount, uint _percent) internal pure
returns (uint256)
{
return (_amount.mul(_percent)).div(100);
} | 0 |
function allowance(address owner, address spender) constant returns (uint256);
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 Basi... | 0 |
function resetEmergencyRelease(address traderAddr) private {
if (emergencyReleaseSince[traderAddr] != 0) {
emergencyReleaseSince[traderAddr] = 0;
}
} | 0 |
modifier spendControlTargeted (address currency, address to, uint256 amount) {
if (to != address(this)) {
assert(Oversight(oversightAddress).validate(currency, amount));
}
_
} | 0 |
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... | 1 |
modifier only_min_value() {
if (msg.value < min_value) throw;
_
} | 0 |
function transfer(address _to, uint256 _value) whenNotPaused returns (bool success) {
require(_to!=0x0);
require(_value>0);
if (balances[msg.sender] >= _value) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
} | 0 |
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);
}
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
if (_a == 0) {
... | 0 |
function getMyShrimp() public view returns(uint256){
return hatcheryShrimp[msg.sender];
} | 0 |
function Ownable() {
owner = msg.sender;
} | 0 |
function transferOwnership(address newOwner) public onlyOwner {owner = newOwner;}
}contract IERC20 {
function totalSupply() public constant returns (uint256);
function balanceOf(address _owner) public constant returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
function transfer... | 0 |
function getNow() internal constant returns (uint) {
return now;
} | 1 |
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 FiatContract
{
functi... | 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 ... | 0 |
function getRateIco() public constant returns (uint256) {
if(now > endTimeIco)
return 0;
else {
return baseRate;
}
} | 0 |
function mktIssue(address _to, uint _time, uint _value) onlyOwner public
{
require(saleTime == false);
require( _time < mktVestingTime);
uint nowTime = now;
require( nowTime > mktVestingTimer[_time] );
uint tokens = _value * E18;
require(tokens <= mktVestingBalances[_time]);
require(tokens > 0);
require(maxMkt... | 0 |
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)... | 0 |
function getBalance() public view returns(uint256){
return this.balance;
} | 0 |
function getRandom(uint _seed) constant public returns(uint) {
return uint(keccak256(block.timestamp, block.difficulty)) ^ _seed;
} | 1 |
function emergencyRefundContract() external payable onlyOwnerOrMultisig {
require(contractFailed);
require(msg.value > 0);
} | 0 |
function approve(address _spender, uint256 _value) public returns (bool success) {
require(balances[msg.sender] >= _value);
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
} | 0 |
function ParsecCrowdsale (address _tokenAddress, address _multisigAddress, address _auditorAddress) public {
parsecToken = ParsecTokenERC20(_tokenAddress);
multisigAddress = _multisigAddress;
auditorAddress = _auditorAddress;
} | 0 |
function rand(uint max, address other) constant internal returns (uint result){
uint add = uint (msg.sender) + uint(other) + uint(block.timestamp);
uint random_number = addmod(uint (block.blockhash(block.number-1)), add, uint (max + 1)) ;
return random_number;
} | 1 |
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 {
uint publi... | 0 |
function terminate() noEther onlyChallengeOwner {
suicide(challengeOwner);
} | 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(addres... | 0 |
function hasTrade() public view returns (bool) {
return block.timestamp>tradeStartTime;
} | 0 |
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
uint256 tokens = _getTokenAmount(weiAmount);
weiRaised = weiRaised.add(weiAmount);
emit TokenPurchase(msg.sender, _beneficiary, weiAmount, tokens);
_updatePurchasingState(_benefi... | 0 |
function mintPresaleTokens(address _investor, uint256 _value) internal {
require(icoState == IcoState.Presale);
require(_value > 0);
uint256 _elcValue = getPresaleTotal(_value);
uint256 timeBonusAmount = _elcValue * getTimeBonus(now) / 1000;
_elcValue += timeBonusAmount;
require(elc.totalSupply() + _elcValue <= t... | 1 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC223 is ERC20 {
function name() constant returns (string _name);
function symbol() constant returns (string _symbol);
function decimals() constant retur... | 0 |
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 Vesting() payable {
creator = msg.sender;
createVestingPeriod(
0xA2690D72D6c932AE7Aa1cC0dE48aEaBBDCaf2799,
block.timestamp,
0,
VESTING_DURATION,
0x5b53f9755f82439cba66007ec7073c59e0da4a7d
);
} | 0 |
function extendDeadline(uint daysToExtend) onlyOwner{
deadLine=deadLine +daysToExtend * 1 days;
} | 0 |
function transfer(address _to, bytes32 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, bytes32 _value) returns (bool success);
function approve(address _spender, uint256 _value) returns (bool s... | 0 |
function safeNumDigits(uint number) pure internal returns (uint8) {
uint8 digits = 0;
while (number != 0) {
number /= 10;
digits++;
}
return digits;
} | 0 |
function setCrowdsaleAddress(address _crowdsale) external onlyOwner whenNotPaused {
require(crowdsale == address(0));
require(_crowdsale != address(0));
crowdsale = _crowdsale;
} | 0 |
function isAuthorized(address operator, uint256 assetId) public view returns (bool);
}
contract Marketplace is Ownable, Pausable, Destructible {
using SafeMath for uint256;
ERC20Interface public acceptedToken;
ERC721Interface public nonFungibleRegistry;
struct Auction {
bytes32 id;
address seller;
uint256 price;... | 0 |
function updateTokenInvestorBalance(address _investor, uint256 _newValue) onlyOwner external
{
addTokens(_investor,_newValue);
} | 0 |
function removeToken(address _from, uint256 _tokenId) private {
require(ownerOf(_tokenId) == _from);
uint256 tokenIndex = ownedTokensIndex[_tokenId];
uint256 lastTokenIndex = balanceOf(_from).sub(1);
uint256 lastToken = ownedTokens[_from][lastTokenIndex];
tokenOwner[_tokenId] = 0;
ownedTokens[_from][tokenIndex] =... | 0 |
function extractApprovedIndexLength() returns (uint256) {
return approvedIndex.length;
} | 0 |
function transferOwnershipImmediately(address _newOwner) public onlyOwner {
OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
newOwner = address(0);
} | 0 |
function totalSupply() external constant returns (uint);
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);
fu... | 0 |
function prepareContinuousPurchase() internal {
uint256 timestamp = block.timestamp;
uint256 bucket = timestamp - (timestamp % BUCKET_SIZE);
if (bucket > lastBucket) {
lastBucket = bucket;
bucketAmount = 0;
}
} | 1 |
function increaseApproval(address _spender, uint256 _addedValue) public returns(bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
} | 0 |
function 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);
function totalSupply() external view returns (uint256);
function balanceOf(address w... | 0 |
function balanceOf(address who) constant returns (uint);
function allowance(address owner, address spender) constant returns (uint);
function transfer(address to, uint value) returns (bool ok);
function transferFrom(address from, address to, uint value) returns (bool ok);
function approve(address spender, uint valu... | 0 |
function settleFrom(address _from, address _to, uint256 _value) isOperational() external returns (bool success) {
var _allowance = allowed[_from][msg.sender];
if (balances[_from] >= _value && (allowed[_from][msg.sender] >= _value || authorized[_from][msg.sender] == true ) && _value > 0) {
balances[_to] = safeAdd(bal... | 0 |
function getInvestorList(uint index) constant returns(address investor, uint endLockPeriod)
{
investor=investors[index].investor;
endLockPeriod=investors[index].time+setting_lockPeriod;
return;
} | 0 |
function safeAdd(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
} | 0 |
function _verification( address _from, address _verificationAddress, uint256 _value) internal
{
require( verificationAddressMap[ _verificationAddress ] );
if ( verificationHoldersVerifierAddressMap[ _from ] == _verificationAddress )
{
uint256 tmpNumberVerification = verificationAddressHoldersListCountMap[ _verific... | 1 |
function unown() onlyOwner {
owner = address(0);
} | 0 |
function TransferTokens(address _to, uint _amount) {
if (beneficiary != msg.sender) throw;
tokenReward.transfer(_to, _amount);
} | 0 |
function ReleaseDate() constant returns (uint) { return Date; }
function WithdrawalEnabled() internal returns (bool) { return Date > 0 && Date <= now; }
function deposit() payable {
if (msg.value >= MinimumDeposit()) {
deposits[msg.sender] += msg.value;
}
Deposit(msg.sender, msg.value);
} | 1 |
function thisweek() private view returns (uint256) {
return now / 1 weeks;
} | 1 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(rate);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
f... | 0 |
function getPlayerVaults(uint256 _pID)
public
view
returns(uint256 ,uint256, uint256)
{
uint256 _rID = rID_;
if (now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
if (round_[_rID].plyr == _pID)
{
return
(
(plyr_[_pID].win).add( ((round_[_rID].pot).mul(48)) / 100 ),
(plyr_[_... | 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 finalize() external {
if ( isFinalized ) throw;
if ( msg.sender != owner ) throw;
if ( generalTokens < tokenCreationMin ) throw;
if ( block.number < end_block ) throw;
isFinalized = true;
end_ts = now;
unlockedAt = end_ts + 2 minutes;
if ( ! multisig_owner.send(this.balance) ) throw;
} | 0 |
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(block.timestamp >= 1545102693);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _va... | 0 |
function approve(address _spender, uint256 _value) public returns (bool success);
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 a_owner, address indexed _spen... | 0 |
modifier canTransfer() {
require(mintingFinished);
require(now > allowTransferTimestamp);
_;
} | 1 |
function acceptTermsAndJoinDXF() payable external
{
if (now>startingDateFunding+365 days) throw;
if (!dxfOpen) throw;
if (vips[msg.sender]) throw;
if (msg.value < 10 ether) throw;
if (msg.value > (tokensCreationCap - totalTokens)) throw;
if (msg.value > (10000 ether - balances[msg.sender])) throw;
if (balances[... | 0 |
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)));}
} | 0 |
function random(uint upper) internal returns (uint) {
seed = uint(keccak256(keccak256(playerPool[playerPool.length -1], seed), now));
return seed % upper;
} | 1 |
function betOnNumber(uint8 numberChosen)
checkWaitingForBet
onlyActive
checkNbBetsCurrentBlock
{
updateStatusPlayer();
if (numberChosen>36) throw;
uint256 betValue= checkBetValue();
gambles.push(Gamble(msg.sender, false, false, BetTypes.number, numberChosen, betValue, block.number, 37));
} | 0 |
function start_ICO() external onlyOwner atStage(Stages.PREICO)
{
stage = Stages.ICO;
stopped = false;
balances[address(this)] =balances[address(this)].add(100000000 * 10 ** 18);
ico_startdate = now;
ico_enddate = now + 21 days;
emit Transfer(0, address(this), 100000000 * 10 ** 18);
} | 0 |
function mint(address _to, uint256 _amount) onlyOwner public returns (bool) {
require(_to != 0x0);
require(!mintingFinished);
require(_amount > 0);
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
holders.push(_to);
Mint(_to, _amount);
Transfer(0x0, _to, _amount);
return true... | 0 |
function increaseApproval(address _owner, address _spender, uint _addedValue) external{
require(msg.sender==_owner);
setAllowance(_owner,_spender,allowance(_owner,_spender).add(_addedValue));
emit Approval(_owner, _spender, allowance(_owner,_spender));
} | 0 |
function init() private {
require(!initialized);
initialized = true;
if (PAUSED) {
pause();
}
address[1] memory addresses = [address(0x8f71659fb57E6C6Be3Ab563D0dD45101235ae762)];
uint[1] memory amounts = [uint(100000000000000000000000000)];
uint64[1] memory freezes = [uint64(0)];
for (uint i = 0; i < addresses... | 0 |
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.