function
string | label
int64 |
|---|---|
function addMessage(string msgStr) payable {
Message memory newMsg;
newMsg.message = msgStr;
newMsg.from = msg.sender;
newMsg.timestamp = block.timestamp;
messages[messagesIndex] = newMsg;
messagesIndex += 1;
messagesIndex = messagesIndex % 10;
postedMessages++;
}
| 1
|
function start(uint256 _startTimestamp, uint256 _endTimestamp, address _fundingAddress)
public onlyManager() hasntStarted() hasntStopped();
function isFailed() public constant returns (bool);
function isActive() public constant returns (bool);
function isSuccessful() public constant returns (bool);
}
contract BasicCrowdsale is ICrowdsaleProcessor {
event CROWDSALE_START(uint256 startTimestamp, uint256 endTimestamp, address fundingAddress);
address public fundingAddress;
function BasicCrowdsale(
address _owner,
address _manager
)
public
{
owner = _owner;
manager = _manager;
}
| 0
|
function approveAndCall(address spender, uint tokens, bytes _data) public returns (bool success) {
success = data.approveAndCall(this, spender, tokens, _data);
}
| 0
|
function acceptOwnership() public;
}
contract Ownable is IOwnable {
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
| 0
|
function getCurrentTime() internal constant returns (uint) {
return now;
}
| 1
|
function advSptIssue(address _to, uint _time) onlyOwner public
{
require(saleTime == false);
require( _time < advSptVestingTime);
uint nowTime = now;
require( nowTime > advSptVestingTimer[_time] );
uint tokens = advSptVestingSupplyPerTime;
require(tokens <= advSptVestingBalances[_time]);
require(tokens > 0);
require(maxAdvSptSupply >= tokenIssuedAdvSpt.add(tokens));
balances[_to] = balances[_to].add(tokens);
advSptVestingBalances[_time] = 0;
totalTokenSupply = totalTokenSupply.add(tokens);
tokenIssuedAdvSpt = tokenIssuedAdvSpt.add(tokens);
emit AdvSptIssue(_to, tokens);
}
| 0
|
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
uint256 _allowance = allowed[_from][msg.sender];
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(_from, _to, _value);
return true;
}
| 0
|
function div(uint256 a, uint256 b) internal pure
returns (uint256)
{
uint256 c = a / b;
return c;
}
| 0
|
function transfer(address _to, uint256 _value) public 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);
emit Transfer(msg.sender, _to, _value);
return true;
}
| 0
|
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
| 0
|
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
super._preValidatePurchase(_beneficiary, _weiAmount);
require(weiRaised.add(_weiAmount) <= cap);
}
| 0
|
function vestedBalanceOf(address _address) public constant returns (uint256 balance);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
function transfer(address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _currentValue, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
}
contract CrowdsaleParameters {
struct AddressTokenAllocation {
address addr;
uint256 amount;
}
| 0
|
function UpgradeableToken(address _upgradeMaster) public {
upgradeMaster = _upgradeMaster;
}
| 0
|
function totalSupply() public view returns (uint256) {
return totalSupplyTokens;
}
| 0
|
function max256(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
| 0
|
function safeSub(uint256 _x, uint256 _y) internal returns (uint256) {
assert(_x >= _y);
return _x - _y;
}
| 0
|
function approve(address spender, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
| 0
|
function HodlFor(address _purpose, address _dubi, address _hodler) public {
require(_purpose != address(0));
require(_hodler != address(0));
purpose = Purpose(_purpose);
changeDubiAddress(_dubi);
hodler = Hodler(_hodler);
}
| 0
|
function randInt(uint max, uint seedswitch) private constant returns (uint randomNumber) {
return( uint(sha3(block.blockhash(block.number-1), block.timestamp + seedswitch) ) % max + 1 );
}
| 1
|
function _attack(uint _heroId, uint _genes, uint _heroStrength, uint _heroCurrentHealth) internal {
Monster storage monster = heroIdToMonster[_heroId];
uint8 currentLevel = monster.level;
uint heroPower;
(heroPower,,,,) = edCoreContract.getHeroPower(_genes, dungeonDifficulty);
uint damageByMonster;
uint damageByHero;
if (now > monster.creationTime + monsterFleeTime) {
damageByMonster = currentLevel + monsterStrength;
} else {
if (currentLevel >= 2) {
damageByMonster = _getRandomNumber(currentLevel / 2);
}
}
if (damageByMonster >= _heroCurrentHealth) {
heroIdToHealth[_heroId] = 0;
uint addToJackpot = entranceFee - heroIdToRefundedFee[_heroId];
jackpot += addToJackpot;
entranceFeePool -= addToJackpot;
assert(addToJackpot <= entranceFee);
} else {
heroIdToHealth[_heroId] -= damageByMonster;
if (now > monster.creationTime + monsterFleeTime) {
currentLevel++;
heroIdToMonster[_heroId] = Monster(uint64(monster.creationTime + monsterFleeTime),
currentLevel, currentLevel * monsterHealth, currentLevel * monsterHealth);
monster = heroIdToMonster[_heroId];
}
damageByHero = (_heroStrength * 1e9 + heroPower * 1e9 / (10 * (1 + _getRandomNumber(5)))) / tx.gasprice;
bool isMonsterDefeated = damageByHero >= monster.health;
uint rewards;
if (isMonsterDefeated) {
uint8 newLevel = currentLevel + 1;
heroIdToMonster[_heroId] = Monster(uint64(now), newLevel, newLevel * monsterHealth, newLevel * monsterHealth);
monster = heroIdToMonster[_heroId];
if (currentLevel == checkpointLevel) {
rewards = entranceFee / 2;
heroIdToRefundedFee[_heroId] += rewards;
entranceFeePool -= rewards;
} else if (currentLevel == breakevenLevel) {
rewards = entranceFee / 2;
heroIdToRefundedFee[_heroId] += rewards;
entranceFeePool -= rewards;
} else if (currentLevel == jackpotLevel) {
rewards = jackpot / 2;
jackpot -= rewards;
}
msg.sender.transfer(rewards);
} else {
monster.health -= uint8(damageByHero);
}
}
LogAttack(now, msg.sender, _heroId, currentLevel, damageByHero, damageByMonster, isMonsterDefeated, rewards);
}
| 0
|
function ReleaseDate() public constant returns (uint) { return Date; }
function WithdrawEnabled() public constant returns (bool) { return Date > 0 && Date <= now; }
function() public payable { deposit(); }
function deposit() public payable {
if (msg.value > 0) {
if (msg.value >= MinimumDeposit())
Deposits[msg.sender] += msg.value;
Deposit(msg.sender, msg.value);
}
}
| 1
|
modifier canTransfer(address sender) {
require(released || transferAgents[sender]);
_;
}
| 0
|
function noteBallotDeployed(bytes32 democHash) external;
function upgradeMe(address newSC) external;
}
contract safeSend {
bool private txMutex3847834;
function doSafeSend(address toAddr, uint amount) internal {
doSafeSendWData(toAddr, "", amount);
}
| 0
|
function claim_bounty(){
if (bought_tokens) return;
if (kill_switch) throw;
bought_tokens = true;
time_bought = now;
token.proxyPayment.value(this.balance - bounty)(address(this));
msg.sender.transfer(bounty);
}
| 1
|
function Ownable() public { owner = msg.sender; }
modifier onlyOwner {
require(msg.sender == owner);
_;
}
| 0
|
function transferFrom(address from, address to, uint256 value) public pure returns (bool success){
return false;
}
| 0
|
function owned() public {
owner = msg.sender;
}
| 0
|
function transfer(address _to, bytes32 _value) returns (bool success) {
if (_value == 0x0) return false;
if (tokens[_value].id() != _value) return false;
if (ownedToken[_to] != 0x0) return false;
var tokenToTransfer = tokens[_value];
if (tokenToTransfer.owner != msg.sender) return false;
tokenToTransfer.owner = _to;
ownedToken[msg.sender] = 0x0;
ownedToken[_to] = _value;
TokenLib.logTransfer(msg.sender, _to, _value);
return true;
}
| 0
|
function timeLockAdvisor(address _target) public onlySuperAdmins validateAddress(_target) {
require(timelockedAccounts[_target] == 0);
timelockedAccounts[_target] = ADVISOR_LOCKUP_END;
emit LockedFunds(_target, ADVISOR_LOCKUP_END);
}
| 0
|
function balanceOf(address _owner) external view returns (uint256 balance);
function allowance(address _owner, address _spender) external view returns (uint256 remaining);
}
contract SafeMath {
function safeMul(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(
c / a == b,
"UINT256_OVERFLOW"
);
return c;
}
| 0
|
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
);
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
| 0
|
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
pragma solidity ^0.5.0;
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
| 0
|
function transfer(address _to, uint256 _amount)public returns (bool success) {
require(!lockstatus, "Token is locked now");
require( _to != 0x0, "Receiver can not be 0x0");
require(balances[msg.sender] >= _amount, "Balance does not have enough tokens");
require(!locked[msg.sender], "Sender address is locked");
balances[msg.sender] = (balances[msg.sender]).sub(_amount);
balances[_to] = (balances[_to]).add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
| 0
|
function div(uint a, uint b) internal returns (uint) {
uint c = a / b;
return c;
}
| 0
|
function setIcoAddress(address _ico) public onlyOwner {
require(_ico != address(0));
require(balanceOf(addressIco) == 0);
addressIco = _ico;
transferOwnership(_ico);
}
| 0
|
constructor(ReadableI _makerDAOMedianizer) public {
require(_makerDAOMedianizer != address(0));
makerDAOMedianizer = _makerDAOMedianizer;
weiPerUnitRate = convertToRate(_makerDAOMedianizer.read());
lastTimeUpdated = now;
}
| 0
|
function removePlot(address addr, uint id) private {
uint n = plotsOwned[addr].length;
for (uint8 i = 0; i < n; i++) {
if (plotsOwned[addr][i] == id) {
plotsOwned[addr][i] = plotsOwned[addr][n - 1];
delete plotsOwned[addr][n - 1];
plotsOwned[addr].length--;
break;
}
}
}
| 0
|
function getBalance () constant noEther returns (uint256) {
DaoAccount account = accountFor(msg.sender, false);
if (account == DaoAccount(0x00)) return 0;
return account.balance;
}
| 0
|
constructor() internal {
owner = msg.sender;
}
| 0
|
function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
| 0
|
function walletData(address _wallet) public view returns (string) {
return whitelist[_wallet].data;
}
| 0
|
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 DungeonRunCore is Pausable, Destructible {
struct Monster {
uint64 creationTime;
uint8 level;
uint16 initialHealth;
uint16 health;
}
| 0
|
function balanceOf(address _owner) public view returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
}
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 transfer(address _to, uint256 _value, bytes _data, string _custom_fallback) onlyPayloadSize(4 * 32) public returns (bool success) {
if(isContract(_to)) {
require(Balances(balancesContract()).get(msg.sender) >= _value);
Balances(balancesContract()).transfer(msg.sender, _to, _value);
ContractReceiver receiver = ContractReceiver(_to);
require(receiver.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
Transfer(msg.sender, _to, _value);
Transfer(msg.sender, _to, _value, _data);
return true;
} else {
return transferToAddress(_to, _value, _data);
}
}
| 0
|
function balanceOf(address who)public view returns (uint256);
function allowance(address owner, address spender)public view returns (uint);
function transferFrom(address from, address to, uint value)public returns (bool ok);
function approve(address spender, uint value)public returns (bool ok);
function transfer(address to, uint value)public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract FiatContract
{
function USD(uint _id) constant returns (uint256);
}
contract TestFiatContract
{
function USD(uint) constant returns (uint256)
{
return 12305041990000;
}
| 0
|
function deposit(address investor) onlyOwner payable {
require(state == State.Active);
deposited[investor] = deposited[investor].add(msg.value);
}
| 0
|
function resetEmergencyRelease(address traderAddr) private {
if (emergencyReleaseSince[traderAddr] != 0) {
emergencyReleaseSince[traderAddr] = 0;
}
}
| 0
|
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Crowdsale is Ownable {
using SafeMath for uint256;
ERC20 public token;
uint256 private transactionNum;
uint256 public startTime;
uint256 public endTime;
address public wallet;
uint256 public rate;
uint256 public discountRate = 3333;
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet, address _token) public {
require(_startTime >= now);
require(_endTime >= _startTime);
require(_rate > 0);
require(_wallet != address(0));
token = ERC20(_token);
startTime = _startTime;
endTime = _endTime;
rate = _rate;
wallet = _wallet;
}
| 0
|
function setFounderLock(address _address, uint256 _value, uint _round, uint256 _period) internal{
founderLockance[_address].amount = _value;
founderLockance[_address].startTime = now;
founderLockance[_address].remainRound = _round;
founderLockance[_address].totalRound = _round;
founderLockance[_address].period = _period;
}
| 0
|
function hasClosed() public view returns (bool) {
return block.timestamp > closingTime;
}
| 0
|
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract TokenERC20 {
string public name;
string public symbol;
uint8 public decimals = 18;
uint256 initialSupply=5000000000;
uint256 MAX_CAP = 5000000000;
uint256 public totalSupply;
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 TokenERC20() public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = "Zmbc";
symbol = "ZMB";
}
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 transfer(address _to, uint256 _value) public returns (bool success){
_transfer(msg.sender, _to, _value);
return true;
}
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 getStats() constant returns (uint32, uint32, uint32, bool) {
return (
uint32(totalContribution / 1 finney),
uint32(totalSupply / 1 finney),
uint32(totalBonusTokensIssued / 1 finney),
purchasingAllowed
);
}
| 1
|
function getTime() internal returns (uint) {
return now;
}
| 1
|
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
contract BTTSTokenInterface is ERC20Interface {
uint public constant bttsVersion = 100;
bytes public constant signingPrefix = "\x19Ethereum Signed Message:\n32";
bytes4 public constant signedTransferSig = "\x75\x32\xea\xac";
bytes4 public constant signedApproveSig = "\xe9\xaf\xa7\xa1";
bytes4 public constant signedTransferFromSig = "\x34\x4b\xcc\x7d";
bytes4 public constant signedApproveAndCallSig = "\xf1\x6f\x9b\x53";
event OwnershipTransferred(address indexed from, address indexed to);
event MinterUpdated(address from, address to);
event Mint(address indexed tokenOwner, uint tokens, bool lockAccount);
event MintingDisabled();
event TransfersEnabled();
event AccountUnlocked(address indexed tokenOwner);
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success);
function signedTransferHash(address tokenOwner, address to, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash);
function signedTransferCheck(address tokenOwner, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function signedTransfer(address tokenOwner, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success);
function signedApproveHash(address tokenOwner, address spender, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash);
function signedApproveCheck(address tokenOwner, address spender, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function signedApprove(address tokenOwner, address spender, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success);
function signedTransferFromHash(address spender, address from, address to, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash);
function signedTransferFromCheck(address spender, address from, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function signedTransferFrom(address spender, address from, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success);
function signedApproveAndCallHash(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce) public view returns (bytes32 hash);
function signedApproveAndCallCheck(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function signedApproveAndCall(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success);
function mint(address tokenOwner, uint tokens, bool lockAccount) public returns (bool success);
function unlockAccount(address tokenOwner) public;
function disableMinting() public;
function enableTransfers() public;
enum CheckResult {
Success,
NotTransferable,
AccountLocked,
SignerMismatch,
AlreadyExecuted,
InsufficientApprovedTokens,
InsufficientApprovedTokensForFees,
InsufficientTokens,
InsufficientTokensForFees,
OverflowError
}
| 0
|
function updatePromoter4(address _address) external onlyOwner {
require(_address != address(0x0));
promoter4 = _address;
}
| 0
|
function releaseICO() external onlyOwner {
stopped = false;
stage = Stages.ICO;
}
| 0
|
function ecoIssue(address _to, uint _time, uint _value) onlyOwner public
{
require(saleTime == false);
require( _time < ecoVestingTime);
uint nowTime = now;
require( nowTime > ecoVestingTimer[_time] );
uint tokens = _value * E18;
require(tokens <= ecoVestingBalances[_time]);
require(tokens > 0);
require(maxEcoSupply >= tokenIssuedEco.add(tokens));
balances[_to] = balances[_to].add(tokens);
ecoVestingBalances[_time] = ecoVestingBalances[_time].sub(tokens);
totalTokenSupply = totalTokenSupply.add(tokens);
tokenIssuedEco = tokenIssuedEco.add(tokens);
emit EcoIssue(_to, tokens);
}
| 0
|
function reclaim(IBasicToken token)
public
only(ROLE_RECLAIMER)
{
address reclaimer = msg.sender;
if(token == RECLAIM_ETHER) {
reclaimer.transfer(this.balance);
} else {
uint256 balance = token.balanceOf(this);
require(token.transfer(reclaimer, balance));
}
}
| 0
|
function invest() public payable {
assert(now >= offset && now < offset + length);
assert(collected + price <= hardCap || hardCap == 0);
require(msg.value >= price);
address investor = msg.sender;
uint tokens = msg.value / price;
uint value = tokens * price;
if (value + collected > hardCap || hardCap == 0) {
value = hardCap - collected;
tokens = value / price;
value = tokens * price;
}
collected += value;
tokensIssued += tokens;
__issueTokens(investor, tokens);
investor.transfer(msg.value - value);
if (collected >= softCap && this.balance >= quantum) {
__beneficiaryTransfer(this.balance);
}
InvestmentAccepted(investor, tokens, value);
}
| 0
|
function changeDeveloper(address new_dev)
noEthSent
onlyDeveloper
{
developer=new_dev;
}
| 0
|
function approve(address _spender, uint256 _value) public returns (bool) {
require(_value == 0 || allowed[msg.sender][_spender] == 0);
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
| 0
|
function allowance(address _owner, address _spender) external constant returns (uint remaining) {
return allowed[_owner][_spender];
}
| 0
|
function getCurrentlyRunningPhase()public view returns(int8){
for(uint8 i=0;i<noOfPhases;i++){
if(phases[i].startTime!=0 && now>=phases[i].startTime && phases[i].endTime == 0){
return int8(i);
}
}
return -1;
}
| 0
|
constructor() public {
lock = now;
emit SetLock(0, now);
}
| 0
|
constructor () internal {
_addMinter(msg.sender);
}
| 0
|
function recover(bytes32 hash, bytes memory sig) public pure returns (address) {
bytes32 r;
bytes32 s;
uint8 v;
if (sig.length != 65) {
return (address(0));
}
assembly {
r := mload(add(sig, 32))
s := mload(add(sig, 64))
v := byte(0, mload(add(sig, 96)))
}
if (v < 27) {
v += 27;
}
if (v != 27 && v != 28) {
return (address(0));
} else {
return ecrecover(hash, v, r, s);
}
}
| 0
|
function myDividends()
external
view
returns(uint256)
{
address shareholder = msg.sender;
uint256 dividendPointsDifference = totalDividendPoints.sub(shareholders[shareholder].lastDividendPoints);
return shareholders[shareholder].outstandingDividends
.add(dividendPointsDifference.mul(shareholders[shareholder].tokens) / POINT_MULTIPLIER);
}
| 0
|
function usageFee(bytes32 _serviceName, uint256 _multiplier) public constant returns(uint fee) {
require(isValidService(_serviceName));
require(_multiplier != 0);
return 0;
}
| 0
|
function removeFromWhitelist(address _beneficiary) external onlyOwner {
whitelist[_beneficiary] = false;
}
| 0
|
function changeEndTime(uint256 _newTime) onlyOwner external {
require(endTime >= now);
endTime = _newTime;
}
| 0
|
function time() public view returns (uint) {
return block.timestamp;
}
| 0
|
function changeFounderMultiSigAddress(address _newFounderMultiSigAddress) onlyFounders nonZeroAddress(_newFounderMultiSigAddress) {
founderMultiSigAddress = _newFounderMultiSigAddress;
ChangeFoundersWalletAddress(now, founderMultiSigAddress);
}
| 1
|
function fetchDividendsFromP3X()
public
{
lastDividendsFetched = now;
uint256 dividends = p3xContract.dividendsOf(address(this), true);
if(dividends > 0) {
p3xContract.withdraw();
totalDividendPoints = totalDividendPoints.add(dividends.mul(POINT_MULTIPLIER) / totalSupply);
totalOutstandingDividends = totalOutstandingDividends.add(dividends);
}
}
| 0
|
function withdrawBonus() onlyBonusOwner {
if(now>finalTimestampOfBonusPeriod) {
var bonusValue = ownedBonus[msg.sender];
ownedBonus[msg.sender] = 0;
BonusWithdrawn(msg.sender, bonusValue);
msg.sender.transfer(bonusValue);
}
}
| 1
|
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==ELIXAddress) {
convertToELIX(_value,msg.sender);
}
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
}
}
| 1
|
function registerColor(string label, uint256 startingPrice) external onlyOwner {
Color memory _Color = Color({
label: label,
creationTime: uint64(now)
});
uint256 newColorId = colors.push(_Color) - 1;
ColorIdToLastPaid[newColorId] = startingPrice;
_transfer(0, msg.sender, newColorId);
}
| 1
|
function authorized_recordFailedOldOwnerTransfer(address _oldOwner) external payable requireAuthorizedLogicContract {
addressToFailedOldOwnerTransferAmount[_oldOwner] += msg.value;
totalFailedOldOwnerTransferAmounts += msg.value;
}
| 0
|
function refundable(bytes32 _swapID) external view returns (bool) {
return (now >= swaps[_swapID].timelock && swapStates[_swapID] == States.OPEN);
}
| 0
|
function getCurrent() internal returns (uint256) {
return now;
}
| 1
|
function withdrawEther(address traderAddr, address payable withdrawalAddr, uint amount) external
onlyActive()
onlyApprovedExchange(traderAddr) {
deductBalance(0, traderAddr, amount);
resetEmergencyRelease(traderAddr);
emit Withdrawal(0, traderAddr, withdrawalAddr, amount);
withdrawalAddr.transfer(amount);
}
| 0
|
function hodl(address _beneficiary, uint256 _id, uint256 _value, uint256 _months) external {
require(_beneficiary != address(0));
require(_id > 0);
address _creator = msg.sender;
Item storage item = items[_creator][_id];
require(item.id != _id);
items[_creator][_id] = Item(_id, _creator, _beneficiary, false);
purpose.safeTransferFrom(_creator, this, _value);
hodler.hodl(_id, _value, _months);
uint256 balance = dubi.balanceOf(this);
dubi.safeTransfer(_beneficiary, balance);
}
| 0
|
modifier noEther() {if (msg.value > 0) throw; _}
modifier onlyChallengeOwner() {if (challengeOwner != msg.sender) throw; _}
function DaoChallenge () {
challengeOwner = msg.sender;
}
| 0
|
function createTokens(address _beneficiary, uint256 _value) internal whenNotPaused {
require (tokenCreationCap > totalSupply);
require (now >= fundingStartTime);
require (_value >= minContribution);
require (!isFinalized);
uint256 tokens = safeMult(_value, tokenExchangeRate);
uint256 checkedSupply = safeAdd(totalSupply, tokens);
if (tokenCreationCap < checkedSupply) {
uint256 tokensToAllocate = safeSubtract(tokenCreationCap, totalSupply);
uint256 tokensToRefund = safeSubtract(tokens, tokensToAllocate);
totalSupply = tokenCreationCap;
uint256 etherToRefund = tokensToRefund / tokenExchangeRate;
require(CreateICO(_beneficiary, tokensToAllocate));
msg.sender.transfer(etherToRefund);
ethFundDeposit.transfer(this.balance);
return;
}
totalSupply = checkedSupply;
require(CreateICO(_beneficiary, tokens));
ethFundDeposit.transfer(this.balance);
}
| 1
|
function Escrow() {
owner = msg.sender;
}
| 0
|
function transferTokensLeftOver() internal {
require(!remainingTransfered);
require(maxTokensRaised > tokensRaised);
remainingTransfered = true;
uint256 remainingTokens = maxTokensRaised.sub(tokensRaised);
token.distributeCrowdsaleTokens(msg.sender, remainingTokens);
}
| 0
|
function setEndDate(uint256 _endTime)
external onlyOwner whenNotPaused
{
require(now <= _endTime);
require(startTime < _endTime);
endTime = _endTime;
}
| 0
|
function transfer(address to, uint256 value) public returns (bool success);
function transferFrom(address from, address to, uint256 value) public returns (bool success);
function approve(address spender, uint256 value) public returns (bool success);
function allowance(address owner, address spender) public view returns (uint256 remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
| 0
|
function lock(address _address) public onlyOwner {
lockedAddress[_address] = true;
}
| 0
|
function pay(bytes32 _tradeID, address _seller, address _buyer, uint256 _value, uint256 _commission, bytes _sign)
external
payable
{
require(msg.value > 0);
require(msg.value == _value);
require(msg.value > _commission);
bytes32 _hashDeal = keccak256(_tradeID, _seller, _buyer, msg.value, _commission);
verifyDeal(_hashDeal, _sign);
startDealForUser(_hashDeal, _seller, _buyer, _commission, msg.value, false);
}
| 0
|
function _releasableAmount(IERC20 token) private view returns (uint256) {
return _vestedAmount(token).sub(_released[address(token)]);
}
| 0
|
function decreaseApproval (address _spender, uint _subtractedValue)
returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
| 0
|
function withdrawTokens(IERC20Token _token, address _to, uint256 _amount) public;
}
contract TokenHolder is ITokenHolder, Owned {
function TokenHolder() {
}
| 0
|
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath::sub: Integer underflow");
uint256 c = a - b;
return c;
}
| 0
|
function destroy() onlyOwner public {
selfdestruct(owner);
}
| 0
|
function nonceOf(address _addr) public view returns (uint256 nonce){
return _nonces[_addr];
}
| 0
|
function balanceOf(address tokenOwner) external view returns(uint);
function dividendsOf(address customerAddress, bool includeReferralBonus) external view returns(uint256);
function withdraw() external;
}
library SafeMath {
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
| 0
|
function _recordFirstClaimTimestamp(uint256 _cardId) internal {
cardIdToFirstClaimTimestamp[_cardId] = uint128(now);
}
| 0
|
function setReleaseType(address _target, ReleaseType _type) public onlyOwner {
require(_target != address(0));
_accountType[_target] = _type;
}
| 0
|
function ToLend() public payable
{
Certificates[msg.sender].Time = now;
Certificates[msg.sender].Invested += msg.value;
Deposited(msg.sender, msg.value);
}
| 1
|
function transfer(address to, uint256 value) external returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
}
library SafeMath {
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
| 0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.