function
string | label
int64 |
|---|---|
function transfer(address _to, uint256 _value) public {
if (TransferActive){_transfer(msg.sender, _to, _value);}
} | 0 |
function advisorIssueVesting(address _to, uint _time) onlyIssuer public
{
require(saleTime == false);
require(advisorVestingTime >= _time);
uint time = now;
require( ( ( endSaleTime + (_time * advisorVestingDate) ) < time ) && ( advisorVestingTimeAtSupply[_time] > 0 ) );
uint tokens = advisorVestingTimeAtSupply[_time];
require(maxAdvisorSupply >= tokenIssuedAdvisor.add(tokens));
balances[_to] = balances[_to].add(tokens);
advisorVestingTimeAtSupply[_time] = 0;
totalTokenSupply = totalTokenSupply.add(tokens);
tokenIssuedAdvisor = tokenIssuedAdvisor.add(tokens);
emit AdvisorIssue(_to, tokens);
} | 0 |
function allowance(address tokenOwner, address spender) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexed tokenOwner,
address indexed spender,
uint256 value
);
}
contract LTLNN is ERC20, Ownable {
using SafeMath for uint256;
string public name = "Lawtest Token";
string public symbol ="LTLNN";
uint8 public decimals = 2;
uint256 initialSupply = 5000000;
uint256 saleBeginTime = 1557824400;
uint256 saleEndTime = 1557835200;
uint256 tokensDestructTime = 1711929599;
mapping (address => uint256) private _balances;
mapping (address => mapping(address => uint)) _allowed;
uint256 private _totalSupply;
uint256 private _amountForSale;
event Mint(address indexed to, uint256 amount, uint256 amountForSale);
event TokensDestroyed();
constructor() public {
_balances[address(this)] = initialSupply;
_amountForSale = initialSupply;
_totalSupply = initialSupply;
} | 0 |
function end_ICO() external onlyOwner atStage(Stages.ICO) {
require(now > ico_fourth);
stage = Stages.ENDED;
} | 0 |
function verify(address tokenContract) public view returns (
bool valid,
address owner,
uint decimals,
bool mintable,
bool transferable
) {
valid = _verify[tokenContract];
if (valid) {
BTTSToken t = BTTSToken(tokenContract);
owner = t.owner();
decimals = t.decimals();
mintable = t.mintable();
transferable = t.transferable();
}
} | 0 |
function changeBridge(address _bridge) public onlyOwner {
require(_bridge != address(0x0));
bridge = Bridge(_bridge);
} | 0 |
function unlockFund () public onlyOwner {
require(releaseTimeFund <= block.timestamp);
require(ReserveFundAmount > 0);
uint tokenBalance = token.balanceOf(this);
require(tokenBalance >= ReserveFundAmount);
if (token.transfer(ReserveFund, ReserveFundAmount)) {
ReserveFundAmount = 0;
}
} | 0 |
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 doPurchaseFor(address _sender) payable {
doPurchase(_sender);
} | 0 |
function _getTokenAmount(uint256 _weiAmount)
internal
view
returns (uint256){
super._getTokenAmount(_weiAmount);
uint256 tokens = _weiAmount.mul(rate);
return tokens.add(tokens.mul(10).div(100));
} | 0 |
function createAuction(address _token, uint _tokenId, uint _startPrice, uint _duration) external returns (bool) {
require(isAcceptedToken(_token));
require(_duration >= minDuration && _duration <= maxDuration);
_createAuction(msg.sender, _token, _tokenId, _startPrice, _duration);
return true;
} | 0 |
function times(uint a, uint b) public pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
function kill() public onlyOwner {
require(now < 1522566000);
selfdestruct(owner);
} | 1 |
function unpauseWithdrawal(address _address) onlyOwner external returns (bool) {
withdrawalPaused[_address] = false;
return true;
} | 0 |
function buyOmegaEgg() payable external {
require(msg.value >= 0.09 ether);
require(START_DATE <= now && now < END_DATE);
require(eggOwners[msg.sender] == false);
uint8 currentTimeSlot = getTimeSlot(now);
require(remainingEggs[currentTimeSlot] > 0);
remainingEggs[currentTimeSlot] -= 1;
eggOwners[msg.sender] = true;
LogOmegaEggSale(msg.sender, now);
if (msg.value > 0.09 ether) {
msg.sender.transfer(msg.value - 0.09 ether);
}
} | 0 |
function transfer(address _to, uint256 _value) public returns (bool);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool);
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 |
modifier can_buy(uint id) {
assert(isActive(id));
_
} | 0 |
function register(address key) {
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;
numRecords++;
} else {
returnValue();
}
} | 1 |
function getTokenCap() view public returns(uint256)
{
return cap;
} | 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 BurnableERC20 is ERC20 {
function burn(uint256 amount) public returns (bool burned);
}
contract NokuTokenBurner is Pausable {
using SafeMath for uint256;
event LogNokuTokenBurnerCreated(address indexed caller, address indexed wallet);
event LogBurningPercentageChanged(address indexed caller, uint256 indexed burningPercentage);
address public wallet;
uint256 public burningPercentage;
uint256 public burnedTokens;
uint256 public transferredTokens;
function NokuTokenBurner(address _wallet) public {
require(_wallet != address(0));
wallet = _wallet;
burningPercentage = 100;
LogNokuTokenBurnerCreated(msg.sender, _wallet);
} | 0 |
function kill() public onlyOwner {
selfdestruct(owner);
} | 0 |
function unlockAccount(address tokenOwner) public {
data.unlockAccount(tokenOwner);
} | 0 |
function floor() constant returns (uint256);
function ceiling() constant returns (uint256);
function purchase(address _sender, uint256 _value, uint256 _price) public returns (uint256);
function sell(address _from, uint256 _price, uint256 _amountBabz);
function powerBalanceOf(address _owner) constant returns (uint256);
function outstandingPower() constant returns (uint256);
function authorizedPower() constant returns (uint256);
function powerTotalSupply() constant returns (uint256);
function powerUp(address _sender, address _from, uint256 _amountBabz) public;
function downTick(address _owner, uint256 _now) public;
function createDownRequest(address _owner, uint256 _amountPower) public;
function downs(address _owner) constant public returns(uint256, uint256, uint256);
function downtime() constant returns (uint256);
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
} | 0 |
constructor() owned() hasAdmins() public {
} | 0 |
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
} | 0 |
function pullFunds()
external
onlyOwner
returns (bool)
{
IBrickblockToken bbk = IBrickblockToken(
registry.getContractAddress("BrickblockToken")
);
uint256 _companyFunds = bbk.balanceOf(address(bbk));
return bbk.transferFrom(address(bbk), address(this), _companyFunds);
} | 0 |
function approve(address spender, uint value) returns(bool ok);
function allowance(address owner, address spender) constant returns(uint);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract SubToken {
function SubTokenCreate ( uint256 _initialSupply, uint8 decimalUnits, string _name, string _symbol, address _tokenowner )returns (address){}
function transfer ( address _address , uint256 amount ){}
function share()returns(uint256){}
function totalSupply()returns(uint256){}
function initialSupply()returns(uint256){}
}
contract Cents is ERC20 {
using strings for *;
string public standard = 'Token 1.0';
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
uint256 public initialSupply;
address public _owner;
address public owner;
address public manager;
address public Centspooladdress;
mapping( address => uint256) public balanceOf;
mapping( uint => address) public accountIndex;
mapping( address =>bool ) public accountFreeze;
uint accountCount;
mapping(address => mapping(address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint value);
event FrozenFunds ( address target, bool frozen );
event TTLAccounts ( uint accounts );
event TTLSupply ( uint supply ) ;
event Burn(address indexed from, uint256 value);
function Cents() {
uint256 _initialSupply = 100000000 ;
uint8 decimalUnits = 0;
appendTokenHolders(msg.sender);
balanceOf[msg.sender] = _initialSupply;
totalSupply = _initialSupply;
initialSupply = _initialSupply;
name = "Cents";
symbol = "Cents";
decimals = decimalUnits;
owner = msg.sender;
} | 0 |
function max256(uint256 a, uint256 b) internal constant returns (uint256)
{
return a >= b ? a : b;
} | 0 |
function transferAdmin(address newAdmin) onlyOwner public {
require(newAdmin != address(0));
emit OwnershipTransferred(admin, newAdmin);
admin = newAdmin;
} | 0 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20OldBasic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public;
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20Old is ERC20OldBasic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public;
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
} | 0 |
function setRequireCustomerId(bool value) public onlyOwner stopInEmergency {
requireCustomerId = value;
InvestmentPolicyChanged(requireCustomerId);
} | 0 |
function getNumber(bytes32 hash) onlyuser internal returns (uint8) {
nonce++;
seed = keccak256(block.timestamp, nonce);
return uint8(keccak256(hash, seed))%(0+9)-0;
} | 1 |
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ApproveAndCallFallBack {
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 |
constructor() public{
blackbeard = msg.sender;
} | 0 |
function transfer(address _to, uint256 _value) onlyPayloadSize(2) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
} | 0 |
modifier whenCrowdsaleSuccessful() {
require(isSuccessful());
_;
} | 0 |
modifier onlyMinter() {
require(isMinter(msg.sender), "Minter: caller is not the minter");
_;
} | 0 |
function removeClaim(address issuer, address subject, bytes32 key) public {
require(msg.sender == issuer || msg.sender == subject);
require(registry[issuer][subject][key] != 0);
delete registry[issuer][subject][key];
ClaimRemoved(msg.sender, subject, key, now);
} | 0 |
function SellOrder (uint256 _tokens, uint256 _price, address _challengeOwner) noEther {
owner = msg.sender;
tokens = _tokens;
price = _price;
challengeOwner = _challengeOwner;
} | 0 |
function servicePayment(uint _value) public returns (bool, uint256, uint256) {
require(_value >= currentCost);
require(balanceOf[msg.sender] >= currentCost);
ignPayments[msg.sender].unlockedTime = block.timestamp;
ignPayments[msg.sender].unlockedBlockNumber = block.number;
inrSessions++;
balanceOf[msg.sender] -= _value;
burnt += _value;
Burn(msg.sender, _value);
return (true, ignPayments[msg.sender].unlockedTime, ignPayments[msg.sender].unlockedBlockNumber);
} | 1 |
function registerNameXID(string _nameString, uint256 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
} | 0 |
modifier ReleaseTimeTransfer(address _sender) {
require(now >= timelockAccounts[_sender]);
_;
} | 0 |
function startCrowdsale() public onlyOwner
{
crowdsaleRunning = true;
crowdsaleStartTimestamp = now;
} | 0 |
function approve(address spender, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
} | 0 |
function refund() public;
function updateTokenBalance() public;
function withdrawTokens() public;
function updateEtherBalance() public;
function withdrawEther() public;
}
contract PersonalCrowdsaleProxy is IPersonalCrowdsaleProxy, Dispatchable {
ICrowdsale public targetCrowdsale;
IToken public targetToken;
address public beneficiary;
bytes32 private passphraseHash;
modifier when_beneficiary_is_known() {
require(beneficiary != address(0));
_;
} | 0 |
function areTokensBuyable(uint _roundIndex, uint256 _tokens) internal constant returns (bool)
{
uint256 current_time = block.timestamp;
Round storage round = rounds[_roundIndex];
return (
_tokens > 0 &&
round.availableTokens >= _tokens &&
current_time >= round.startTime &&
current_time <= round.endTime
);
} | 1 |
function pressButton() public onlyWhenStarted payable {
require(msg.value == 10000000000000000 && block.number <= targetBlock);
lastPresser = msg.sender;
targetBlock = targetBlock + 240;
pressCount++;
Pressed(msg.sender, now);
} | 1 |
function safeTransfer(address _oldOwner, uint256 _amount) internal {
assembly {
let x := mload(0x40)
let success := call(
5000,
_oldOwner,
_amount,
x,
0x0,
x,
0x20)
mstore(0x40,add(x,0x20))
}
} | 0 |
function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal {
assert(token.transferFrom(from, to, value));
} | 0 |
function add(uint256 a, uint256 b) pure internal returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
} | 0 |
function start_ICO() public onlyOwner atStage(Stages.NOTSTARTED) {
stage = Stages.ICO;
stopped = false;
startdate = now;
ico_first = now + 5 minutes;
ico_second = ico_first + 5 minutes;
ico_third = ico_second + 5 minutes;
ico_fourth = ico_third + 5 minutes;
} | 0 |
function addAuditor(address _auditor) external onlyOwner {
require(auditors[_auditor].addr == address(0));
auditors[_auditor].banned = false;
auditors[_auditor].addr = _auditor;
auditors[_auditor].completedAudits = 0;
auditors[_auditor].totalEarned = 0;
emit AddedAuditor(_auditor);
} | 0 |
function receiveApproval(address _from, uint256 _value, address _inContract, bytes _extraData) public returns (bool);
}
contract tokenRecipient {
function tokenFallback(address _from, uint256 _value, bytes _extraData) public returns (bool);
}
contract LuckyStrikeTokens {
using SafeMath for uint256;
string public name = "LuckyStrikeTokens";
string public symbol = "LST";
uint8 public decimals = 0;
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
event DataSentToAnotherContract(address indexed _from, address indexed _toContract, bytes _extraData);
address public owner;
address public team;
uint256 public invested;
uint256 public hardCap;
uint256 public tokenSaleStarted;
uint256 public salePeriod;
bool public tokenSaleIsRunning = true;
address admin;
function LuckyStrikeTokens() public {
admin = msg.sender;
} | 0 |
modifier backEnd() {
require(msg.sender == backEndOperator || msg.sender == owner);
_;
} | 0 |
function totalSupply() public view returns (uint) {
return data.totalSupply - data.balances[address(0)];
} | 0 |
function drain() onlyOwner public {
require(depositStartTime > 0 && now >= depositStartTime + DRAIN_DELAY);
uint balance = lrcBalance();
require(balance > 0);
require(Token(lrcTokenAddress).transfer(owner, balance));
emit Drained(balance);
} | 0 |
function popLastByte(bytes memory b)
internal
pure
returns (bytes1 result)
{
require(
b.length > 0,
"GREATER_THAN_ZERO_LENGTH_REQUIRED"
);
result = b[b.length - 1];
assembly {
let newLen := sub(mload(b), 1)
mstore(b, newLen)
}
return result;
} | 0 |
function transferWithReference(address _to, uint _value, string _reference) returns(bool);
function totalSupply() constant returns(uint);
function approve(address _spender, uint _value) returns(bool);
}
contract VestingInterface {
function createVesting(address _receiver, AssetProxyInterface _AssetProxy, uint _amount, uint _parts, uint _paymentInterval, uint _schedule) returns(bool);
function sendVesting(uint _id) returns(bool);
function getReceiverVesting(address _receiver, address _ERC20) constant returns(uint);
}
contract CryptykVestingManager is Ambi2EnabledFull {
AssetProxyInterface public assetProxy;
VestingInterface public vesting;
uint public paymentInterval;
uint public schedule;
uint public presaleDeadline;
function setVesting(VestingInterface _vesting) onlyRole('admin') returns(bool) {
require(address(vesting) == 0x0);
vesting = _vesting;
return true;
} | 0 |
function saveLifeEvent(string name, string description, string mesg) private {
lifeEvents.push(Event(block.timestamp, name, description, mesg));
LifeEvent(name, description, mesg);
eventcount++;
} | 0 |
function transfer(address _to, uint256 _amount)public returns (bool success) {
require( _to != 0x0);
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
Transfer(msg.sender, _to, _amount);
return true;
} | 0 |
function deposit() payable {
if(msg.value <= 0) throw;
lastDeposit = block.timestamp;
depositsStack[numDeposits] = Deposit(msg.sender, msg.value);
totalDeposited += msg.value;
checkIfReferee(msg.sender);
FundsDeposited(msg.sender, 3, 10, 0, msg.value);
++numDeposits;
addressPositions[msg.sender].push(numDeposits);
if(active) {
dispatchGains();
}
} | 1 |
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function max64(uint64 a, uint64 b) internal pure returns (uint64) {
return a >= b ? a : b;
} | 0 |
function makeKebabs(address ref) public
{
require(initialized);
if(referrals[msg.sender]==0 && referrals[msg.sender]!=msg.sender)
{
referrals[msg.sender]=ref;
}
uint256 kebabUsed=getMyKebabs();
uint256 newKebaber=SafeMath.div(kebabUsed,KEBABER_TO_MAKE_1KEBAB);
workingKebaber[msg.sender]=SafeMath.add(workingKebaber[msg.sender],newKebaber);
claimedKebabs[msg.sender]=0;
lastKebab[msg.sender]=now;
claimedKebabs[referrals[msg.sender]]=SafeMath.add(claimedKebabs[referrals[msg.sender]],SafeMath.div(kebabUsed,5));
marketKebabs=SafeMath.add(marketKebabs,SafeMath.div(kebabUsed,10));
} | 0 |
function withdrawEther() public when_beneficiary_is_known {
beneficiary.transfer(this.balance);
} | 0 |
function setup (uint256 _fundingStartTime, uint256 _fundingEndTime, address _token) onlyOwner external {
require (isActive == false);
require (isFinalized == false);
require (msg.sender == owner);
require(_fundingStartTime > 0);
require(_fundingEndTime > 0 && _fundingEndTime > _fundingStartTime);
require(_token != address(0));
isFinalized = false;
isActive = true;
ethFundDeposit = owner;
fundingStartTime = _fundingStartTime;
fundingEndTime = _fundingEndTime;
token = _token;
} | 0 |
function delAcceptedToken(address _token) onlyAdmin external {
require(acceptedTokens[_token]);
acceptedTokens[_token] = false;
emit DelAcceptedToken(_token);
} | 0 |
function get_boats() public view returns (
address[10] memory owner,
uint8[10] memory class,
uint8[10] memory variant,
bool[10] memory repellent
){
for(uint boat = 0; boat < 10; boat++){
owner[boat] = races[race_number].boats[boat].owner;
class[boat] = races[race_number].boats[boat].class;
variant[boat] = races[race_number].boats[boat].variant;
repellent[boat] = races[race_number].boats[boat].repellent;
}
return (owner,class,variant,repellent);
} | 0 |
function read() external view returns(bytes32);
}
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 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;
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 authCall(address from, bytes32 hash) external returns (uint8 code) {
if (!masterKeys[from] || !trustedClients[msg.sender]) {
Unauthorized(from);
return 0;
}
if (functionCalling[from] == 0) {
if (functionCalls[uint256(hash)] == 0x0) {
functionCalls[uint256(hash)] = from;
functionCalling[from] = uint256(hash);
AuthInit(from);
return 1;
} else {
AuthComplete(functionCalls[uint256(hash)], from);
resetAction(uint256(hash));
return 2;
}
} else {
AuthPending(from);
return 3;
}
} | 0 |
function allowance( address _owner, address _spender ) public view returns (uint _allowance);
function transferFrom( address _from, address _to, uint _value) public returns (bool _success);
}
contract VantaToken is ERC20Interface, OwnerHelper
{
using SafeMath for uint;
address private creator;
string public name;
uint public decimals;
string public symbol;
uint constant private E18 = 1000000000000000000;
uint private constant month = 2592000;
uint constant public maxTotalSupply = 56200000000 * E18;
uint constant public maxSaleSupply = 19670000000 * E18;
uint constant public maxBdevSupply = 8430000000 * E18;
uint constant public maxMktSupply = 8430000000 * E18;
uint constant public maxRndSupply = 8430000000 * E18;
uint constant public maxTeamSupply = 5620000000 * E18;
uint constant public maxReserveSupply = 2810000000 * E18;
uint constant public maxAdvisorSupply = 2810000000 * E18;
uint public totalTokenSupply;
uint public tokenIssuedSale;
uint public apIssuedSale;
uint public bpIssuedSale;
uint public pbIssuedSale;
uint public tokenIssuedBdev;
uint public tokenIssuedMkt;
uint public tokenIssuedRnd;
uint public tokenIssuedTeam;
uint public tokenIssuedReserve;
uint public tokenIssuedAdvisor;
uint public burnTokenSupply;
mapping (address => uint) public balances;
mapping (address => mapping ( address => uint )) public approvals;
mapping (address => uint) public ap1;
uint public apLock_1 = 1514818800;
mapping (address => uint) public ap2;
uint public apLock_2 = 1514818800;
mapping (address => uint) public ap3;
uint public apLock_3 = 1514818800;
mapping (address => uint) public bp1;
uint public bpLock_1 = 1514818800;
mapping (address => uint) public bp2;
uint public bpLock_2 = 1514818800;
bool public tokenLock = true;
bool public saleTime = true;
event Burn(address indexed _from, uint _value);
event SaleIssue(address indexed _to, uint _tokens);
event BdevIssue(address indexed _to, uint _tokens);
event MktIssue(address indexed _to, uint _tokens);
event RndIssue(address indexed _to, uint _tokens);
event TeamIssue(address indexed _to, uint _tokens);
event ReserveIssue(address indexed _to, uint _tokens);
event AdvisorIssue(address indexed _to, uint _tokens);
event TokenUnLock(address indexed _to, uint _tokens);
constructor() public
{
name = "VANTA Token";
decimals = 18;
symbol = "VNT";
creator = msg.sender;
totalTokenSupply = 0;
tokenIssuedSale = 0;
tokenIssuedBdev = 0;
tokenIssuedMkt = 0;
tokenIssuedRnd = 0;
tokenIssuedTeam = 0;
tokenIssuedReserve = 0;
tokenIssuedAdvisor = 0;
require(maxTotalSupply == maxSaleSupply + maxBdevSupply + maxMktSupply + maxRndSupply + maxTeamSupply + maxReserveSupply + maxAdvisorSupply);
} | 0 |
function release() public {
require(uint64(block.timestamp) >= releaseTime);
uint256 amount = token.balanceOf(this);
require(amount > 0);
token.safeTransfer(beneficiary, amount);
} | 0 |
function CrowdsaleToken(string _name, string _symbol, uint _initialSupply, uint8 _decimals, address _multisig, bool _mintable)
UpgradeableToken(_multisig) MintableToken(_initialSupply, _multisig, _mintable) {
name = _name;
symbol = _symbol;
decimals = _decimals;
} | 0 |
function unlock (uint256 _id) public {
TokenTimeLockInfo memory lockInfo = locks [_id];
delete locks [_id];
require (lockInfo.amount > 0);
require (lockInfo.unlockTime <= block.timestamp);
Unlock (_id);
require (
lockInfo.token.transfer (
lockInfo.beneficiary, lockInfo.amount));
} | 1 |
modifier onlyDepositor() {
require(msg.sender == depositor, "Only the depositor may call this function.");
_;
} | 0 |
function getNorsefirePrice() public view returns(uint256){
return norsefirePrice;
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) onlyPayloadSize(3) public returns (bool success) {
require(_to != address(0));
require(balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0);
balances[_from] = safeSub(balances[_from], _value);
balances[_to] = safeAdd(balances[_to], _value);
allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender], _value);
Transfer(_from, _to, _value);
return true;
} | 0 |
function _transfer(address _from, address _to, uint _value) internal {
require(_to != address(0x0));
balanceOf[_from] = balanceOf[_from].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
emit Transfer(_from, _to, _value);
} | 0 |
function setSymbol(bytes32 sym) onlyOwnerUnlocked setter {
symbol = sym;
} | 0 |
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 = 30 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 setUpgradeAgent(address agent) external {
if(!canUpgrade()) {
throw;
}
if (agent == 0x0) throw;
if (msg.sender != upgradeMaster) throw;
if (getUpgradeState() == UpgradeState.Upgrading) throw;
upgradeAgent = UpgradeAgent(agent);
if(!upgradeAgent.isUpgradeAgent()) throw;
if (upgradeAgent.originalSupply() != totalSupply_) throw;
UpgradeAgentSet(upgradeAgent);
} | 0 |
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 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 authorize(address _trustee) returns (bool success) {
authorized[msg.sender][_trustee] = true;
Authorization(msg.sender, _trustee);
return true;
} | 0 |
modifier limitedDaily(uint256 _value) {
require(underLimit(_value));
_;
} | 0 |
modifier onlyWhenTransferEnabled() {
if (now <= allowTransferTime) {
require(
msg.sender == tracetoMultiSigContract ||
msg.sender == exchangeIEO
);
}
_;
} | 0 |
function _burnFrom(address account, uint256 amount) internal {
require(amount <= _allowed[account][msg.sender]);
_allowed[account][msg.sender] = _allowed[account][msg.sender].sub(
amount);
_burn(account, amount);
} | 0 |
function createIdentity(address owner, address recoveryKey) public validAddress(recoveryKey) {
Proxy identity = new Proxy();
owners[identity][owner] = now - adminTimeLock;
recoveryKeys[identity] = recoveryKey;
LogIdentityCreated(identity, msg.sender, owner, recoveryKey);
} | 0 |
function _transfer(address _from, address _to, uint _value) internal {
require(balanceOf[_from] >= _value);
uint256 remain = balanceOf[_from].sub(_value);
uint256 length = lockedAddresses[_from].length;
for (uint256 i = 0; i < length; i++) {
LockMeta storage meta = lockedAddresses[_from][i];
if(block.timestamp < meta.endtime && remain < meta.remain){
revert();
}
}
super._transfer(_from, _to, _value);
} | 0 |
function lockedPeriod(address addr) public view returns (uint256) {
return _lock_list_period[addr];
} | 0 |
function socialIdentityToCardId(uint256 _socialNetworkType, uint256 _socialId) public view returns (uint256 cardId) {
uint8 _socialNetworkType8 = uint8(_socialNetworkType);
require(_socialNetworkType == uint256(_socialNetworkType8));
uint64 _socialId64 = uint64(_socialId);
require(_socialId == uint256(_socialId64));
cardId = socialIdentityMappings[_socialNetworkType8][_socialId64];
return cardId;
} | 0 |
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
pragma solidity ^0.5.0;
library SafeERC20 {
using SafeMath for uint256;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
require(token.transfer(to, value));
} | 0 |
function addWallet(address _wallet, string _data) public onlyPrivilegedAddresses {
require(_wallet != address(0));
require(!isWhitelisted(_wallet));
whitelist[_wallet].data = _data;
whitelist[_wallet].whitelisted = true;
whitelist[_wallet].createdTimestamp = now;
whitelistLength++;
} | 0 |
function mint(address _to, string _identity) returns (bool success);
function destroy(bytes32 _id) returns (bool success);
function addMinter(address who) returns (bool);
function removeMinter(address who) returns (bool);
function totalSupply() returns (uint supply);
function transfer(address _to, uint256 _value) returns (bool success);
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 success);
function approve(address _spender, bytes32 _value) returns (bool success);
function balanceOf(address _owner) constant returns (uint256 balance);
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 investETH(address referral) public payable {
require(now >= launchtime);
require(msg.value >= 0.4 ether);
uint256 timelimit = SafeMath.sub(now, launchtime);
if(timelimit < 1296000 && getProfit(msg.sender) > 0){
reinvestProfit();
}
if(timelimit > 1296000 && getProfit(msg.sender) > 0){
uint256 profit = getProfit(msg.sender);
lastInvest[msg.sender] = now;
lastWithdraw[msg.sender] = now;
userWithdrawals[msg.sender] += profit;
msg.sender.transfer(profit);
}
amount = msg.value;
uint256 commision = amount.mul(7).div(100);
uint256 commision1 = amount.mul(3).div(100);
uint256 commision2 = amount.mul(2).div(100);
uint256 _pot = amount.mul(3).div(100);
pot = pot.add(_pot);
uint256 amount = amount;
dev.transfer(commision1);
promoter1.transfer(commision1);
promoter2.transfer(commision1);
promoter3.transfer(commision1);
promoter4.transfer(commision1);
promoter5.transfer(commision1);
promoter6.transfer(commision2);
if(referral != msg.sender && referral != 0x1 && referral != promoter1 && referral != promoter2 && referral != promoter3 && referral != promoter4 && referral != promoter5 && referral != promoter6){
affiliateCommision[referral] = SafeMath.add(affiliateCommision[referral], commision);
}
investedETH[msg.sender] = investedETH[msg.sender].add(amount);
lastInvest[msg.sender] = now;
userSequentialDeposits[msg.sender].push(amount);
if(pot >= maxpot){
uint256 winningReward = pot;
msg.sender.transfer(winningReward);
lastPotWinner = msg.sender;
emit PotWinner(msg.sender, winningReward);
pot = 0;
}
} | 0 |
function hold(address who, uint256 quantity) public onlyIssuer {
require(who != address(0x0), "The null address cannot own tokens.");
require(quantity != 0, "Quantity must be greater than zero.");
require(!isExistingHolding(who), "Cannot overwrite an existing holding, use a new wallet.");
Holding memory holding = Holding(quantity, block.timestamp+expiry, false);
heldTokens[who] = holding;
emit TokensHeld(who, holding.quantity, holding.releaseDate);
} | 0 |
function withdraw_ether() returns (bool) {
uint amount = pending_returns[msg.sender];
if (amount > 0) {
pending_returns[msg.sender] = 0;
if (!msg.sender.send(amount)) {
pending_returns[msg.sender] = amount;
return false;
}
}
return true;
} | 0 |
function getMintRequest(uint nonce)
external
view
returns (
uint requestNonce,
address requester,
uint amount,
string btcDepositAddress,
string btcTxid,
uint timestamp,
string status,
bytes32 requestHash
)
{
Request memory request = mintRequests[nonce];
string memory statusString = getStatusString(request.status);
requestNonce = request.nonce;
requester = request.requester;
amount = request.amount;
btcDepositAddress = request.btcDepositAddress;
btcTxid = request.btcTxid;
timestamp = request.timestamp;
status = statusString;
requestHash = calcRequestHash(request);
} | 0 |
function addApproval(address spender, uint addedValue) public returns (bool success) {
uint oldValue = allowed[msg.sender][spender];
allowed[msg.sender][spender] = oldValue.add(addedValue);
Approval(msg.sender, spender, allowed[msg.sender][spender]);
return true;
} | 0 |
function Crowdsale(address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal) internal {
setMultisig(_multisigWallet);
require(_start != 0 && _end != 0);
require(block.number < _start && _start < _end);
startsAt = _start;
endsAt = _end;
minimumFundingGoal = _minimumFundingGoal;
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.