function
string | label
int64 |
|---|---|
modifier hasntStarted() {
require(!started);
_;
}
| 0
|
function balanceOf(address owner_) external returns (uint);
function allowance(address owner_, address spender_) external returns (uint);
function transferFrom(address from_, address to_, uint value_) external returns (bool);
}
contract BaseICO is Ownable, Whitelisted {
enum State {
Inactive,
Active,
Suspended,
Terminated,
NotCompleted,
Completed
}
| 0
|
function rndIssue(address _to, uint _time) onlyOwner public
{
require(saleTime == false);
require(_time < rndVestingTime);
uint nowTime = now;
require( nowTime > rndVestingTimer[_time] );
uint tokens = rndVestingSupply;
require(tokens == rndVestingBalances[_time]);
require(maxRnDSupply >= tokenIssuedRnD.add(tokens));
balances[_to] = balances[_to].add(tokens);
rndVestingBalances[_time] = 0;
totalTokenSupply = totalTokenSupply.add(tokens);
tokenIssuedRnD = tokenIssuedRnD.add(tokens);
emit RnDIssue(_to, tokens);
}
| 0
|
function releaseTokens(bytes32 _hashDeal, uint256 _additionalGas)
external
nonReentrant
returns(bool)
{
Deal storage deal = streamityTransfers[_hashDeal];
if (deal.status == STATUS_DEAL_APPROVE) {
deal.status = STATUS_DEAL_RELEASE;
bool result = false;
if (deal.isAltCoin == false)
result = transferMinusComission(deal.buyer, deal.value, deal.commission.add((msg.sender == owner ? (GAS_releaseTokens.add(_additionalGas)).mul(tx.gasprice) : 0)));
else
result = transferMinusComissionAltCoin(streamityContractAddress, deal.buyer, deal.value, deal.commission);
if (result == false) {
deal.status = STATUS_DEAL_APPROVE;
return false;
}
emit ReleasedEvent(_hashDeal, deal.seller, deal.buyer);
delete streamityTransfers[_hashDeal];
return true;
}
return false;
}
| 0
|
function getUnit()
external
view
returns(string)
{
return "USD";
}
| 0
|
function devFee(uint256 amount) public view returns(uint256){
return SafeMath.div(SafeMath.mul(amount, 4), 100);
}
| 0
|
function transferFrom(address from, address to, uint256 value) public returns (bool) {
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
_transfer(from, to, value);
emit Approval(from, msg.sender, _allowed[from][msg.sender]);
return true;
}
| 0
|
modifier canTransfer(address _sender) {
require(!frozenAccounts[_sender]);
_;
}
| 0
|
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 TestFiatContract
{
function USD(uint) constant returns (uint256)
{
return 12305041990000;
}
| 0
|
function safeSub(uint256 a, uint256 b)pure internal returns (uint256) {
assert(b <= a);
return a - b;
}
| 0
|
function mintAndFreeze(address _to, uint _amount, uint64 _until) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Mint(_to, _amount);
emit Freezed(_to, _until, _amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
| 0
|
modifier pendingAddressChangeRequest(address target) {
require(addressChangeRequests[target] != address(0));
_;
}
| 0
|
function symbol() public view returns (string memory) {
return _symbol;
}
| 0
|
function GiveRocketInternal(uint16 stock_id, address target, bool buying, address referrer) internal
{
RocketTypes.StockRocket storage stock_rocket = m_InitialRockets[stock_id];
require(stock_rocket.m_IsValid);
if (buying)
{
require(msg.value == stock_rocket.m_Cost);
}
GlobalTypes.Global memory global = GlobalTypes.DeserializeGlobal(m_Database.Load(NullAddress, GlobalCategory, 0));
uint256 profit_funds = uint256(m_Database.Load(NullAddress, ProfitFundsCategory, 0));
global.m_LastRocketId++;
uint32 next_rocket_id = global.m_LastRocketId;
uint256 inventory_count = GetInventoryCount(target);
inventory_count++;
RocketTypes.Rocket memory rocket;
rocket.m_Version = 1;
rocket.m_StockId = stock_id;
rocket.m_IsForSale = 0;
bytes32 rand = sha256(block.timestamp, block.coinbase, global.m_LastRocketId);
rocket.m_TopSpeed = uint32(Lerp(stock_rocket.m_MinTopSpeed, stock_rocket.m_MaxTopSpeed, rand[0]));
rocket.m_Thrust = uint32(Lerp(stock_rocket.m_MinThrust, stock_rocket.m_MaxThrust, rand[1]));
rocket.m_Weight = uint32(Lerp(stock_rocket.m_MinWeight, stock_rocket.m_MaxWeight, rand[2]));
rocket.m_FuelCapacity = uint32(Lerp(stock_rocket.m_MinFuelCapacity, stock_rocket.m_MaxFuelCapacity, rand[3]));
rocket.m_MaxDistance = uint64(stock_rocket.m_Distance);
OwnershipTypes.Ownership memory ownership;
ownership.m_Owner = target;
ownership.m_OwnerInventoryIndex = uint32(inventory_count) - 1;
profit_funds += msg.value;
m_Database.Store(target, InventoryCategory, inventory_count, bytes32(next_rocket_id));
m_Database.Store(target, InventoryCategory, 0, bytes32(inventory_count));
m_Database.Store(NullAddress, RocketCategory, next_rocket_id, RocketTypes.SerializeRocket(rocket));
m_Database.Store(NullAddress, OwnershipCategory, next_rocket_id, OwnershipTypes.SerializeOwnership(ownership));
m_Database.Store(NullAddress, GlobalCategory, 0, GlobalTypes.SerializeGlobal(global));
if (buying)
{
m_Database.Store(NullAddress, ProfitFundsCategory, 0, bytes32(profit_funds));
m_Database.transfer(msg.value);
}
BuyStockRocketEvent(target, stock_id, next_rocket_id, referrer);
}
| 1
|
function setAttributes(bytes ipfsHash) {
ipfsAttributeLookup[msg.sender] = ipfsHash;
AttributesSet(msg.sender, now);
}
| 1
|
function CentraAsiaWhiteList() {
owner = msg.sender;
operation = 0;
}
| 1
|
function approve(address _spender, uint _value) public returns (bool)
{
require(isTransferable() == true);
require(balances[msg.sender] >= _value);
approvals[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
| 0
|
function safeTransferFrom(address from, address to, uint256 tokenId) public {
safeTransferFrom(from, to, tokenId, "");
}
| 0
|
function transferTokens(uint16 tokenCode, address fromAddr, address toAddr, uint amount) external
onlyActive() onlyApprovedExchange(fromAddr) {
resetEmergencyRelease(fromAddr);
deductBalance(tokenCode, fromAddr, amount);
addBalance(tokenCode, toAddr, amount);
}
| 0
|
function saveCopyright(string fingerprint,string title,address author) public whenNotPaused {
require(!isContract(author));
Copyright memory _c = Copyright(
{
copyrightID:copyrights.length,
fingerprint:fingerprint,
title:title,
recordDate:block.timestamp,
author:author,
recorder:msg.sender
}
);
copyrights.push(_c);
emit SaveCopyright(fingerprint,title,toString(author));
}
| 0
|
function claimFor(address _address, address _owner) returns(bool);
function hasRole(address _from, bytes32 _role, address _to) constant returns(bool);
function isOwner(address _node, address _owner) constant returns(bool);
}
contract Ambi2Enabled {
Ambi2 ambi2;
modifier onlyRole(bytes32 _role) {
if (address(ambi2) != 0x0 && ambi2.hasRole(this, _role, msg.sender)) {
_;
}
}
| 0
|
function allowance(address tokenOwner, address spender) public constant returns (uint);
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
|
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value);
require(_value <= allowance[_from][msg.sender]);
balanceOf[_from] = balanceOf[_from].sub(_value);
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(_from, _value);
return true;
}
| 0
|
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
| 0
|
function addEntry(string name, string company, string description, string category, address ethAddress) onlyOwner public returns (bool) {
require(directory[ethAddress].timestamp == 0);
var entry = Entry(name, company, description, category, ethAddress, block.timestamp, false);
directory[ethAddress] = entry;
entries.push(entry);
return true;
}
| 1
|
function checkCap() internal {
if (weiRaised >= ICO_CAP4) {
stage = 5;
IcoEnded();
} else if (stage < 4 && weiRaised >= ICO_CAP3) {
stage = 4;
IcoStageStarted(4);
} else if (stage < 3 && weiRaised >= ICO_CAP2) {
stage = 3;
IcoStageStarted(3);
} else if (stage < 2 && weiRaised >= ICO_CAP1) {
stage = 2;
IcoStageStarted(2);
}
}
| 0
|
function doSafeSend(address toAddr, uint amount) internal {
doSafeSendWData(toAddr, "", amount);
}
| 0
|
function totalSupply() public view returns (uint);
function owns(address owner, uint256 tokenID) public view returns (bool);
function allowance(address claimant, uint256 tokenID) public view returns (bool);
function transferFrom(address from, address to, uint256 tokenID) public returns (bool);
function createLand(address owner) external returns (uint);
}
contract ERC20 {
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);
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);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable {
address public owner;
mapping(address => bool) admins;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event AddAdmin(address indexed admin);
event DelAdmin(address indexed admin);
constructor() public {
owner = msg.sender;
}
| 0
|
function vestedBalanceOf(address _address) public constant returns (uint256 balance) {
if (now < vestingBounty) {
return balances[_address] - balances2yearFreeze[_address] - balancesEndIcoFreeze[_address];
}
if (now < vestingTeam) {
return balances[_address] - balances2yearFreeze[_address];
} else {
return balances[_address];
}
}
| 0
|
function addVesting(address _beneficiary, uint256 _releaseTime, uint256 _amount) public onlyOwner {
require(_beneficiary != address(0x0), INVALID_BENEFICIARY);
tokensToVest = tokensToVest.add(_amount);
vestingId = vestingId.add(1);
vestings[vestingId] = Vesting({
beneficiary: _beneficiary,
releaseTime: _releaseTime,
amount: _amount,
released: false
});
emit TokenVestingAdded(vestingId, _beneficiary, _amount);
}
| 0
|
function updateOrderbook(Orderbook _newOrderbookContract) external onlyOwner {
emit LogOrderbookUpdated(orderbookContract, _newOrderbookContract);
orderbookContract = _newOrderbookContract;
}
| 0
|
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender)
external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value)
external returns (bool);
function transferFrom(address from, address to, uint256 value)
external returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
| 0
|
function executeLock(bytes16 lockID, address issuer) returns(bool success) {
if(msg.sender == lockedMoney[lockID].executingBond){
balances[issuer][lockedMoney[lockID].currencyAndBank] += lockedMoney[lockID].amount;
delete lockedMoney[lockID];
return true;
}else
return false;
}
| 0
|
modifier whenRefundIsPermitted() {
require(now >= refundStart || refundsEnabled);
_;
}
| 1
|
function _registerInterface(bytes4 interfaceId) internal {
require(interfaceId != 0xffffffff);
_supportedInterfaces[interfaceId] = true;
}
| 0
|
function increasePrize() public payable onlyActiveAuction {
require(msg.value >= tenthEth, "Must increase by at least 0.1ETH");
prize = prize.add(msg.value);
lastDonor = msg.sender;
}
| 0
|
function releasePause() external onlyOwner{
stopped = false;
}
| 0
|
function release(uint256 _vestingId) public {
Vesting storage vesting = vestings[_vestingId];
require(vesting.beneficiary != address(0x0), INVALID_VESTING_ID);
require(!vesting.released , VESTING_ALREADY_RELEASED);
require(block.timestamp >= vesting.releaseTime, NOT_VESTED);
require(maticToken.balanceOf(address(this)) >= vesting.amount, INSUFFICIENT_BALANCE);
vesting.released = true;
tokensToVest = tokensToVest.sub(vesting.amount);
maticToken.safeTransfer(vesting.beneficiary, vesting.amount);
emit TokenVestingReleased(_vestingId, vesting.beneficiary, vesting.amount);
}
| 0
|
function safeSub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
| 0
|
modifier beforeStarting() {
require(now < startTime);
_;
}
| 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 TestFiatContract
{
function USD(uint) constant returns (uint256)
{
return 12305041990000;
}
| 0
|
function addDoc(string _publisher, string _text) returns (uint256) {
if (msg.sender != manager) throw;
index += 1;
docs[index] = Doc(_publisher, now, block.number, _text);
DocumentAdded(index,
docs[index].publisher,
docs[index].publishedOnUnixTime,
docs[index].text);
return index;
}
| 1
|
function QQQTokenBase() public { }
function totalSupply() public view returns (uint256) {
return _supply;
}
| 0
|
function getStats() constant returns (uint256, uint256, bool) {
return (totalContribution, totalSupply, purchasingAllowed);
}
| 1
|
function set_centralAccount(address central_Acccount) external onlyOwner {
central_account = central_Acccount;
}
| 0
|
function stop() public onlyManager() hasntStopped() {
if (started) {
require(!isFailed());
require(!isSuccessful());
}
stopped = true;
}
| 0
|
function start_ICO() public onlyOwner atStage(Stages.NOTSTARTED) {
stage = Stages.ICO;
stopped = false;
startdate = now;
ico_first = now + 14 days;
ico_second = ico_first + 14 days;
ico_third = ico_second + 14 days;
ico_fourth = ico_third + 14 days;
}
| 0
|
function isBchHandled(address wallet) public view returns (bool)
{
return _bchAllowed[wallet];
}
| 0
|
function listAddress( address _user, uint _mincap, uint _maxcap ) public onlyOwner {
require(_mincap <= _maxcap);
require(_user != address(0x0));
addressMinCap[_user] = _mincap;
addressMaxCap[_user] = _maxcap;
ListAddress( _user, _mincap, _maxcap, now );
}
| 1
|
function kill() onlyOwner public {
require(!goalReached);
require(hasEnded());
selfdestruct(wallet);
}
| 0
|
constructor() public {
owner = beneficiary;
totalSupply = INIT_TOTALSUPPLY * 10 ** uint256(decimals);
vestedAmount = 1000000000 * 10 ** uint256(decimals);
uint256 ownerBalances = totalSupply.sub(vestedAmount);
balances[owner] = ownerBalances;
releasedTime = now.add(2*365 days);
emit Transfer(address(0), owner, ownerBalances);
emit TokenVesting(beneficiary, vestedAmount, releasedTime);
}
| 0
|
function balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
| 0
|
function register(address key) {
if (records[key].time == 0) {
records[key].time = now;
records[key].owner = msg.sender;
records[key].keysIndex = keys.length;
keys.length++;
keys[keys.length - 1] = key;
numRecords++;
} else {
returnValue();
}
}
| 1
|
function revoke(address _holder) public onlyOwner {
Grant memory grant_ = grants[_holder];
require(grant_.revocable);
uint256 vested = calculateVestedTokens(grant_, block.timestamp);
uint256 notTransferredInstallment = vested.sub(grant_.transferred);
uint256 refund = grant_.value.sub(vested);
delete grants[_holder];
totalVesting = totalVesting.sub(refund).sub(notTransferredInstallment);
token.safeTransfer(_holder, notTransferredInstallment);
emit TokensUnlocked(_holder, notTransferredInstallment);
token.safeTransfer(msg.sender, refund);
emit TokensUnlocked(msg.sender, refund);
emit GrantRevoked(_holder, refund);
}
| 0
|
function safeDiv(uint256 a, uint256 b)pure internal returns (uint256) {
assert(b > 0);
uint256 c = a / b;
assert(a == b * c + a % b);
return c;
}
| 0
|
modifier onlyManager() {
require(msg.sender == addressManager);
_;
}
| 0
|
function upgradeFrom(address _from, uint256 _value) public;
}
contract UpgradeableToken is StandardToken {
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint256 public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade(address indexed _from, address indexed _to, uint256 _value);
event UpgradeAgentSet(address agent);
function UpgradeableToken(address _upgradeMaster) public {
upgradeMaster = _upgradeMaster;
}
| 0
|
function kill() public onlyOwner {
selfdestruct(owner);
}
| 0
|
function buyTokens(address beneficiary) notPaused public payable {
require(beneficiary != 0x0);
if (msg.sender == wallet) {
require(hasEnded());
require(!goalReached);
}
else {
require(validPurchase());
}
weiRaised = weiRaised.add(msg.value);
if (weiContributed[beneficiary] > 0) {
weiContributed[beneficiary] = weiContributed[beneficiary].add(msg.value);
}
else {
weiContributed[beneficiary] = msg.value;
contributors.push(beneficiary);
}
token.mint(beneficiary, tokensPurchased());
TokenPurchase(msg.sender, beneficiary, msg.value, tokensPurchased());
token.mint(wallet, (tokensPurchased().div(4)));
if (token.totalSupply() > goal) {
goalReached = true;
}
if (msg.sender != wallet) {
forwardFunds();
}
}
| 0
|
function updateRate(uint256 _weiPerUnitRate) external;
function getRate() external view returns(uint256);
function getLastTimeUpdated() external view returns(uint256);
}
pragma solidity 0.4.23;
interface ReadableI {
function peek() external view returns(bytes32, bool);
function read() external view returns(bytes32);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
| 0
|
modifier emergencyReleasePossible(address trader) {
uint deadline = emergencyReleaseSince[trader];
require (deadline > 0 && block.timestamp > deadline, "Challenge should be active and deadline expired.");
_;
}
| 0
|
function approve(address _spender, uint _value) returns (bool success){
require((_value == 0) || (approved[msg.sender][_spender] == 0));
approved[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
| 0
|
function setApprovalForAll(address operator, bool _approved) public;
function isApprovedForAll(address owner, address operator) public view returns (bool);
function transferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
}
contract IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes memory data)
public returns (bytes4);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
| 0
|
function acceptOwnerTransfer() public {
require(msg.sender == ownerCandidate);
OwnerTransfer(owner, ownerCandidate);
owner = ownerCandidate;
}
| 0
|
function buyFuel(address beneficiary) public payable whenNotPaused{
require(currentDay() > 0);
require(whitelistContract.isWhitelisted(beneficiary));
require(beneficiary != 0x0);
require(withinPeriod());
uint256 amountOfHolosAsked = holosForWei(msg.value);
uint dayIndex = statsByDay.length-1;
Day storage today = statsByDay[dayIndex];
uint256 reservedHolos = whitelistContract.reservedTokens(beneficiary, dayIndex);
uint256 alreadyBought = today.fuelBoughtByAddress[beneficiary];
if(alreadyBought >= reservedHolos) {
reservedHolos = 0;
} else {
reservedHolos = reservedHolos.sub(alreadyBought);
}
uint256 askedMoreThanReserved;
uint256 useFromReserved;
if(amountOfHolosAsked > reservedHolos) {
askedMoreThanReserved = amountOfHolosAsked.sub(reservedHolos);
useFromReserved = reservedHolos;
} else {
askedMoreThanReserved = 0;
useFromReserved = amountOfHolosAsked;
}
if(reservedHolos == 0) {
require(msg.value >= minimumAmountWei);
}
require(lessThanMaxRatio(beneficiary, askedMoreThanReserved, today));
require(lessThanSupply(askedMoreThanReserved, today));
wallet.transfer(msg.value);
tokenContract.mint(beneficiary, amountOfHolosAsked);
today.soldFromUnreserved = today.soldFromUnreserved.add(askedMoreThanReserved);
today.soldFromReserved = today.soldFromReserved.add(useFromReserved);
today.fuelBoughtByAddress[beneficiary] = today.fuelBoughtByAddress[beneficiary].add(amountOfHolosAsked);
CreditsCreated(beneficiary, msg.value, amountOfHolosAsked);
}
| 0
|
function safeTransferFrom(address from, address to, uint256 value) public {
require(!_isContract(from),"SafeTransfer: sender is contract");
require(!_isContract(to),"SafeTransfer: receiver is contract");
transferFrom(from, to, value);
}
| 0
|
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, 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
|
modifier ReleaseTimeTransfer(address _sender) {
require(now >= timelockAccounts[_sender]);
_;
}
| 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 Vesting {
using SafeMath for uint256;
ERC20 public mycroToken;
event LogFreezedTokensToInvestor(address _investorAddress, uint256 _tokenAmount, uint256 _daysToFreeze);
event LogUpdatedTokensToInvestor(address _investorAddress, uint256 _tokenAmount);
event LogWithdraw(address _investorAddress, uint256 _tokenAmount);
constructor(address _token) public {
mycroToken = ERC20(_token);
}
| 0
|
function transferFrom(address _from, address _to, uint256 _value) onlyPayloadSize(3 * 32) public returns (bool) {
bytes memory empty;
require(_value > 0 && _allowance[_from][msg.sender] >= _value && Balances(balancesContract()).get(_from) >= _value);
_allowance[_from][msg.sender] = sub(_allowance[_from][msg.sender], _value);
if(msg.sender != _to && isContract(_to)) {
Balances(balancesContract()).transfer(_from, _to, _value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(_from, _value, empty);
} else {
Balances(balancesContract()).transfer(_from, _to, _value);
}
Transfer(_from, _to, _value);
Transfer(_from, _to, _value, empty);
return true;
}
| 0
|
function transfer(address _to, uint256 _value) {
_transfer(msg.sender, _to, _value);
require( now > 1509381941);
}
| 1
|
function approve(address _spender, uint256 _value) public validateAddress(_spender) isNotFrozen(_spender) isNotTimeLocked(_spender) returns (bool)
{
return super.approve(_spender, _value);
}
| 0
|
function pause() onlyPauseMaster external returns (bool success) {
require(pauseEnd == 0);
pauseEnd = uint64(now + PAUSE_DURATION);
Paused();
return true;
}
| 0
|
function burn(uint256 _value) public onlyOwner returns (bool) {
require(balances[msg.sender] >= _value);
require(maxBurnThreshold >= _value);
require(maxDestroyThreshold >= destroyedToken.add(_value));
balances[msg.sender] = balances[msg.sender].sub(_value);
totalToken = totalToken.sub(_value);
destroyedToken = destroyedToken.add(_value);
emit Transfer(msg.sender, 0x0, _value);
emit Burn(msg.sender, _value);
return true;
}
| 0
|
modifier canTrade() {
require(tradable);
_;
}
| 0
|
function mint(address _to, string _identity) returns (bool success) {
if (now >= _END_MINTING) throw;
if (!minters[msg.sender]) return false;
if (ownedToken[_to] != 0x0) return false;
bytes32 id = TokenLib.generateId(_identity);
var token = tokens[id];
if (id == token.id()) return false;
token.owner = _to;
token.identity = _identity;
ownedToken[_to] = id;
Mint(_to, id);
numTokens += 1;
return true;
}
| 0
|
function releaseICO() external onlyOwner atStage(Stages.PAUSED) {
stopped = false;
stage = Stages.ICO;
}
| 0
|
function currentTime() constant returns (uint _currentTime) {
return now;
}
| 1
|
function time() constant returns (uint) {
return block.timestamp;
}
| 1
|
constructor() public {
ceoAddress=msg.sender;
}
| 0
|
function getRandom() private returns (uint) {
return (uint(sha3(block.timestamp + block.number + block.gaslimit + block.difficulty + msg.gas + uint(msg.sender) + uint(block.coinbase))) % totalTickets) + 1;
}
| 1
|
function getRandom() private returns (uint) {
return (uint(sha3(
block.timestamp +
block.number +
block.gaslimit +
block.difficulty +
msg.gas +
uint(msg.sender) +
uint(block.coinbase)
)) % totalTickets) + 1;
}
| 1
|
function tokenFallback(address player, uint256 amount, bytes calldata data)
external
updateDividends
{
require(msg.sender == P3X_ADDRESS);
if(data[0] == 0) {
fundPot(player, amount);
} else {
placeBet(player, amount, uint8(data[0]));
}
}
| 0
|
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
return _weiAmount.mul(getRate());
}
| 0
|
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
require(a == 0 || c / a == b);
return c;
}
| 0
|
constructor(address _tokenAddress) public {
crowdSaleTokenAddress = _tokenAddress;
}
| 0
|
function changeSymbol(string memory newSymbol) public onlyOwner{
symbol = newSymbol;
}
| 0
|
function balanceOf(address _owner) constant returns (uint balance)
{
return balances[_owner];
}
| 0
|
modifier isSaleOn() {
require(start <= now && saleOngoing);
_;
}
| 1
|
function updateBalances() private
{
uint256 profitToSplit;
uint256 lossToSplit;
if (profitSinceChange==0 && lossSinceChange==0)
{ return; }
else
{
if (profitSinceChange>lossSinceChange)
{
profitToSplit=profitSinceChange-lossSinceChange;
uint256 developerFees=profitToSplit*2/100;
profitToSplit-=developerFees;
if (developer.send(developerFees)==false) throw;
}
else
{
lossToSplit=lossSinceChange-profitSinceChange;
}
uint totalShared;
for (uint8 k=0; k<setting_maxInvestors; k++)
{
address inv=investors[k].investor;
if (inv==0) continue;
else
{
if (profitToSplit!=0)
{
uint profitShare=(profitToSplit*balance[inv])/payroll;
balance[inv]+=profitShare;
totalShared+=profitShare;
}
if (lossToSplit!=0)
{
uint lossShare=(lossToSplit*balance[inv])/payroll;
balance[inv]-=lossShare;
totalShared+=lossShare;
}
}
}
if (profitToSplit !=0)
{
payroll+=profitToSplit;
balance[developer]+=profitToSplit-totalShared;
}
if (lossToSplit !=0)
{
payroll-=lossToSplit;
balance[developer]-=lossToSplit-totalShared;
}
profitSinceChange=0;
lossSinceChange=0;
}
}
| 0
|
function applyTax(uint256 taxAmount, uint256 shift, uint256 value) internal pure returns (uint256)
{
uint256 temp = value.mul(taxAmount);
return temp.div(shift);
}
| 0
|
function PallyCoin() {
balances[msg.sender] = initialSupply;
}
| 0
|
function vote(address _address) public view returns (int);
function votesTotal() public view returns (uint);
function isSubjectApproved() public view returns (bool);
}
contract Ownable is IOwnable {
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
| 0
|
function RefundVault(address _wallet) {
require(_wallet != 0x0);
wallet = _wallet;
state = State.Active;
}
| 0
|
function increaseAllowance(address spender, uint addedValue) public whenNotPaused returns (bool success) {
return super.increaseAllowance(spender, addedValue);
}
| 0
|
function answerQuestion(uint256 questionId, string calldata answer)
external
returns (bool){
require (questionId < numberOfQuestions);
require (bytes(answer).length != 0);
_theFormSI060719.push(answer);
_totalSupply = _totalSupply.add(1);
_supplyPerQ[questionId] = _supplyPerQ[questionId].add(1);
_theQAtoIndex[questionId].push(_totalSupply - 1);
_theIndexToQA.push([questionId, _supplyPerQ[questionId] - 1]);
_tokenOwner[_totalSupply - 1] = msg.sender;
_ownedTokensCount[msg.sender] = _ownedTokensCount[msg.sender].add(1);
emit QuestionAnswered(questionId, _supplyPerQ[questionId] - 1,
msg.sender);
return true;
}
| 0
|
function EIForceCoin () public {
balances[msg.sender] = TOTAL_SUPPLY;
totalSupply = TOTAL_SUPPLY;
transfer(WALLET_FOUNDER, ALLOC_FOUNDER);
}
| 0
|
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 getGameSettings() external view returns (
uint _recruitHeroFee,
uint _transportationFeeMultiplier,
uint _noviceDungeonId,
uint _consolationRewardsRequiredFaith,
uint _challengeFeeMultiplier,
uint _dungeonPreparationTime,
uint _trainingFeeMultiplier,
uint _equipmentTrainingFeeMultiplier,
uint _preparationPeriodTrainingFeeMultiplier,
uint _preparationPeriodEquipmentTrainingFeeMultiplier
);
function getPlayerDetails(address _address) external view returns (
uint dungeonId,
uint payment,
uint dungeonCount,
uint heroCount,
uint faith,
bool firstHeroRecruited
);
function getDungeonDetails(uint _id) external view returns (
uint creationTime,
uint status,
uint difficulty,
uint capacity,
address owner,
bool isReady,
uint playerCount
);
function getDungeonFloorDetails(uint _id) external view returns (
uint floorNumber,
uint floorCreationTime,
uint rewards,
uint seedGenes,
uint floorGenes
);
function getHeroDetails(uint _id) external view returns (
uint creationTime,
uint cooldownStartTime,
uint cooldownIndex,
uint genes,
address owner,
bool isReady,
uint cooldownRemainingTime
);
function getHeroAttributes(uint _genes) public pure returns (uint[]);
function getHeroPower(uint _genes, uint _dungeonDifficulty) public pure returns (
uint totalPower,
uint equipmentPower,
uint statsPower,
bool isSuper,
uint superRank,
uint superBoost
);
function getDungeonPower(uint _genes) public pure returns (uint);
function calculateTop5HeroesPower(address _address, uint _dungeonId) public view returns (uint);
}
contract DungeonRunBeta is Pausable, Destructible {
struct Monster {
uint64 creationTime;
uint8 level;
uint16 initialHealth;
uint16 health;
}
| 0
|
function increaseApproval (address _spender, uint256 _addedValue) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
| 0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.