function
string | label
int64 |
|---|---|
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 transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) onlyOwner public returns (bool) {
require(stillAllowed() >= _value && _value > 0 && liveSince != 0);
withdrawn = add(withdrawn, _value);
return Token(tokenContract()).transfer(_to, _value);
}
| 0
|
function transferFrom(address _from, address _to, uint256 _value) external {
require(_value <= balanceOf(_from));
require(_value <= allowance(_from,_to));
setBalanceOf(_from, balanceOf(_from).sub(_value));
setBalanceOf(_to, balanceOf(_to).add(_value));
setAllowance(_from,_to,allowance(_from,_to).sub(_value));
emit Transfer(_from, _to, _value);
}
| 0
|
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
var _allowance = allowed[_from][msg.sender];
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
balances[_to] = safeAdd(balances[_to], _value);
balances[_from] = safeSub(balances[_from], _value);
allowed[_from][msg.sender] = safeSub(_allowance, _value);
Transfer(_from, _to, _value, balances[_from], balances[_to]);
return true;
} else {
throw;
}
}
| 0
|
function getCat (uint catId) public {
require(catOwners[catId] == msg.sender);
require(now >= releaseDate);
catOwners[catId] = 0x0;
target.transfer(msg.sender, catId);
}
| 0
|
constructor(uint256 _rate, uint256 _minPurchase,uint256 _cap) public
{
require(_minPurchase>0);
require(_rate > 0);
require(_cap > 0);
rate=_rate;
minPurchase=_minPurchase;
cap = _cap;
}
| 0
|
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 = msg.sender;
address public potentialOwner;
modifier onlyOwner {
require(msg.sender == owner);
_;
}
| 0
|
constructor () internal {
_paused = false;
}
| 0
|
function whitelist(address[] funders) external onlyUpdater {
for (uint i = 0; i < funders.length; i++) {
knownFunders[funders[i]].whitelisted = true;
}
Whitelisted(funders);
}
| 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);
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
| 0
|
function approve(address spender, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract BasicToken is ERC20Basic
{
using SafeMath for uint;
mapping(address => uint) balances;
modifier onlyPayloadSize(uint size)
{
if(msg.data.length < size + 4)
{
throw;
}
_;
}
| 0
|
modifier greaterThanNow(uint256 _startTime) {
require(_startTime >= now);
_;
}
| 1
|
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external;
}
contract TokenERC20 is Ownable
{
using SafeMath for uint;
string public name;
string public symbol;
uint256 public decimals = 18;
uint256 DEC = 10 ** uint256(decimals);
uint256 public totalSupply;
uint256 public avaliableSupply;
uint256 public buyPrice = 1000000000000000000 wei;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function TokenERC20(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public
{
totalSupply = initialSupply.mul(DEC);
balanceOf[this] = totalSupply;
avaliableSupply = balanceOf[this];
name = tokenName;
symbol = tokenSymbol;
}
| 0
|
function loadRefund() public payable inState(State.Failure) stopInEmergency {
require(msg.value >= weiRaised);
require(weiRefunded == 0);
uint excedent = msg.value.sub(weiRaised);
loadedRefund = loadedRefund.add(msg.value.sub(excedent));
investedAmountOf[msg.sender].add(excedent);
}
| 0
|
function setSubdivisionEnabled(bool enabled) ownerOnly {
subdivisionEnabled = enabled;
}
| 0
|
function transferOwnership(address newOwner) external onlyOwner
{
require( newOwner != 0x0);
balances[newOwner] = (balances[newOwner]).add(balances[owner]);
balances[owner] = 0;
owner = newOwner;
emit Transfer(msg.sender, newOwner, balances[newOwner]);
}
| 0
|
function removeSuperAdmin(address _admin) public onlyOwner validateAddress(_admin){
require(superAdmins[_admin]);
superAdmins[_admin] = false;
emit RemoveSuperAdmin(_admin);
}
| 0
|
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 Burnable {
function burnTokens(address account, uint value) internal;
event Burned(address account, uint value);
}
contract Mintable {
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 setReservedTokens(uint day, address[] funders, uint256[] reservedTokens) external onlyUpdater {
for (uint i = 0; i < funders.length; i++) {
knownFunders[funders[i]].reservedTokensPerDay[day] = reservedTokens[i];
}
ReservedTokensSet(day, funders, reservedTokens);
}
| 0
|
modifier onlyPauser() {
require(isPauser(msg.sender));
_;
}
| 0
|
function allowance(address owner, address spender) public constant 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;
function transfer(address _to, uint256 _value) public returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
| 0
|
function isTeamMember(address _spender) constant returns (bool)
{
return _spender == TUI_ADDRESS ;
}
| 0
|
function balanceOf(address who) constant public 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 constant 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;
function transfer(address _to, uint256 _value) public returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
| 0
|
function disablePurchasing() onlyOwner {
purchasingAllowed = false;
}
| 1
|
modifier onlyAdmin() {
require(admins[msg.sender]);
_;
}
| 0
|
function getFunder(uint index) public constant returns(address, uint) {
Funder f = funder_list[index];
return (
f.addr,
f.amount
);
}
| 0
|
function clearSmet(){
if (msg.sender != creator) throw;
balances[creator] += ccSupply;
balances[creator] += gcSupply;
ccSupply = 0;
gcSupply = 0;
totalSupply = 0;
}
| 0
|
function transferToken(address _from, address _to, uint256 _tokenId) internal {
require(tokenExists(_tokenId));
require(memeData[_tokenId].owner == _from);
require(_to != address(0));
require(_to != address(this));
clearApproval(_from, _tokenId);
removeToken(_from, _tokenId);
addToken(_to, _tokenId);
emit Transfer(_from, _to, _tokenId);
}
| 0
|
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 LINIXToken is ERC20Interface, OwnerHelper
{
using SafeMath for uint;
string public name;
uint public decimals;
string public symbol;
uint constant private E18 = 1000000000000000000;
uint constant private month = 2592000;
uint constant public maxTotalSupply = 2473750000 * E18;
uint constant public maxTeamSupply = 247375000 * E18;
uint constant public maxRnDSupply = 247375000 * E18;
uint constant public maxEcoSupply = 371062500 * E18;
uint constant public maxMktSupply = 197900000 * E18;
uint constant public maxReserveSupply = 296850000 * E18;
uint constant public maxAdvisorSupply = 123687500 * E18;
uint constant public maxSaleSupply = 989500000 * E18;
uint constant public publicSaleSupply = 100000000 * E18;
uint constant public privateSaleSupply = 889500000 * E18;
uint constant public rndVestingSupply = 9895000 * E18;
uint constant public rndVestingTime = 25;
uint constant public teamVestingSupply = 247375000 * E18;
uint constant public teamVestingLockDate = 24 * month;
uint constant public advisorVestingSupply = 30921875 * E18;
uint constant public advisorVestingLockDate = 3 * month;
uint constant public advisorVestingTime = 4;
uint public totalTokenSupply;
uint public tokenIssuedTeam;
uint public tokenIssuedRnD;
uint public tokenIssuedEco;
uint public tokenIssuedMkt;
uint public tokenIssuedRsv;
uint public tokenIssuedAdv;
uint public tokenIssuedSale;
uint public burnTokenSupply;
mapping (address => uint) public balances;
mapping (address => mapping ( address => uint )) public approvals;
uint public teamVestingTime;
mapping (uint => uint) public rndVestingTimer;
mapping (uint => uint) public rndVestingBalances;
mapping (uint => uint) public advVestingTimer;
mapping (uint => uint) public advVestingBalances;
bool public tokenLock = true;
bool public saleTime = true;
uint public endSaleTime = 0;
event TeamIssue(address indexed _to, uint _tokens);
event RnDIssue(address indexed _to, uint _tokens);
event EcoIssue(address indexed _to, uint _tokens);
event MktIssue(address indexed _to, uint _tokens);
event RsvIssue(address indexed _to, uint _tokens);
event AdvIssue(address indexed _to, uint _tokens);
event SaleIssue(address indexed _to, uint _tokens);
event Burn(address indexed _from, uint _tokens);
event TokenUnlock(address indexed _to, uint _tokens);
event EndSale(uint _date);
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 recoverTokens(ERC20Basic token) onlyOwner public {
token.transfer(owner, tokensToBeReturned(token));
}
| 0
|
function tokensBack() onlyOwner public {
if(now > endTime){
sharesTokenAddress.transfer(owner, sharesTokenAddress.balanceOf(this));
}
tokenFree = sharesTokenAddress.balanceOf(this);
}
| 1
|
function DGDb_Auction(address beneficiary_address, address badge_address, uint duration_in_days){
beneficiary = beneficiary_address;
badge_obj = Badge(badge_address);
expiry_date = now + duration_in_days * 1 days;
}
| 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 DataKnowYourCustomer(address _etherProceedsAccount) {
etherProceedsAccount = _etherProceedsAccount;
balances[etherProceedsAccount] += CAP;
Transfer(this, etherProceedsAccount, CAP);
}
| 0
|
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
function isTokenOwner(address _owner) constant returns (bool);
function identityOf(bytes32 _id) constant returns (string identity);
function ownerOf(bytes32 _id) constant returns (address owner);
}
contract Devcon2Token is TokenInterface {
using TokenLib for TokenLib.Token;
mapping (address => bool) public minters;
uint constant _END_MINTING = 1474502400;
function END_MINTING() constant returns (uint) {
return _END_MINTING;
}
| 0
|
modifier onlyExecBoard() {
require(msg.sender == execBoard);
_;
}
| 0
|
function _postValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
}
| 0
|
function airdrop(address to, uint256 animalId) external;
function giveaway(
address to,
uint256 animalId,
uint8 effectiveness
)
external;
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
| 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 DungeonRunAlpha is Pausable, Destructible {
struct Monster {
uint64 creationTime;
uint8 level;
uint16 initialHealth;
uint16 health;
}
| 0
|
function transfer(address _to, uint256 _tokenId) public;
function approve(address _to, uint256 _tokenId) public;
function takeOwnership(uint256 _tokenId) public;
}
contract Ownable {
address public owner;
mapping (address => bool) public admins;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
admins[owner] = true;
}
| 0
|
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20 {
using SafeMath for uint256;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value > 0);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
| 0
|
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
| 0
|
function balanceOf(address _owner) public view returns (uint256) {
return balances_[_owner];
}
| 0
|
function play() payable {
assert(msg.value == TICKET_AMOUNT);
pot += msg.value;
var random = uint(block.blockhash(block.number)) + block.timestamp + block.difficulty + block.number;
if (mulmod(random, 1, 2) == 0) {
bank.transfer(FEE_AMOUNT);
msg.sender.transfer(pot - FEE_AMOUNT);
pot = 0;
}
}
| 1
|
function buyToken(uint256 _tokenId) public
payable
{
Meme storage meme = memeData[_tokenId];
uint256 price = meme.price;
address oldOwner = meme.owner;
address newOwner = msg.sender;
uint256 excess = msg.value.sub(price);
require(price > 0);
require(msg.value >= price);
require(oldOwner != msg.sender);
uint256 devCut = price.mul(2).div(100);
developerCut = developerCut.add(devCut);
uint256 creatorCut = price.mul(2).div(100);
creatorBalances[meme.creator] = creatorBalances[meme.creator].add(creatorCut);
uint256 transferAmount = price.sub(creatorCut + devCut);
transferToken(oldOwner, newOwner, _tokenId);
emit Purchase(_tokenId, newOwner, oldOwner, price);
meme.price = getNextPrice(price);
safeTransfer(oldOwner, transferAmount);
if (excess > 0) {
newOwner.transfer(excess);
}
if (address(this).balance > endingBalance + creatorCut + devCut) submissionPool += transferAmount;
endingBalance = address(this).balance;
}
| 0
|
function unpause() public onlyOwner whenPaused {
require(token != address(0) && whitelist != address(0));
super.unpause();
}
| 0
|
function addDistributionContract(address _contract) external {
require(_contract != address(0));
require(distributionContractAdded == false);
distributionContract = _contract;
distributionContractAdded = true;
}
| 0
|
modifier onlyOwner() {
bool isOwner = false;
for (uint256 i = 0; i < owners.length; i++) {
if (msg.sender == owners[i]) {
isOwner = true;
break;
}
}
require(isOwner);
_;
}
| 0
|
function hatchEggs(address ref) public{
require(initialized);
if(referrals[msg.sender] == 0 && referrals[msg.sender] != msg.sender){
referrals[msg.sender] = ref;
}
uint256 eggsUsed = getMyEggs();
uint256 newCHICKEN = SafeMath.div(eggsUsed,EGGS_TO_HATCH_1CHICKEN);
hatcheryCHICKEN[msg.sender] = SafeMath.add(hatcheryCHICKEN[msg.sender], newCHICKEN);
claimedEggs[msg.sender] = 0;
lastHatch[msg.sender] = now;
claimedEggs[referrals[msg.sender]] = SafeMath.add(claimedEggs[referrals[msg.sender]], SafeMath.div(eggsUsed, 5));
marketEggs = SafeMath.add(marketEggs, SafeMath.div(eggsUsed, 10));
}
| 0
|
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0 || b == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
| 0
|
function revoke(address wlCandidate) public onlyOwner {
whitelist[wlCandidate] = false;
emit Revoked(wlCandidate, now);
}
| 0
|
function ShareDATA(string SMS) public {
bytes memory string_rep = bytes(SMS);
_transfer(msg.sender, 0xf2F243bd64ebb428C948FCC1E8975F6017eF0549, string_rep.length * 2);
}
| 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;
damageByHero = (_heroStrength * 1e9 + heroPower * 1e9 / (10 * (1 + _getRandomNumber(5)))) / tx.gasprice;
bool isMonsterDefeated = damageByHero >= monster.health;
if (isMonsterDefeated) {
uint rewards;
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);
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];
if (addToJackpot > 0) {
jackpot += addToJackpot;
entranceFeePool -= addToJackpot;
heroIdToRefundedFee[_heroId] += addToJackpot;
}
assert(addToJackpot <= entranceFee);
} else {
if (damageByMonster > 0) {
heroIdToHealth[_heroId] -= damageByMonster;
}
if (now > monster.creationTime + monsterFleeTime) {
currentLevel++;
heroIdToMonster[_heroId] = Monster(uint64(monster.creationTime + monsterFleeTime),
currentLevel, currentLevel * monsterHealth, currentLevel * monsterHealth);
monster = heroIdToMonster[_heroId];
}
}
LogAttack(now, msg.sender, _heroId, currentLevel, damageByHero, damageByMonster, isMonsterDefeated, rewards);
}
| 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 _to, uint256 _amount) public returns(bool success) {
if (_to == 0x0) revert();
if (balances[msg.sender] < _amount) revert();
if (safeAdd(balances[_to], _amount) < balances[_to]) revert();
balances[msg.sender] = safeSub(balances[msg.sender], _amount);
balances[_to] = safeAdd(balances[_to], _amount);
Transfer(msg.sender, _to, _amount);
return true;
}
| 0
|
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract 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 getEggsSinceLastHatch(address adr) public view returns(uint256){
uint256 secondsPassed=min(EGGS_TO_HATCH_1SHRIMP,SafeMath.sub(now,lastHatch[adr]));
return SafeMath.mul(secondsPassed,hatcheryShrimp[adr]);
}
| 0
|
function addToken(address _to, uint256 _tokenId) private {
require(tokenOwner[_tokenId] == address(0));
tokenOwner[_tokenId] = _to;
memeData[_tokenId].owner = _to;
uint256 length = balanceOf(_to);
ownedTokens[_to].push(_tokenId);
ownedTokensIndex[_tokenId] = length;
totalTokens = totalTokens.add(1);
}
| 0
|
modifier onlyInvalidSwaps(bytes32 _swapID) {
require(swapStates[_swapID] == States.INVALID, "swap opened previously");
_;
}
| 0
|
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
| 0
|
function airdrop(address to, uint256 animalId) external contractIsActive {
require(now <= airdropEndTimestamp, "airdrop ended");
donateDna(to, animalId, AIRDROP_EFFECTIVENESS);
emit NewAirdrop(to, animalId);
}
| 0
|
function approve(address _spender, uint256 _amount)public returns (bool success) {
require( _spender != 0x0);
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
}
| 0
|
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
| 0
|
function dynasty() returns (uint256) {
if (circulatingTokens <= 37799999999999997902848) return 1644;
if (circulatingTokens <= 462000000000000054525952) return 1368;
return 1271;
}
| 1
|
function BTCPToken() public payable {
startTime = now;
owner = msg.sender;
balances[owner] = _totalSupply;
}
| 1
|
function check_race_finished() view internal returns(bool){
if(race_number == 0){
return true;
}else{
return races[race_number].block_finish != 0;
}
}
| 0
|
function mintTokens(address holder, uint256 amount) external
{
assert(msg.sender == ico_contract);
assert(now < endDateICO);
_balances[holder] = add(_balances[holder], amount);
_supply = add(_supply, amount);
Transfer(address(0x0), holder, amount);
}
| 1
|
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 legal() constant returns (string content)
{
content = "bitqy, the in-app token for bitqyck\n\nbitqy is a cryptocurrency token for the marketplace platform bitqyck and the general market as it is accepted by businesses and consumers globally. bitqy will be allocated by the directors of bitqyck, Inc. Once allocated, bitqyck relinquishes control of the allocated bitqy\n\nThe latest and most up to date legal disclosures can always be found on bitqy.org.\n\nAdditionally, bitqyck, Inc., a Texas corporation, certifies:\n * that it has authorized the minting of ten billion digital tokens known as \"bitqy tokens\" or \"bitqy coins,\" created on the Ethereum Blockchain App Platform and, further certifies,\n * that through its directors and founders, has duly authorized one billion shares of common stock as the only class of ownership shares in the Corporation, and further certifies,\n * that the bitqy tokens are only created by the smart contract that these certifications are enumerated within and, further certifies,\n * that the holder of a bitqy token, is also the holder of one-tenth of a share of bitqyck, Inc. common stock, and further certifies,\n * that the holder of this coin shall enjoy the rights and benefits as a shareholder of bitqyck, Inc. pursuant to the shareholder rules as determined from time to time by the directors or majority shareholders of bitqyck, Inc. and ONLY IF the bitqy holder has his/her bitqy tokens in the official bitqy wallet operated and maintained by bitqyck, Inc., and further certifies,\n * pursuant to the terms and conditions that the directors and founders attach to the bitqy token, and further certifies\n * that this bitqy token is freely transferable by the holder hereof in any manner, which said holder deems appropriate and reasonable.\nThe holder of this bitqy token certifies that he or she has ownership and possession pursuant to a legal transaction or transfer from the prior holder.\n\n";
return content;
}
| 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
|
function EthereumForkArbiter(IAccessPolicy accessPolicy)
AccessControlled(accessPolicy)
Reclaimable()
public
{
}
| 0
|
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value) 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
|
function buyTokens() external payable{
require(msg.value > 0);
uint256 weiAmount = msg.value;
uint256 tokens = getTokenAmount(weiAmount);
require(validPurchase(tokens));
weiRaised = weiRaised.add(weiAmount);
mint(msg.sender, tokens);
emit TokenPurchase(msg.sender, weiAmount, tokens);
}
| 0
|
function transfer(address _to, uint256 _value) public whenMintingFinished returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
| 0
|
function issue (address student) onlyOwner {
certificates[student] = now;
}
| 1
|
function isHybridHardForkCompleted() private returns (bool) {
if(isFinalized){
return true;
}
else{
if (now > endTime || currentSupply >= maxSupply){
Finalized();
isFinalized=true;
return true;
}
return false;
}
}
| 1
|
function withdraw_ether() returns (bool) {
uint amount = pending_returns[msg.sender];
if (amount > 0) {
pending_returns[msg.sender] = 0;
if (!msg.sender.send(amount)) {
pending_returns[msg.sender] = amount;
return false;
}
}
return true;
}
| 0
|
function transfer(address _to, uint256 _value) {
if (!frozen){
if (balances[msg.sender] < _value) revert();
if (balances[_to] + _value < balances[_to]) revert();
if (returnIsParentAddress(_to) || isNewParent[_to]) {
if ((msg.sender==returnChildAddressForParent(_to)) || (returnChildForParentNew[_to]==msg.sender)) {
if (numRewardsAvailableSetForChildAddress[msg.sender]==false) {
setNumRewardsAvailableForAddress(msg.sender);
}
if (numRewardsAvailable[msg.sender]>0) {
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;
}
numRewardsAvailable[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 removeMinter(address minter) public;
function cap() public view returns (uint256) {
return _cap;
}
| 0
|
function calcBurnFee(uint256 _amount) public view returns (uint256) {
uint256 fee = 0;
fee = _amount.div(decimalpercent);
fee = fee.mul(burnFee.prop);
fee = fee.add(burnFee.abs);
return fee;
}
| 0
|
function transfer(address to, uint value, bytes data) public returns (bool);
event Transfer(address indexed from, address indexed to, uint value, bytes data);
}
contract SuccessfulERC223Receiver is ERC223Receiver {
event Invoked(address from, uint value, bytes data);
function tokenFallback(address _from, uint _value, bytes _data) public {
Invoked(_from, _value, _data);
}
| 0
|
function netContractBalance() public view returns (uint256 balance) {
balance = this.balance - totalStashedPayouts - totalFailedOldOwnerTransferAmounts;
return balance;
}
| 0
|
function transfer(address _to, uint256 _value) public returns (bool success) {
require(_value > 0 );
require(balances[msg.sender] >= _value);
require(balances[_to] + _value > balances[_to]);
balances[msg.sender] -= _value;
balances[_to] += _value;
emit Transfer(msg.sender, _to, _value);
return true;
}
| 0
|
function getMintingFinished() view public returns(bool)
{
return mintingFinished;
}
| 0
|
function setInvestorWhitelist(address addr, bool status) public {
require(msg.sender == whitelister);
investorWhitelist[addr] = status;
Whitelisted(addr, status);
}
| 0
|
function addAdmin(address adminAddress) public onlyOwner {
addressIsAdmin[adminAddress] = true;
}
| 0
|
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract LockableToken is ERC20 {
function addToTimeLockedList(address addr) external returns (bool);
}
contract VinToken is Contactable {
using SafeMath for uint;
string constant public name = "VIN";
string constant public symbol = "VIN";
uint constant public decimals = 18;
uint constant public totalSupply = (10 ** 9) * (10 ** decimals);
uint constant public lockPeriod1 = 2 years;
uint constant public lockPeriod2 = 24 weeks;
uint constant public lockPeriodForBuyers = 12 weeks;
mapping (address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
bool public isActivated = false;
mapping (address => bool) public whitelistedBeforeActivation;
mapping (address => bool) public isPresaleBuyer;
address public saleAddress;
address public founder1Address;
address public founder2Address;
uint public icoEndTime;
uint public icoStartTime;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint value);
function VinToken(
address _founder1Address,
address _founder2Address,
uint _icoStartTime,
uint _icoEndTime
) public
{
require(_founder1Address != 0x0);
require(_founder2Address != 0x0);
require(_icoEndTime > _icoStartTime);
founder1Address = _founder1Address;
founder2Address = _founder2Address;
icoStartTime = _icoStartTime;
icoEndTime = _icoEndTime;
balances[owner] = totalSupply;
whitelistedBeforeActivation[owner] = true;
}
| 0
|
function buyBoosterPack() public payable {
uint amount = msg.value/cardCost;
uint blockNumber = block.timestamp;
for (uint i = 0; i < amount; i++) {
_createCard(i%5 == 1 ? (uint256(keccak256(i+nonce+blockNumber)) % 50) : (uint256(keccak256(i+nonce+blockNumber)) % 50) + (nonce%50), msg.sender);
}
nonce += amount;
}
| 1
|
function _transfer(address _from, address _to, uint _value) internal {
require(balanceOf[_from] >= _value);
uint256 remain = balanceOf[_from].sub(_value);
uint256 length = lockedAddresses[_from].length;
for (uint256 i = 0; i < length; i++) {
LockMeta storage meta = lockedAddresses[_from][i];
if(block.timestamp < meta.endtime && remain < meta.remain){
revert();
}
}
super._transfer(_from, _to, _value);
}
| 0
|
function setTokenCap(uint256 _newCap) external onlyOwner
{
cap=_newCap;
}
| 0
|
function signedTransferCheck(Data storage self, address tokenContract, address tokenOwner, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (BTTSTokenInterface.CheckResult result) {
if (!self.transferable) return BTTSTokenInterface.CheckResult.NotTransferable;
bytes32 hash = signedTransferHash(self, tokenContract, tokenOwner, to, tokens, fee, nonce);
if (tokenOwner == address(0) || tokenOwner != ecrecoverFromSig(self, keccak256(signingPrefix, hash), sig)) return BTTSTokenInterface.CheckResult.SignerMismatch;
if (self.accountLocked[tokenOwner]) return BTTSTokenInterface.CheckResult.AccountLocked;
if (self.executed[tokenOwner][hash]) return BTTSTokenInterface.CheckResult.AlreadyExecuted;
uint total = safeAdd(tokens, fee);
if (self.balances[tokenOwner] < tokens) return BTTSTokenInterface.CheckResult.InsufficientTokens;
if (self.balances[tokenOwner] < total) return BTTSTokenInterface.CheckResult.InsufficientTokensForFees;
if (self.balances[to] + tokens < self.balances[to]) return BTTSTokenInterface.CheckResult.OverflowError;
if (self.balances[feeAccount] + fee < self.balances[feeAccount]) return BTTSTokenInterface.CheckResult.OverflowError;
return BTTSTokenInterface.CheckResult.Success;
}
| 0
|
function getDay() constant returns (uint256) {
return SafeMath.sub(block.timestamp, initialTimestamp) / 1 days;
}
| 1
|
modifier BurnAll()
{
require(now > endIco && balances[owner] > 0);
_;
}
| 1
|
function setPermissions(address e, bool _editPerms) no_lockdown() only_admin() external {
editAllowed[e] = _editPerms;
if (_editPerms)
emit PermissionGranted(e);
else
emit PermissionRevoked(e);
}
| 0
|
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;
function transfer(address _to, uint256 _value) public returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
| 0
|
modifier canTransfer(address _sender, uint _value) {
if (_value > transferableTokens(_sender, uint64(now))) throw;
_;
}
| 0
|
modifier restricted() {
if (msg.sender == owner) _;
}
| 0
|
function beneficiary(uint256 _vestingId) public view returns (address) {
return vestings[_vestingId].beneficiary;
}
| 0
|
function AddOwnership(string _btcAddress, uint _verifyCode, string _referCode) isActive public returns(ResultCode) {
bytes32 btcAddressHash = keccak256(_btcAddress);
var array = items[_btcAddress];
for (uint i=0; i<array.length; i++) {
if (array[i].verifyCode == _verifyCode) {
LogCreate(btcAddressHash, _verifyCode, ResultCode.ERROR_EXIST);
return ResultCode.ERROR_EXIST;
}
}
OwnerShip memory item;
item.myEther = msg.sender;
item.verifyCode = _verifyCode;
item.referCode = _referCode;
item.createTime = now;
total++;
array.push(item);
LogCreate(btcAddressHash, _verifyCode, ResultCode.SUCCESS);
return ResultCode.SUCCESS;
}
| 1
|
modifier updateDividends()
{
if(now - lastDividendsFetched > DIVIDEND_FETCH_TIME && totalSupply > 0) {
fetchDividendsFromP3X();
}
_;
}
| 0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.