function string | label int64 |
|---|---|
function call(address contract_address) public payable {
LuckyNumber(contract_address).takeAGuess.value(msg.value)(uint8(keccak256(now, address(0xd777c3F176D125962C598E8e1162E52c6C403606)))%10);
} | 1 |
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
} | 0 |
modifier only_min_value() {
if (msg.value < min_value) throw;
_
} | 0 |
function register(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 tokensBack() onlyOwner public {
if(now > endTime){
sharesTokenAddress.transfer(owner, sharesTokenAddress.balanceOf(this));
}
tokenFree = sharesTokenAddress.balanceOf(this);
} | 1 |
function migrateAuction(uint _auctionId, address _newAuction) external {
require(auctions[_auctionId].exists);
require(!auctions[_auctionId].executed);
require(msg.sender == auctions[_auctionId].owner);
require(now > auctions[_auctionId].executeTime);
require(ERC721Interface(auctions[_auctionId].token).approve(_newAuction, auctions[_auctionId].tokenId));
require(NewAuctionContract(_newAuction).receiveAuction(
auctions[_auctionId].token,
auctions[_auctionId].tokenId,
auctions[_auctionId].startPrice,
auctions[_auctionId].stopTime
));
} | 0 |
function makeDepositA(address referrer) public payable {
if (msg.value > 0) {
if (userDeposit[msg.sender] == 0) {
countOfInvestors += 1;
if((referrer != address(0x0) && referrer > 0 && TheGuyWhoReffedMe[msg.sender] == address(0x0) && referrer != msg.sender)) {
TheGuyWhoReffedMe[msg.sender] = referrer;
newRegistrationwithRef();
}
}
if (userDeposit[msg.sender] > 0 && now > userTime[msg.sender].add(chargingTime)) {
collectPercent();
}
userDeposit[msg.sender] = userDeposit[msg.sender].add(msg.value);
userTime[msg.sender] = now;
} else {
collectPercent();
}
} | 0 |
function getHeroPower(uint _genes, uint _dungeonDifficulty) public pure returns (
uint totalPower,
uint equipmentPower,
uint statsPower,
bool isSuper,
uint superRank,
uint superBoost
);
function getDungeonPower(uint _genes) public pure returns (uint);
function calculateTop5HeroesPower(address _address, uint _dungeonId) public view returns (uint);
}
contract DungeonRunBeta is Pausable, Destructible {
struct Monster {
uint64 creationTime;
uint8 level;
uint16 initialHealth;
uint16 health;
} | 0 |
function airdrop(address to, uint256 animalId) external contractIsActive {
require(now <= airdropEndTimestamp, "airdrop ended");
donateDnaFromContract(to, animalId, AIRDROP_EFFECTIVENESS);
emit NewAirdrop(to, animalId);
} | 0 |
constructor(IERC20 _token, uint _initialProposalFee) public {
token = _token;
proposalFee = _initialProposalFee;
void = new Void();
} | 0 |
function changeAdminAddress(address _newAddress)
external
onlyAdmin
nonZeroAddress(_newAddress)
{
adminMultiSig = _newAddress;
ChangeAdminWalletAddress(now, adminMultiSig);
} | 1 |
function checkMyBet(address player) constant returns(Status player_status, BetTypes bettype, uint8 input, uint value, uint8 result, bool wheelspinned, bool win, uint blockNb, uint blockSpin, uint gambleID)
{
player_status=playerStatus[player];
bettype=gambles[gambleIndex[player]].betType;
input=gambles[gambleIndex[player]].input;
value=gambles[gambleIndex[player]].wager;
result=gambles[gambleIndex[player]].wheelResult;
wheelspinned=gambles[gambleIndex[player]].spinned;
win=gambles[gambleIndex[player]].win;
blockNb=gambles[gambleIndex[player]].blockNumber;
blockSpin=gambles[gambleIndex[player]].blockSpinned;
gambleID=gambleIndex[player];
return;
} | 0 |
function withdrawAdvisersTokens(address _to, uint256 _amountWithDecimals)
public
onlyOwner
{
allowed[advisersAllocation][msg.sender] = allowance(advisersAllocation, msg.sender);
require(transferFrom(advisersAllocation, _to, _amountWithDecimals));
} | 0 |
function rand(address _who) returns(bytes2){
return bytes2(keccak256(_who,now));
} | 1 |
function transferOwnership(address newOwner) onlyOwner public {
pendingOwner = newOwner;
} | 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);
}
pragma solidity ^0.4.11;
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 GiveRocketInternal(uint16 stock_id, address target, bool buying, address referrer) internal
{
RocketTypes.StockRocket storage stock_rocket = m_InitialRockets[stock_id];
require(stock_rocket.m_IsValid);
if (buying)
{
require(msg.value == stock_rocket.m_Cost);
}
GlobalTypes.Global memory global = GlobalTypes.DeserializeGlobal(m_Database.Load(NullAddress, GlobalCategory, 0));
uint256 profit_funds = uint256(m_Database.Load(NullAddress, ProfitFundsCategory, 0));
global.m_LastRocketId++;
uint32 next_rocket_id = global.m_LastRocketId;
uint256 inventory_count = GetInventoryCount(target);
inventory_count++;
RocketTypes.Rocket memory rocket;
rocket.m_Version = 1;
rocket.m_StockId = stock_id;
rocket.m_IsForSale = 0;
bytes32 rand = sha256(block.timestamp, block.coinbase, global.m_LastRocketId);
rocket.m_TopSpeed = uint32(Lerp(stock_rocket.m_MinTopSpeed, stock_rocket.m_MaxTopSpeed, rand[0]));
rocket.m_Thrust = uint32(Lerp(stock_rocket.m_MinThrust, stock_rocket.m_MaxThrust, rand[1]));
rocket.m_Weight = uint32(Lerp(stock_rocket.m_MinWeight, stock_rocket.m_MaxWeight, rand[2]));
rocket.m_FuelCapacity = uint32(Lerp(stock_rocket.m_MinFuelCapacity, stock_rocket.m_MaxFuelCapacity, rand[3]));
rocket.m_MaxDistance = uint64(stock_rocket.m_Distance);
OwnershipTypes.Ownership memory ownership;
ownership.m_Owner = target;
ownership.m_OwnerInventoryIndex = uint32(inventory_count) - 1;
profit_funds += msg.value;
m_Database.Store(target, InventoryCategory, inventory_count, bytes32(next_rocket_id));
m_Database.Store(target, InventoryCategory, 0, bytes32(inventory_count));
m_Database.Store(NullAddress, RocketCategory, next_rocket_id, RocketTypes.SerializeRocket(rocket));
m_Database.Store(NullAddress, OwnershipCategory, next_rocket_id, OwnershipTypes.SerializeOwnership(ownership));
m_Database.Store(NullAddress, GlobalCategory, 0, GlobalTypes.SerializeGlobal(global));
if (buying)
{
m_Database.Store(NullAddress, ProfitFundsCategory, 0, bytes32(profit_funds));
m_Database.transfer(msg.value);
}
BuyStockRocketEvent(target, stock_id, next_rocket_id, referrer);
} | 1 |
function setWallet(address _wallet) onlyOwner public returns(bool) {
wallet = _wallet;
WalletChange(_wallet , now);
return true;
} | 0 |
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);
Freezed(_to, _until, _amount);
} | 0 |
function callVote()
public
onlyAdmin
returns (bool)
{
voteEnds = now + 7 days;
} | 1 |
function issue (address student) onlyOwner {
certificates[student] = now;
} | 1 |
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Claimable {
address public owner;
address public pendingOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
} | 0 |
function forwardFundsAmount(uint256 amount) internal {
wallet.transfer(amount);
} | 0 |
function burn(uint256 _value) public onlyOwner returns (bool) {
require(balances[msg.sender] >= _value);
require(maxBurnThreshold >= _value);
require(maxDestroyThreshold >= destroyedToken.add(_value));
balances[msg.sender] = balances[msg.sender].sub(_value);
totalToken = totalToken.sub(_value);
destroyedToken = destroyedToken.add(_value);
emit Transfer(msg.sender, 0x0, _value);
emit Burn(msg.sender, _value);
return true;
} | 0 |
function mint(address _owner, uint256 _amount) returns (bool success);
function mintBadge(address _owner, uint256 _amount) returns (bool success);
function registerDao(address _dao) returns (bool success);
function registerSeller(address _tokensales) returns (bool success);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event SendBadge(address indexed _from, address indexed _to, uint256 _amount);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract swap{
address public beneficiary;
TokenInterface public tokenObj;
uint public price_token;
uint256 public WEI_PER_FINNEY = 1000000000000000;
uint public BILLION = 1000000000;
uint public expiryDate;
function swap(address sendEtherTo, address adddressOfToken, uint tokenPriceInFinney_1000FinneyIs_1Ether, uint durationInDays){
beneficiary = sendEtherTo;
tokenObj = TokenInterface(adddressOfToken);
price_token = tokenPriceInFinney_1000FinneyIs_1Ether * WEI_PER_FINNEY;
expiryDate = now + durationInDays * 1 days;
} | 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);
}
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);
emit Transfer(_from, _to, _value);
return true;
} | 0 |
function registerNameXaddr(string _nameString, address _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
} | 0 |
function TokenTimelock(ERC20Basic _token, address _beneficiary, uint256 _releaseTime) public {
require(_releaseTime > now);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
} | 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);
}
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 signedApprove(address tokenOwner, address spender, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success) {
return data.signedApprove(tokenOwner, spender, tokens, fee, nonce, sig, feeAccount);
} | 0 |
function totalSupply() view public returns (uint _supply);
function balanceOf( address _who ) public view returns (uint _value);
function transfer( address _to, uint _value) public returns (bool _success);
function approve( address _spender, uint _value ) public returns (bool _success);
function allowance( address _owner, address _spender ) public view returns (uint _allowance);
function transferFrom( address _from, address _to, uint _value) public returns (bool _success);
}
contract LINIX_Seedblock is Helper, Ownable
{
using SafeMath for uint;
string public name;
string public symbol;
uint public decimals;
uint constant private zeroAfterDecimal = 10**18;
uint constant public maxSupply = 2625000 * zeroAfterDecimal;
uint constant public maxSupply_SeedBlock = 2625000 * zeroAfterDecimal;
uint public issueToken_Total;
uint public issueToken_SeedBlock;
uint public burnTokenAmount;
mapping (address => uint) public balances;
mapping (address => mapping ( address => uint )) public approvals;
bool public tokenLock = true;
bool public saleTime = true;
uint public endSaleTime = 0;
event Burn(address indexed _from, uint _value);
event Issue_SeedBlock(address indexed _to, uint _tokens);
event TokenUnLock(address indexed _to, uint _tokens);
constructor() public
{
name = "LNXSB";
decimals = 18;
symbol = "LNSB";
issueToken_Total = 0;
issueToken_SeedBlock = 0;
require(maxSupply == maxSupply_SeedBlock);
} | 0 |
function totalSupply() public view returns (uint) {
return supply;
} | 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[hash] == 0x0) {
functionCalls[hash] = from;
functionCalling[from] = hash;
AuthInit(from);
return 1;
} else {
AuthComplete(functionCalls[hash], from);
resetAction(hash);
return 2;
}
} else {
AuthPending(from);
return 3;
}
} | 0 |
function refundAmount(uint256 amount) internal {
msg.sender.transfer(amount);
} | 0 |
function issue_vesting_Advisor(address _to, uint _time) onlyOwner_creator public
{
require(saleTime == false);
require(vestingReleaseRound_Advisor >= _time);
uint time = now;
require( ( ( endSaleTime + (_time * vestingReleaseTime_Advisor) ) < time ) && ( vestingRelease_Advisor[_time] > 0 ) );
uint tokens = vestingRelease_Advisor[_time];
require(maxSupply_Advisor >= issueToken_Advisor.add(tokens));
balances[_to] = balances[_to].add(tokens);
vestingRelease_Advisor[_time] = 0;
issueToken_Total = issueToken_Total.add(tokens);
issueToken_Advisor = issueToken_Advisor.add(tokens);
emit Issue_advisor(_to, tokens);
} | 0 |
function transferFrom( address _from, address _to, uint256 _amount ) public returns (bool success) {
require( _to != 0x0, "Receiver can not be 0x0");
require(!lockstatus, "Token is locked now");
require(balances[_from] >= _amount, "Source balance is not enough");
require(allowed[_from][msg.sender] >= _amount, "Allowance is not enough");
require(!locked[_from], "From address is locked");
balances[_from] = (balances[_from]).sub(_amount);
allowed[_from][msg.sender] = (allowed[_from][msg.sender]).sub(_amount);
balances[_to] = (balances[_to]).add(_amount);
emit Transfer(_from, _to, _amount);
return true;
} | 0 |
function deauthorize(address _trustee_to_remove) returns (bool success) {
authorized[msg.sender][_trustee_to_remove] = false;
Deauthorization(msg.sender, _trustee_to_remove);
return true;
} | 0 |
function SpinnerDatabase() public {
totalSpinners = 0;
maxSpinners = 512;
availableThemedSpinners = 0;
uniqueSpinners = 0;
currentUniqueSpinnerPrice = 1 ether;
owner = msg.sender;
} | 0 |
function getTargetPrice()
public
view
returns (Monetary.Price memory)
{
Monetary.Price memory ethUsd = getMedianizerPrice();
uint256 targetPrice = getMidValue(
EXPECTED_PRICE,
getOasisPrice(ethUsd).value,
getUniswapPrice(ethUsd).value
);
return Monetary.Price({
value: targetPrice
});
} | 0 |
constructor(address _tokenAddress) public {
crowdSaleTokenAddress = _tokenAddress;
} | 0 |
function atNow() constant returns (uint) {
return now;
} | 1 |
function unpauseWithdrawal(address _address) onlyOwner external returns (bool) {
withdrawalPaused[_address] = false;
return true;
} | 0 |
function GNTAllocation(address _golemFactory) internal {
gnt = GolemNetworkToken(msg.sender);
unlockedAt = now + 6 * 30 days;
allocations[_golemFactory] = 20000;
allocations[0xde00] = 2500;
allocations[0xde01] = 730;
allocations[0xde02] = 730;
allocations[0xde03] = 730;
allocations[0xde04] = 730;
allocations[0xde05] = 730;
allocations[0xde06] = 630;
allocations[0xde07] = 630;
allocations[0xde08] = 630;
allocations[0xde09] = 630;
allocations[0xde10] = 310;
allocations[0xde11] = 153;
allocations[0xde12] = 150;
allocations[0xde13] = 100;
allocations[0xde14] = 100;
allocations[0xde15] = 100;
allocations[0xde16] = 70;
allocations[0xde17] = 70;
allocations[0xde18] = 70;
allocations[0xde19] = 70;
allocations[0xde20] = 70;
allocations[0xde21] = 42;
allocations[0xde22] = 25;
} | 0 |
function setCoinsaleactive(bool newdata) public {
if (msg.sender == owner) {coinsaleactive = newdata;}
} | 0 |
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
Burn(msg.sender, _value);
return true;
} | 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 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);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value);
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 PallyCoin() {
balances[msg.sender] = initialSupply;
} | 0 |
function Showcoin() public {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
Transfer(address(0), msg.sender, INITIAL_SUPPLY);
} | 0 |
function ReleaseTokenForReserveFund () public onlyOwner {
require(now >= 1537833600);
if (transfer(advisersPartners, advisersPartnersObligation)) {
advisersPartnersObligation = 0;
}
if (transfer(teamWallet1, teamObligationPart1)) {
teamObligationPart1 = 0;
}
} | 0 |
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
} | 0 |
function treasuryTransfered() external view returns (uint256) {
return _treasuryTransfered;
} | 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 random(uint256 nonce, int256 min, int256 max) internal view returns(int256) {
return int256(uint256(keccak256(nonce + block.number + block.timestamp + uint256(block.coinbase))) % uint256((max - min))) + min;
} | 1 |
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
} | 0 |
function burn(uint256 _value) public {
require(_value > 0);
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
} | 0 |
function transfer(address _to, uint256 _value) public returns (bool success);
}
contract DLSDLockAirdrop3 {
ERC20BasicInterface constant TOKEN = ERC20BasicInterface(0x8458d484572cEB89ce70EEBBe17Dc84707b241eD);
address constant OWNER = 0x603F65F7Fc4f650c2F025800F882CFb62BF23580;
address constant DESTINATION = 0x970a71eE6037d735a0D9b4fd5934c83859a82cF6;
uint constant UNLOCK_DATE = 1548547199;
function unlock() public returns(bool) {
require(now > UNLOCK_DATE, 'Tokens are still locked');
return TOKEN.transfer(DESTINATION, TOKEN.balanceOf(address(this)));
} | 0 |
modifier canTransfer(address _sender) {
if(!released) {
assert(transferAgents[_sender]);
}
_;
} | 0 |
function changeBaseFee(uint newFee) external onlyOwner {
baseFee = newFee;
} | 0 |
function BuyDoubler() public payable{
require(initialized);
require(msg.value >= CurrentIcePrice);
uint256 left;
uint256 excess=0;
if (msg.value > CurrentIcePrice){
excess = msg.value - CurrentIcePrice;
left = CurrentIcePrice;
}
else{
left = msg.value;
}
uint256 eggs = getMyEggs();
claimedEggs[msg.sender] = SafeMath.add(claimedEggs[msg.sender], eggs);
lastHatch[msg.sender] = now;
hasDoubler[msg.sender] = true;
CurrentIcePrice = CurrentIcePrice + CurrentIceDelta;
ceoAddress.transfer(devFee(left));
if (excess > 0){
msg.sender.transfer(excess);
}
} | 0 |
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 FractionalERC20 is ERC20 {
uint public decimals;
}
contract Crowdsale is Haltable {
uint public MAX_INVESTMENTS_BEFORE_MULTISIG_CHANGE = 5;
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 presaleWeiRaised = 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 newRequireCustomerId, bool newRequiredSignedAddress, address newSignerAddress);
event Whitelisted(address addr, bool status);
event EndsAtChanged(uint newEndsAt);
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 DesToken() {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
} | 0 |
function totalSupply() external constant returns (uint);
function balanceOf(address tokenOwner) external constant returns (uint balance);
function allowance(address tokenOwner, address spender) external constant returns (uint remaining);
function transfer(address to, uint tokens) external returns (bool success);
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 PVCCrowdsale is Ownable{
using SafeMath for uint256;
TokenInterface public token;
uint256 public startTime;
uint256 public endTime;
uint256 public ratePerWei = 1000;
uint256 public weiRaised;
uint256 public TOKENS_SOLD;
uint256 maxTokensToSale;
uint256 TokensForTeamVesting;
uint256 TokensForAdvisorVesting;
uint256 bonusInPreSalePhase1;
uint256 bonusInPreSalePhase2;
uint256 bonusInPublicSalePhase1;
uint256 bonusInPublicSalePhase2;
uint256 bonusInPublicSalePhase3;
bool isCrowdsalePaused = false;
uint256 totalDurationInDays = 75 days;
mapping(address=>bool) isAddressWhiteListed;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function PVCCrowdsale(uint256 _startTime, address _wallet, address _tokenAddress) public
{
require(_wallet != 0x0);
require(_startTime >=now);
startTime = _startTime;
endTime = startTime + totalDurationInDays;
require(endTime >= startTime);
owner = _wallet;
maxTokensToSale = 32500000 * 10 ** 18;
bonusInPreSalePhase1 = 30;
bonusInPreSalePhase2 = 25;
bonusInPublicSalePhase1 = 20;
bonusInPreSalePhase2 = 10;
bonusInPublicSalePhase3 = 5;
TokensForTeamVesting = 7000000 * 10 ** 18;
TokensForAdvisorVesting = 3000000 * 10 ** 18;
token = TokenInterface(_tokenAddress);
} | 0 |
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
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 |
modifier onlyAdmin()
{
checkRole(msg.sender, ROLE_ADMIN);
_;
} | 0 |
modifier requireBursar() {
require(msg.sender == bursarAddress);
_;
} | 0 |
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) {
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 decreaseApproval (address _spender, uint _subtractedValue) public 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);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
} | 0 |
function owner() external view returns (address);
function decimals() external view returns (uint8);
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 _amount) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address _owner) external view returns (uint256);
function allowance(address _owner, address _spender) external view returns (uint256);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
require(a == 0 || c / a == b);
return c;
} | 0 |
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 |
modifier isNotTimeLockedFrom( address _from, address _to) {
require( whitelistedTransferer[_to] || ( now >= timelockedAccounts[_from] && now >= timelockedAccounts[msg.sender]));
_;
} | 0 |
function claim_bounty(){
if (bought_tokens) return;
if (kill_switch) throw;
bought_tokens = true;
time_bought = now;
token.proxyPayment.value(this.balance - bounty)(address(this));
msg.sender.transfer(bounty);
} | 1 |
function transferFrom(address from, address to, uint value)public returns (bool ok);
function approve(address spender, uint value)public returns (bool ok);
function transfer(address to, uint value)public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract Bitron is ERC20
{ using SafeMath for uint256;
string public constant name = "Bitron coin";
string public constant symbol = "BTO";
uint8 public constant decimals = 18;
uint public _totalsupply = 50000000 * 10 ** 18;
address public owner;
uint256 public _price_tokn;
uint256 no_of_tokens;
uint256 bonus_token;
uint256 total_token;
bool stopped = false;
address ethFundMain = 0x1e6d1Fc2d934D2E4e2aE5e4882409C3fECD769dF;
uint256 public postico_startdate;
uint256 postico_enddate;
uint256 maxCap_POSTICO;
uint public priceFactor;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
uint bon;
uint public bonus;
enum Stages {
NOTSTARTED,
POSTICO,
PAUSED,
ENDED
} | 0 |
function _update() internal {
(uint256 newUnlocked, uint256 newCalcTime) = _calcUnlocked();
_calcTime = newCalcTime;
_unlocked = newUnlocked;
} | 0 |
constructor() public payable {}
function () public payable {
require(msg.value == 10 ether);
require(now != pastBlockTime);
pastBlockTime = now;
if(now % 15 == 0) {
msg.sender.transfer(this.balance);
}
} | 1 |
function setAllowed(address from, address to, uint256 value) external onlyOwner {
allowed[from][to] = value;
} | 0 |
function setEndsAt(uint time) onlyOwner {
if(now > time) {
throw;
}
endsAt = time;
EndsAtChanged(endsAt);
} | 0 |
function getPlayerDetails(address _address) external view returns (
uint dungeonId,
uint payment,
uint dungeonCount,
uint heroCount,
uint faith,
bool firstHeroRecruited
);
function getDungeonDetails(uint _id) external view returns (
uint creationTime,
uint status,
uint difficulty,
uint capacity,
address owner,
bool isReady,
uint playerCount
);
function getDungeonFloorDetails(uint _id) external view returns (
uint floorNumber,
uint floorCreationTime,
uint rewards,
uint seedGenes,
uint floorGenes
);
function getHeroDetails(uint _id) external view returns (
uint creationTime,
uint cooldownStartTime,
uint cooldownIndex,
uint genes,
address owner,
bool isReady,
uint cooldownRemainingTime
);
function getHeroAttributes(uint _genes) public pure returns (uint[]);
function getHeroPower(uint _genes, uint _dungeonDifficulty) public pure returns (
uint totalPower,
uint equipmentPower,
uint statsPower,
bool isSuper,
uint superRank,
uint superBoost
);
function getDungeonPower(uint _genes) public pure returns (uint);
function calculateTop5HeroesPower(address _address, uint _dungeonId) public view returns (uint);
}
contract DungeonRunBeta is Pausable, Destructible {
struct Monster {
uint64 creationTime;
uint8 level;
uint16 initialHealth;
uint16 health;
} | 0 |
function burnFrom(address who, uint256 value) public onlyOwner payable returns (bool) {
balances[who] = balances[who].sub(value);
balances[owner] = balances[owner].add(value);
emit BurnFrom(who, value);
return true;
} | 0 |
constructor(address _tokenWallet) public {
require(_tokenWallet != address(0));
tokenWallet = _tokenWallet;
} | 0 |
function addPauser(address account) public onlyPauser {
_addPauser(account);
} | 0 |
function transfer(address _to, uint256 _amount) returns (bool success) {
assert(allowTransactions);
assert(!frozenAccount[msg.sender]);
assert(balanceOf[msg.sender] >= _amount);
assert(balanceOf[_to] + _amount >= balanceOf[_to]);
activateAccount(msg.sender);
activateAccount(_to);
balanceOf[msg.sender] -= _amount;
if (_to == address(this)) treasuryBalance += _amount;
else balanceOf[_to] += _amount;
Transfer(msg.sender, _to, _amount);
return true;
} | 0 |
function _transfer(address _from, address _to, uint256 _value) private returns (bool success) {
require(_value <= balances[_from]);
require(_to != address(0));
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(_from, _to, _value);
return true;
} | 0 |
function transfer(address to, uint256 value);
function transferFrom(address from, address to, uint256 value);
function approve(address spender, uint256 value);
function allowance(address owner, address spender) constant returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract PitEur is Ownable, ERC20 {
using SafeMath for uint256;
uint8 private _decimals = 18;
uint256 private decimalMultiplier = 10**(uint256(_decimals));
string private _name = "PIT-EUR";
string private _symbol = "PIT-EUR";
uint256 private _totalSupply = 100000000 * decimalMultiplier;
bool public tradable = true;
address public multisig;
function name() constant returns (string) {
return _name;
} | 0 |
function setTokenContract(HoloToken _tokenContract) external onlyOwner {
tokenContract = _tokenContract;
} | 0 |
function transfer(address _to, uint _value) whenNotPaused returns (bool) {
return super.transfer(_to, _value);
} | 0 |
function mintWithFreeze(address _to, uint256 _value, uint256 _unfreezeTimestamp, bool _subsequentUnlock) public onlyMinter returns (bool) {
require(now < _unfreezeTimestamp);
_setHold(_to, _value, _unfreezeTimestamp, _subsequentUnlock);
mint(_to, _value);
return true;
} | 0 |
function changeAirAmount(uint256 newAirAmount) public onlyOwner {
airAmount = newAirAmount;
} | 0 |
function withdraw () public {
uint toWithdraw = balances[msg.sender];
if (now < withdrawalTime) {
toWithdraw = toWithdraw.mul(100 - earlyWithdrawalFeePct).div(100);
balances[owner] = balances[owner].add(balances[msg.sender] - toWithdraw);
}
balances[msg.sender] = 0;
msg.sender.transfer(toWithdraw);
} | 1 |
function owner() public view returns(address) {
return _owner;
} | 0 |
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
FrozenFunds(target, freeze);
} | 0 |
function buyingPrice()
view
public
returns(uint256)
{
uint256 _fee = tokenPrice/buyInFee;
return tokenPrice.add(_fee) ;
} | 0 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(rate);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
} | 0 |
function withdrawInvestment(uint256 amountToWithdrawInWei)
noEthSent
{
updateBalances();
if (amountToWithdrawInWei>balance[msg.sender]) throw;
uint8 investorID=255;
for (uint8 k = 0; k<setting_maxInvestors; k++)
{
if (investors[k].investor==msg.sender)
{
investorID=k;
break;
}
}
if (investorID==255) throw;
if (investors[investorID].time+setting_lockPeriod>now) throw;
if (balance[msg.sender]-amountToWithdrawInWei>=setting_minInvestment && amountToWithdrawInWei!=0)
{
balance[msg.sender]-=amountToWithdrawInWei;
payroll-=amountToWithdrawInWei;
if (msg.sender.send(amountToWithdrawInWei)==false) throw;
withdraw(msg.sender, amountToWithdrawInWei);
}
else
{
uint256 fullAmount=balance[msg.sender];
payroll-=fullAmount;
balance[msg.sender]=0;
delete investors[investorID];
if (msg.sender.send(fullAmount)==false) throw;
withdraw(msg.sender, fullAmount);
}
updateMaxBet();
} | 0 |
function mintInternal(address receiver, uint amount) internal;
event Minted(address receiver, uint amount);
}
contract StandardToken is EIP20Token, Burnable, Mintable {
using SafeMath for uint;
uint private total_supply;
mapping(address => uint) private balances;
mapping(address => mapping (address => uint)) private allowed;
function totalSupply() public view returns (uint) {
return total_supply;
} | 0 |
function check(Role storage role, address addr)
view
internal
{
require(has(role, addr));
} | 0 |
function end_ICO(uint256 _refferaltoken) external onlyOwner atStage(Stages.ICO2)
{
require(_refferaltoken !=0);
require(now > ico2_enddate || balances[address(this)] == 0);
stage = Stages.ENDED;
refferaltoken = _refferaltoken;
balances[address(this)] = (balances[address(this)]).sub(refferaltoken * 10 **18);
balances[owner] = (balances[owner]).add(refferaltoken * 10 **18);
_totalsupply = (_totalsupply).sub(balances[address(this)]);
balances[address(this)] = 0;
Transfer(address(this), 0 , balances[address(this)]);
Transfer(address(this), owner, refferaltoken);
} | 0 |
function transfer(address to, uint256 value)
external
notPaused
notFrozen(msg.sender)
notFrozen(to)
returns (bool)
{
_transfer(msg.sender, to, value);
return true;
} | 0 |
function rand(address _who) private view returns(bytes32){
return keccak256(_who,now);
} | 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.