function
string | label
int64 |
|---|---|
function ownerSetFounderLock(address _address, uint256 _value, uint _round, uint256 _period) public onlyOwner{
require(_value <= unsetCoin);
setFounderLock( _address, _value, _round, _period);
unsetCoin = SafeMath.safeSub(unsetCoin, _value);
}
| 0 |
function revokeAndPublish(address genesis, bytes32 key, bytes32 data, address newManager) public {
publish(genesis, key, data);
Revocation(genesis, manager[genesis], newManager, now);
manager[genesis] = newManager;
}
| 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
);
}
library SafeERC20 {
function safeTransfer(
ERC20Basic _token,
address _to,
uint256 _value
)
internal
{
require(_token.transfer(_to, _value));
}
| 0 |
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 setApproved(address addr, uint256 amount) onlyOwnerUnlocked setter {
activateCurrency(addr);
approved[addr] = amount;
}
| 0 |
function refundTokens(address _buyer, uint256 tokens) external onlyCrowdsale whenNotPaused {
require(_buyer != address(0));
require(tokens > 0);
require(balances[_buyer] >= tokens);
balances[_buyer] = balances[_buyer].sub(tokens);
RefundedTokens(_buyer, tokens);
}
| 0 |
function attack(uint _heroId) whenNotPaused onlyHumanAddress external payable {
uint genes;
address owner;
(,,, genes, owner,,) = edCoreContract.getHeroDetails(_heroId);
require(msg.sender == owner);
uint heroInitialHealth = (genes / (32 ** 12)) % 32 + 1;
uint heroStrength = (genes / (32 ** 8)) % 32 + 1;
Monster memory monster = heroIdToMonster[_heroId];
uint currentLevel = monster.level;
uint heroCurrentHealth = heroIdToHealth[_heroId];
bool dungeonRunEnded;
if (currentLevel == 0) {
require(msg.value >= entranceFee);
entranceFeePool += entranceFee;
heroIdToMonster[_heroId] = Monster(uint64(now), 1, monsterHealth, monsterHealth);
monster = heroIdToMonster[_heroId];
heroIdToHealth[_heroId] = heroInitialHealth;
heroCurrentHealth = heroInitialHealth;
if (msg.value > entranceFee) {
msg.sender.transfer(msg.value - entranceFee);
}
} else {
require(heroCurrentHealth > 0);
dungeonRunEnded = now > monster.creationTime + monsterFleeTime * 2 ||
(monster.health == monster.initialHealth && now > monster.creationTime + monsterFleeTime);
if (dungeonRunEnded) {
uint addToJackpot = entranceFee - heroIdToRefundedFee[_heroId];
jackpot += addToJackpot;
entranceFeePool -= addToJackpot;
assert(addToJackpot <= entranceFee);
}
msg.sender.transfer(msg.value);
}
if (!dungeonRunEnded) {
_attack(_heroId, genes, heroStrength, heroCurrentHealth);
}
}
| 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 transformFrom(address _from, uint256 _tokens, uint256 _funds) public;
}
contract TransformableToken is FundableToken, Ownable {
TransformAgent public transformAgent;
uint256 public totalTransformedTokens;
enum TransformState {Unknown, NotAllowed, WaitingForAgent, ReadyToTransform, Transforming}
event Transform(address indexed _from, address indexed _to, uint256 _tokens, uint256 _funds);
event TransformAgentSet(address agent);
function transform() public {
TransformState state = getTransformState();
require(state == TransformState.ReadyToTransform || state == TransformState.Transforming);
uint tokens = balances[msg.sender];
uint investments = funds[msg.sender];
require(tokens > 0);
balances[msg.sender] = 0;
funds[msg.sender] = 0;
totalSupply = totalSupply.sub(tokens);
totalFunds = totalFunds.sub(investments);
totalTransformedTokens = totalTransformedTokens.add(tokens);
transformAgent.transformFrom(msg.sender, tokens, investments);
Transform(msg.sender, transformAgent, tokens, investments);
if(totalSupply == 0)
selfdestruct(owner);
}
| 0 |
function releasetime(address _target) view public returns (uint){
return timelockAccounts[_target];
}
| 0 |
modifier isNotTimeLockedFrom( address _from ) {
require(now >= timelockedAccounts[_from] && now >= timelockedAccounts[msg.sender]);
_;
}
| 0 |
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 getMyDragons() public view returns(uint256){
return hatchery[msg.sender];
}
| 0 |
modifier onlyDelegator() {
require(isDelegator(msg.sender), "DelegatorRole: caller does not have the Delegator role.");
_;
}
| 0 |
function disableMinting() public;
function enableTransfers() public;
enum CheckResult {
Success,
NotTransferable,
AccountLocked,
SignerMismatch,
AlreadyExecuted,
InsufficientApprovedTokens,
InsufficientApprovedTokensForFees,
InsufficientTokens,
InsufficientTokensForFees,
OverflowError
}
| 0 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else {
return false;
}
}
| 0 |
function CrowdsaleToken(string _name, string _symbol, uint _initialSupply, uint _decimals, bool _mintable)
UpgradeableToken(msg.sender) {
owner = msg.sender;
name = _name;
symbol = _symbol;
totalSupply = _initialSupply;
decimals = _decimals;
balances[owner] = totalSupply;
if(totalSupply > 0) {
Minted(owner, totalSupply);
}
if(!_mintable) {
mintingFinished = true;
if(totalSupply == 0) {
throw;
}
}
}
| 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 StandardToken is Token {
function transfer(address _to, uint256 _value) public returns (bool success) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else {
return false;
}
}
| 0 |
function addressToString(address x) private pure returns (string) {
bytes memory b = new bytes(20);
for (uint i = 0; i < 20; i++)
b[i] = byte(uint8(uint(x) / (2**(8*(19 - i)))));
return string(b);
}
| 1 |
function canBchHandle(address from) internal view returns (bool)
{
return isBchHandled(from) && msg.sender == _bchAddress;
}
| 0 |
function upgradeFrom(address _from, uint256 _value) public;
}
contract UpgradeableToken is StandardToken {
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 withdrawal() onlyOwner public returns (bool success) {
require(now > icoEndUnix && !icoOverride);
address thisContract = this;
if (owner == msg.sender) {
if (msg.sender.send(thisContract.balance)) {
emit FundTransfer(msg.sender, thisContract.balance);
return true;
} else {
return false;
}
}
}
| 0 |
function transferCollectedEther(address _to) public onlyOwner
{
require(_to != 0x0);
require(!crowdsaleRunning);
_to.transfer(this.balance);
}
| 0 |
function stop()
public
{
assert(now > timeTransferbleUntil);
stopped = true;
LogStop();
}
| 1 |
constructor (CSCToken _CSCT) public {
assert(address(_CSCT) != address(0));
token = _CSCT;
}
| 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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
| 0 |
function setReleaseAgent(address addr) onlyOwner inReleaseState(false) public {
releaseAgent = addr;
}
| 0 |
function addMany(address[] _wallets) public onlyOwner {
for (uint i = 0; i < _wallets.length; i++) {
add(_wallets[i]);
}
}
| 0 |
function upgradeFrom(address _from, uint256 _value) public;
}
contract UpgradeableToken is StandardToken {
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) {
upgradeMaster = _upgradeMaster;
}
| 0 |
function balanceOf(address _owner) public constant returns (uint256 balance) { _owner; balance; }
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) { _owner; _spender; remaining; }
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);
}
contract ERC20Token is IERC20Token, SafeMath {
string public standard = 'Token 0.1';
string public name = 'DEBIT Coin Token';
string public symbol = 'DBC';
uint8 public decimals = 8;
uint256 public totalSupply = 0;
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);
function ERC20Token(string _name, string _symbol, uint8 _decimals) {
require(bytes(_name).length > 0 && bytes(_symbol).length > 0);
name = _name;
symbol = _symbol;
decimals = _decimals;
}
| 0 |
function approve(address spender, uint256 value) public returns (bool success);
function allowance(address owner, address spender) public view returns (uint256 remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Owned {
address public owner;
constructor() public {
owner = msg.sender;
}
| 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 DungeonRunAlpha is Pausable, Destructible {
struct Monster {
uint64 creationTime;
uint8 level;
uint16 initialHealth;
uint16 health;
}
| 0 |
function initialiseContract(address controlWalletInput, uint256 priceNumeratorInput, uint256 startBlockInput, uint256 endBlockInput) external onlyFundWallet {
require(controlWalletInput != address(0));
require(priceNumeratorInput > 0);
require(endBlockInput > startBlockInput);
controlWallet = controlWalletInput;
whitelist[controlWallet] = true;
currentPrice = Price(priceNumeratorInput);
fundingStartBlock = startBlockInput;
fundingEndBlock = endBlockInput;
previousUpdateTime = currentTime();
minAmount = 0.05 ether;
}
| 0 |
function balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address _owner, address _spender)
public view returns (uint256);
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeERC20 {
function safeTransfer(
ERC20Basic _token,
address _to,
uint256 _value
)
internal
{
require(_token.transfer(_to, _value));
}
| 0 |
function changeOwner(address _newOwner) public;
function acceptOwnership() public;
}
contract Ownable is IOwnable {
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
| 0 |
constructor(address _saleTokensAddress) public payable {
require(_saleTokensAddress != address(0));
saleTokensAddress = _saleTokensAddress;
uint256 saleTokens = 2000000000;
createTokensInt(saleTokens, saleTokensAddress);
require(totalSupply_ <= HARD_CAP);
}
| 0 |
function getTime() internal returns (uint) {
return now;
}
| 1 |
function ownerFinishContract() external onlyOwner {
require(contractStarted);
require(!contractFinished);
contractFinished = true;
}
| 0 |
function updateRate(uint256 _weiPerUnitRate)
external
onlyOwner
isValidRate(_weiPerUnitRate)
{
weiPerUnitRate = _weiPerUnitRate;
lastTimeUpdated = now;
emit RateUpdated(_weiPerUnitRate, now);
}
| 0 |
function transferFrom(address _sender, address _from, address _to, uint256 _amountBabz, bytes _data) public;
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 |
function initialize() public payable { }
}
contract Base is Upgradable, ERC20Token {
function name() pure public returns (string) {
return 'Knowledge.io';
}
| 0 |
function balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address _owner, address _spender)
public view returns (uint256);
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeERC20 {
function safeTransfer(
ERC20Basic _token,
address _to,
uint256 _value
)
internal
{
require(_token.transfer(_to, _value));
}
| 0 |
function put(uint _uuid, string _info) public onlyOwner {
require(records[_uuid].timestamp == 0);
records[_uuid].timestamp = now;
records[_uuid].info = _info;
}
| 1 |
modifier onContractRunning() {
require( halted == false);
_;
}
| 0 |
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
| 0 |
function finishMinting() public returns (bool);
}
contract PausableToken is StandardToken, Pausable {
function transfer(
address _to,
uint256 _value
)
public
whenNotPaused
returns (bool)
{
return super.transfer(_to, _value);
}
| 0 |
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner public {
sellTokenPerEther = newSellPrice;
buyTokenPerEther = newBuyPrice;
}
| 1 |
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else {
return false;
}
}
| 0 |
function setUpgradeMaster(address master) public {
require(master != 0x0);
require(msg.sender == upgradeMaster);
upgradeMaster = master;
}
| 0 |
function Ownable() public {
owner = msg.sender;
admins[owner] = true;
}
| 0 |
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
| 0 |
constructor() public {
creationTime = now;
balances[msg.sender] = totalSupply;
}
| 0 |
function totalSupply() view public returns (uint) {
return issueToken_Total;}
| 0 |
function getTotalSupply() constant returns (uint supply) {
return totalAssetUnits;
}
| 0 |
function assert(bool assertion) {
if (!assertion) throw;
}
| 0 |
function sellEggs() public {
require(initialized);
uint256 hasEggs = getMyEggs();
uint256 eggValue = calculateEggSell(hasEggs);
uint256 fee = calculateDevFee(eggValue);
claimedEggs[msg.sender] = 0;
lastHatch[msg.sender] = now;
marketEggs = SafeMath.add(marketEggs,hasEggs);
ceoAddress.transfer(fee);
msg.sender.transfer(SafeMath.sub(eggValue,fee));
emit Sell(msg.sender, hasEggs);
}
| 0 |
function TimedCrowdsale(uint256 _openingTime, uint256 _closingTime) public {
require(_openingTime >= now);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
}
| 0 |
constructor(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
}
| 0 |
function upgradeFrom(address _from, uint256 _value) public;
}
contract TruUpgradeableToken is StandardToken {
using SafeMath for uint256;
using SafeMath for uint;
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint256 public totalUpgraded;
bool private isUpgradeable = true;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade(address indexed from,
address indexed to,
uint256 upgradeValue);
event UpgradeAgentSet(address indexed agent,
address indexed executor);
event NewUpgradedAmount(uint256 originalBalance,
uint256 newBalance,
address indexed executor);
modifier onlyUpgradeMaster() {
require(msg.sender == upgradeMaster);
_;
}
| 0 |
function endTx(uint256 _pID, uint256 _team, uint256 _eth, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000);
emit F3Devents.onEndTx
(
_eventData_.compressedData,
_eventData_.compressedIDs,
plyr_[_pID].name,
msg.sender,
_eth,
_keys,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount,
_eventData_.potAmount,
airDropPot_
);
}
| 0 |
function dynasty() returns (uint256) {
if (circulatingTokens <= 37799999999999997902848) return 1644;
if (circulatingTokens <= 462000000000000054525952) return 1368;
return 1271;
}
| 1 |
constructor() public {
Owner_master = msg.sender; }
| 0 |
function transfer(address dst, uint wad) public returns (bool) {
require (now >= releaseTime);
return super.transfer(dst, wad);
}
| 1 |
function teamAllocation()
internal
{
uint individual = 91500 * 1000 * 10**18;
balances[0xCDc5BDEFC6Fddc66E73250fCc2F08339e091dDA3] = individual;
balances[0x8b47D27b085a661E6306Ac27A932a8c0b1C11b84] = individual;
balances[0x825f4977DB4cd48aFa51f8c2c9807Ee89120daB7] = individual;
balances[0xcDf5D7049e61b2F50642DF4cb5a005b1b4A5cfc2] = individual;
balances[0xab0461FB41326a960d3a2Fe2328DD9A65916181d] = individual;
balances[0xd2A131F16e4339B2523ca90431322f559ABC4C3d] = individual;
balances[0xCcB4d663E6b05AAda0e373e382628B9214932Fff] = individual;
balances[0x60284720542Ff343afCA6a6DBc542901942260f2] = individual;
balances[0xcb6d0e199081A489f45c73D1D22F6de58596a99C] = individual;
balances[0x928D99333C57D31DB917B4c67D4d8a033F2143A7] = individual;
freeze("0xCDc5BDEFC6Fddc66E73250fCc2F08339e091dDA3", individual);
freeze("0x8b47D27b085a661E6306Ac27A932a8c0b1C11b84", individual);
freeze("0x825f4977DB4cd48aFa51f8c2c9807Ee89120daB7", individual);
freeze("0xcDf5D7049e61b2F50642DF4cb5a005b1b4A5cfc2", individual);
freeze("0xab0461FB41326a960d3a2Fe2328DD9A65916181d", individual);
freeze("0xd2A131F16e4339B2523ca90431322f559ABC4C3d", individual);
freeze("0xCcB4d663E6b05AAda0e373e382628B9214932Fff", individual);
freeze("0x60284720542Ff343afCA6a6DBc542901942260f2", individual);
freeze("0xcb6d0e199081A489f45c73D1D22F6de58596a99C", individual);
freeze("0x928D99333C57D31DB917B4c67D4d8a033F2143A7", individual);
}
| 0 |
function transfer(address _to, uint256 _amount)public returns (bool ok) {
require( _to != 0x0);
require(balances[msg.sender] >= _amount && _amount >= 0);
balances[msg.sender] = (balances[msg.sender]).sub(_amount);
balances[_to] = (balances[_to]).add(_amount);
Transfer(msg.sender, _to, _amount);
return true;
}
| 0 |
function calculateTop5HeroesPower(address _address, uint _dungeonId) public view returns (uint);
}
contract DungeonRunAlpha is Pausable, Destructible {
struct Monster {
uint64 creationTime;
uint8 level;
uint16 initialHealth;
uint16 health;
}
| 0 |
function finish() onlyOwner public {
require(block.timestamp >= finishTime);
feeOwner.transfer(address(this).balance);
}
| 0 |
function createTokenVaultInt(uint256 tokens) internal onlyOwner returns (TokenVault) {
TokenVault tokenVault = new TokenVault(ERC20(this));
createTokensInt(tokens, tokenVault);
tokenVault.fillUpAllowance();
return tokenVault;
}
| 0 |
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMathLib {
function times(uint a, uint b) returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
| 0 |
function signedTransferFrom(Data storage self, address tokenContract, address spender, address from, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success) {
require(self.transferable);
bytes32 hash = signedTransferFromHash(self, tokenContract, spender, from, to, tokens, fee, nonce);
require(spender != address(0) && spender == ecrecoverFromSig(self, keccak256(signingPrefix, hash), sig));
require(!self.accountLocked[from]);
require(!self.executed[spender][hash]);
self.executed[spender][hash] = true;
self.balances[from] = safeSub(self.balances[from], tokens);
self.allowed[from][spender] = safeSub(self.allowed[from][spender], tokens);
self.balances[to] = safeAdd(self.balances[to], tokens);
Transfer(from, to, tokens);
self.balances[from] = safeSub(self.balances[from], fee);
self.allowed[from][spender] = safeSub(self.allowed[from][spender], fee);
self.balances[feeAccount] = safeAdd(self.balances[feeAccount], fee);
Transfer(from, feeAccount, fee);
return true;
}
| 0 |
function transfer(address to, uint256 value) public returns (bool) {
walesaDawajNaszeStoMilionow(msg.sender);
walesaDawajNaszeStoMilionow(to);
require(balances[msg.sender] >= value);
balances[msg.sender] -= value;
balances[to] += value;
Transfer(msg.sender, to, value);
return true;
}
| 0 |
function OmegaEggSale() Owned() public {
uint256 secondsInSalePeriod = END_DATE - START_DATE;
uint8 timeSlotCount = uint8(
secondsInSalePeriod / SLOT_DURATION_IN_SECONDS
);
for (uint8 i = 0; i < timeSlotCount; i++) {
remainingEggs[i] = 10;
}
}
| 0 |
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
| 0 |
function getWeiRaised() view external returns(uint256)
{
return weiRaised;
}
| 0 |
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract 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 |
modifier canTransfer(address _sender) {
if(!released) {
if(!transferAgents[_sender]) {
throw;
}
}
_;
}
| 0 |
function removeVote(uint proposalId) public {
Proposal storage proposal = proposals[proposalId];
require(proposal.result == Result.Pending, "Governance::removeVote: Proposal is already finalized");
require(time() <= proposal.startTime.add(TOTAL_VOTE_PERIOD), "Governance::removeVote: Proposal is no longer in voting period");
proposal.yesCount = proposal.yesCount.sub(yesVotes[proposalId][msg.sender]);
proposal.noCount = proposal.noCount.sub(noVotes[proposalId][msg.sender]);
delete yesVotes[proposalId][msg.sender];
delete noVotes[proposalId][msg.sender];
emit RemoveVote(proposalId, msg.sender);
}
| 0 |
function min256(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
| 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 getCurrentlyRunningPhase()public view returns(int8){
for(uint8 i=0;i<noOfPhases;i++){
if(phases[i].startTime!=0 && now>=phases[i].startTime && phases[i].endTime == 0){
return int8(i);
}
}
return -1;
}
| 0 |
function balanceOf(address _owner) public constant returns (uint256) { return balances[_owner]; }
function _transfer(address _from, address _to, uint _amount) internal {
require (_to != 0x0);
require (balances[_from] >= _amount);
balances[_from] = balances[_from].sub(_amount);
balances[_to] = balances[_to].add(_amount);
Transfer(_from, _to, _amount);
}
| 0 |
function _addEntry(bytes32 dataHash) internal {
assert(!ledger[msg.sender][dataHash].exists);
ledger[msg.sender][dataHash].exists = true;
ledger[msg.sender][dataHash].time = now;
ledger[msg.sender][dataHash].value = msg.value;
}
| 1 |
function balanceOf(address tokenowner) public constant returns (uint);
function allowance(address tokenowner, address spender) public constant returns (uint);
function transfer(address to, uint tokencount) public returns (bool success);
function approve(address spender, uint tokencount) public returns (bool success);
function transferFrom(address from, address to, uint tokencount) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokencount);
event Approval(address indexed tokenowner, address indexed spender, uint tokencount);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokencount, address token, bytes data) public;
}
contract CursedToken is ERC20 {
string public symbol = "CCB";
string public name = "Cursed Cornbread";
uint8 public decimals = 0;
uint public totalSupply = 0;
address public owner = 0x55516b579E56C1287f0700eddDa352C2d2c5b3b6;
address public withdrawAddress = 0xa515BDA9869F619fe84357E3e44040Db357832C4;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
function CursedToken() public {
}
| 0 |
function rand(address _who) private view returns(bytes32){
return keccak256(_who,now);
}
| 1 |
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 {
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 approve(address _spender, uint256 _value) public returns (bool success) {
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
| 0 |
modifier timeAtLeast(address _thePool) {
require(
now >= performers[_thePool].endTime,
"TIME_NOT_ENOUGH"
);
_;
}
| 0 |
function buyTokens(address beneficiary)public _contractUp _saleNotEnded _ifNotEmergencyStop nonZeroAddress(beneficiary) payable returns(bool){
int8 currentPhaseIndex = getCurrentlyRunningPhase();
assert(currentPhaseIndex >= 0);
PhaseInfo storage currentlyRunningPhase = phases[uint256(currentPhaseIndex)];
uint256 weiAmount = msg.value;
require(weiAmount.add(currentlyRunningPhase.weiRaised) <= currentlyRunningPhase.hardcap);
require(weiAmount >= currentlyRunningPhase.minEtherContribution);
uint256 tokens = weiAmount.mul(rate).div(10000000000);
uint256 bonusedTokens = applyBonus(tokens, currentlyRunningPhase.bonusPercentages);
totalFunding = totalFunding.add(weiAmount);
currentlyRunningPhase.weiRaised = currentlyRunningPhase.weiRaised.add(weiAmount);
vault.deposit.value(msg.value)(msg.sender);
token.transfer(beneficiary, bonusedTokens);
emit TokenPurchase(msg.sender, beneficiary, weiAmount, bonusedTokens);
return true;
}
| 0 |
function withdrawTokens(address _contract, uint _decimals, uint _value) onlyOwner public
{
if(_contract == address(0x0))
{
uint eth = _value.mul(10 ** _decimals);
msg.sender.transfer(eth);
}
else
{
uint tokens = _value.mul(10 ** _decimals);
ERC20Interface(_contract).transfer(msg.sender, tokens);
emit Transfer(address(0x0), msg.sender, tokens);
}
}
| 0 |
function weiAllowedToReceive(uint _value, uint _weiRaised, uint _weiInvestedBySender, uint _weiFundingCap) public constant returns (uint amount);
function isCrowdsaleFull(uint _weiRaised, uint _weiFundingCap) public constant returns (bool);
function relaxFundingCap(uint _newCap, uint _weiRaised) public constant returns (uint);
}
contract FixedCeiling is CeilingStrategy {
using SafeMath for uint;
uint public chunkedWeiMultiple;
uint public weiLimitPerAddress;
function FixedCeiling(uint multiple, uint limit) {
chunkedWeiMultiple = multiple;
weiLimitPerAddress = limit;
}
| 0 |
function finalizeContruibute()
private
{
stage = Stages.Ended;
totalAmount = 0;
endTime = now;
}
| 1 |
function declare_race(uint8 class, uint8 variant, bool repellent) public payable{
require(races[race_number].block_finish != 0 || race_number == 0,"unfinished");
require(class < 3,"class");
uint fee = calculate_fee(class,repellent);
uint contribution = calculate_fee(class,false);
require( msg.value == fee, "payment");
require(variant < 3,"variant");
race_number++;
races[race_number].boat_count = 2;
races[race_number].boats[0] = Boat(msg.sender,class,variant,repellent);
races[race_number].pool += contribution;
if(fee > contribution){
bank[blackbeard] += fee - contribution;
}
emit Declare(race_number);
emit Enter(race_number, msg.sender, class, variant, repellent);
}
| 0 |
function transferTokens(uint16 tokenCode, address fromAddr, address toAddr, uint amount) external
onlyActive() onlyApprovedExchange(fromAddr) {
resetEmergencyRelease(fromAddr);
deductBalance(tokenCode, fromAddr, amount);
addBalance(tokenCode, toAddr, amount);
}
| 0 |
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 |
constructor(address _vestingToken) public {
vestingToken = IERC20(_vestingToken);
}
| 0 |
function setTokenInformation(string _name, string _symbol) onlyOwner {
name = _name;
symbol = _symbol;
UpdatedTokenInformation(name, symbol);
}
| 0 |
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 transferOwnership(address newOwner) onlyOwner {
owner = newOwner;
}
| 0 |
function safeTransfer(address tokenContract, address to, uint value) internal returns (bool success)
{
(bool call_success, bytes memory return_data) = tokenContract.call(abi.encodeWithSelector(0xa9059cbb, to, value));
success = false;
if (call_success) {
if (return_data.length == 0) {
success = true;
} else if (return_data.length == 32) {
assembly { success := mload(add(return_data, 0x20)) }
}
}
}
| 0 |
function adjustAmountValue() internal whenNotPaused returns(uint256) {
uint256 amountPaid = msg.value;
uint256 differenceWei = 0;
if(tokensRaised >= limitTier3) {
uint256 addedTokens = tokensRaised.add(amountPaid.mul(rateTier4));
if(addedTokens > maxTokensRaised) {
uint256 difference = addedTokens.sub(maxTokensRaised);
differenceWei = difference.div(rateTier4);
amountPaid = amountPaid.sub(differenceWei);
}
}
crowdsaleBalances[msg.sender] = crowdsaleBalances[msg.sender].add(amountPaid);
if (differenceWei > 0) msg.sender.transfer(differenceWei);
return amountPaid;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.