function
string | label
int64 |
|---|---|
function transferFrom( address from, address to, uint value) returns (bool ok) {
if( _balances[from] < value ) {
throw;
}
if( _approvals[from][msg.sender] < value ) {
throw;
}
if( !safeToAdd(_balances[to], value) ) {
throw;
}
_approvals[from][msg.sender] -= value;
_balances[from] -= value;
_balances[to] += value;
Transfer( from, to, value );
return true;
} | 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);
}
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);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
} | 0 |
function logShiftAndBookAward() internal {
uint256 shiftAward;
if ((phase == Phases.PreIcoA) || (phase == Phases.PreIcoB)) {
shiftAward = PRE_OPENING_AWARD;
} else if (phase == Phases.MainIco) {
shiftAward = ICO_OPENING_AWARD;
} else {
shiftAward = ICO_CLOSING_AWARD;
returnAllowedTime = uint64(now + RETURN_WEI_PAUSE);
}
setWithdrawal(msg.sender, shiftAward);
NewPhase(phase);
} | 0 |
modifier pastCliffTime(address target) {
VestingSchedule storage vestingSchedule = schedules[target];
require(block.timestamp > vestingSchedule.cliffTimeInSec);
_;
} | 0 |
function min64(uint64 a, uint64 b) internal pure returns (uint64) {
return a < b ? a : b;
} | 0 |
function revoke(address wlCandidate) public onlyOwner {
whitelist[wlCandidate] = false;
emit Revoked(wlCandidate, now);
} | 0 |
function upgradeFrom(address _tokenHolder, uint256 _amount) external;
}
contract UpgradeableToken is ProsperMintableToken {
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);
event NewUpgradeMaster(address upgradeMaster);
function UpgradeableToken(address _upgradeMaster) {
upgradeMaster = _upgradeMaster;
NewUpgradeMaster(upgradeMaster);
} | 0 |
function transferable() public view returns (bool) {
return data.transferable;
} | 0 |
function addInvestment(address _from, uint256 _value) internal {
investments[_from] = investments[_from].add(_value);
} | 0 |
function isEthereumBased(address _tokenAddress) private pure returns (bool) {
return (_tokenAddress != address(0x0));
} | 0 |
function releasableAmount() public view returns (uint256) {
return vestedAmount().sub(releasedTokens[msg.sender]);
} | 0 |
function startDealForUser(bytes32 _hashDeal, address _seller, address _buyer, uint256 _commission, uint256 _value, bool isAltCoin)
private returns(bytes32)
{
Deal storage userDeals = streamityTransfers[_hashDeal];
userDeals.seller = _seller;
userDeals.buyer = _buyer;
userDeals.value = _value;
userDeals.commission = _commission;
userDeals.cancelTime = block.timestamp.add(requestCancelationTime);
userDeals.status = STATUS_DEAL_WAIT_CONFIRMATION;
userDeals.isAltCoin = isAltCoin;
emit StartDealEvent(_hashDeal, _seller, _buyer);
return _hashDeal;
} | 0 |
function audit(bytes32 _swapID) external view returns (uint256 timelock, uint256 value, address to, address from, bytes32 secretLock) {
Swap memory swap = swaps[_swapID];
return (swap.timelock, swap.value, swap.withdrawTrader, swap.ethTrader, swap.secretLock);
} | 0 |
modifier onlyIco() {
require(msg.sender == addressIco);
_;
} | 0 |
function hasEnded() external view returns (bool) {
return now > endTime;
} | 0 |
function addGame(address key, string description, string url) {
if (msg.value < REGISTRATION_COST) {
if (msg.value > 0) {
msg.sender.send(msg.value);
}
return;
}
distributeValue();
if (records[key].time == 0) {
records[key].time = now;
records[key].owner = msg.sender;
records[key].keysIndex = keys.length;
keys.length++;
keys[keys.length - 1] = key;
records[key].description = description;
records[key].url = url;
numRecords++;
}
} | 1 |
function motionConfirming(uint motionID)
public
view
returns (bool)
{
uint startTime = motionStartTime[motionID];
return startTime + votingPeriod <= now &&
now < startTime + votingPeriod + confirmationPeriod;
} | 0 |
function reserveIssue(address _to, uint _value) onlyOwner public
{
uint tokens = _value * E18;
require(maxReserveSupply >= tokenIssuedReserve.add(tokens));
balances[_to] = balances[_to].add(tokens);
totalTokenSupply = totalTokenSupply.add(tokens);
tokenIssuedReserve = tokenIssuedReserve.add(tokens);
emit ReserveIssue(_to, tokens);
} | 0 |
function checkBetLowhigh(uint8 result) private
{
bool win;
if (result!=0 && ( (result<19 && gambles[gambleIndex[msg.sender]].input==0)
|| (result>18 && gambles[gambleIndex[msg.sender]].input==1)
) )
{
win=true;
}
solveBet(msg.sender,result,win,2);
} | 0 |
constructor() public {
creationTime = now;
} | 0 |
function DividendManager(address token_address, address auth_address) public {
token = SingleTokenCoin(token_address);
set_new_admin(auth_address);
dividends_share = 50;
reinvestment_share = 50;
} | 1 |
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
contract BTTSTokenInterface is ERC20Interface {
uint public constant bttsVersion = 100;
bytes public constant signingPrefix = "\x19Ethereum Signed Message:\n32";
bytes4 public constant signedTransferSig = "\x75\x32\xea\xac";
bytes4 public constant signedApproveSig = "\xe9\xaf\xa7\xa1";
bytes4 public constant signedTransferFromSig = "\x34\x4b\xcc\x7d";
bytes4 public constant signedApproveAndCallSig = "\xf1\x6f\x9b\x53";
event OwnershipTransferred(address indexed from, address indexed to);
event MinterUpdated(address from, address to);
event Mint(address indexed tokenOwner, uint tokens, bool lockAccount);
event MintingDisabled();
event TransfersEnabled();
event AccountUnlocked(address indexed tokenOwner);
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success);
function signedTransferHash(address tokenOwner, address to, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash);
function signedTransferCheck(address tokenOwner, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function signedTransfer(address tokenOwner, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success);
function signedApproveHash(address tokenOwner, address spender, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash);
function signedApproveCheck(address tokenOwner, address spender, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function signedApprove(address tokenOwner, address spender, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success);
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 releaseVestedTokens(address _adr) public changesToVestingFreezed(_adr) {
VestingSchedule storage vestingSchedule = vestingMap[_adr];
require(vestingSchedule.amount.minus(vestingSchedule.amountReleased) > 0);
uint256 totalTime = block.timestamp - vestingSchedule.startAt;
uint256 totalSteps = totalTime / vestingSchedule.step;
require(vestingSchedule.cliff <= totalSteps);
uint256 tokensPerStep = vestingSchedule.amount / vestingSchedule.duration;
if (tokensPerStep * vestingSchedule.duration != vestingSchedule.amount) tokensPerStep++;
uint256 totalReleasableAmount = tokensPerStep.times(totalSteps);
if (totalReleasableAmount > vestingSchedule.amount) totalReleasableAmount = vestingSchedule.amount;
uint256 amountToRelease = totalReleasableAmount.minus(vestingSchedule.amountReleased);
vestingSchedule.amountReleased = vestingSchedule.amountReleased.plus(amountToRelease);
ERC20 token = ERC20(crowdSaleTokenAddress);
token.transfer(_adr, amountToRelease);
totalUnreleasedTokens = totalUnreleasedTokens.minus(amountToRelease);
emit VestedTokensReleased(_adr, amountToRelease);
} | 0 |
function yes(address _address, uint _votes) public;
function no(address _address, uint _votes) public;
function vote(address _address) public view returns (int);
function votesTotal() public view returns (uint);
function isSubjectApproved() public view returns (bool);
}
contract Ownable is IOwnable {
modifier onlyOwner() {
require(msg.sender == owner);
_;
} | 0 |
function pause() public onlyOwner whenNotPaused {
_paused = true;
emit Paused(msg.sender);
} | 0 |
function deposit(bytes32 _password) public payable {
require(msg.value > commissionFee);
uint256 rand = _rand();
bytes32 pass = sha3(_password, rand);
randToAddress[msg.sender] = rand;
password[pass].from = msg.sender;
password[pass].amount = password[pass].amount.add(msg.value);
_updateSeed();
emit LogDeposit(msg.sender, msg.value);
} | 0 |
function transfer(address to, uint256 value) 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) returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function strConcat(string _a, string _b, string _c) internal pure returns (string) {
return strConcat(_a, _b, _c, "", "");
} | 0 |
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 SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
function add_referral(address referral, string promo, uint256 amount) external returns(address partner, uint256 p_partner, uint256 p_referral){
bytes32 promo_code = stringTobytes32(promo);
p_partner = 0;
p_referral = 0;
partner = address(0x0);
if(partnersPromo[promo_code] != address(0x0) && partnersPromo[promo_code] != referral){
partner = partnersPromo[promo_code];
if (msg.sender == contractICO){
referralsInfo[referral] += amount;
amount_referral_invest += amount;
partnersInfo[partner].attracted_investments += amount;
history[partner].push(itemHistory(now, referral, amount));
p_partner = (amount*uint256(calc_partnerPercent(partner)))/10000;
p_referral = (amount*uint256(ref_percent))/10000;
}
}
} | 1 |
function freezeTo(address _to, uint _amount, uint64 _until) public {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Transfer(msg.sender, _to, _amount);
emit Freezed(_to, _until, _amount);
} | 0 |
function approve(address _spender, uint256 _currentValue, uint256 _value) public onlyPayloadSize(3*32) returns (bool success) {
require(allowed[msg.sender][_spender] == _currentValue);
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
} | 0 |
function claimTokens(address _token) external onlyFundWallet {
require(_token != address(0));
Token token = Token(_token);
uint256 balance = token.balanceOf(this);
token.transfer(fundWallet, balance);
} | 0 |
function date_check() private returns(bool check_newyears){
is_leap_year();
if((_year <= now) && (now <= (_year + 1209600))){
return true;
}
else{
return false;
}
} | 0 |
function storeAuthenticity(string sha256) {
if (checkAuthenticity(sha256) == 0) {
authenticity[sha256] = now;
}
} | 1 |
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool success);
function transferFrom(address from, address to, uint256 value) public returns (bool success);
function approve(address spender, uint256 value) public returns (bool success);
function allowance(address owner, address spender) public view returns (uint256 remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
function mul(uint256 a, uint256 b) pure internal returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
function getTimeLeft()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now < round_[_rID].end)
if (_now > round_[_rID].strt + rndGap_)
return( (round_[_rID].end).sub(_now) );
else
return( (round_[_rID].strt + rndGap_).sub(_now) );
else
return(0);
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) public validateAddress(_to) isNotTimeLockedFrom(_from, _to) isNotFrozenFrom(_from, _to) returns (bool)
{
return super.transferFrom(_from, _to, _value);
} | 0 |
function approve(address spender, uint256 value) public returns (bool success);
function allowance(address owner, address spender) public view returns (uint256 remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Owned {
address public owner = msg.sender;
address public potentialOwner;
modifier onlyOwner {
require(msg.sender == owner);
_;
} | 0 |
function investETH(address referral) public payable {
require(msg.value >= 0.1 ether);
if(getProfit(msg.sender) > 0){
uint256 profit = getProfit(msg.sender);
lastInvest[msg.sender] = now;
msg.sender.transfer(profit);
}
uint256 amount = msg.value;
uint256 commision = SafeMath.div(amount, 20);
if(referral != msg.sender && referral != 0x1 && referral != promoter && referral != promoter1){
affiliateCommision[referral] = SafeMath.add(affiliateCommision[referral], commision);
}
affiliateCommision[promoter] = SafeMath.add(affiliateCommision[promoter], commision);
affiliateCommision[promoter1] = SafeMath.add(affiliateCommision[promoter1], commision);
investedETH[msg.sender] = SafeMath.add(investedETH[msg.sender], amount);
lastInvest[msg.sender] = now;
} | 0 |
function HubiiCrowdsale(address _teamMultisig, uint _start, uint _end) Crowdsale(_teamMultisig, _start, _end, hubii_minimum_funding) public {
PricingStrategy p_strategy = new FlatPricing(token_in_wei);
CeilingStrategy c_strategy = new FixedCeiling(chunked_multiple, limit_per_address);
FinalizeAgent f_agent = new BonusFinalizeAgent(this, bonus_base_points, _teamMultisig);
setPricingStrategy(p_strategy);
setCeilingStrategy(c_strategy);
token = new CrowdsaleToken(token_name, token_symbol, token_initial_supply, token_decimals, _teamMultisig, token_mintable);
token.setMintAgent(address(this), true);
token.setMintAgent(address(f_agent), true);
token.setReleaseAgent(address(f_agent));
setFinalizeAgent(f_agent);
} | 0 |
constructor() public {
owner = msg.sender;
emit OwnerChanged(address(0), owner);
} | 0 |
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) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
} | 0 |
function remoteAllowanceOnMyAddress () public view
returns(uint256 allowance) {
allowance = _remoteToken.allowance(msg.sender, address(this));
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) {
require (_value > 0);
require(_to != address(0));
require(_from != 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);
} | 0 |
function start_PREICO() external onlyOwner atStage(Stages.NOTSTARTED)
{
stage = Stages.PREICO;
stopped = false;
_price_tokn = 70;
balances[address(this)] =10000000 * 10 ** 18 ;
preico_startdate = now;
preico_enddate = now + 7 days;
emit Transfer(0, address(this), balances[address(this)]);
} | 0 |
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 WithdrawETH(uint _amount) {
if (beneficiary != msg.sender) throw;
coldWallet.transfer(_amount);
} | 0 |
function balanceOf(address who) constant public 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 constant 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);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function sellPoohs() public{
require(initialized);
uint256 hasPoohs=getMyPoohs();
uint256 poohValue=calculatePoohSell(hasPoohs);
uint256 fee=devFee(poohValue);
hatcheryPlumber[msg.sender] = SafeMath.div(hatcheryPlumber[msg.sender],2);
claimedPoohs[msg.sender]=0;
lastHatch[msg.sender]=now;
marketPoohs=SafeMath.add(marketPoohs,hasPoohs);
ceoAddress.transfer(fee);
msg.sender.transfer(SafeMath.sub(poohValue,fee));
} | 0 |
function notarize(string sha256) {
bytes memory b_hash = bytes(sha256);
if ( b_hash.length == 64 ){
if ( proofs[sha256] == 0 ){
proofs[sha256] = block.timestamp;
}
}
} | 1 |
function TokenTimelock(ERC20Basic _token, address _beneficiary, uint256 _releaseTime) public {
require(_releaseTime > now);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
} | 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 balanceOf(address who) constant returns (uint);
function allowance(address owner, address spender) constant returns (uint);
function transfer(address to, uint value) returns (bool ok);
function transferFrom(address from, address to, uint value) returns (bool ok);
function approve(address spender, uint value) returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract FractionalERC20 is ERC20 {
uint public decimals;
}
contract Crowdsale is Haltable {
using SafeMathLib for uint;
FractionalERC20 public token;
PricingStrategy public pricingStrategy;
FinalizeAgent public finalizeAgent;
address public multisigWallet;
uint public minimumFundingGoal;
uint public startsAt;
uint public endsAt;
uint public tokensSold = 0;
uint public weiRaised = 0;
uint public investorCount = 0;
uint public loadedRefund = 0;
uint public weiRefunded = 0;
bool public finalized;
bool public requireCustomerId;
bool public requiredSignedAddress;
address public signerAddress;
mapping (address => uint256) public investedAmountOf;
mapping (address => uint256) public tokenAmountOf;
mapping (address => bool) public earlyParticipantWhitelist;
uint public ownerTestValue;
enum State{Unknown, Preparing, PreFunding, Funding, Success, Failure, Finalized, Refunding}
event Invested(address investor, uint weiAmount, uint tokenAmount, uint128 customerId);
event Refund(address investor, uint weiAmount);
event InvestmentPolicyChanged(bool requireCustomerId, bool requiredSignedAddress, address signerAddress);
event Whitelisted(address addr, bool status);
event EndsAtChanged(uint endsAt);
function Crowdsale(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal) {
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 externalTokensRecovery(ERC20Basic _address) onlyAdmin(2) public{
require(state == State.Successful);
uint256 remainder = _address.balanceOf(this);
_address.transfer(msg.sender,remainder);
} | 0 |
function transferFrom(address _from, address _to, uint _value) public returns (bool)
{
require(isTransferable(_from) == true);
require(isTransferable(_to) == true);
require(balances[_from] >= _value);
require(approvals[_from][msg.sender] >= _value);
approvals[_from][msg.sender] = approvals[_from][msg.sender].sub(_value);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(_from, _to, _value);
return true;
} | 0 |
function setBurningPercentage(uint256 _burningPercentage) public onlyOwner {
require(0 <= _burningPercentage && _burningPercentage <= 100);
require(_burningPercentage != burningPercentage);
burningPercentage = _burningPercentage;
LogBurningPercentageChanged(msg.sender, _burningPercentage);
} | 0 |
function completeCrowdsale() external onlyOwner whenNotPaused {
require(hasEnded());
transferTokensLeftOver();
Finalized();
} | 0 |
function updateRate(uint newOneTokenInWei) public onlyOwner {
assert(!finalized);
assert(isUpdatable);
assert(now <= startsAt);
CrowdsaleExt lastTierCntrct = CrowdsaleExt(getLastTier());
assert(!lastTierCntrct.finalized());
pricingStrategy.updateRate(newOneTokenInWei);
} | 0 |
function getCat (uint catId) public {
require(catOwners[catId] == msg.sender);
require(now >= releaseDate);
catOwners[catId] = 0x0;
target.transfer(msg.sender, catId);
} | 0 |
function getNow() public constant returns (uint) {
return now;
} | 1 |
function getToken(uint _auctionId) external {
require(auctions[_auctionId].exists);
require(!auctions[_auctionId].executed);
require(now <= auctions[_auctionId].executeTime);
require(msg.sender == auctions[_auctionId].winner);
uint fullPrice = auctions[_auctionId].finalPrice;
require(arconaToken.transferFrom(msg.sender, this, fullPrice));
if (!inWhiteList(msg.sender)) {
uint fee = valueFromPercent(fullPrice, auctionFee);
fullPrice = fullPrice.sub(fee).sub(gasInTokens);
}
arconaToken.transfer(auctions[_auctionId].owner, fullPrice);
require(ERC721Interface(auctions[_auctionId].token).transfer(auctions[_auctionId].winner, auctions[_auctionId].tokenId));
auctions[_auctionId].executed = true;
emit GetToken(_auctionId, msg.sender);
} | 0 |
function balanceOf(address owner) public view returns (uint256 balance);
function transfer(address to, uint256 value) public returns (bool success);
function transferFrom(address from, address to, uint256 value) public returns (bool success);
function approve(address spender, uint256 value) public returns (bool success);
function allowance(address owner, address spender) public view returns (uint256 remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Owned {
address public owner;
constructor() public {
owner = msg.sender;
} | 0 |
function call_lucky(address contract_address, address contract_owner) public payable {
uint8 guess = uint8(keccak256(now, contract_owner)) % 10;
LuckyNumber(contract_address).takeAGuess.value(msg.value)(guess);
require(this.balance > 0);
msg.sender.transfer(this.balance);
} | 1 |
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_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
}
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff
);
}
} | 0 |
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowed[_owner][_spender];
} | 0 |
function FlatPricing(uint _oneTokenInWei) {
oneTokenInWei = _oneTokenInWei;
} | 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
);
}
pragma solidity ^0.4.23;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
} | 0 |
function release() public {
require(block.timestamp >= releaseTime);
uint256 amount = token.balanceOf(this);
require(amount > 0);
token.safeTransfer(beneficiary, amount);
} | 0 |
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 withdraw() external onlyOwner {
uint withdrawLimit = 500 ether;
if (withdrawn < withdrawLimit) {
uint toWithdraw = collected.sub(withdrawn);
if (toWithdraw + withdrawn > withdrawLimit) {
toWithdraw = withdrawLimit.sub(withdrawn);
}
beneficiary.transfer(toWithdraw);
withdrawn = withdrawn.add(toWithdraw);
return;
}
require(block.timestamp >= endTime);
beneficiary.transfer(collected);
token.transfer(beneficiary, token.balanceOf(this));
crowdsaleFinished = true;
} | 0 |
modifier onlyNotZero(uint256 amount) {
require(amount != 0);
_;
} | 0 |
function check(Role storage role, address addr)
view
internal
{
require(has(role, addr));
} | 0 |
modifier onlyRateControl()
{
require(msg.sender == rateControl, "rateControl key required for this function.");
_;
} | 0 |
function transfer(address _to, uint256 _value, bytes _data) onlyUnlocked public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(_value > 0);
uint256 codeLength;
assembly {
codeLength := extcodesize(_to)
}
if(codeLength > 0) {
return transferToContract(_to, _value, _data);
} else {
return transferToAddress(_to, _value, _data);
}
} | 0 |
function start_PREICO() public onlyOwner atStage(Stages.NOTSTARTED)
{
stage = Stages.PREICO;
stopped = false;
maxCap_PRE = 350000000 * 10 ** 18;
balances[address(this)] = maxCap_PRE;
pre_startdate = now;
pre_enddate = now + 20 days;
Transfer(0, address(this), balances[address(this)]);
} | 0 |
function requestWithdrawal(uint256 amountTokensToWithdraw) external isTradeable onlyWhitelist {
require(currentBlock() > fundingEndBlock);
require(amountTokensToWithdraw > 0);
address participant = msg.sender;
require(balanceOf(participant) >= amountTokensToWithdraw);
require(withdrawals[participant].tokens == 0);
balances[participant] = safeSub(balances[participant], amountTokensToWithdraw);
withdrawals[participant] = Withdrawal({tokens: amountTokensToWithdraw, time: previousUpdateTime});
WithdrawRequest(participant, amountTokensToWithdraw);
} | 0 |
function max(uint256 a, uint256 b) internal returns (uint256 res) {
if (a >= b) return a;
return b;
} | 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 SafeERC20 {
function safeTransfer(
ERC20Basic _token,
address _to,
uint256 _value
)
internal
{
require(_token.transfer(_to, _value));
} | 0 |
function setOwner(address _owner) onlyOwner
{ owner = _owner; }
modifier onlyOwner { if (msg.sender != owner) throw; _; }
}
contract TRMCrowdsale is Owned {
using SafeMath for uint;
event Print(string _message, address _msgSender);
uint public ETHUSD = 100000;
address manager = 0xf5c723B7Cc90eaA3bEec7B05D6bbeBCd9AFAA69a;
address ETHUSDdemon;
address public multisig = 0xc2CDcE18deEcC1d5274D882aEd0FB082B813FFE8;
address public addressOfERC20Token = 0x8BeF0141e8D078793456C4b74f7E60640f618594;
ERC20 public token;
uint public startICO = now;
uint public endICO = 1519776000;
uint public endPostICO = 1522454400;
uint public tokenIcoUsdCentPrice = 550;
uint public tokenPostIcoUsdCentPrice = 650;
uint public bonusWeiAmount = 29900000000000000000;
uint public smallBonusPercent = 27;
uint public bigBonusPercent = 37;
function TRMCrowdsale(){
owner = msg.sender;
token = ERC20(addressOfERC20Token);
ETHUSDdemon = msg.sender;
} | 0 |
function getActiveGrants(address _recipient) public view returns(uint256[]){
uint256 i = 0;
uint256[] memory recipientGrants = new uint256[](totalVestingCount);
uint256 totalActive = 0;
for(i; i < totalVestingCount; i++){
if(tokenGrants[i].isActive && tokenGrants[i].recipient == _recipient){
recipientGrants[totalActive] = i;
totalActive++;
}
}
assembly {
mstore(recipientGrants, totalActive)
}
return recipientGrants;
} | 0 |
function OBGAllocation(address _prospectors_team) internal {
obg = ProspectorsObligationToken(msg.sender);
unlockedAt = now + 6 * 30 days;
allocations[_prospectors_team] = 30000;
} | 0 |
constructor(address _token, address _profitAddress) public {
arconaToken = ERC20(_token);
profitAddress = _profitAddress;
} | 0 |
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool success);
function transferFrom(address from, address to, uint256 value) public returns (bool success);
function approve(address spender, uint256 value) public returns (bool success);
function allowance(address owner, address spender) public view returns (uint256 remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function allowance(address owner, address spender)
public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value)
public returns (bool);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable {
address public _owner;
event OwnershipTransferred(
address indexed previousOwner, address indexed newOwner
);
constructor() public {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
} | 0 |
function time() constant returns (uint) {
if(cTime > 0) {
return cTime;
}
return block.timestamp;
} | 1 |
function withdraw() public{
uint256 profit = getProfit(msg.sender);
uint256 timelimit = SafeMath.sub(now, launchtime);
uint256 maximumProfit = maximumProfitUser();
uint256 availableProfit = maximumProfit - userWithdrawals[msg.sender];
uint256 maxwithdrawlimit = SafeMath.div(SafeMath.mul(maxwithdraw, investedETH[msg.sender]), 100);
require(profit > 0);
require(timelimit >= 1296000);
lastInvest[msg.sender] = now;
lastWithdraw[msg.sender] = now;
if(profit < availableProfit){
if(profit < maxwithdrawlimit){
userWithdrawals[msg.sender] += profit;
msg.sender.transfer(profit);
}
else if(profit >= maxwithdrawlimit){
uint256 PartPayment = maxwithdrawlimit;
uint256 finalprofit = SafeMath.sub(profit, PartPayment);
userWithdrawals[msg.sender] += profit;
msg.sender.transfer(PartPayment);
investedETH[msg.sender] = SafeMath.add(investedETH[msg.sender], finalprofit);
}
}
else if(profit >= availableProfit && userWithdrawals[msg.sender] < maximumProfit){
uint256 finalPartialPayment = availableProfit;
if(finalPartialPayment < maxwithdrawlimit){
userWithdrawals[msg.sender] = 0;
investedETH[msg.sender] = 0;
delete userSequentialDeposits[msg.sender];
msg.sender.transfer(finalPartialPayment);
}
else if(finalPartialPayment >= maxwithdrawlimit){
uint256 finalPartPayment = maxwithdrawlimit;
uint256 finalprofits = SafeMath.sub(finalPartialPayment, finalPartPayment);
userWithdrawals[msg.sender] += finalPartialPayment;
msg.sender.transfer(finalPartPayment);
investedETH[msg.sender] = SafeMath.add(investedETH[msg.sender], finalprofits);
}
}
} | 0 |
function transfer(address _to, uint256 _value) public onlyPayloadSize(2*32) returns (bool success) {
require(vestedBalanceOf(msg.sender) >= _value);
balances[msg.sender] -= _value;
balances[_to] += _value;
if ((msg.sender == bounty.addr) && (now < vestingBounty)) {
balancesEndIcoFreeze[_to] += _value;
}
if ((msg.sender == team.addr) && (now < vestingTeam)) {
balances2yearFreeze[_to] += _value;
}
Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function vestCmd3Month1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, lock90Days, 0, unlock100Days);
} | 0 |
function withdrawEther(address beneficiary, uint256 etherAmount) onlyOwner public {
beneficiary.transfer(etherAmount);
} | 0 |
function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
} | 0 |
function burnFrom(address from, uint256 value) public {
_burnFrom(from, value);
} | 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 indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
function mint(address _to, uint256 _amount) public onlyOwner {
require(_to != address(0));
Contribution memory contribution = Contribution({
contributor: _to,
contributionAmount: _amount,
contributionTimestamp: uint64(now)
});
uint256 tokenId = contributions.push(contribution) - 1;
addToken(_to, tokenId);
Transfer(0x0, _to, tokenId);
ContributionMinted(_to, _amount, tokenId);
} | 1 |
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 unlockVestedTokens() external {
Grant storage grant_ = grants[msg.sender];
require(grant_.value != 0);
uint256 vested = calculateVestedTokens(grant_, block.timestamp);
if (vested == 0) {
return;
}
uint256 transferable = vested.sub(grant_.transferred);
if (transferable == 0) {
return;
}
grant_.transferred = grant_.transferred.add(transferable);
totalVesting = totalVesting.sub(transferable);
token.safeTransfer(msg.sender, transferable);
emit TokensUnlocked(msg.sender, transferable);
} | 0 |
function end_auction() {
require(msg.sender == beneficiary);
require(now > (expiry_date + 1 days));
selfdestruct(beneficiary);
} | 0 |
function approve(address _spender, uint256 _amount)public returns (bool success) {
require(!lockstatus, "Token is locked now");
require( _spender != 0x0, "Address can not be 0x0");
require(balances[msg.sender] >= _amount, "Balance does not have enough tokens");
require(!locked[msg.sender], "Sender address is locked");
allowed[msg.sender][_spender] = _amount;
emit Approval(msg.sender, _spender, _amount);
return true;
} | 0 |
function totalSupply() public view returns (uint) {
return supply;
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.