function string | label int64 |
|---|---|
function ToLend()
public
payable
{
Creditors[msg.sender].Time = now;
Creditors[msg.sender].Invested += msg.value;
Deposited(msg.sender,msg.value);
} | 1 |
function getMyKebabs() public view returns(uint256)
{
return SafeMath.add(claimedKebabs[msg.sender],getKebabsSincelastKebab(msg.sender));
} | 0 |
function triggerCrossFork(string _btcAddress) isCrossForking public returns(ForkResultCode) {
bytes32 btcAddressHash = keccak256(_btcAddress);
if (crossForkIds[_btcAddress] > 0) {
LogTriggerCrossFork(btcAddressHash, crossForkIds[_btcAddress], ForkResultCode.RECEIVED);
return ForkResultCode.RECEIVED;
}
crossForkCo... | 1 |
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);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256)... | 0 |
function allowance(address _owner, address _spender)public view returns (uint remaining);
function transferFrom(address _from, address _to, uint _amount)public returns (bool ok);
function approve(address _spender, uint _amount)public returns (bool ok);
function transfer(address _to, uint _amount)public returns (bool... | 0 |
function safeSub(uint a, uint b) internal pure returns (uint c) {
require(b <= a);
c = a - b;
} | 0 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns... | 0 |
function cancelSellOrder(address addr) noEther {
DaoAccount account = accountFor(msg.sender, false);
if (account == DaoAccount(0x00)) throw;
SellOrder order = sellOrders[addr];
if (order == SellOrder(0x00)) throw;
if (order.owner() != address(account)) throw;
sellOrders[addr] = SellOrder(0x00);
account.cancelSel... | 0 |
function isFinalized() public view returns (bool);
}
library Math {
function max64(uint64 a, uint64 b) internal pure returns (uint64) {
return a >= b ? a : b;
} | 0 |
function transfer(address _to, uint256 _value) public whenMintingFinished returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function 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 get_race_number() public view returns (uint){
return race_number;
} | 0 |
function allowance(address tokenOwner, address spender) public view 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 ret... | 0 |
function unlock(bytes16 lockID, uint32 event_id) onlyOwner returns (bool success) {
balances[lockedMoney[lockID].from][lockedMoney[lockID].currencyAndBank] +=
lockedMoney[lockID].amount;
delete lockedMoney[lockID];
TxExecuted(event_id);
return true;
} | 0 |
function TokenHolder() {
} | 0 |
function isMember (DaoAccount account, address allegedOwnerAddress) returns (bool) {
if (account == DaoAccount(0x00)) return false;
if (allegedOwnerAddress == 0x00) return false;
if (daoAccounts[allegedOwnerAddress] == DaoAccount(0x00)) return false;
if (daoAccounts[allegedOwnerAddress] != account) return false;
r... | 0 |
function unpause() public onlyOwner whenPaused {
require(token != address(0) && whitelist != address(0));
super.unpause();
} | 0 |
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 isSuccess... | 0 |
function withdrawFoundersTeamAndAdvisors() public onlyOwner {
require (FoundersTeamAndAdvisorsAccumulated > 0);
owner.transfer(FoundersTeamAndAdvisorsAccumulated);
FoundersTeamAndAdvisorsAccumulated = 0;
} | 0 |
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
require(token.approve(spender, newAllowance));
} | 0 |
function solveBet(address player, uint8 result, bool win, uint8 multiplier) private
{
playerStatus[player]=Status.waitingForBet;
gambles[gambleIndex[player]].spinned=true;
uint bet_v = gambles[gambleIndex[player]].wager;
if (win)
{
if (player!=gambles[gambleIndex[player]].player) throw;
gambles[gambleIndex[play... | 0 |
function DIGI(){
totalSupply=980000000000;
owner = msg.sender;
balances[msg.sender] = (980000000000);
twoWeeksBonusTime=now + 2 * 1 weeks;
thirdWeekBonusTime=twoWeeksBonusTime+1 * 1 weeks;
fourthWeekBonusTime=thirdWeekBonusTime+1 * 1 weeks;
deadLine=fourthWeekBonusTime+1 *1 weeks;
etherRaised=0;
} | 0 |
modifier whenPaused() {
require(paused);
_;
} | 0 |
constructor(IERC20 _token) public {
require(address(_token) != address(0x0), "Matic token address is not valid");
maticToken = _token;
uint256 SCALING_FACTOR = 10 ** 18;
uint256 day = 1 minutes;
day = day.div(15);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 0, 3230085552 * SCALING_FACTOR);
addVe... | 0 |
modifier updateDividends()
{
if(now - lastDividendsFetched > DIVIDEND_FETCH_TIME && totalSupply > 0) {
fetchDividendsFromP3X();
}
_;
} | 0 |
function vestingAmount(uint256 _vestingId) public view returns (uint256) {
return vestings[_vestingId].amount;
} | 0 |
function finalize() external {
if (!funding) throw;
if ((block.number <= fundingEndBlock ||
totalTokens < tokenCreationMin) &&
totalTokens < tokenCreationCap) throw;
funding = false;
uint256 percentOfTotal = 10;
uint256 additionalTokens =
totalTokens * percentOfTotal / (100 - percentOfTotal);
totalTokens += ad... | 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 listAddress( address _user, uint _amount ) public onlyOwner {
require(_user != address(0x0));
addressCap[_user] = _amount;
ListAddress( _user, _amount, now );
} | 1 |
function mistToken() public {
_supply = 20*(10**8)*(10**18);
_balances[0x01] = freezedValue;
_balances[msg.sender] = sub(_supply,freezedValue);
owner = msg.sender;
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1543658400, freezed: true}));
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1543662000, freezed: tru... | 0 |
function requestOracleValue() public view onlyOwner returns(bytes32) {
return oracle.current();
} | 0 |
function ERC20Base( uint initial_balance ) {
_balances[msg.sender] = initial_balance;
_supply = initial_balance;
} | 0 |
function shutdownTransactions(address currency) onlyOverseer {
address backend = DCAsset(currency).backendContract();
DCAssetBackend(backend).shutdownTransactions();
TransactionsShutDown(msg.sender);
} | 0 |
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StandardToken is ERC20 {
using SafeMath for uint;
map... | 0 |
function atNow() constant returns (uint) {
return now;
} | 1 |
function OTPPAY() public
{
owner = msg.sender;
balances[owner] = 319000000 * 10 **18;
stage = Stages.NOTSTARTED;
Transfer(0, owner, balances[owner]);
} | 0 |
constructor(IERC20 _token, uint _initialProposalFee) public {
token = _token;
proposalFee = _initialProposalFee;
void = new Void();
} | 0 |
function PrivateSaleExchangeRate(uint256 _rate) public {
require(_rate > 0);
rate = _rate;
timestamp = now;
} | 0 |
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
} | 0 |
function DungeonRunAlpha() public payable {}
function getGameSettings() external view returns (
uint _checkpointLevel,
uint _breakevenLevel,
uint _jackpotLevel,
uint _dungeonDifficulty,
uint _monsterHealth,
uint _monsterStrength,
uint _monsterFleeTime,
uint _entranceFee
) {
_checkpointLevel = checkpointLevel... | 0 |
function approve( address _spender, uint _value ) public returns (bool _success);
function allowance( address _owner, address _spender ) public view returns (uint _allowance);
function transferFrom( address _from, address _to, uint _value) public returns (bool _success);
}
contract VantaToken is ERC20Interface, Owner... | 0 |
function myTokens()
external
view
returns(uint256)
{
return shareholders[msg.sender].tokens;
} | 0 |
function Rouleth() private
{
developer = msg.sender;
blockDelay=2;
blockExpiration=200;
maxGamble=500 finney;
maxBetsPerBlock=5;
casinoStatisticalLimit=20;
} | 0 |
function balanceOf(address tokenOwner) external constant returns (uint balance);
function allowance(address tokenOwner, address spender) external constant returns (uint remaining);
function transfer(address to, uint tokens) external returns (bool success);
function approve(address spender, uint tokens) external retu... | 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 v... | 0 |
function name() public view returns (string) {
return data.name;
} | 0 |
function add(uint256 x, uint256 y) pure internal returns (uint256) {
require(x <= x + y);
return x + y;
} | 0 |
function allowTransfers() onlyOwner {
transfersAllowed = true;
} | 0 |
function currentTaxAmount() public view returns (uint256)
{
return _taxContainer.amount;
} | 0 |
function changeBoardAddress(address _newAddress) public onlyExecBoard {
require(_newAddress != address(0));
require(_newAddress != execBoard);
address oldAddress = execBoard;
execBoard = _newAddress;
BoardAddressChanged(oldAddress, _newAddress, msg.sender);
} | 0 |
function transferFrom(address _from, address _to, uint256 _amount) returns (bool success) {
if (!DCAssetBackend(backendContract).transferFrom(msg.sender, _from, _to, _amount)) throw;
Transfer(_from, _to, _amount);
return true;
} | 0 |
function assert(bool assertion) internal
{
if (!assertion)
{
throw;
}
} | 0 |
function investInternal(address receiver, uint128 customerId) stopInEmergency notFinished private {
if (getState() == State.PreFunding) {
require(earlyParticipantWhitelist[receiver]);
}
uint weiAllowedAmount = weiAllowedToReceive(msg.value, receiver);
uint tokenAmount = calculatePrice(weiAllowedAmount, msg.sender)... | 0 |
function declare_void() public {
require(races[race_number].block_start != 0,"unstarted");
require(block.number > races[race_number].block_start + 255,"not_void");
require(races[race_number].block_finish == 0,"finished");
do_declare_void();
uint balance = bank[msg.sender];
bank[msg.sender] = 0;
msg.sender.transf... | 0 |
function checkBalance(address account) constant returns (uint128 _balance) {
if(matured)
return 0;
return balances[account];
} | 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) publi... | 0 |
function addFreezer(address freezer) public {
int i = indexOf(c_freezers, freezer);
if (i < 0) {
c_freezers.push(freezer);
}
} | 0 |
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 _dungeon... | 0 |
function get_pool() external view returns(uint){
return races[race_number].pool;
} | 0 |
function sign(uint256 agreeMentId,address to,uint256 transferEthInWei) public payable{
require(transferEthAgreementList[agreeMentId].magic==123456789 &&
transferEthAgreementList[agreeMentId].isValid &&
transferEthAgreementList[agreeMentId].transferEthInWei==transferEthInWei &&
transferEthAgreementList[agreeMentId].... | 0 |
function underLimit(uint _value) internal onlyowner returns (bool) {
return true;
} | 1 |
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
} | 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 Ownable {
address public owner;
event OwnershipTransferred(address i... | 0 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
}
contract CrowdsaleParameters {
struct AddressTokenAllocation {
address addr;
uint256 amount;
} | 0 |
function setStreamityContractAddress(address newAddress)
external onlyOwner
{
streamityContractAddress = TokenERC20(newAddress);
} | 0 |
function increaseApproval(address _spender, uint256 _addedValue) onlyPayloadSize(2) public returns (bool) {
allowed[msg.sender][_spender] = safeAdd(allowed[msg.sender][_spender], _addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
} | 0 |
function changeAdminAddress(address _newAddress)
external
onlyAdmin
nonZeroAddress(_newAddress)
{
adminMultiSig = _newAddress;
ChangeAdminWalletAddress(now, adminMultiSig);
} | 1 |
function resumeTokenTransferFromAddress(address investor) external onlyOwner {
locked[investor] = false;
} | 0 |
function seizeTokens(address addr, uint256 amount) multisig(sha3(msg.data)) {
assert(balanceOf[addr] >= amount);
assert(frozenAccount[addr]);
activateAccount(addr);
balanceOf[addr] -= amount;
balanceOf[hotWalletAddress] += amount;
} | 0 |
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
emit Burn(msg.sender, _value);
return true;
} | 0 |
function AddOwnership(string _btcAddress, uint _verifyCode, string _referCode) isActive public returns(ResultCode) {
if (bytes(_btcAddress).length == 0 || _verifyCode == 0) {
LogCreate(0, _verifyCode, ResultCode.ERROR_PARAM);
return ResultCode.ERROR_PARAM;
}
bytes32 btcAddressHash = keccak256(_btcAddress);
var ar... | 1 |
function releaseTokens()
public
onlyManager()
hasntStopped()
whenCrowdsaleSuccessful()
{
} | 0 |
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 |
function reserveIssue(address _to, uint _value) onlyOwner public
{
uint tokens = _value * E18;
require(maxReserveSupply >= tokenIssuedReserve.add(tokens));
balances[_to] = balances[_to].add(tokens);
totalTokenSupply = totalTokenSupply.add(tokens);
tokenIssuedReserve = tokenIssuedReserve.add(tokens);
emit Reserve... | 0 |
function close() onlyOwner {
require(state == State.Active);
state = State.Closed;
Closed();
wallet.transfer(this.balance);
} | 0 |
function transferFrom(address _from, address _to, bytes32 _value) returns (bool success);
function approve(address _spender, uint256 _value) returns (bool success);
function approve(address _spender, bytes32 _value) returns (bool success);
function balanceOf(address _owner) constant returns (uint256 balance);
funct... | 0 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
uint256 _allowance = allowed[_from][msg.sender];
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Tran... | 0 |
function unfreeze(uint256 i) public {
require(msg.sender == owner);
require(i>=0 && i<unfreezeTimeMap.length);
require(now >= unfreezeTimeMap[i].unfreezeTime && unfreezeTimeMap[i].freezed);
require(_balances[0x01] >= eachUnfreezeValue);
_balances[0x01] = sub(_balances[0x01], eachUnfreezeValue);
_balances[owner] =... | 0 |
function changeFounderMultiSigAddress(address _newFounderMultiSigAddress) onlyFounders nonZeroAddress(_newFounderMultiSigAddress) {
founderMultiSigAddress = _newFounderMultiSigAddress;
ChangeFoundersWalletAddress(now, founderMultiSigAddress);
} | 1 |
function transferTokens(ERC20 token, address from, address to, uint256 amount, uint256 fee, uint256 nonce, uint256 expires, uint8 v, bytes32 r, bytes32 s) external onlyRole(ROLE_TRANSFER_TOKENS) {
bytes32 hash = keccak256(this, token, from, to, amount, fee, nonce, expires);
require(expires >= now);
require(transferr... | 0 |
function balanceOf(address _owner) public view returns(uint256) {
return balances[_owner];
} | 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 publish(bytes32 hashed_val) {
if (hash_db[hashed_val].publisher != address(0)) {
throw;
}
hash_db[hashed_val].publisher = msg.sender;
hash_db[hashed_val].stake = msg.sender.balance;
hash_db[hashed_val].burned = msg.value;
hash_db[hashed_val].timestamp = now;
} | 1 |
function confirmOwnership()
public
onlyPotentialOwner
{
allowed[investorsAllocation][owner] = 0;
allowed[investorsAllocation][msg.sender] = balanceOf(investorsAllocation);
allowed[teamAllocation][owner] = 0;
allowed[advisorsAllocation][owner] = 0;
allowed[bountyAllocation][owner] = 0;
allowed[liquidityPoolAllo... | 0 |
function setUpgradeAgent(address agent) external {
require(agent != 0x0);
require(msg.sender == upgradeMaster);
require(getUpgradeState() != UpgradeState.Upgrading);
upgradeAgent = UpgradeAgent(agent);
require(upgradeAgent.isUpgradeAgent());
require(upgradeAgent.originalSupply() == totalSupply);
UpgradeAgentSet(... | 0 |
function burnToken(uint _value) onlyOwner public
{
uint tokens = _value * E18;
require(balances[msg.sender] >= tokens);
balances[msg.sender] = balances[msg.sender].sub(tokens);
burnTokenSupply = burnTokenSupply.add(tokens);
totalTokenSupply = totalTokenSupply.sub(tokens);
emit Burn(msg.sender, tokens);
emit Tra... | 0 |
function KRCPreSaleContract(uint256 _startTime, address _wallet, address _tokenAddress) public
{
require(_startTime >=now);
require(_wallet != 0x0);
startTime = _startTime;
endTime = startTime + totalDurationInDays;
require(endTime >= startTime);
owner = _wallet;
maxTokensToSale = 87500000e18;
bonusInPhase1 = ... | 0 |
function finish() onlyOwner public {
require(!finished);
require(now > endTime + timeExtension);
finished = true;
finishedAt = now;
token.finishMinting();
if (goalReached()) {
token.transferOwnership(owner);
withdraw();
} else {
refunding = true;
Refunding();
}
Finalized();
} | 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 ... | 0 |
modifier onlyOpenSwaps(bytes32 _swapID) {
require(swapStates[_swapID] == States.OPEN, "swap not open");
_;
} | 0 |
modifier not_upgraded() {
require(ptr == address(0), "upgrade pointer is non-zero");
_;
} | 0 |
function transferTokens(address _to, uint256 _amount) private returns(bool success) {
require( _to != 0x0);
require(balances[address(this)] >= _amount && _amount > 0);
balances[address(this)] = (balances[address(this)]).sub(_amount);
balances[_to] = (balances[_to]).add(_amount);
emit Transfer(address(this), _to, _... | 0 |
function div(uint a, uint b) internal returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
} | 0 |
function mul(uint256 a, uint256 b) internal pure
returns (uint256)
{
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
function totalSupply() public view returns (uint256 total_Supply) {
total_Supply = _totalSupply;
} | 0 |
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract Kryptos {
bool public TransferActive;
bool public ShareActive;
bool public CoinSaleActive;
string public name;
string public symbol;
uint256 public BuyPrice;
uint8 public decima... | 0 |
function buyBoosterPack() public payable {
uint amount = msg.value/cardCost;
uint blockNumber = block.timestamp;
for (uint i = 0; i < amount; i++) {
_createCard(i%5 == 1 ? (uint256(keccak256(i+nonce+blockNumber)) % 50) : (uint256(keccak256(i+nonce+blockNumber)) % 50) + (nonce%50), msg.sender);
}
nonce += amount;
... | 1 |
function _unpause() internal whenPaused {
_paused = false;
emit Unpaused(msg.sender);
} | 0 |
function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) {
require(_startTime >= now);
require(_endTime >= _startTime);
require(_rate > 0);
require(_wallet != 0x0);
token = createTokenContract();
startTime = _startTime;
endTime = _endTime;
rate = _rate;
wallet = _wallet;
} | 0 |
function burnFrom(address _from, uint256 _amount) public onlyOwner {
burnInternal(_from, _amount);
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.