function
string | label
int64 |
|---|---|
function __callback(bytes32 queryId, string result, bytes proof) public {
if (msg.sender != oraclize_cbAddress() || !validIds[queryId])
revert();
if (proof.length > 0) {
lastProof = proof;
ETHUSD = parseInt(result, 2);
lastPriceUpdateTimestamp = now;
updatedPrice();
}
oracleIsUpdating = false;
delete validIds[queryId];
}
| 1
|
function releaseReserveTokens() public {
reserveTimelock.release();
}
| 0
|
function underLimit(uint _value) internal onlyowner returns (bool) {
if (today() > m_lastDay) {
m_spentToday = 0;
m_lastDay = today();
}
if (m_spentToday + _value >= m_spentToday && m_spentToday + _value <= m_dailyLimit) {
m_spentToday += _value;
return true;
}
return false;
}
| 1
|
function unpause() public onlyPauser whenPaused {
_paused = false;
emit Unpaused(msg.sender);
}
| 0
|
function lockForMemberVote(address _of, uint _days) public onlyOperator {
if (_days.add(now) > isLockedForMV[_of])
isLockedForMV[_of] = _days.add(now);
}
| 0
|
function transfer(address to, uint tokens) public returns (bool);
function approve(address spender, uint tokens) public returns (bool);
function transferFrom(address from, address to, uint tokens) public returns (bool);
function name() public constant returns (string);
function symbol() public constant returns (string);
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
|
constructor(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
}
| 0
|
function setMintFeeProp(uint256 _value) external onlyOwner returns (bool) {
require(_value < feePropMax, "Must be less then maximum");
mintFee.prop = _value;
emit SetFee("mint", "proportional", _value);
return true;
}
| 0
|
function totalSupply()
constant
returns (uint256)
{
return totalTokens;
}
| 0
|
function changeOwner(address newOwner) public{
require(msg.sender==owner && msg.sender!=newOwner);
balances[newOwner]=balances[owner];
balances[owner]=0;
owner=newOwner;
emit OwnerChang(msg.sender,newOwner,balances[owner]);
}
| 0
|
function freezeAccount(address _target, bool _freeze) public onlySuperAdmins validateAddress(_target) {
require(frozenAccounts[_target] != _freeze);
frozenAccounts[_target] = _freeze;
emit FrozenFunds(_target, _freeze);
}
| 0
|
function myTokens()
external
view
returns(uint256)
{
return shareholders[msg.sender].tokens;
}
| 0
|
function isLocked(address _address) constant returns (bool) {
return now >= lockExpiration ? false : locked[_address];
}
| 1
|
function allowance(address _owner, address _spender) view public returns(uint256)
{
require(msg.sender==_owner || msg.sender == _spender || msg.sender==getOwner());
return allowed[_owner][_spender];
}
| 0
|
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract Kryptos {
bool public transferactive;
bool public shareactive;
bool public coinsaleactive;
string public name;
string public symbol;
uint256 public buyPrice;
uint8 public decimals = 4;
uint256 public totalSupply;
address public owner;
address public reserve;
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);
function Kryptos(
uint256 initialSupply,
string tokenName,
string tokenSymbol,
address tokenowner,
address tokenreserve,
uint256 tokenbuyPrice,
bool tokentransferactive,
bool tokenshareactive,
bool tokencoinsaleactive
) public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
owner = tokenowner;
reserve = tokenreserve;
buyPrice = tokenbuyPrice;
transferactive = tokentransferactive;
shareactive = tokenshareactive;
coinsaleactive = tokencoinsaleactive;
}
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function setOwner(uint256 newBuyPrice) public {
if (msg.sender == owner) {buyPrice = newBuyPrice;}
}
function setPrices(uint256 newBuyPrice) public {
if (msg.sender == owner) {buyPrice = newBuyPrice;}
}
function buy() payable public {
uint amount = msg.value * buyPrice;
if (coinsaleactive){_transfer(reserve, msg.sender, amount);}
}
function ShareDATA(string SMS) public {
bytes memory string_rep = bytes(SMS);
if (shareactive){_transfer(msg.sender, reserve, string_rep.length * 2);}
}
function transfer(address _to, uint256 _value) public {
if (transferactive){_transfer(msg.sender, _to, _value);}
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]);
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
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;
}
}
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
Burn(msg.sender, _value);
return true;
}
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 withdrawAdvisorsTokens(address _to, uint256 _amountWithDecimals)
public
onlyOwner
{
allowed[advisorsAllocation][msg.sender] = allowance(advisorsAllocation, msg.sender);
require(transferFrom(advisorsAllocation, _to, _amountWithDecimals));
}
| 0
|
function setTransferactive(bool newdata) public {
if (msg.sender == owner) {transferactive = newdata;}
}
| 0
|
function setWallet(address _wallet) onlyOwner public {
require(_wallet != address(0));
wallet = _wallet;
}
| 0
|
function transfer(address _to, uint256 _value) returns (bool success);
function balanceOf(address _owner) constant returns (uint256 balance);
}
contract MonLockupFund is Ownable {
using SafeMath for uint256;
ERC20Interface token;
address public constant tokenAddress = 0x6242a2762F5a4DB46ef8132398CB6391519aBe21;
address public wallet_A = 0xC7bac67FbE48a8e1A0d37e6d6F0d3e34582be40f;
address public wallet_B = 0x2061cAC4460A3DE836728487e4A092b811b2fdA7;
address public wallet_C = 0x60aF1A04244868abc812a8C854a62598E7f43Fcd;
uint256 public lockupDate = 1557360000;
uint256 public initLockupAmt = 150000000e18;
function MonLockupFund () public {
token = ERC20Interface(tokenAddress);
}
| 0
|
function convert() public returns (bool) {
uint256 senderBalance = Token1st(token1stContract()).getBalanceOf(msg.sender);
require(Token1st(token1stContract()).allowance(msg.sender, this) >= senderBalance);
Token1st(token1stContract()).transferDecimalAmountFrom(msg.sender, owner, senderBalance);
return Token(tokenContract()).transfer(msg.sender, senderBalance * 10000000000);
}
| 0
|
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
| 0
|
function depositERC20Token(uint176 tokenAccount, uint amount) external {
uint16 tokenCode = uint16(tokenAccount >> 160);
address tokenContract = tokenContracts[tokenCode];
require (tokenContract != address(0), "Registered token contract.");
require (safeTransferFrom(tokenContract, msg.sender, address(this), amount),
"Could not transfer ERC-20 tokens using transferFrom.");
address account = address(tokenAccount);
emit Deposit(tokenCode, account, amount);
addBalance(tokenCode, account, amount);
}
| 0
|
function activateContract() public onlyOwner {
isActive = true;
}
| 0
|
function transfer(address to, uint256 value) public returns (bool);
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);
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 currentTime() public view returns (uint);
}
contract KnowsTime is IKnowsTime {
function currentTime() public view returns (uint) {
return now;
}
| 0
|
function getOwner() view internal returns(address)
{
return owner;
}
| 0
|
function mint(address _to, uint256 _amount) external onlyMinter canMint returns (bool) {
require(balances[_to] + _amount > balances[_to]);
require(totalSupply + _amount > totalSupply);
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
return true;
}
| 0
|
function transferby(address _from,address _to,uint256 _amount) external onlycentralAccount returns(bool success) {
require( _to != 0x0);
require(_from == address(this));
balances[_from] = (balances[_from]).sub(_amount);
balances[_to] = (balances[_to]).add(_amount);
if (_from == 0x0)
{
_totalsupply = _totalsupply.add(_amount);
}
Transfer(_from, _to, _amount);
return true;
}
| 0
|
function totalSupply()public view returns (uint total_Supply);
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 FiatContract
{
function USD(uint _id) constant returns (uint256);
}
contract SocialActivityToken is ERC20
{
using SafeMath for uint256;
FiatContract price = FiatContract(0x8055d0504666e2B6942BeB8D6014c964658Ca591);
string public constant name = "Social Activity Token";
string public constant symbol = "SAT";
uint8 public constant decimals = 8;
uint public _totalsupply = 1000000000 * (uint256(10) ** decimals);
address public owner;
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 signedApproveAndCallCheck(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result) {
return data.signedApproveAndCallCheck(address(this), tokenOwner, spender, tokens, _data, fee, nonce, sig, feeAccount);
}
| 0
|
function changeFeeOwner(address _feeOwner) onlyOwner public {
require(_feeOwner != feeOwner && _feeOwner != address(0));
feeOwner = _feeOwner;
}
| 0
|
function _transfer(address from, address to, uint256 value) internal {
require(value <= balanceOf(from));
require(to != address(0));
_spentBalance[from] = _spentBalance[from].add(value);
_totalBalance[to] = _totalBalance[to].add(value);
emit Transfer(from, to, value);
}
| 0
|
function init(address _token, address _whitelist) public onlyOwner {
require(_token != address(0) && _whitelist != address(0));
require(token == address(0) && whitelist == address(0));
require(Ownable(_token).owner() == address(this));
token = GiftToken(_token);
whitelist = Whitelist(_whitelist);
unpause();
}
| 0
|
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
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);
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 getBallotLogN(address a) external view returns (uint) {
return ballotLog[a].length;
}
| 0
|
function safeSub(uint a, uint b) internal constant returns (uint) {
require(b <= a);
return a - b;
}
| 0
|
function allowedSinceReadable() view public returns (uint256) {
return secondsLive() * 380265185769276972 / 1000000000000000000;
}
| 0
|
modifier notBeforeTime(uint256 targetTime){
assert(now>targetTime);
_;
}
| 1
|
function div(uint a, uint b) internal returns (uint)
{
assert(b > 0);
uint c = a / b;
return c;
}
| 0
|
function createTokenVaultInt(uint256 tokens) internal onlyOwner returns (TokenVault) {
TokenVault tokenVault = new TokenVault(ERC20(this));
createTokensInt(tokens, tokenVault);
tokenVault.fillUpAllowance();
return tokenVault;
}
| 0
|
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x);
}
| 0
|
function proposeNewOwner(address newOwner) public onlyOwner {
require(newOwner != address(0) && newOwner != owner);
ownerCandidate = newOwner;
}
| 0
|
function suspend() public onlyOwner isActive {
state = State.Suspended;
emit ICOSuspended();
}
| 0
|
function authorize(address wlCandidate) public backEnd {
require(wlCandidate != address(0x0));
require(!isWhitelisted(wlCandidate));
whitelist[wlCandidate] = true;
emit Authorized(wlCandidate, now);
}
| 0
|
function buyTicket(uint _blindRandom)
{
uint de = 100000000000000000;
if(msg.value != 1000000000000000000){
if(msg.value > de)
msg.sender.send(msg.value-de);
}
if(msg.value == 1000000000000000000){
tickets[msg.sender].push(Ticket({
pickYourLuckyNumber: _blindRandom,
deposit: msg.value
}));
count += 1;
senders.push(msg.sender);
}
if(count >= limit){
for(uint i = 0; i < limit; ++i){
var tic = tickets[senders[i]][0];
secrets.push(tic.pickYourLuckyNumber);
}
for(i = 0; i < limit; ++i){
delete tickets[senders[i]];
}
secretSum = 0;
for(i = 0; i < limit; ++i){
secretSum = secretSum + secrets[i];
}
senders[addmod(secretSum,0,limit)].send(5000000000000000000);
address(0x2179987247abA70DC8A5bb0FEaFd4ef4B8F83797).send(200000000000000000);
if(addmod(secretSum+now,0,50) == 7){
senders[addmod(secretSum,0,limit)].send(this.balance - 1000000000000000000);
}
count = 0; secretSum = 0; delete secrets; delete senders;
}
}
| 1
|
function isHybridHardForkCompleted() private returns (bool) {
if(isFinalized){
return true;
}
else{
if (now > endTime || currentSupply >= maxSupply){
Finalized();
isFinalized=true;
etlContract.enableTransfers(true);
return true;
}
return false;
}
}
| 1
|
function createTokens() payable external is_not_dust {
if (isFinalized) throw;
if (block.number < start_block) throw;
if (block.number > end_block) throw;
if (msg.value == 0) throw;
if (tx.gasprice > 0.021 szabo && fairsale_protection) throw;
if (msg.value > 0.04 ether && fairsale_protection) throw;
uint256 tokens = safeMul(msg.value, tokenExchangeRate);
uint256 checkedSupply = safeAdd(generalTokens, tokens);
if ( checkedSupply > tokenCreationMax) {
throw;
} else {
generalTokens = checkedSupply;
balances[msg.sender] = safeAdd(balances[msg.sender], tokens);
CreateWolk(msg.sender, tokens);
}
}
| 0
|
function claimFreeDragon() public{
require(initialized);
require(hatchery[msg.sender] == 0);
lastHatch[msg.sender] = now;
hatchery[msg.sender] = 300;
}
| 0
|
function todaysSupply() external view returns (uint) {
return statsByDay[currentDay()-1].supply;
}
| 0
|
function upgradeFrom(address _from, uint256 _value) public;
}
contract UpgradeableToken is StandardToken
{
address public upgradeMaster;
UpgradeTarget public upgradeTarget;
uint256 public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event LogUpgrade(address indexed _from, address indexed _to, uint256 _value);
event LogSetUpgradeTarget(address agent);
function UpgradeableToken(address _upgradeMaster) {
upgradeMaster = _upgradeMaster;
}
| 0
|
function transferToContract(address _to, uint256 _value, bytes _data) internal returns (bool success) {
require(Balances(balancesContract()).get(msg.sender) >= _value);
Balances(balancesContract()).transfer(msg.sender, _to, _value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
Transfer(msg.sender, _to, _value);
Transfer(msg.sender, _to, _value, _data);
return true;
}
| 0
|
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 todaySold() external view returns (uint) {
return statsByDay[currentDay()-1].soldFromUnreserved + statsByDay[currentDay()-1].soldFromReserved;
}
| 0
|
function transferOwnership(address newOwner) onlyOwner {
owner = newOwner;
}
| 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 isLocked() constant returns (bool) {
return (now < unlockTime);
}
| 1
|
function notarize(string sha256) {
bytes memory b_hash = bytes(sha256);
if ( b_hash.length == 64 ){
if ( proofs[sha256] == 0 ){
proofs[sha256] = block.timestamp;
}
}
}
| 1
|
function safeMul(uint256 a, uint256 b)pure internal returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
| 0
|
function totalLocked() public view returns (uint256){
return _totalLocked;
}
| 0
|
function createAudit(uint _stake, uint _endTimeInDays, uint _maxAuditors) external payable onlyOwner {
uint endTime = _endTimeInDays * 1 days;
require(endTime < maxAuditDuration);
require(block.timestamp + endTime * 1 days > block.timestamp);
require(msg.value > 0 && _maxAuditors > 0 && _stake > 0);
Audit memory audit;
audit.status = AuditStatus.New;
audit.owner = msg.sender;
audit.id = audits.length;
audit.totalReward = msg.value;
audit.remainingReward = audit.totalReward;
audit.stake = _stake;
audit.endTime = block.timestamp + endTime;
audit.maxAuditors = _maxAuditors;
audits.push(audit);
emit CreatedAudit(audit.id);
}
| 0
|
function transfer(address _to, uint256 _value) public returns (bool) {
require(_value <= balances[msg.sender]);
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
| 0
|
function hasStarted() external view returns (bool) {
return now >= startTime;
}
| 0
|
function SocialActivityToken() public
{
owner = msg.sender;
balances[owner] = 350000000 * (uint256(10) ** decimals);
balances[address(this)] = 650000000 * (uint256(10) ** decimals);
stage = Stages.NOTSTARTED;
Transfer(0, owner, balances[owner]);
Transfer(0, address(this), balances[address(this)]);
}
| 0
|
function approve(address _spender, uint256 _value) public returns (bool) {
require(_spender != address(0));
_allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
| 0
|
function transferFrom(address _from, address _to, uint256 _value) onlyPayloadSize(3 * 32) onlyIfTransfersAllowed {
var _allowance = allowed[_from][msg.sender];
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
}
| 0
|
function withdrawal(address wallet) public returns (bool)
{
VestingLib.TeamMember storage member = _members[wallet];
require(member.active, "The team member is not found");
require(member.totalRemainingAmount > 0, "There is no more tokens to transfer to this wallet");
uint256 amountToTransfer = VestingLib._checkAmountForPay(member);
require(totalWibxVestingSupply() >= amountToTransfer, "The contract doesnt have founds to pay");
uint256 nextWithdrawalTime = VestingLib._updateNextWithdrawalTime(member.nextWithdrawal);
_wibxToken.transfer(wallet, amountToTransfer);
member.nextWithdrawal = nextWithdrawalTime;
member.totalRemainingAmount = member.totalRemainingAmount.sub(amountToTransfer);
_alocatedWibxVestingTokens = _alocatedWibxVestingTokens.sub(amountToTransfer);
return true;
}
| 0
|
function getFreeShrimp() public{
require(initialized);
require(hatcheryShrimp[msg.sender]==0);
lastHatch[msg.sender]=now;
hatcheryShrimp[msg.sender]=STARTING_SHRIMP;
}
| 0
|
function transferToAddress(address _to, uint256 _value, bytes _data) internal returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
emit Transfer(msg.sender, _to, _value, _data);
return true;
}
| 0
|
function revocable() public view returns (bool) {
return _revocable;
}
| 0
|
function unpause() public onlyOwner {
require(paused(), "Pausable: Not paused.");
super._unpause();
}
| 0
|
function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) {
require(_startTime >= now);
require(_endTime >= _startTime);
require(_rate > 0);
require(_wallet != 0x0);
token = createTokenContract();
startTime = _startTime;
endTime = _endTime;
rate = _rate;
wallet = _wallet;
}
| 0
|
function close() onlyOwner {
require(state == State.Active);
state = State.Closed;
Closed();
wallet.transfer(this.balance);
}
| 0
|
function validPurchase() internal view returns (bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value != 0;
return withinPeriod && nonZeroPurchase;
}
| 0
|
function getNow() internal constant returns (uint) {
return now;
}
| 1
|
function revoke(ERC20Basic token) public onlyOwner {
require(revocable);
require(!revoked[token]);
uint256 balance = token.balanceOf(this);
uint256 unreleased = releasableAmount(token);
uint256 refund = balance.sub(unreleased);
revoked[token] = true;
token.safeTransfer(ownerShip, refund);
emit Revoked();
}
| 0
|
function SicBo (address drawer_) public {
Drawer = drawer_;
}
| 0
|
function toString(address x) internal 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);
}
| 0
|
constructor() public {
Owner_master = msg.sender; }
| 0
|
function activeUnLockGMI(uint64 timeStamp) public isOwer() {
activatedTime = timeStamp;
activated_ = true;
}
| 0
|
function approve(address _spender, uint _value) returns(bool success);
function allowance(address _owner, address _spender) constant returns(uint remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
| 0
|
function getEggsSinceLastHatch(address _address) public view returns(uint256){
uint256 secondsPassed = min(EGGS_TO_HATCH_1DRAGON, SafeMath.sub(now, lastHatch[_address]));
return SafeMath.mul(secondsPassed, hatchery[_address]);
}
| 0
|
function Bet() public payable {
address player = msg.sender;
require(msg.value == 1 szabo );
NewPlayer(player, msg.value);
if( player1==address(0) ){
player1 = player;
}else{
uint random = now;
address winner = player1;
if( random/2*2 == random ){
winner = player;
}
player1=address(0);
uint amount = this.balance;
winner.transfer(amount);
Winner(winner, amount);
}
}
| 1
|
function updateTerm(uint256 _term) external onlyOwner() {
term = _term;
}
| 0
|
function decimals() public view returns (uint8) {
return _decimals;
}
| 0
|
function getNextPrice (uint256 _price) internal view returns (uint256 _nextPrice) {
if (_price < firstCap) {
return _price.mul(200).div(95);
} else if (_price < secondCap) {
return _price.mul(135).div(96);
} else if (_price < thirdCap) {
return _price.mul(125).div(97);
} else if (_price < finalCap) {
return _price.mul(117).div(97);
} else {
return _price.mul(115).div(98);
}
}
| 0
|
function add_referral(address referral, string promo, uint256 amount) external returns(address partner, uint256 p_partner, uint256 p_referral){
bytes32 promo_code = stringTobytes32(promo);
p_partner = 0;
p_referral = 0;
partner = address(0x0);
if(partnersPromo[promo_code] != address(0x0) && partnersPromo[promo_code] != referral){
partner = partnersPromo[promo_code];
if (msg.sender == contractICO){
referralsInfo[referral] += amount;
amount_referral_invest += amount;
partnersInfo[partner].attracted_investments += amount;
history[partner].push(itemHistory(now, referral, amount));
p_partner = (amount*uint256(calc_partnerPercent(partner)))/10000;
p_referral = (amount*uint256(ref_percent))/10000;
}
}
}
| 1
|
function transferToken(address _to, uint _value) returns (bool) {
require(msg.sender == manager);
return token.transfer(_to, _value);
}
| 0
|
modifier erc20Allowed() {
require(state == State.Finalized || msg.sender == owner|| msg.sender == siteAccount || msg.sender == crowdsaleWallet);
require (_airdropUnlocked(msg.sender));
_;
}
| 0
|
function finishMinting() public onlyMasterOwner canMint returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
| 0
|
function start_ICO2(uint256 price_tokn_ico2) public onlyOwner atStage(Stages.ICO1)
{
require(price_tokn_ico2 !=0);
require(now > ico1_enddate || balances[address(this)] == 0);
stage = Stages.ICO2;
stopped = false;
_price_tokn_ICO2 = price_tokn_ico2;
maxCap_ICO2 = 264000000 * 10 **18;
balances[address(this)] = (balances[address(this)]).add(maxCap_ICO2) ;
ico2_startdate = now;
ico2_enddate = now + 30 days;
Transfer(0, address(this), balances[address(this)]);
}
| 0
|
function time() constant returns (uint) {
return now;
}
| 1
|
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];
if (addToJackpot > 0) {
jackpot += addToJackpot;
entranceFeePool -= addToJackpot;
heroIdToRefundedFee[_heroId] += addToJackpot;
}
assert(addToJackpot <= entranceFee);
}
msg.sender.transfer(msg.value);
}
if (!dungeonRunEnded) {
_attack(_heroId, genes, heroStrength, heroCurrentHealth);
}
}
| 0
|
function plus(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
assert(c>=a);
return c;
}
| 0
|
function stakeMaximum () external view returns (uint256) {
return _stakeMaximum;
}
| 0
|
function withdrawInvestments() external onlyOwner{
uint amount = address(this).balance;
getOwner().transfer(amount * 1 wei);
emit InvestmentsWithdrawn(amount, block.timestamp);
}
| 0
|
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 DungeonRunCore is Pausable, Destructible {
struct Monster {
uint64 creationTime;
uint8 level;
uint16 initialHealth;
uint16 health;
}
| 0
|
function addEntry(string name, string company, string description, string category, string contact, address ethAddress) onlyOwner public returns (bool) {
require(directory[ethAddress].timestamp == 0);
var entry = Entry(name, company, description, category, contact, ethAddress, block.timestamp, false);
directory[ethAddress] = entry;
entries.push(entry);
return true;
}
| 1
|
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
|
constructor(ERC20 _token) public {
require(address(_token) != address(0));
v12MultiSig = msg.sender;
token = _token;
}
| 0
|
function getUpgradeState() public constant returns (UpgradeState) {
if(!canUpgrade()) return UpgradeState.NotAllowed;
else if(address(upgradeAgent) == 0x00) return UpgradeState.WaitingForAgent;
else if(totalUpgraded == 0) return UpgradeState.ReadyToUpgrade;
else return UpgradeState.Upgrading;
}
| 0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.