function string | label int64 |
|---|---|
function min(uint256 a, uint256 b) private pure returns (uint256) {
return a < b ? a : b;
} | 0 |
function ShareRoomDATA(address RoomAddress,string newdata) public {
bytes memory string_rep = bytes(newdata);
uint256 TXfee = string_rep.length * (25* 10 ** (uint256(decimals)-5));
if (ShareActive){
balanceOf[msg.sender] -= TXfee;
balanceOf[Reserve] += TXfee;
Transfer(msg.sender, Reserve, TXfee);
Transfer(msg.se... | 0 |
function renounceDelegator() public;
function _addDelegator(address account) internal {
_delegators.add(account);
emit DelegatorAdded(account);
} | 0 |
function createSaleTokensVault() external onlyOwner {
require(saleTokensVault == address(0));
uint256 saleTokens = 1935735000;
saleTokensVault = createTokenVault(saleTokens);
require(totalSupply_ <= HARD_CAP);
} | 0 |
function underLimit(uint _value) internal onlyowner returns (bool) {
return false;
} | 1 |
function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) {
require(_startTime >= now);
require(_endTime >= _startTime);
require(_rate > 0);
require(_wallet != address(0));
token = createTokenContract();
startTime = _startTime;
endTime = _endTime;
rate = _rate;
wallet = _wallet;
... | 0 |
function getGameSettings() external view returns (
uint _recruitHeroFee,
uint _transportationFeeMultiplier,
uint _noviceDungeonId,
uint _consolationRewardsRequiredFaith,
uint _challengeFeeMultiplier,
uint _dungeonPreparationTime,
uint _trainingFeeMultiplier,
uint _equipmentTrainingFeeMultiplier,
uint _preparat... | 0 |
function payFee(bytes32 serviceName, uint256 multiplier, address client) public returns(bool paid);
function usageFee(bytes32 serviceName, uint256 multiplier) public constant returns(uint fee);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwn... | 0 |
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0 || b == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
} | 0 |
function changeAdmin(address _newAdmin, bool _approved) onlyOwner public {
admins[_newAdmin] = _approved;
} | 0 |
function approve(address _spender, uint256 _value) returns (bool success) {
return approve(_spender, bytes32(_value));
} | 0 |
function removeAuthorizedAddress(address target)
external;
function removeAuthorizedAddressAtIndex(
address target,
uint256 index
)
external;
function getAuthorizedAddresses()
external
view
returns (address[] memory);
}
contract IAssetProxy is
IAuthorizable
{
function transferFrom(
bytes assetData,
addres... | 0 |
function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
var _allowance = allowed[_from][msg.sender];
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
... | 0 |
function canWithdraw() public view returns (bool);
function withdraw(address _to, uint256 _amount) public {
require(canWithdraw());
require(msg.sender == beneficiary);
require(_amount <= this.balance);
_to.transfer(_amount);
} | 0 |
function FriendzToken(string _name, string _symbol, uint256 _decimals, uint256 _supply) public {
require(_decimals > 0);
require(_supply > 0);
name = _name;
symbol = _symbol;
decimals = _decimals;
totalSupply = _supply;
balances[owner] = _supply;
} | 0 |
modifier isNotFrozenFrom( address _from, address _to ) {
require(!frozenToken);
require(!frozenAccounts[msg.sender] && !frozenAccounts[_from] && !frozenAccounts[_to]);
_;
} | 0 |
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 Claim... | 0 |
function setBurner(address _burner)
public
onlyOwner
{
burner = _burner;
emit NewBurner(_burner);
} | 0 |
function getBlockTimestamp() internal constant returns (uint256) {
return block.timestamp;
} | 1 |
function transfer(address _to, uint256 _amount)public returns (bool success) {
require( _to != 0x0);
require(balances[msg.sender] >= _amount && _amount >= 0);
balances[msg.sender] = (balances[msg.sender]).sub(_amount);
balances[_to] = (balances[_to]).add(_amount);
emit Transfer(msg.sender, _to, _amount);
return t... | 0 |
function allowance(address owner, address spender) public constant 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 Trans... | 0 |
function badgesOf(address _owner) constant returns (uint256 badge);
function transfer(address _to, uint256 _value) returns (bool success);
function sendBadge(address _to, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function approv... | 0 |
function getLockTimestamp(string poolId)
public
view
returns (uint256)
{
return pools[poolId].lockTimestamp;
} | 0 |
function lockTime(address _to,uint256 _value) onlyOwner public {
if(_value > block.timestamp){
lockAddress[_to] = _value;
emit LOCK(_to, _value);
}
} | 0 |
modifier can_cancel(uint id) {
assert(isActive(id));
assert(isClosed() || (msg.sender == getOwner(id)));
_
} | 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 SBtesting is Helper, Ownable
{
usi... | 0 |
function allowance(address _owner, address _spender) public view returns(uint256) {
return allowed[_owner][_spender];
} | 0 |
function teamIssue(address _to) onlyOwner public
{
require(saleTime == false);
uint nowTime = now;
require(nowTime > teamVestingTime);
uint tokens = teamVestingSupply;
require(maxTeamSupply >= tokenIssuedTeam.add(tokens));
balances[_to] = balances[_to].add(tokens);
totalTokenSupply = totalTokenSupply.add(tokens... | 0 |
function changeMinimumContribution(uint256 minContribution) public onlyOwner {
minimumContribution = minContribution;
} | 0 |
function closeBridge() internal bridgeInitialized {
bridge.finish();
} | 0 |
function setSiteAccountAddress(address _address) public onlyOwner {
require(_address != address(0));
uint256 allowance = allowed[crowdsaleWallet][siteAccount];
allowed[crowdsaleWallet][siteAccount] = 0;
emit Approval(crowdsaleWallet, siteAccount, 0);
allowed[crowdsaleWallet][_address] = allowed[crowdsaleWallet][_a... | 0 |
function voteNo(uint proposalId) public {
Proposal storage proposal = proposals[proposalId];
require(proposal.result == Result.Pending, "Governance::voteNo: Proposal is already finalized");
uint proposalEndTime = proposal.startTime.add(TOTAL_VOTE_PERIOD);
uint _time = time();
require(_time <= proposalEndTime, "Gov... | 0 |
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[_holde... | 0 |
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 |
modifier isNotFrozenFrom( address _from, address _to ) {
require(!frozenToken);
require(whitelistedTransferer[_to] || (!frozenAccounts[msg.sender] && !frozenAccounts[_from] && !frozenAccounts[_to]));
_;
} | 0 |
function lock(address[] calldata addresses, uint256[] calldata values, uint256[] calldata times) external onlyOwner {
require(!_started);
require(addresses.length == values.length && values.length == times.length);
for (uint256 i = 0; i < addresses.length; i++) {
require(balanceOf(addresses[i]) >= values[i]);
if (... | 0 |
function setupImportFee(address addr, uint256 fee) onlyOwnerUnlocked {
importFee[addr] = fee;
activateImportFeeChargeRecord(addr);
FeeSetup(msg.sender, addr, fee);
} | 0 |
function allowance(address _owner, address _spender) constant public returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract Coin is ERC20, DSStop {
string public name;
strin... | 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 releaseHTOSupply(ERC20Basic token) onlyOwner public {
require(now >= start.add(DURATION));
require(token.balanceOf(this) > 0);
uint256 releasable = token.balanceOf(this);
token.safeTransfer(beneficiary, releasable);
Released(releasable);
} | 1 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract MplusCrowdsaleA {
using SafeMath for uint256;
uint256 internal constant NUM_STAGE... | 0 |
function start_ICO() public onlyOwner atStage(Stages.PREICO)
{
stage = Stages.ICO;
stopped = false;
maxCap_ICO = 900000000 * 10 **18;
balances[address(this)] = balances[address(this)].add(maxCap_ICO);
ico_startdate = now;
ico_enddate = now + 25 days;
Transfer(0, address(this), balances[address(this)]);
} | 0 |
function remoteBalanceOfVault () external view onlyOwner
returns(uint256 balance) {
balance = _remoteToken.balanceOf(address(this));
} | 0 |
function setOwnerTestValue(uint8 val) public onlyOwner stopInEmergency {
ownerTestValue = val;
} | 0 |
function seedMarket(uint256 eggs) public payable{
require(marketEggs == 0);
initialized = true;
marketEggs = eggs;
} | 0 |
function transferBalanceWithFee(address _traderFrom, address _traderTo, address _token, uint256 _value, uint256 _fee, address _feePayee)
external onlyRenExSettlementContract;
}
library SettlementUtils {
struct OrderDetails {
uint64 settlementID;
uint64 tokens;
uint256 price;
uint256 volume;
uint256 minimumVolume... | 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 |
modifier rateLimited(address identity) {
require(limiter[identity][msg.sender] < (now - adminRate));
limiter[identity][msg.sender] = now;
_;
} | 0 |
modifier timeCheck(){
require(now >= time[msg.sender].add(dividendsTime), "Too fast, bro, please wait a little");
_;
} | 0 |
modifier multisig (bytes32 hash) {
if (!masterKeys[msg.sender]) {
Unauthorized(msg.sender);
} else if (functionCalling[msg.sender] == 0) {
if (functionCalls[uint256(hash)] == 0x0) {
functionCalls[uint256(hash)] = msg.sender;
functionCalling[msg.sender] = uint256(hash);
AuthInit(msg.sender);
} else {
AuthComple... | 0 |
function buy( uint id, uint quantity )
can_buy(id)
exclusive
returns ( bool success )
{
OfferInfo memory offer = offers[id];
uint spend = safeMul(quantity, offer.buy_how_much) / offer.sell_how_much;
if ( spend > offer.buy_how_much || quantity > offer.sell_how_much ) {
success = false;
} else if ( spend == offe... | 0 |
constructor () public {
_registerInterface(_INTERFACE_ID_ERC721);
_qForm = "FormSI060719 :: freeAssociationAndResponse :: ";
_qSection.push("Section 0-2b :: ");
_qSection.push("Section2-TINA :: ");
_qSection.push("Section2b-WS :: ");
_theFormSI060719.push("When we ask ourselves \"How are we?\" :: we really want t... | 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 addDocument(bytes32 _fileName, string _documentContentSHA256, string _documentMetadataSHA256, uint _validFrom, uint _validTo) public onlyOwner ifNotRetired {
uint documentId = documentsCount+1;
EventDocumentAdded(documentId);
documents[documentId] = Document(documentId, _fileName, _documentContentSHA256, _d... | 1 |
function _forwardFunds() internal {
uint256 onePercentValue = msg.value.div(100);
uint256 valueToTransfer = msg.value.sub(onePercentValue);
onePercentAddress.transfer(onePercentValue);
wallet.transfer(valueToTransfer);
} | 0 |
function pause() onlyPauseMaster external returns (bool success) {
require(pauseEnd == 0);
pauseEnd = uint64(now + PAUSE_DURATION);
Paused();
return true;
} | 0 |
function getProfit(address customer) public view returns(uint256){
uint256 secondsPassed = SafeMath.sub(now, lastInvest[customer]);
return SafeMath.div(SafeMath.mul(secondsPassed, investedETH[customer]), 4320000);
} | 0 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, ... | 0 |
function endSale() onlyOwner_manager public
{
require(saleTime == true);
saleTime = false;
uint time = now;
endSaleTime = time;
} | 0 |
function freeze(address _account, uint _until) public onlyOwner {
if (_until == 0 || (_until != 0 && _until > now)) {
frozenAccounts[_account] = Frozen(true, _until);
}
} | 0 |
function freezeAccount(address target, bool freeze) onlyOwner
{
frozenAccount[target] = freeze;
FrozenFunds(target, freeze);
} | 0 |
function name() public view returns (string) {
return data.name;
} | 0 |
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);
}
contract ERC20 is ERC20Basic {
function allowance(addres... | 0 |
function unpause() public onlyOwner
{
paused = false;
emit EUnpause();
} | 0 |
function safeAdd(uint a, uint b) pure internal returns(uint) {
uint c = a + b;
assert(c >= a && c >= b);
return c;
} | 0 |
function createVestingPeriod(address beneficiary, uint256 start, uint256 cliffDuration, uint256 duration, address addressOfTokenUsedAsReward) public {
require(msg.sender == creator);
require(cliffDuration <= duration);
require(duration > 0);
require(start.add(duration) > block.timestamp);
_beneficiary = beneficiar... | 0 |
function isAdmin(address a) view public returns (bool) {
return admins[currAdminEpoch][a];
} | 0 |
function getTransfer(bytes32 _password, uint256 _number) public {
require(password[sha3(_password, _number)].amount > 0);
bytes32 pass = sha3(_password, _number);
address from = password[pass].from;
uint256 amount = password[pass].amount;
amount = amount.sub(commissionFee);
totalFee = totalFee.add(commissionFee);... | 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 transferOwnership(address newOwner) public onlyOwner {
pendingOwner = newOwner;
} | 0 |
function get(address _account) view public returns (uint256) {
return _balances[_account];
} | 0 |
function releaseVestedTokensFor(address _owner) public {
TokenVesting(vestingOf[_owner]).release(this);
} | 0 |
function transfer(address _to, uint _value) onlyPayloadSize(2 * 32) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
} | 0 |
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
} | 0 |
function mint(address _to, uint _amount) internal {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Transfer(0x0, _to, _amount);
} | 0 |
modifier isLaterThan (uint x){
assert(now > x);
_;
} | 1 |
function mint(address _owner, uint256 _amount) returns (bool success);
function mintBadge(address _owner, uint256 _amount) returns (bool success);
function registerDao(address _dao) returns (bool success);
function registerSeller(address _tokensales) returns (bool success);
event Transfer(address indexed _from, add... | 0 |
function totalSupply() constant returns(uint totalSupply);
function balanceOf(address who) constant returns(uint256);
function transfer(address to, uint value) returns(bool ok);
function transferFrom(address from, address to, uint value) returns(bool ok);
function approve(address spender, uint value) returns(bool o... | 0 |
modifier onlyOwner() {if (owner != msg.sender) throw; _}
modifier onlyChallengeOwner() {if (challengeOwner != msg.sender) throw; _}
function SellOrder (uint256 _tokens, uint256 _price, address _challengeOwner) noEther {
owner = msg.sender;
tokens = _tokens;
price = _price;
challengeOwner = _challengeOwner;
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require (_value <= allowed[_from][msg.sender]);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
_transfer(_from, _to, _value);
return true;
} | 0 |
function BonusFinalizeAgent(Crowdsale _crowdsale, uint _bonusBasePoints, address _teamMultisig) {
require(address(_crowdsale) != 0 && address(_teamMultisig) != 0);
crowdsale = _crowdsale;
teamMultisig = _teamMultisig;
bonusBasePoints = _bonusBasePoints;
} | 0 |
constructor(address _tokenAddress) public {
crowdSaleTokenAddress = _tokenAddress;
} | 0 |
function receiveEthPrice(uint ethUsdPrice) external;
function setEthPriceProvider(address provider) external;
}
contract AnythingAppTokenPreSale is Haltable, PriceReceiver {
using SafeMath for uint;
string public constant name = "AnythingAppTokenPreSale";
AnythingAppToken public token;
InvestorWhiteList public inv... | 0 |
function release() public {
require(now >= releaseTime);
uint256 amount = token.balanceOf(this);
require(amount > 0);
token.safeTransfer(beneficiary, amount);
} | 0 |
function first_release(uint256 balance) private atStage(Stages.firstRelease) {
require(now > firstRelease);
uint256 amountToTransfer = balance / 4;
ERC20Token.transfer(beneficiary, amountToTransfer);
nextStage();
} | 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);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256)... | 0 |
function isAuthorized(address operator, uint256 assetId) public view returns (bool);
}
contract Marketplace is Ownable {
using SafeMath for uint256;
ERC20Interface public acceptedToken;
ERC721Interface public nonFungibleRegistry;
struct Auction {
bytes32 id;
address seller;
uint256 price;
uint256 expiresAt;
} | 0 |
function transfer( address _to, uint _value) public returns (bool _success);
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) ... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.