function
string | label
int64 |
|---|---|
function setRate(uint256 _new_EUR_WEI)
public
onlyRateControl
{
lastUpdate = now;
require(_new_EUR_WEI > 0, "Please assign a valid rate.");
EUR_WEI = _new_EUR_WEI;
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) onlyPayloadSize(3 * 32) onlyIfTransfersAllowed {
var _allowance = allowed[_from][msg.sender];
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
} | 0 |
function submitEntry(bytes _hash, string note) public {
require(entries[_hash].timestamp == 0);
entries[_hash] = Entry(msg.sender, now, note);
} | 1 |
function currentTime() constant returns (uint _currentTime) {
return now;
} | 1 |
function approve(address spender, uint256 value) public 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;
function isToken() public constant returns (bool weAre) {
return true;
} | 0 |
function mintAdminApproval(address _address, uint256 _value) public onlyAdmin {
if (mintApprove[_address].amount > 0) {
require(mintApprove[_address].amount == _value, "Value is diferent");
}
else {
mintApprove[_address].amount = _value;
}
mintApprove[_address].admin = msg.sender;
if ((mintApprove[_address].audit != 0x0) && (mintApprove[_address].marketMaker != 0x0))
mint(_address, _value);
} | 0 |
function getBalance() public view returns(uint256){
return address(this).balance;
} | 0 |
function tokenFallback(address player, uint256 amount, bytes calldata data)
external
updateDividends
{
require(msg.sender == P3X_ADDRESS);
if(data[0] == 0) {
fundPot(player, amount);
} else {
placeBet(player, amount, uint8(data[0]));
}
} | 0 |
function convert() public returns (bool) {
uint256 senderBalance = Token1st(token1stContract()).getBalanceOf(msg.sender);
require(Token1st(token1stContract()).allowance(msg.sender, this) >= senderBalance);
Token1st(token1stContract()).transferDecimalAmountFrom(msg.sender, owner, senderBalance);
return Token(tokenContract()).transfer(msg.sender, senderBalance * 10000000000);
} | 0 |
function removeSuperAdmin(address _admin) public onlyOwner validateAddress(_admin){
require(superAdmins[_admin]);
superAdmins[_admin] = false;
emit RemoveSuperAdmin(_admin);
} | 0 |
function token1stContract() view internal returns (address) {
return web.getContractAddress("Token1st");
} | 0 |
function setTokenUnlock() onlyOwner public
{
require(tokenLock == true);
require(saleTime == false);
tokenLock = false;
} | 0 |
function ZYHToken() public {
balances[msg.sender] = TOTAL_SUPPLY;
totalSupply = TOTAL_SUPPLY;
transfer(WALLET_ECOSYSTEM, ALLOC_ECOSYSTEM);
} | 0 |
function balanceOf(address who) constant returns (uint);
function transfer(address to, uint value);
event Transfer(address indexed from, address indexed to, uint value);
}
contract ERC20 is ERC20Basic
{
function allowance(address owner, address spender) constant returns (uint);
function transferFrom(address from, address to, uint value);
function approve(address spender, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract BasicToken is ERC20Basic
{
using SafeMath for uint;
mapping(address => uint) balances;
modifier onlyPayloadSize(uint size)
{
if(msg.data.length < size + 4)
{
throw;
}
_;
} | 0 |
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
function isTokenOwner(address _owner) constant returns (bool);
function identityOf(bytes32 _id) constant returns (string identity);
function ownerOf(bytes32 _id) constant returns (address owner);
}
contract Devcon2Token is TokenInterface {
using TokenLib for TokenLib.Token;
mapping (address => bool) public minters;
uint constant _END_MINTING = 1474502400;
function END_MINTING() constant returns (uint) {
return _END_MINTING;
} | 0 |
function ownerResumeContract() external onlyOwner {
require(contractPaused);
contractPaused = false;
} | 0 |
function updateInvestorFunds(uint tokenAmount, uint weiAmount, address receiver, uint128 customerId) private {
investedAmountOf[receiver] = investedAmountOf[receiver].add(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].add(tokenAmount);
weiRaised = weiRaised.add(weiAmount);
tokensSold = tokensSold.add(tokenAmount);
assignTokens(receiver, tokenAmount);
Invested(receiver, weiAmount, tokenAmount, customerId);
} | 0 |
function setPaycarnita(uint256 _newPaycarnita) onlyManager public{
toPaycarnita=_newPaycarnita;
} | 0 |
constructor() public
{
owner1 = msg.sender;
} | 0 |
function hasRole(address _from, bytes32 _role, address _to) constant returns(bool);
function isOwner(address _node, address _owner) constant returns(bool);
}
contract Ambi2Enabled {
Ambi2 ambi2;
modifier onlyRole(bytes32 _role) {
if (address(ambi2) != 0x0 && ambi2.hasRole(this, _role, msg.sender)) {
_;
}
} | 0 |
function transferFrom( address _from, address _to, uint256 _amount )public returns (bool ok) {
require( _to != 0x0);
require(balances[_from] >= _amount && allowed[_from][msg.sender] >= _amount && _amount >= 0);
balances[_from] = (balances[_from]).sub(_amount);
allowed[_from][msg.sender] = (allowed[_from][msg.sender]).sub(_amount);
balances[_to] = (balances[_to]).add(_amount);
Transfer(_from, _to, _amount);
return true;
} | 0 |
function allocateTokens(address participant, uint256 amountTokens) private {
require(vestingSet);
uint256 precision = 10**18;
uint256 allocationRatio = safeMul(amountTokens, precision) / 570000000;
uint256 developmentAllocation = safeMul(allocationRatio, 380000000) / precision;
uint256 newTokens = safeAdd(amountTokens, developmentAllocation);
require(safeAdd(totalSupply, newTokens) <= tokenCap);
totalSupply = safeAdd(totalSupply, newTokens);
balances[participant] = safeAdd(balances[participant], amountTokens);
balances[vestingContract] = safeAdd(balances[vestingContract], developmentAllocation);
} | 0 |
function transfer(address to, uint256 value) public canTransfer(to) returns (bool) {
require(isLockedForMV[msg.sender] < now);
require(value <= _balances[msg.sender]);
_transfer(to, value);
return true;
} | 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;
mapping (address => uint256) public investedAmountOf;
mapping (address => uint256) public tokenAmountOf;
uint public ownerTestValue;
enum State{Unknown, Preparing, PreFunding, Funding, Success, Failure, Finalized, Refunding}
event Invested(address investor, uint weiAmount, uint tokenAmount);
event Refund(address investor, uint weiAmount);
function Crowdsale(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal) {
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;
}
minimumFundingGoal = _minimumFundingGoal;
} | 0 |
function subApproval(address _spender, uint _subtractedValue) public
returns (bool success) {
uint oldVal = allowed[msg.sender][_spender];
if (_subtractedValue > oldVal) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldVal.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
} | 0 |
function upgrade(uint256 value) public {
UpgradeState state = getUpgradeState();
require(state == UpgradeState.ReadyToUpgrade || state == UpgradeState.Upgrading);
require(value != 0);
balances[msg.sender] = balances[msg.sender].sub(value);
totalSupply = totalSupply.sub(value);
totalUpgraded = totalUpgraded.add(value);
upgradeAgent.upgradeFrom(msg.sender, value);
Upgrade(msg.sender, upgradeAgent, value);
} | 0 |
function hasBoughtEgg(address _buyer) view external returns (bool) {
return eggOwners[_buyer] == true;
} | 0 |
function PallyCoin() {
balances[msg.sender] = initialSupply;
} | 0 |
function payFee()
external
payable
returns (bool);
}
interface IAccessToken {
function lockBBK(
uint256 _value
)
external
returns (bool);
function unlockBBK(
uint256 _value
)
external
returns (bool);
function transfer(
address _to,
uint256 _value
)
external
returns (bool);
function distribute(
uint256 _amount
)
external
returns (bool);
function burn(
address _address,
uint256 _value
)
external
returns (bool);
}
contract BrickblockAccount is Ownable {
uint8 public constant version = 1;
uint256 public releaseTimeOfCompanyBBKs;
IRegistry private registry;
constructor
(
address _registryAddress,
uint256 _releaseTimeOfCompanyBBKs
)
public
{
require(_releaseTimeOfCompanyBBKs > block.timestamp);
releaseTimeOfCompanyBBKs = _releaseTimeOfCompanyBBKs;
registry = IRegistry(_registryAddress);
} | 0 |
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 {
int256 constant private INT256_MIN = -2**255;
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
} | 0 |
function transfer(address _to, uint256 _value, bytes _data)public returns (bool success) {
require(hasTrade());
require(_to != address(0));
if(isContract(_to)) {
transferToContract(_to, _value, _data);
}
else {
transferToAddress(_to, _value, _data);
}
return true;
} | 0 |
function BTCPToken() public payable {
startTime = now;
owner = msg.sender;
balances[owner] = _totalSupply;
} | 1 |
function transfer(address _to, uint _value) returns(bool) {
if (now < presaleDeadline) {
require(assetProxy.transferFrom(msg.sender, address(this), _value));
require(vesting.createVesting(_to, assetProxy, _value, 1, paymentInterval, schedule));
return true;
}
return assetProxy.transferFrom(msg.sender, _to, _value);
} | 0 |
function burn(uint256 _value)public returns (bool success) {
if (balanceOf[msg.sender] < _value) revert();
if (_value <= 0) revert();
balanceOf[msg.sender] = SafeMath.safeSub(balanceOf[msg.sender], _value);
totalSupply = SafeMath.safeSub(totalSupply,_value);
emit Burn(msg.sender, _value);
return true;
} | 0 |
function init_claim(uint256 balance) private atStage(Stages.initClaim) {
firstRelease = now + 26 weeks;
secondRelease = firstRelease + 26 weeks;
thirdRelease = secondRelease + 26 weeks;
fourthRelease = thirdRelease + 26 weeks;
uint256 amountToTransfer = safeMul(balance, 53846153846) / 100000000000;
ERC20Token.transfer(beneficiary, amountToTransfer);
nextStage();
} | 0 |
function NokuTokenBurner(address _wallet) public {
require(_wallet != address(0));
wallet = _wallet;
burningPercentage = 100;
LogNokuTokenBurnerCreated(msg.sender, _wallet);
} | 0 |
function vestCmdNow1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, 0, unlock100Days);
} | 0 |
function freezeTokensToInvestor(address _investorAddress, uint256 _tokenAmount, uint256 _daysToFreeze) public returns (bool) {
require(_investorAddress != address(0));
require(_tokenAmount != 0);
require(!investors[_investorAddress].isInvestor);
_daysToFreeze = _daysToFreeze.mul(1 days);
investors[_investorAddress] = Investor({tokenAmount: _tokenAmount, frozenPeriod: now.add(_daysToFreeze), isInvestor: true});
require(mycroToken.transferFrom(msg.sender, address(this), _tokenAmount));
emit LogFreezedTokensToInvestor(_investorAddress, _tokenAmount, _daysToFreeze);
return true;
} | 0 |
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,
InvalidNonce,
InsufficientApprovedTokens,
InsufficientApprovedTokensForFees,
InsufficientTokens,
InsufficientTokensForFees,
OverflowError
} | 0 |
function withdraw() public {
uint256 currBalance = token.balanceOf(this);
uint256 currLocking = getCurrLocking();
require(currBalance > currLocking);
uint256 available = currBalance.sub(currLocking);
token.transfer(wallet_A, available.mul(60).div(100));
token.transfer(wallet_B, available.mul(30).div(100));
token.transfer(wallet_C, available.mul(10).div(100));
} | 0 |
function calcTransferFee(uint256 _amount) public view returns (uint256) {
uint256 fee = 0;
fee = _amount.div(decimalpercent);
fee = fee.mul(transferFee.prop);
fee = fee.add(transferFee.abs);
return fee;
} | 0 |
function setClaim(address subject, bytes32 key, bytes32 value) public {
registry[msg.sender][subject][key] = value;
ClaimSet(msg.sender, subject, key, value, now);
} | 0 |
function changeState(uint256 _id, uint8 _state) public onlyEpisodeManager returns (bool) {
require(started);
require(!gameOver);
require(!gameOverByUser);
require(_id > 0 && _id <= cap);
require(_state <= 1);
require(citizens[_id].state != _state);
citizens[_id].state = _state;
TokenState(_id, _state);
timestamp = now;
if (_state == 0) {
livingSupply--;
} else {
livingSupply++;
}
return true;
} | 0 |
function approve(address spender, uint tokens) external returns (bool success);
function transferFrom(address from, address to, uint tokens) external returns (bool success);
function burn(uint256 _value) external;
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
event Burn(address indexed burner, uint256 value);
}
contract EzeCrowdsale is Ownable{
using SafeMath for uint256;
TokenInterface public token;
uint256 public startTime;
uint256 public endTime;
uint256 public ratePerWeiInSelfDrop = 60000;
uint256 public ratePerWeiInPrivateSale = 30000;
uint256 public ratePerWeiInPreICO = 20000;
uint256 public ratePerWeiInMainICO = 15000;
uint256 public weiRaised;
uint256 public TOKENS_SOLD;
uint256 maxTokensToSale;
uint256 bonusInSelfDrop = 20;
uint256 bonusInPrivateSale = 10;
uint256 bonusInPreICO = 5;
uint256 bonusInMainICO = 2;
bool isCrowdsalePaused = false;
uint256 totalDurationInDays = 213 days;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
constructor(uint256 _startTime, address _wallet, address _tokenAddress) public
{
require(_startTime >=now);
require(_wallet != 0x0);
startTime = _startTime;
endTime = startTime + totalDurationInDays;
require(endTime >= startTime);
owner = _wallet;
maxTokensToSale = uint(15000000000).mul( 10 ** uint256(18));
token = TokenInterface(_tokenAddress);
} | 0 |
function 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 StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
} | 0 |
function upgradeFrom(address _from, uint256 _value) public;
}
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) public {
upgradeMaster = _upgradeMaster;
} | 0 |
function approve(address _spender, uint256 _value) public returns(bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
} | 0 |
function signedTransferFromCheck(Data storage self, address tokenContract, address spender, address from, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (BTTSTokenInterface.CheckResult result) {
if (!self.transferable) return BTTSTokenInterface.CheckResult.NotTransferable;
bytes32 hash = signedTransferFromHash(self, tokenContract, spender, from, to, tokens, fee, nonce);
if (spender == address(0) || spender != ecrecoverFromSig(self, keccak256(signingPrefix, hash), sig)) return BTTSTokenInterface.CheckResult.SignerMismatch;
if (self.accountLocked[from]) return BTTSTokenInterface.CheckResult.AccountLocked;
if (self.executed[spender][hash]) return BTTSTokenInterface.CheckResult.AlreadyExecuted;
uint total = safeAdd(tokens, fee);
if (self.allowed[from][spender] < tokens) return BTTSTokenInterface.CheckResult.InsufficientApprovedTokens;
if (self.allowed[from][spender] < total) return BTTSTokenInterface.CheckResult.InsufficientApprovedTokensForFees;
if (self.balances[from] < tokens) return BTTSTokenInterface.CheckResult.InsufficientTokens;
if (self.balances[from] < total) return BTTSTokenInterface.CheckResult.InsufficientTokensForFees;
if (self.balances[to] + tokens < self.balances[to]) return BTTSTokenInterface.CheckResult.OverflowError;
if (self.balances[feeAccount] + fee < self.balances[feeAccount]) return BTTSTokenInterface.CheckResult.OverflowError;
return BTTSTokenInterface.CheckResult.Success;
} | 0 |
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 calculateRewards() public view returns(uint256,uint256) {
uint256 tokenRewardPart = IWingsController(manager).tokenRewardPart();
uint256 ethRewardPart = IWingsController(manager).ethRewardPart();
uint256 tokenReward = totalSold.mul(tokenRewardPart) / 1000000;
bool hasEthReward = (ethRewardPart != 0);
uint256 ethReward = 0;
if (hasEthReward) {
ethReward = totalCollected.mul(ethRewardPart) / 1000000;
}
return (ethReward, tokenReward);
} | 0 |
function isSane() public constant returns (bool);
function finalizeCrowdsale();
}
contract ERC20 {
uint public totalSupply;
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;
mapping (address => uint256) public investedAmountOf;
mapping (address => uint256) public tokenAmountOf;
uint public ownerTestValue;
enum State{Unknown, Preparing, PreFunding, Funding, Success, Failure, Finalized, Refunding}
event Invested(address investor, uint weiAmount, uint tokenAmount);
event Refund(address investor, uint weiAmount);
function Crowdsale(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal) {
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;
}
minimumFundingGoal = _minimumFundingGoal;
} | 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 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 SafeMath {
function safeMul(uint a, uint b) pure internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
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 |
modifier isBeforeDeadline(uint _bountyId) {
require(now < bounties[_bountyId].deadline);
_;
} | 0 |
function Paygine() {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
PaygineHasDeployed(now);
} | 1 |
function setWhitelistContract(HoloWhitelist _whitelistContract) external onlyOwner {
whitelistContract = _whitelistContract;
} | 0 |
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 deductFullBalance(uint tokenCode, address addr) private returns (uint amount) {
uint176 tokenAccount = uint176(tokenCode) << 160 | uint176(addr);
amount = tokenAmounts[tokenAccount];
tokenAmounts[tokenAccount] = 0;
} | 0 |
function burnRemainingTokens() onlyOwner external {
require(now > fundingEndTime);
uint256 tokensToBurn = tokenReward.balanceOf(this);
tokenReward.burn(tokensToBurn);
} | 0 |
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
} | 1 |
function createReserveTokensVault() external onlyOwner {
require(reserveTokensVault == address(0));
uint256 reserveTokens = 400000000;
reserveTokensVault = createTokenVaultInt(reserveTokens);
require(totalSupply_ <= HARD_CAP);
} | 0 |
constructor () public {
highScore = 0;
currentWinner = msg.sender;
lastTimestamp = now;
} | 0 |
function mintTokensFor(address beneficiaryAddress, uint256 amountOfTokens)
public
onlyOwner
{
require(beneficiaryAddress != address(0));
require(token.totalSupply().add(amountOfTokens) <= TOTAL_TOKENS_FOR_CROWDSALE);
_deliverTokens(beneficiaryAddress, amountOfTokens);
emit MintedTokensFor(beneficiaryAddress, amountOfTokens);
} | 0 |
function safeDiv(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
require(a == b * c + a % b);
return c;
} | 0 |
function burn(uint burnAmount) {
address burner = msg.sender;
balances[burner] = balances[burner].sub(burnAmount);
totalSupply_ = totalSupply_.sub(burnAmount);
Burned(burner, burnAmount);
Transfer(burner, BURN_ADDRESS, burnAmount);
} | 0 |
function buyTokens(address beneficiary) public payable {
require(!isFinalized);
require(beneficiary == msg.sender);
require(msg.value != 0);
require(msg.value >= individualCap);
uint256 weiAmount = msg.value;
require(isWhiteListedAddress(beneficiary));
require(validPurchase(weiAmount));
weiRaised = weiRaised.add(weiAmount);
uint256 _transactionId = transactionId;
uint256 tokensAmount = weiAmount.mul(rate);
pendingTransactions[_transactionId] = TokenPurchaseRecord(now, weiAmount, beneficiary);
transactionId += 1;
TokenPurchaseRequest(_transactionId, beneficiary, now, weiAmount, tokensAmount);
forwardFunds();
} | 0 |
modifier onlyMerchant() {
require(controller.isMerchant(msg.sender), "sender not a merchant.");
_;
} | 0 |
function setCrowdsaleActive(bool _crowdsaleActive) public {
require(msg.sender == tokenOwner);
crowdsaleActive = _crowdsaleActive;
} | 0 |
function ZZZToken() public {
balances[msg.sender] = TOTAL_SUPPLY;
totalSupply = TOTAL_SUPPLY;
transfer(WALLET_ECOSYSTEM, ALLOC_ECOSYSTEM);
} | 0 |
function Ownable() public {
ownerOne = msg.sender;
ownerTwo = msg.sender;
} | 0 |
function isEnded() public view returns (bool);
function hasBalance(address _beneficiary, uint _releaseDate) public view returns (bool);
function balanceOf(address _owner) public view returns (uint);
function ethBalanceOf(address _owner) public view returns (uint);
function refundableEthBalanceOf(address _owner) public view returns (uint);
function getRate(uint _phase, uint _volume) public view returns (uint);
function toTokens(uint _wei, uint _rate) public view returns (uint);
function () public payable;
function contribute() public payable returns (uint);
function contributeFor(address _beneficiary) public payable returns (uint);
function withdrawTokens() public;
function withdrawTokensTo(address _beneficiary) public;
function withdrawEther() public;
function withdrawEtherTo(address _beneficiary) public;
function refund() public;
function refundTo(address _beneficiary) public;
}
contract Dispatchable {
address private target;
}
contract SimpleDispatcher {
address private target;
function SimpleDispatcher(address _target) public {
target = _target;
} | 0 |
function _addPauser(address account) internal {
_pausers.add(account);
emit PauserAdded(account);
} | 0 |
function participantClawbackEther(uint256 value) external {
require(contractRefundStarted);
require(!contractRefundFinished);
uint256 totalContribution = contributionOf[msg.sender];
uint256 alreadyRefunded = refundOf[msg.sender];
uint256 maxWithdrawalAmount = totalContribution.sub(alreadyRefunded);
require(maxWithdrawalAmount > 0);
require(value > 0);
require(value <= maxWithdrawalAmount);
refundOf[msg.sender] = alreadyRefunded.add(value);
refundedFunding = refundedFunding.add(value);
msg.sender.transfer(value);
} | 0 |
function checkBetNumber(uint8 result) private
{
bool win;
if (result==gambles[gambleIndex[msg.sender]].input)
{
win=true;
}
solveBet(msg.sender, result,win,36);
} | 0 |
function setEndsAt(uint time) onlyOwner {
if(now > time) {
throw;
}
endsAt = time;
EndsAtChanged(endsAt);
} | 0 |
function getIdeasSinceLastDeploy(address adr) public view returns(uint256){
uint256 secondsPassed=min(clones_to_create_one_idea, now.sub(lastDeploy[adr]));
return secondsPassed.mul(arrayOfClones[adr]);
} | 0 |
function setContractAllowance(address allowedAddress, uint256 allowedAmount) onlyOwner public returns (bool success) {
require(allowedAmount <= totalSupply);
allowance[this][allowedAddress] = allowedAmount;
return true;
} | 0 |
function nextForkBlockNumber()
public
constant
returns (uint256)
{
return _nextForkBlockNumber;
} | 0 |
function burn(uint256 value) public {
_burn(msg.sender, value);
} | 0 |
function proportionalAmount(uint256 agreementId) private view returns (uint256) {
(uint256 start, uint256 duration, ) = decodeMeta(agreements[agreementId].meta);
if (block.timestamp >= start.add(duration)) {
return agreements[agreementId].totalAmount;
} else if (block.timestamp <= start) {
return 0;
} else {
return agreements[agreementId].totalAmount.mul(
block.timestamp.sub(start)
).div(duration);
}
} | 0 |
function setRate(uint256 _rate) onlyOwner public {
require(_rate > 0 && _rate < 1000000);
rate = _rate;
} | 0 |
function getIndexfromQA(uint256 questionId, uint256 textId)
public view
returns (uint256) {
require (questionId < numberOfQuestions);
require (textId < _supplyPerQ[questionId]);
return _theQAtoIndex[questionId][textId];
} | 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 StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
var _allowance = allowed[_from][msg.sender];
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
} | 0 |
function deposit() private {
if (msg.value > 0) {
if (balance[msg.sender] == 0) {
countOfInvestors += 1;
}
if (balance[msg.sender] > 0 && now > time[msg.sender].add(stepTime)) {
collectPercent();
percentWithdraw[msg.sender] = 0;
}
balance[msg.sender] = balance[msg.sender].add(msg.value);
time[msg.sender] = now;
ownerAddress.transfer(msg.value.mul(projectPercent).div(100));
emit Invest(msg.sender, msg.value);
} else {
collectPercent();
}
} | 0 |
function setEndingBlock(uint endingBlock) public onlyOwner notFinished {
require(endingBlock > block.number && endingBlock > startsAt);
endsAt = endingBlock;
} | 0 |
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 hasStarted() public constant returns (bool) {
return now >= startTime;
} | 0 |
function Owned() public {
owner = msg.sender;
} | 0 |
function approve(address _spender, uint256 _value) public returns (bool);
function allowance(address _owner, address _spender) public constant returns (uint256);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract ICrowdsaleProcessor is Ownable, HasManager {
modifier whenCrowdsaleAlive() {
require(isActive());
_;
} | 0 |
function setIntervalSchedulePresale(uint _paymentInterval, uint _schedule, uint _presaleDeadline) onlyRole('admin') returns(bool) {
paymentInterval = _paymentInterval;
schedule = _schedule;
presaleDeadline = _presaleDeadline;
return true;
} | 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 {
assert(token.transfer(to, value));
} | 0 |
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);
}
pragma solidity ^0.5.0;
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
} | 0 |
function decreaseApproval (address _spender, uint _subtractedValue) public whenNotPaused
returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
} | 0 |
function verifyMatchDetails(OrderDetails memory _buy, OrderDetails memory _sell) internal pure returns (bool) {
if (!verifyTokens(_buy.tokens, _sell.tokens)) {
return false;
}
if (_buy.price < _sell.price) {
return false;
}
if (_buy.volume < _sell.minimumVolume) {
return false;
}
if (_sell.volume < _buy.minimumVolume) {
return false;
}
if (_buy.settlementID != _sell.settlementID) {
return false;
}
return true;
} | 0 |
function allowance(address _owner, address _spender) external constant returns (uint remaining) {
return allowed[_owner][_spender];
} | 0 |
function releaseToken(address accountAddress) private returns (bool) {
require(accountAddress != address(0x0), "accountAddress not right");
Account memory _account = accountMapping[accountAddress];
if(_account.ownAmount == 0){
return true;
}
if(_account.releasedAmount == _account.ownAmount){
return true;
}
uint256 _releasedAmount = 0;
uint256 releaseTime;
uint256 nolockRate;
uint256 releaseRate;
(releaseTime,nolockRate,releaseRate) = getRoles(_account.roleType);
if(nolockRate > 0 && nolockReleasedMapping[accountAddress] != true){
_releasedAmount = _releasedAmount.add(_account.ownAmount.mul(nolockRate).div(100));
nolockReleasedMapping[accountAddress] = true;
}
if(releaseTime <= now){
uint256 _momth = now.sub(releaseTime).div(30 days).add(1);
if(releasedRateMapping[accountAddress] <= _momth) {
_releasedAmount = _releasedAmount.add(_account.ownAmount.mul(_momth-releasedRateMapping[accountAddress]).mul(releaseRate).div(100));
releasedRateMapping[accountAddress] = _momth;
}
}
if(_releasedAmount > 0){
if(accountMapping[accountAddress].releasedAmount.add(_releasedAmount) <= _account.ownAmount){
accountMapping[accountAddress].releasedAmount = accountMapping[accountAddress].releasedAmount.add(_releasedAmount);
}else{
accountMapping[accountAddress].releasedAmount = _account.ownAmount;
}
}
return true;
} | 0 |
function TokenTimelock(ERC20Basic _token, address _beneficiary, uint256 _releaseTime) {
require(_releaseTime > now);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
} | 0 |
function unlock() external {
if(now < unlockDate) throw;
uint256 entitled = allocations[msg.sender];
allocations[msg.sender] = 0;
if(!StandardToken(INDI).transfer(msg.sender, entitled * exponent)) throw;
} | 1 |
function transfer(address _to, uint256 _value) public ReleaseTimeTransfer(msg.sender) returns (bool success) {
return super.transfer(_to, _value);
} | 0 |
function setStartingBlock(uint startingBlock) public onlyOwner inState(State.PreFunding) {
require(startingBlock > block.number && startingBlock < endsAt);
startsAt = startingBlock;
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.