function
string | label
int64 |
|---|---|
function getFreezing(address _addr, uint _index) public view returns (uint64 _release, uint _balance) {
for (uint i = 0; i < _index + 1; i ++) {
_release = chains[toKey(_addr, _release)];
if (_release == 0) {
return;
}
}
_balance = freezings[toKey(_addr, _release)];
} | 0 |
function alterGoal(uint256 _goalLimitMinInWei, uint256 _goalLimitMaxInWei) external onlyOwner {
ICOStatus status = status(block.timestamp);
require(ICOStatus.GoalReached != status);
require(ICOStatus.GoalNotReached != status);
require(_goalLimitMinInWei < _goalLimitMaxInWei);
goalLimitMinInWei = _goalLimitMinInWei;
goalLimitMaxInWei = _goalLimitMaxInWei;
emit GoalChange(_goalLimitMinInWei, _goalLimitMaxInWei);
} | 0 |
function adminAddRole(address addr, string roleName)
onlyAdmin
public
{
addRole(addr, roleName);
} | 0 |
function _attack(uint _heroId, uint _genes, uint _heroStrength, uint _heroCurrentHealth) internal {
Monster storage monster = heroIdToMonster[_heroId];
uint8 currentLevel = monster.level;
uint heroPower;
(heroPower,,,,) = edCoreContract.getHeroPower(_genes, dungeonDifficulty);
uint damageByMonster;
uint damageByHero;
if (now > monster.creationTime + monsterFleeTime) {
damageByMonster = currentLevel + monsterStrength;
} else {
if (currentLevel >= 2) {
damageByMonster = _getRandomNumber(currentLevel / 2);
}
}
if (damageByMonster >= _heroCurrentHealth) {
heroIdToHealth[_heroId] = 0;
uint addToJackpot = entranceFee - heroIdToRefundedFee[_heroId];
jackpot += addToJackpot;
entranceFeePool -= addToJackpot;
assert(addToJackpot <= entranceFee);
} else {
heroIdToHealth[_heroId] -= damageByMonster;
if (now > monster.creationTime + monsterFleeTime) {
currentLevel++;
heroIdToMonster[_heroId] = Monster(uint64(monster.creationTime + monsterFleeTime),
currentLevel, currentLevel * monsterHealth, currentLevel * monsterHealth);
monster = heroIdToMonster[_heroId];
}
damageByHero = (_heroStrength * 1e9 + heroPower * 1e9 / (10 * (1 + _getRandomNumber(5)))) / tx.gasprice;
bool isMonsterDefeated = damageByHero >= monster.health;
uint rewards;
if (isMonsterDefeated) {
uint8 newLevel = currentLevel + 1;
heroIdToMonster[_heroId] = Monster(uint64(now), newLevel, newLevel * monsterHealth, newLevel * monsterHealth);
monster = heroIdToMonster[_heroId];
if (currentLevel == checkpointLevel) {
rewards = entranceFee / 2;
heroIdToRefundedFee[_heroId] += rewards;
entranceFeePool -= rewards;
} else if (currentLevel == breakevenLevel) {
rewards = entranceFee / 2;
heroIdToRefundedFee[_heroId] += rewards;
entranceFeePool -= rewards;
} else if (currentLevel == jackpotLevel) {
rewards = jackpot / 2;
jackpot -= rewards;
}
msg.sender.transfer(rewards);
} else {
monster.health -= uint8(damageByHero);
}
}
LogAttack(now, msg.sender, _heroId, currentLevel, damageByHero, damageByMonster, isMonsterDefeated, rewards);
} | 0 |
function removeODEMClaim(address subject, bytes32 key) public {
require(hasRole(msg.sender, ROLE_ISSUER) || msg.sender == subject, "Access denied: missing role");
address resolved = resolveAddress(subject);
delete claims[resolved][key];
emit ClaimRemoved(msg.sender, subject, key, now);
} | 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);
}
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 _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
address owner = ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
} | 0 |
function finish() public
hasntStopped()
hasBeenStarted()
whenCrowdsaleAlive()
onlyCrowdsale()
{
completed = true;
} | 0 |
modifier erc20Allowed() {
require(state == State.Finalized || msg.sender == owner|| msg.sender == siteAccount || msg.sender == crowdsaleWallet);
require (_airdropUnlocked(msg.sender));
_;
} | 0 |
modifier hasntStopped() {
require(!stopped);
_;
} | 0 |
function voteToUpdatePrenup() public {
if(msg.sender == partner1_address){
partner1_voted_update_prenup = true;
saveContractEvent("Vote - Update Prenup", "Partner 1 voted to updated Prenuptial Aggreement");
}
if(msg.sender == partner2_address){
partner2_voted_update_prenup = true;
saveContractEvent("Vote - Update Prenup", "Partner 2 voted to updated Prenuptial Aggreement");
}
} | 0 |
function decimals() public constant returns (uint8);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ERC223 is ERC20Interface {
function transfer(address to, uint value, bytes data) public returns (bool);
event Transfer(address indexed from, address indexed to, uint tokens);
event Transfer(address indexed from, address indexed to, uint value, bytes data);
}
contract NXX is ERC223, Pausable {
using SafeMath for uint256;
using ContractLib for address;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
event Burn(address indexed from, uint256 value);
function NXX() public {
symbol = "NASHXX";
name = "XXXX CASH";
decimals = 18;
totalSupply = 100000000000 * 10**uint(decimals);
balances[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
} | 0 |
function approve(address spender, uint tokens) external returns(bool success);
function transferFrom(address from, address to, uint tokens) external returns(bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract admined {
mapping(address => uint8) public level;
constructor() internal {
level[0x7a3a57c620fA468b304b5d1826CDcDe28E2b2b98] = 2;
emit AdminshipUpdated(0x7a3a57c620fA468b304b5d1826CDcDe28E2b2b98, 2);
} | 0 |
function balanceOf(address who)public view returns (uint256);
function allowance(address owner, address spender)public view returns (uint);
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 SATCoin is ERC20
{ using SafeMath for uint256;
string public constant name = "SATCoin";
string public constant symbol = "SAT";
uint8 public constant decimals = 8;
uint public _totalsupply = 1000000000 * 10 ** 8;
address public owner;
uint256 public _price_tokn = 7000 ;
uint256 no_of_tokens;
uint256 bonus_token;
uint256 total_token;
bool stopped = false;
uint256 public startdate;
uint256 ico_first;
uint256 ico_second;
uint256 ico_third;
uint256 ico_fourth;
address central_account;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
enum Stages {
NOTSTARTED,
ICO,
PAUSED,
ENDED
} | 0 |
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 timeLock(address spender, uint256 date) public onlyOwner returns (bool) {
releaseTimes[spender] = date;
return true;
} | 0 |
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount)
internal
whenNotPaused
{
require(_beneficiary != address(0));
require(_weiAmount >= 1 ether);
require(token.totalSupply() < TOTAL_TOKENS_FOR_CROWDSALE);
} | 0 |
function isToken() public pure returns (bool weAre) {
return true;
} | 0 |
function setOversightAddress(address addr, bool value) onlyOwnerUnlocked setter {
activateOversightAddress(addr);
oversightAddresses[addr] = value;
} | 0 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Hodl {
mapping(address => mapping(address => uint)) private amounts;
mapping(address => mapping(address => uint)) private timestamps;
event Hodling(address indexed sender, address indexed tokenAddress, uint256 amount);
event TokenReturn(address indexed sender, address indexed tokenAddress, uint256 amount);
function hodlTokens(address tokenAddress, uint256 amount, uint timestamp) public {
assert(tokenAddress != address(0));
assert(amount != uint256(0));
assert(timestamp != uint(0));
assert(amounts[msg.sender][tokenAddress] == 0);
amounts[msg.sender][tokenAddress] = amount;
timestamps[msg.sender][tokenAddress] = timestamp;
ERC20 erc20 = ERC20(tokenAddress);
assert(erc20.transferFrom(msg.sender, this, amount) == true);
Hodling(msg.sender, tokenAddress, amount);
} | 0 |
function setFeeCollector(address _collector) public;
function addDelegator(address minter) public;
function removeDelegator(address minter) public;
function renounceDelegator() public;
function _setFeeRate(uint16 _rate) internal{
_feeRate = _rate;
} | 0 |
function updateTerm(uint256 _term) external onlyOwner() {
term = _term;
} | 0 |
modifier requireBursar() {
require(msg.sender == bursarAddress);
_;
} | 0 |
function addAcceptedContribution(address participant, uint256 ethValue, uint256 parsecValue) private {
contributionOf[participant] = contributionOf[participant].add(ethValue);
parsecsOf[participant] = parsecsOf[participant].add(parsecValue);
raisedFunding = raisedFunding.add(ethValue);
spentParsecs = spentParsecs.add(parsecValue);
LogContribution(participant, ethValue, parsecValue, now);
multisigAddress.transfer(ethValue);
parsecToken.transfer(participant, parsecValue);
} | 0 |
function _sendBatchSelf(address[] memory recipients, uint256[] memory values, uint transactionCount) private returns (bool)
{
for (uint i = 0; i < transactionCount; i++)
{
_fullTransfer(msg.sender, recipients[i], values[i]);
}
return true;
} | 0 |
function depositEther(address account) external payable {
emit Deposit(0, account, msg.value);
addBalance(0, account, msg.value);
} | 0 |
function transfer(address _to, uint256 _value) whenNotPaused public returns (bool) {
super.transfer(_to, _value);
return true;
} | 0 |
function signedApproveAndCallHash(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce) public view returns (bytes32 hash);
function signedApproveAndCallCheck(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function signedApproveAndCall(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success);
function mint(address tokenOwner, uint tokens, bool lockAccount) public returns (bool success);
function unlockAccount(address tokenOwner) public;
function disableMinting() public;
function enableTransfers() public;
enum CheckResult {
Success,
NotTransferable,
AccountLocked,
SignerMismatch,
AlreadyExecuted,
InsufficientApprovedTokens,
InsufficientApprovedTokensForFees,
InsufficientTokens,
InsufficientTokensForFees,
OverflowError
} | 0 |
function transferMinusComissionAltCoin(TokenERC20 _contract, address _to, uint256 _value, uint256 _commission)
private returns(bool)
{
uint256 _totalComission = _commission;
_contract.transfer(_to, _value.sub(_totalComission));
return true;
} | 0 |
function addMonsterObj(uint32 _classId, address _trainer, string _name) onlyModerators public returns(uint64) {
MonsterClass storage class = monsterClass[_classId];
if (class.classId == 0)
return 0;
totalMonster += 1;
class.total += 1;
MonsterObj storage obj = monsterWorld[totalMonster];
obj.monsterId = totalMonster;
obj.classId = _classId;
obj.trainer = _trainer;
obj.name = _name;
obj.exp = 1;
obj.createIndex = class.total;
obj.lastClaimIndex = class.total;
obj.createTime = now;
addMonsterIdMapping(_trainer, obj.monsterId);
return obj.monsterId;
} | 1 |
function assert(bool assertion) internal
{
if (!assertion)
{
throw;
}
} | 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) {
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 verifyParticipant(address participant) external onlyManagingWallets {
whitelist[participant] = true;
Whitelist(participant);
} | 0 |
function clearExpiredFreezing(address addr) public {
FreezingNode[] storage nodes = c_freezing_list[addr];
uint length = nodes.length;
uint left = 0;
while (left < length) {
if (nodes[left].end_stamp <= block.timestamp) {
break;
}
left++;
}
uint right = left + 1;
while (left < length && right < length) {
if (nodes[right].end_stamp > block.timestamp) {
nodes[left] = nodes[right];
left++;
}
right++;
}
if (length != left) {
nodes.length = left;
emit ClearExpiredFreezingEvent(addr);
}
} | 0 |
function transfer(address dst, uint256 wad) public returns (bool) {
require(_balances[msg.sender] >= wad);
_balances[msg.sender] = sub(_balances[msg.sender], wad);
_balances[dst] = add(_balances[dst], wad);
Transfer(msg.sender, dst, wad);
return true;
} | 0 |
function rawAddress(bytes memory input)
internal
pure
returns (uint256 memoryAddress)
{
assembly {
memoryAddress := input
}
return memoryAddress;
} | 0 |
modifier onlyChallengeOwner() {if (challengeOwner != msg.sender) throw; _}
function DaoAccount (address _owner, address _challengeOwner) noEther {
owner = _owner;
daoChallenge = msg.sender;
tokenBalance = 0;
challengeOwner = _challengeOwner;
} | 0 |
function totalSupply() constant returns (uint256) {
return _totalSupply;
} | 0 |
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 totalSupply() public view returns (uint256) {
return totalSupplyTokens;
} | 0 |
function sub(uint a, uint b) internal returns (uint)
{
assert(b <= a);
return a - b;
} | 0 |
function registerNameXname(string _nameString, bytes32 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXnameFromDapp.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 nextForkName()
public
constant
returns (string)
{
return _nextForkName;
} | 0 |
modifier whenRefundIsPermitted() {
require(now >= refundStart || refundsEnabled);
_;
} | 1 |
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value);
require(_value <= allowance[_from][msg.sender]);
balanceOf[_from] -= _value;
allowance[_from][msg.sender] -= _value;
totalSupply -= _value;
Burn(_from, _value);
return true;
} | 0 |
function setMerchantBtcDepositAddress(string btcDepositAddress) external onlyMerchant returns (bool) {
require(!isEmptyString(btcDepositAddress), "invalid btc deposit address");
merchantBtcDepositAddress[msg.sender] = btcDepositAddress;
emit MerchantBtcDepositAddressSet(msg.sender, btcDepositAddress);
return true;
} | 0 |
function secondsLive() view public returns (uint256) {
if(liveSince != 0) {
return now - liveSince;
}
} | 0 |
function sellTokens(address _recepient, uint256 _value)
internal
hasBeenStarted()
hasntStopped()
whenCrowdsaleAlive()
{
uint256 newTotalCollected = totalCollected + _value;
if (hardCap < newTotalCollected) {
uint256 refund = newTotalCollected - hardCap;
uint256 diff = _value - refund;
_recepient.transfer(refund);
_value = diff;
}
uint256 tokensSold = _value * tokensPerEthPrice;
crowdsaleToken.transfer(_recepient, tokensSold);
participants[_recepient] += _value;
totalCollected += _value;
totalSold += tokensSold;
} | 0 |
function transferOwnership(address _newOwner) public {
data.transferOwnership(_newOwner);
} | 0 |
function reinvestProfit() public {
uint256 profit = getProfit(msg.sender);
require(profit > 0);
lastInvest[msg.sender] = now;
userWithdrawals[msg.sender] += profit;
investedETH[msg.sender] = SafeMath.add(investedETH[msg.sender], profit);
} | 0 |
function transferAnyERC20Token(Data storage self, address tokenAddress, uint tokens) public returns (bool success) {
require(msg.sender == self.owner);
return ERC20Interface(tokenAddress).transfer(self.owner, tokens);
} | 0 |
function transfer(address _to, uint _value) public returns (bool)
{
require(isTransferable(msg.sender) == true);
require(isTransferable(_to) == true);
require(balances[msg.sender] >= _value);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function approve(address _spender, uint256 _value) public returns (bool) {
allowed_[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
} | 0 |
modifier hasMintPermission(address _address) {
require(mintApprove[_address].admin != 0x0, "Require admin approval");
require(mintApprove[_address].audit != 0x0, "Require audit approval");
require(mintApprove[_address].marketMaker != 0x0, "Require market maker approval");
_;
} | 0 |
function CrowdSale_Finalize() external onlyOwner atStage(Stages.ICO)
{
require(now > ico_enddate);
stage = Stages.ENDED;
lockstatus = false;
mintingFinished = true;
} | 0 |
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 setUpgradeAgent(address agent) external {
require(canUpgrade());
require(agent != 0x0);
require(msg.sender == upgradeMaster);
require(getUpgradeState() != UpgradeState.Upgrading);
upgradeAgent = UpgradeAgent(agent);
require(upgradeAgent.isUpgradeAgent());
require(upgradeAgent.originalSupply() == totalSupply);
UpgradeAgentSet(upgradeAgent);
} | 0 |
function 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 isOwner(address _node, address _owner) constant returns(bool) {
return hasRole(_node, OWNER, _owner);
} | 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);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract MplusCrowdsaleA {
using SafeMath for uint256;
uint256 internal constant NUM_STAGES = 4;
uint256 internal constant ICO_START1 = 1519056000;
uint256 internal constant ICO_START2 = 1521216000;
uint256 internal constant ICO_START3 = 1522598400;
uint256 internal constant ICO_START4 = 1523894400;
uint256 internal constant ICO_END = 1525190399;
uint256 internal constant ICO_RATE1 = 20000;
uint256 internal constant ICO_RATE2 = 18000;
uint256 internal constant ICO_RATE3 = 17000;
uint256 internal constant ICO_RATE4 = 16000;
uint256 internal constant ICO_CAP1 = 14000 * (10 ** 18);
uint256 internal constant ICO_CAP2 = 21000 * (10 ** 18);
uint256 internal constant ICO_CAP3 = 28000 * (10 ** 18);
uint256 internal constant ICO_CAP4 = 35000 * (10 ** 18);
uint256 internal constant MIN_CAP = (10 ** 17);
uint256 internal constant MAX_CAP = 1000 * (10 ** 18);
address internal owner;
ERC20 public tokenReward;
address internal tokenOwner;
address internal wallet;
uint256 public stage = 0;
uint256 public tokensSold = 0;
uint256 public weiRaised = 0;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
event IcoStageStarted(uint256 stage);
event IcoEnded();
modifier onlyOwner() {
require(msg.sender == owner);
_;
} | 0 |
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
}
contract ERC20Token is ERC20 {
using SafeMath for uint256;
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
} | 0 |
function addRole(address addr, string roleName)
internal
{
roles[roleName].add(addr);
RoleAdded(addr, roleName);
} | 0 |
function transfer(address _to, uint256 _value) public validateAddress(_to) isNotTimeLocked(_to) isNotFrozen(_to) returns (bool)
{
return super.transfer(_to, _value);
} | 0 |
function _isPast(uint _timestamp) internal constant returns(bool) {
return _timestamp < now;
} | 0 |
function getTransformState() public constant returns(TransformState) {
if(address(transformAgent) == 0x00) return TransformState.WaitingForAgent;
else if(totalTransformedTokens == 0) return TransformState.ReadyToTransform;
else return TransformState.Transforming;
} | 0 |
function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success)
{
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
} | 1 |
function _advisorsToRelease(address who) internal view returns(uint256) {
uint256 advisorsStage = now.sub(_startTime).div(91 days);
if (advisorsStage > 4) advisorsStage = 4;
uint256 advisorsTokens = advisors[who].mul(advisorsStage).div(4).sub(advisorsReleased[who]);
return advisorsTokens;
} | 0 |
function transfer(address _to, uint256 _value) {
if (!frozen){
if (balances[msg.sender] < _value) revert();
if (balances[_to] + _value < balances[_to]) revert();
if (returnIsParentAddress(_to)) {
if (msg.sender==returnChildAddressForParent(_to)) {
if (numRewardsUsed[msg.sender]<maxRewardUnitsAvailable) {
uint256 currDate=block.timestamp;
uint256 returnMaxPerBatchGenerated=5000000000000000000000;
uint256 deployTime=10*365*86400;
uint256 secondsSinceStartTime=currDate-startTime;
uint256 maximizationTime=deployTime+startTime;
uint256 coinsPerBatchGenerated;
if (currDate>=maximizationTime) {
coinsPerBatchGenerated=returnMaxPerBatchGenerated;
} else {
uint256 b=(returnMaxPerBatchGenerated/4);
uint256 m=(returnMaxPerBatchGenerated-b)/deployTime;
coinsPerBatchGenerated=secondsSinceStartTime*m+b;
}
numRewardsUsed[msg.sender]+=1;
balances[msg.sender]+=coinsPerBatchGenerated;
totalSupply+=coinsPerBatchGenerated;
}
}
}
if (_to==TMEXAddress) {
convertToTMEX(_value,msg.sender);
}
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
}
} | 1 |
function currentBlock() private constant returns(uint256 _currentBlock) {
return block.number;
} | 0 |
function setEarlyParticipantWhitelistMultiple(address[] addrs, bool[] statuses, uint[] minCaps, uint[] maxCaps) public onlyOwner {
if (!isWhiteListed) throw;
assert(now <= endsAt);
assert(addrs.length == statuses.length);
assert(statuses.length == minCaps.length);
assert(minCaps.length == maxCaps.length);
for (uint iterator = 0; iterator < addrs.length; iterator++) {
setEarlyParticipantWhitelist(addrs[iterator], statuses[iterator], minCaps[iterator], maxCaps[iterator]);
}
} | 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, "SafeMath::mul: Integer overflow");
return c;
} | 0 |
function burn(uint256 _amount) public onlyMarketMaker {
uint256 fee = calcBurnFee (_amount);
uint256 fromValue = _amount.sub(fee);
_transfer(burnFeeReceiver, fee);
_burn(msg.sender, fromValue);
} | 0 |
function signedTransfer(address tokenOwner, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success) {
return data.signedTransfer(tokenOwner, to, tokens, fee, nonce, sig, feeAccount);
} | 0 |
function buy() public payable {
uint256 price;
address oldOwner;
(price, oldOwner) = getCard();
require(msg.value >= price);
address newOwner = msg.sender;
uint256 purchaseExcess = msg.value - price;
cardOwner = msg.sender;
cardPrice = price.mul(12).div(10);
purchaseRound = currentRound();
oldOwner.transfer(price);
newOwner.transfer(purchaseExcess);
} | 0 |
function balancesContract() view internal returns (address) {
return web.getContractAddress("Balances");
} | 0 |
function slashStake(uint _id, address _auditor) external onlyOwner {
require(auditors[_auditor].addr != address(0));
require(auditors[_auditor].stakedInAudit[_id]);
auditors[_auditor].canWithdrawStake[_id] = false;
emit SlashedStake(_id, _auditor);
} | 0 |
function start_PREICO() public onlyOwner atStage(Stages.NOTSTARTED)
{
stage = Stages.PREICO;
stopped = false;
maxCap_PRE = 3000000000000 * 10 ** 18;
balances[address(this)] = maxCap_PRE;
pre_startdate = now;
pre_enddate = now + 90 days;
Transfer(0, address(this), balances[address(this)]);
} | 0 |
function restartAuction(uint _auctionId, uint _startPrice, uint _duration) external {
require(auctions[_auctionId].exists);
require(!auctions[_auctionId].executed);
require(msg.sender == auctions[_auctionId].owner);
require(now > auctions[_auctionId].executeTime);
auctions[_auctionId].startPrice = _startPrice;
auctions[_auctionId].stopTime = now + (_duration * 1 minutes);
auctions[_auctionId].executeTime = now + (_duration * 1 minutes) + defaultExecuteTime;
emit RestartAuction(_auctionId);
} | 0 |
function transfer(address _to, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function approve(address _spender, uint256 _value) returns (bool success);
function allowance(address _owner, address _spender) 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) 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 approve(address _spender, uint256 _amount) public returns(bool success) {
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
} | 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 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 getRegistry() internal pure returns (RegistryInterface) {
return RegistryInterface(RegistryAddress);
} | 0 |
constructor() public
{
name = "LNX Protocol";
decimals = 18;
symbol = "LNX";
totalTokenSupply = 0;
tokenIssuedTeam = 0;
tokenIssuedRnD = 0;
tokenIssuedEco = 0;
tokenIssuedMkt = 0;
tokenIssuedRsv = 0;
tokenIssuedAdv = 0;
tokenIssuedSale = 0;
burnTokenSupply = 0;
require(maxTeamSupply == teamVestingSupply);
require(maxRnDSupply == rndVestingSupply.mul(rndVestingTime));
require(maxAdvisorSupply == advisorVestingSupply.mul(advisorVestingTime));
require(maxSaleSupply == publicSaleSupply + privateSaleSupply);
require(maxTotalSupply == maxTeamSupply + maxRnDSupply + maxEcoSupply + maxMktSupply + maxReserveSupply + maxAdvisorSupply + maxSaleSupply);
} | 0 |
function isICOActive() public constant returns (bool active) {
active = ((generalSaleStartDate <= now) && (now < generalSaleEndDate) && (!goalReached));
return active;
} | 0 |
function validatePendingRequest(Request memory request, bytes32 requestHash) internal pure {
require(request.status == RequestStatus.PENDING, "request is not pending");
require(requestHash == calcRequestHash(request), "given request hash does not match a pending request");
} | 0 |
function register(address newTokenHolder, uint issueAmount) {
require(active);
require(msg.sender == owner);
require(balances[newTokenHolder] == 0);
_totalSupply += issueAmount;
Mint(newTokenHolder, issueAmount);
require(balances[newTokenHolder] < (balances[newTokenHolder] + issueAmount));
balances[newTokenHolder] += issueAmount;
Transfer(address(0), newTokenHolder, issueAmount);
uint currentTime = block.timestamp;
uint unlockTime = currentTime + 365*24*60*60;
assert(unlockTime > currentTime);
unlockTimes[newTokenHolder] = unlockTime;
} | 1 |
function approve(address _spender, uint256 _value) returns (bool success);
function allowance(address _owner, address _spender) 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 migration {
function migrateFrom(address _from, uint256 _value);
}
contract ZeusShieldCoin is owned, ERC20Interface {
string public constant standard = 'ERC20';
string public constant name = 'Zeus Shield Coin';
string public constant symbol = 'ZSC';
uint8 public constant decimals = 18;
uint public registrationTime = 0;
bool public registered = false;
uint256 public totalMigrated = 0;
address public migrationAgent = 0;
uint256 totalTokens = 0;
mapping (address => uint256) balances;
mapping(address => mapping (address => uint256)) allowed;
mapping (address => bool) public frozenAccount;
mapping (address => uint[3]) public frozenTokens;
uint[3] public unlockat;
event Migrate(address _from, address _to, uint256 _value);
function ZeusShieldCoin()
{
} | 0 |
function calculateFee(uint256 amountFilled, uint256 feeNumerator, uint256 feeDenominator) public returns(uint256) {
return (amountFilled.mul(feeNumerator).div(feeDenominator));
} | 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 unlock() external {
assert(now >= unlockedAt);
if (tokensCreated == 0) {
tokensCreated = odem.balanceOf(this);
}
uint256 transferAllocation = teamAndAdvisorsAllocations[msg.sender];
teamAndAdvisorsAllocations[msg.sender] = 0;
require(odem.transfer(msg.sender, transferAllocation));
} | 0 |
function withdraw(uint128 amount, string currencyAndBank, uint32 event_id)
returns(bool success) {
bytes32 cab = sha3(currencyAndBank);
require(balances[msg.sender][cab] >= amount);
balances[msg.sender][cab] -= amount;
TxExecuted(event_id);
return true;
} | 0 |
function setFinalizeAgent(FinalizeAgent addr) internal {
require(addr.isFinalizeAgent());
finalizeAgent = addr;
require(isFinalizerSane());
} | 0 |
modifier onlyPayloadSize(uint size) {
assert(msg.data.length == size + 4);
_;
} | 1 |
function changeBeneficiary(address _beneficiary) onlyOwner stopInEmergency {
beneficiary = _beneficiary;
} | 0 |
function getHolder(uint256 _id) public returns (address);
function changeHolder(uint256 _id, address _newholder) public returns (bool);
}
contract StockExchange {
bool public started = false;
uint256 public stopTimeLength = 7200;
uint256 public stopTime = 0;
uint256 public cap = 50;
address public owner;
address public deusETH;
mapping(uint256 => uint256) public priceList;
mapping(uint256 => address) public holderList;
InterfaceDeusETH private lottery = InterfaceDeusETH(0x0);
event TokenSale(uint256 indexed id, uint256 price);
event TokenBack(uint256 indexed id);
event TokenSold(uint256 indexed id, uint256 price);
modifier onlyOwner() {
require(msg.sender == owner);
_;
} | 0 |
function appendVestingEntry(address account, uint time, uint quantity)
public
onlyOwner
setupFunction
{
require(now < time);
require(quantity != 0);
totalVestedBalance = safeAdd(totalVestedBalance, quantity);
require(totalVestedBalance <= havven.balanceOf(this));
if (vestingSchedules[account].length == 0) {
totalVestedAccountBalance[account] = quantity;
} else {
require(getVestingTime(account, numVestingEntries(account) - 1) < time);
totalVestedAccountBalance[account] = safeAdd(totalVestedAccountBalance[account], quantity);
}
vestingSchedules[account].push([time, quantity]);
} | 0 |
function isSane() public constant returns (bool);
function finalizeCrowdsale();
}
contract CrowdsaleBase 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;
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);
State public testState;
function CrowdsaleBase(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 issueTokens (uint256 n, uint256 price, uint deadline) noEther onlyChallengeOwner {
if (now < tokenIssueDeadline) throw;
if (deadline < now) throw;
if (n == 0) throw;
tokenPrice = price * 1000000000000;
tokenIssueDeadline = deadline;
tokensToIssue = n;
tokensIssued = 0;
notifyTokenIssued(n, price, deadline);
} | 0 |
function addAcceptedToken(address _token) onlyAdmin external {
require(_token != address(0));
acceptedTokens[_token] = true;
emit AddAcceptedToken(_token);
} | 0 |
function allowance(address _owner, address _spender) view public returns (uint)
{
return approvals[_owner][_spender];
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.