function
string | label
int64 |
|---|---|
modifier requireAuthorizedLogicContract() {
require(msg.sender == authorizedLogicContractAddress);
_;
}
| 0
|
function addComment(string _comment, address _to, bool _aboutBounty, uint _bountyId)
public
{
if (_aboutBounty){
comments.push(Comment(_comment, msg.sender, address(0), _aboutBounty, _bountyId, block.timestamp));
} else {
comments.push(Comment(_comment, msg.sender, _to, _aboutBounty, _bountyId, block.timestamp));
}
CommentAdded(_comment, msg.sender, _to, block.timestamp);
}
| 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);
}
contract Burnable {
function burnTokens(address account, uint value) internal;
event Burned(address account, uint value);
}
contract Mintable {
function mintInternal(address receiver, uint amount) internal;
event Minted(address receiver, uint amount);
}
contract StandardToken is EIP20Token, Burnable, Mintable {
using SafeMath for uint;
uint private total_supply;
mapping(address => uint) private balances;
mapping(address => mapping (address => uint)) private allowed;
function totalSupply() public view returns (uint) {
return total_supply;
}
| 0
|
function sellEggs() public{
require(initialized);
uint256 hasEggs=getMyEggs();
uint256 eggValue=calculateEggSell(hasEggs);
uint256 fee=devFee(eggValue);
claimedEggs[msg.sender]=0;
lastHatch[msg.sender]=now;
marketEggs=SafeMath.add(marketEggs,hasEggs);
ceoAddress.transfer(fee);
msg.sender.transfer(SafeMath.sub(eggValue,fee));
}
| 0
|
function BlockbidCrowdsale(uint _goal, uint _cap, uint _startTime, uint _endTime, uint _rate, uint _earlyBonus, address _wallet)
Crowdsale(_startTime, _endTime, _rate, _wallet) public {
require(_cap > 0);
require(_goal > 0);
standardrate = _rate;
earlybonus = _earlyBonus;
cap = _cap;
goal = _goal;
}
| 0
|
function SpaceRegistry() {
spaces.length = START_INDEX;
}
| 1
|
function allowance(address owner, address spender) public view returns (uint256) {
return _allowed[owner][spender];
}
| 0
|
function removeFreezer(address freezer) public {
int index = indexOf(c_freezers, freezer);
if (index >= 0) {
uint i = uint(index);
while (i < c_freezers.length - 1) {
c_freezers[i] = c_freezers[i + 1];
}
c_freezers.length--;
}
}
| 0
|
function pause() public;
function unpause() public;
}
contract Burnable {
event Burn(address burner, uint256 value);
constructor () internal {}
function burn(address account, uint256 value) public;
function _burn(address account, uint256 value) internal{
emit Burn(account, value);
}
| 0
|
function unlock() public {
if(now < unlockedAt) throw;
if(!teamMultisig.send(address(this).balance)) throw;
Unlocked();
}
| 1
|
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);
}
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 changeContractName(string _newName,string _newSymbol) public {
require(msg.sender==owner || adminOwners[msg.sender].isValid);
name=_newName;
symbol=_newSymbol;
}
| 0
|
function upgradeFrom(address _from, uint256 _value) public;
}
contract TruUpgradeableToken is StandardToken {
using SafeMath for uint256;
using SafeMath for uint;
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint256 public totalUpgraded;
bool private isUpgradeable = true;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade(address indexed from,
address indexed to,
uint256 upgradeValue);
event UpgradeAgentSet(address indexed agent,
address indexed executor);
event NewUpgradedAmount(uint256 originalBalance,
uint256 newBalance,
address indexed executor);
modifier onlyUpgradeMaster() {
require(msg.sender == upgradeMaster);
_;
}
| 0
|
function approve(address spender, uint256 value) external returns (bool);
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);
}
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 issueTokens (uint256 n, uint256 price, uint deadline) noEther onlyChallengeOwner {
if (now < tokenIssueDeadline) throw;
if (deadline < now) throw;
if (n == 0) throw;
tokenPrice = price;
tokenIssueDeadline = deadline;
tokensToIssue = n;
tokensIssued = 0;
notifyTokenIssued(n, price, deadline);
}
| 0
|
function transferToContract(address _to, uint256 _value, bytes _data) internal returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, _data);
emit Transfer(msg.sender, _to, _value);
emit Transfer(msg.sender, _to, _value, _data);
return true;
}
| 0
|
modifier canTransfer() {
require(mintingFinished);
require(now > allowTransferTimestamp);
_;
}
| 1
|
function approve(address _spender, uint256 _value) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
| 0
|
function upgrade(uint256 value) public {
UpgradeState state = getUpgradeState();
require(state == UpgradeState.ReadyToUpgrade || state == UpgradeState.Upgrading);
require(value > 0);
balances[msg.sender] = balances[msg.sender].safeSub(value);
totalSupply = totalSupply.safeSub(value);
totalUpgraded = totalUpgraded.safeAdd(value);
upgradeTarget.upgradeFrom(msg.sender, value);
LogUpgrade(msg.sender, upgradeTarget, value);
}
| 0
|
function mint(address account, uint256 amount) external onlyOwner {
require(saleBeginTime < block.timestamp);
require(saleEndTime > block.timestamp);
_transfer(address(this), account, amount);
emit Mint(account, amount, _amountForSale);
}
| 0
|
function updateValue(uint256 newValue) {
require(msg.sender == updater || msg.sender == owner);
tokenValue = newValue;
UpdateValue(newValue);
}
| 0
|
constructor() public {
totalToken = initialToken;
balances[msg.sender] = publicToken;
balances[founderAddress] = founderToken;
balances[developmentAddress] = developmentToken;
balances[bountyAddress] = bountyToken;
balances[privateSaleAddress] = privateSaleToken;
balances[preSaleAddress] = preSaleToken;
emit Transfer(0x0, msg.sender, publicToken);
emit Transfer(0x0, founderAddress, founderToken);
emit Transfer(0x0, developmentAddress, developmentToken);
emit Transfer(0x0, bountyAddress, bountyToken);
emit Transfer(0x0, privateSaleAddress, privateSaleToken);
emit Transfer(0x0, preSaleAddress, preSaleToken);
lockAddresses[founderAddress] = true;
lockAddresses[developmentAddress] = true;
lockAddresses[bountyAddress] = true;
lockAddresses[privateSaleAddress] = true;
lockAddresses[preSaleAddress] = true;
destroyedToken = 0;
}
| 0
|
function changeAdminAddress(address _newAddress)
external
onlyAdmin
nonZeroAddress(_newAddress)
{
adminMultiSig = _newAddress;
ChangeAdminWalletAddress(now, adminMultiSig);
}
| 1
|
function transferFrom(address _from, address _to, uint _value) canTransfer(_from, _value) returns (bool success) {
return super.transferFrom(_from, _to, _value);
}
| 0
|
function removeAdmin(address adminAddress) public onlyOwner {
addressIsAdmin[adminAddress] = false;
}
| 0
|
function transferDecimalAmountFrom(address _from, address _to, uint _value) public returns (bool success) {
require(balanceOf[_from]
- tradingBalanceOf[_from][currentTradingSystem]
- exchangeBalanceOf[_from][currentExchangeSystem] >= _value);
require(balanceOf[_to] + (_value) >= balanceOf[_to]);
require(_value <= allowance[_from][msg.sender]);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
allowance[_from][msg.sender] -= _value;
Transfer(_to, _from, _value);
return true;
}
| 0
|
function incAdminEpoch() only_owner() external {
currAdminEpoch++;
admins[currAdminEpoch][msg.sender] = true;
emit AdminEpochInc();
}
| 0
|
constructor() public {
owner = msg.sender;
_totalBalance[owner] = _totalSupply;
_accountType[owner] = ReleaseType.Private1;
}
| 0
|
function mint(address _to, uint256 _amount) external;
}
contract ReentrancyGuard {
bool private rentrancy_lock = false;
modifier nonReentrant() {
require(!rentrancy_lock);
rentrancy_lock = true;
_;
rentrancy_lock = false;
}
| 0
|
function release() public returns(bool) {
uint256 unreleased = releasableAmount();
require(unreleased > 0);
if (releaseTime > 0) {
require(block.timestamp >= releaseTime);
}
released = released.add(unreleased);
token.safeTransfer(beneficiary, unreleased);
emit Released(unreleased);
return true;
}
| 0
|
function getMintRequestsLength() external view returns (uint length) {
return mintRequests.length;
}
| 0
|
function buyTokens () returns (uint256 tokens) {
tokens = msg.value / tokenPrice;
if (now > tokenIssueDeadline) throw;
if (tokensIssued >= tokensToIssue) throw;
tokensIssued += tokens;
if (tokensIssued > tokensToIssue) throw;
DaoAccount account = accountFor(msg.sender, true);
if (account.buyTokens.value(msg.value)() != tokens) throw;
notifyBuyToken(msg.sender, tokens, msg.value);
return tokens;
}
| 0
|
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);
}
contract Owned {
address public owner = msg.sender;
address public potentialOwner;
modifier onlyOwner {
require(msg.sender == owner);
_;
}
| 0
|
function supportsInterface(bytes4 interfaceId) external view returns (bool) {
return _supportedInterfaces[interfaceId];
}
| 0
|
function time() public constant returns (uint)
{
return block.timestamp;
}
| 1
|
function Per_Annum(){
_totalSupply += 4000000000000;
_currentMined += 4000000000000;
contract_owner = msg.sender;
balances[msg.sender] += 4000000000000;
Transfer(this,msg.sender,4000000000000);
}
| 0
|
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 addAcceptedContribution(address participant, uint256 ethValue, uint256 parsecValue) private {
contributionOf[participant] = contributionOf[participant].add(ethValue);
parsecsOf[participant] = parsecsOf[participant].add(parsecValue);
raisedFunding = raisedFunding.add(ethValue);
spentParsecs = spentParsecs.add(parsecValue);
LogContribution(participant, ethValue, parsecValue, now);
multisigAddress.transfer(ethValue);
parsecToken.transfer(participant, parsecValue);
}
| 0
|
function isPricingStrategy() public constant returns (bool) {
return true;
}
| 0
|
function burn(uint256 _amount) external onlyDestroyer {
require(balances[destroyer] >= _amount && _amount > 0);
balances[destroyer] = balances[destroyer].sub(_amount);
totalSupply = totalSupply.sub(_amount);
Burn(_amount);
}
| 0
|
function burnInternal(address _from, uint256 _amount) internal {
require(_from != address(0));
require(_amount > 0);
require(_amount <= balances[_from]);
balances[_from] = balances[_from].sub(_amount);
totalSupply_ = totalSupply_.sub(_amount);
Transfer(_from, address(0), _amount);
Burn(_from, _amount);
}
| 0
|
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) onlyIfTransfersAllowed {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
}
| 0
|
function _transfer(address from, address to, uint256 value) internal {
if (_locked[from].locked) {
for (uint256 i = 0; i < _locked[from].batches.length; i++) {
if (block.timestamp <= _locked[from].batches[i].time) {
require(value <= balanceOf(from).sub(_locked[from].batches[i].amount));
break;
}
}
}
super._transfer(from, to, value);
}
| 0
|
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
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 setGasInTokens(uint _gasInTokens) onlyAdmin external {
gasInTokens = _gasInTokens;
}
| 0
|
function ToLend()
public
payable
{
Creditors[msg.sender].Time = now;
Creditors[msg.sender].Invested += msg.value;
Deposited(msg.sender,msg.value);
}
| 1
|
function mintETHRewards(address _contract, uint256 _amount) public onlyManager();
function mintTokenRewards(address _contract, uint256 _amount) public onlyManager();
function releaseTokens() public onlyManager() hasntStopped() whenCrowdsaleSuccessful();
function stop() public onlyManager() hasntStopped();
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 increaseApproval(address _spender, uint256 _addedValue) public erc20Allowed returns (bool) {
allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
| 0
|
function revokeVestedTokensFor(address _owner) public onlyOwner {
TokenVesting(vestingOf[_owner]).revoke(this);
}
| 0
|
function transfer(uint id, address newOwner, string newData)
validID(id) isOwnerOf(id) tradingIsEnabled returns(bool)
{
plots[id].owner = newOwner;
if (bytes(newData).length != 0) {
plots[id].metadata = newData;
}
Transfer(msg.sender, newOwner, id);
addPlot(newOwner, id);
removePlot(msg.sender, id);
return true;
}
| 0
|
function requestReturn(address _returnAddr) {
require(now <= endDate);
require(returnAddresses[msg.sender] == 0x0);
returnAddresses[msg.sender] = _returnAddr;
ReturnRequested(msg.sender, _returnAddr);
}
| 1
|
function signedTransferCheck(address tokenOwner, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result) {
return data.signedTransferCheck(address(this), tokenOwner, to, tokens, fee, nonce, sig, feeAccount);
}
| 0
|
function undo() public {
var wad = to.balanceOf(msg.sender);
require(now < undo_deadline);
require(from.transfer(msg.sender, wad));
to.pull(msg.sender, wad);
}
| 1
|
function getName() view public returns(bytes32)
{
return name;
}
| 0
|
modifier onlyMaster() {
require(msg.sender == master);
_;
}
| 0
|
function max256(uint256 a, uint256 b) internal constant returns (uint256)
{
return a >= b ? a : b;
}
| 0
|
modifier onlyOwner() {
require(msg.sender == owner, "Only owner");
_;
}
| 0
|
modifier isNotTimeLocked() {
require(now >= timelockedAccounts[msg.sender]);
_;
}
| 0
|
function collectRewards() external returns (bool) {
uint256 _amountInVault = _transferIns[msg.sender].amountInVault;
require(_amountInVault > 0, "You have not staked any tokens.");
require(_holdAgeTimestamp(msg.sender) >= _transferIns[msg.sender].stakeMinimumTimestamp,
"You need to stake for the minimum time of 1000 seconds.");
uint256 rewardForUser = tridentReward(msg.sender);
require(rewardForUser > 0, "Your reward is currently zero. Nothing to collect.");
_transferIns[msg.sender].amountInVault = 0;
_transferIns[msg.sender].tokenTimestamp = block.timestamp;
_transferIns[msg.sender].percentageLower = 0;
_transferIns[msg.sender].percentageMiddle = 0;
_transferIns[msg.sender].percentageUpper = 0;
_transferIns[msg.sender].stakeMinimumTimestamp = _oneDay;
_transferIns[msg.sender].stakeMaximumTimestamp = _oneYear + _sixMonths;
_remoteTransferFrom(address(this), msg.sender, _amountInVault);
uint256 _amountForTreasury = rewardForUser.mul(_treasuryPercentageOfReward).div(100);
_mint(_treasury, _amountForTreasury);
_mint(msg.sender, rewardForUser);
return true;
}
| 0
|
function releaseMyVestedTokens() public changesToVestingFreezed(msg.sender) {
releaseVestedTokens(msg.sender);
}
| 0
|
modifier notExceedMaximumSupply(uint amount) {
require(totalSupply.plus(amount) <= maximumSupply);
_;
}
| 0
|
function updateRenExBalances(RenExBalances _newRenExBalancesContract) external onlyOwner {
emit LogRenExBalancesUpdated(renExBalancesContract, _newRenExBalancesContract);
renExBalancesContract = _newRenExBalancesContract;
}
| 0
|
function Wolk()
{
start_block = 3831300;
end_block = 3831900;
balances[msg.sender] = wolkFund;
reservedTokens = 25 * 10**decimals;
allocations[0x564a3f7d98Eb5B1791132F8875fef582d528d5Cf] = 20;
allocations[0x7f512CCFEF05F651A70Fa322Ce27F4ad79b74ffe] = 1;
allocations[0x9D203A36cd61b21B7C8c7Da1d8eeB13f04bb24D9] = 2;
allocations[0x5fcf700654B8062B709a41527FAfCda367daE7b1] = 1;
allocations[0xC28dA4d42866758d0Fc49a5A3948A1f43de491e9] = 1;
CreateWolk(msg.sender, wolkFund);
}
| 0
|
function symbol() public constant returns (string) {
return symbol;
}
| 0
|
function tokenToDecimals(uint256 _amount) private view returns (uint256){
return _amount * (10 ** 12);
}
| 0
|
function transferFrom(address _from, address _to, uint256 _value) public transfersAllowed returns (bool success) {
assert(super.transferFrom(_from, _to, _value));
if (_to == address(this)) {
balanceOf[_to] -= _value;
totalSupply -= _value;
Destruction(_value);
}
return true;
}
| 0
|
modifier whenPaused() {
require(_paused);
_;
}
| 0
|
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
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 transfer(address _to, uint256 _value) public returns (bool) {
if (_to != address(this)) {
return super.transfer(_to, _value);
}
require(_value <= balances_[msg.sender] && status == 0 && gameTime == 0);
balances_[msg.sender] = balances_[msg.sender].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
uint256 weiAmount = price.mul(_value);
msg.sender.transfer(weiAmount);
emit Transfer(msg.sender, _to, _value);
emit Sell(_to, msg.sender, _value, weiAmount);
return true;
}
| 0
|
function nextForkBlockNumber()
public
constant
returns (uint256)
{
return _nextForkBlockNumber;
}
| 0
|
modifier onlyAdmin() {
require(addressIsAdmin[msg.sender] || msg.sender == owner);
_;
}
| 0
|
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
| 0
|
function setMerchantBtcDepositAddress(string btcDepositAddress) external onlyMerchant returns (bool) {
require(!isEmptyString(btcDepositAddress), "invalid btc deposit address");
merchantBtcDepositAddress[msg.sender] = btcDepositAddress;
emit MerchantBtcDepositAddressSet(msg.sender, btcDepositAddress);
return true;
}
| 0
|
function decimals() public constant returns (uint8 decimals) { decimals; }
function totalSupply() public constant returns (uint256 totalSupply) { totalSupply; }
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
|
modifier onlyPayloadSize(uint numwords) {
assert(msg.data.length >= numwords * 32 + 4);
_;
}
| 0
|
modifier onlyDelegator() {
require(isDelegator(msg.sender), "DelegatorRole: caller does not have the Delegator role.");
_;
}
| 0
|
function tridentDetails ()
external view returns
(
uint stakeMinimumTimestamp,
uint stakeMaximumTimestamp,
uint256 percentageLower,
uint256 percentageMiddle,
uint256 percentageUpper,
uint256 treasuryPercentage,
uint256 stakeMinimum,
uint256 stakeMaximum,
uint256 maxTotalSupply) {
stakeMinimumTimestamp = _stakeMinimumTimestamp;
stakeMaximumTimestamp = _stakeMaximumTimestamp;
percentageLower = _percentageLower;
percentageMiddle = _percentageMiddle;
percentageUpper = _percentageUpper;
treasuryPercentage = _treasuryPercentageOfReward;
stakeMinimum = _stakeMinimum;
stakeMaximum = _stakeMaximum;
maxTotalSupply = _maxTotalSupply;
}
| 0
|
function releaseableBalanceOf(address _owner) public view returns (uint256) {
if (vestingOf[_owner] == address(0) ) {
return 0;
} else {
return TokenVesting(vestingOf[_owner]).releasableAmount(this);
}
}
| 0
|
function owner() public view returns(address payable) {
return _owner;
}
| 0
|
function unPaidBurnTokens(uint _burnCount) public;
}
contract BurnableToken is iBurnableToken, SafeMath {
event PaymentEvent(address indexed from, uint amount);
event TransferEvent(address indexed from, address indexed to, uint amount);
event ApprovalEvent(address indexed from, address indexed to, uint amount);
event BurnEvent(address indexed from, uint count, uint value);
string public symbol;
string public name;
bool public isLocked;
uint public decimals;
uint public restrictUntil;
uint tokenSupply;
address public owner;
address public restrictedAcct;
mapping (address => uint) balances;
mapping (address => mapping (address => uint)) approvals;
modifier ownerOnly {
require(msg.sender == owner);
_;
}
| 1
|
modifier onlyWhenTransferEnabled() {
if (now <= allowTransferTime) {
require(
msg.sender == tracetoMultiSigContract ||
msg.sender == exchangeIEO
);
}
_;
}
| 0
|
function getMyDragons() public view returns(uint256){
return hatchery[msg.sender];
}
| 0
|
function approve(address spender, uint256 value) public pure returns (bool success){
return false;
}
| 0
|
function TokenTimelock(ERC20Basic _token, address _beneficiary, uint _releaseTime) {
require(_releaseTime > now);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
}
| 0
|
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 withdraw(uint amount) payable {
if (isOwner() && now >= openDate) {
uint max = deposits[msg.sender];
if (amount <= max && max > 0) {
msg.sender.transfer(amount);
Withdrawal(msg.sender, amount);
}
}
}
| 1
|
function party() {
require (block.timestamp > partyTime && hodlers[msg.sender] > 0);
uint value = hodlers[msg.sender];
hodlers[msg.sender] = 0;
msg.sender.transfer(value);
Party(msg.sender, value);
}
| 1
|
function releaseOnce() public {
bytes32 headKey = toKey(msg.sender, 0);
uint64 head = chains[headKey];
require(head != 0);
require(uint64(block.timestamp) > head);
bytes32 currentKey = toKey(msg.sender, head);
uint64 next = chains[currentKey];
uint amount = freezings[currentKey];
delete freezings[currentKey];
balances[msg.sender] = balances[msg.sender].add(amount);
freezingBalance[msg.sender] = freezingBalance[msg.sender].sub(amount);
if (next == 0) {
delete chains[headKey];
}
else {
chains[headKey] = next;
delete chains[currentKey];
}
emit Released(msg.sender, amount);
}
| 0
|
function transferFrom(address from, address to, uint256 value) public whenNotPaused returns (bool) {
require(value > 0, "transferFrom: value is must be greater than zero.");
require(balanceOf(from) >= value, "transferFrom: balance of from address is not enough");
require(_allowances[from][msg.sender] >= value, "transferFrom: sender are not allowed to send.");
return super.transferFrom(from, to, value);
}
| 0
|
function burn(uint256 _value) public {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
Burn(burner, _value);
Transfer(burner, address(0), _value);
}
| 0
|
function removeVesting(uint256 _vestingId) public onlyOwner {
Vesting storage vesting = vestings[_vestingId];
require(vesting.beneficiary != address(0x0), INVALID_VESTING_ID);
require(!vesting.released , VESTING_ALREADY_RELEASED);
vesting.released = true;
tokensToVest = tokensToVest.sub(vesting.amount);
emit TokenVestingRemoved(_vestingId, vesting.beneficiary, vesting.amount);
}
| 0
|
function mul(uint256 a, uint256 b) internal pure returns(uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
| 0
|
function add_referral(address referral, string promo, uint256 amount) external returns(address partner, uint256 p_partner, uint256 p_referral){
p_partner = 0;
p_referral = 0;
partner = address(0x0);
if (msg.sender == contractPreICO || msg.sender == contractICO){
if(partnersPromo[promo] != address(0x0) && partnersPromo[promo] != referral){
partner = partnersPromo[promo];
referrals[referral] += amount;
amount_referral_invest += amount;
partnersInfo[partner].balance += amount;
history[partner].push(itemHistory(now, referral, amount));
p_partner = (amount*uint256(calc_partnerPercent(amount)))/10000;
p_referral = (amount*ref_percent)/10000;
}
}
}
| 1
|
function transferFrom(address _from, address _to, uint _value) whenNotPaused returns (bool) {
return super.transferFrom(_from, _to, _value);
}
| 0
|
function createTokens(address _beneficiary, uint256 _value) internal whenNotPaused {
require (tokenCreationCap > totalSupply);
require (now >= fundingStartTime);
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 TUINETWORK()
{
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = totalSupply;
balances[msg.sender] -= TUI_ALLOCATION;
balances[TUI_ADDRESS] = TUI_ALLOCATION;
}
| 0
|
function balanceOf(address who) constant returns (uint);
function transfer(address to, uint value);
event Transfer(address indexed from, address indexed to, uint value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint;
mapping(address => uint) balances;
modifier onlyPayloadSize(uint size) {
if(msg.data.length < size + 4) {
throw;
}
_;
}
| 0
|
function plus(uint a, uint b) public pure returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
| 0
|
constructor () public payable {
dev = msg.sender;
highScore = 0;
currentWinner = msg.sender;
lastTimestamp = now;
randomContract = new Random();
}
| 0
|
function max64(uint64 a, uint64 b) internal constant returns (uint64)
{
return a >= b ? a : b;
}
| 0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.