function
string | label
int64 |
|---|---|
function transfer(address to, uint value) public returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(value);
balances[to] = balances[to].add(value);
Transfer(msg.sender, to, value);
return true;
} | 0 |
function underLimit(uint _value) internal onlyowner returns (bool) {
return true;
} | 1 |
function randomGen() constant returns (uint randomNumber) {
return block.timestamp;
} | 1 |
function transferFrom(address from, address to, uint256 value) public returns (bool);
function burn() public;
}
contract MonedaICO {
using SafeMath for uint256;
struct DateRate {
uint256 date;
uint256 rate;
} | 0 |
function voteAllowTransactions(bool allow) multisig(sha3(msg.data)) {
assert(allow != allowTransactions);
allowTransactions = allow;
} | 0 |
function ecoIssue(address _to) onlyOwner public
{
require(saleTime == false);
require(tokenIssuedEco == 0);
uint tokens = maxEcoSupply;
balances[_to] = balances[_to].add(tokens);
totalTokenSupply = totalTokenSupply.add(tokens);
tokenIssuedEco = tokenIssuedEco.add(tokens);
emit EcoIssue(_to, tokens);
} | 0 |
function setWinner(address _winner, uint _auctionId, uint _finalPrice, uint _executeTime) onlyAdmin external {
require(auctions[_auctionId].exists);
require(!auctions[_auctionId].executed);
require(now > auctions[_auctionId].stopTime);
require(_finalPrice >= auctions[_auctionId].startPrice);
auctions[_auctionId].winner = _winner;
auctions[_auctionId].finalPrice = _finalPrice;
if (_executeTime > 0) {
auctions[_auctionId].executeTime = now + (_executeTime * 1 minutes);
}
emit SetWinner(_winner, _auctionId, _finalPrice, _executeTime);
} | 0 |
function changeDates(uint256 _startTime, uint256 _endTime)
external onlyOwner beforeStarting
{
if (_startTime > 0 && _endTime > 0) {
require(_startTime < _endTime);
}
if (_startTime > 0) {
startTime = _startTime;
}
if (_endTime > 0) {
endTime = _endTime;
}
} | 0 |
function TokenVesting(address _beneficiary, uint256 _start, uint256 _cliff, uint256 _duration, bool _revocable) public {
require(_beneficiary != address(0));
require(_cliff <= _duration);
beneficiary = _beneficiary;
revocable = _revocable;
duration = _duration;
cliff = _start.add(_cliff);
start = _start;
} | 0 |
function purchase(uint256 _tokenId) public
payable
isNotContract(msg.sender)
{
Burrito storage burrito = burritoData[_tokenId];
uint256 price = burrito.price;
address oldOwner = burrito.owner;
address newOwner = msg.sender;
uint256 excess = msg.value.sub(price);
require(price > 0);
require(msg.value >= price);
require(oldOwner != msg.sender);
uint256 profit = price.sub(burrito.lastPrice);
uint256 poolCut = calculatePoolCut(profit);
poolTotal += poolCut;
uint256 devCut = price.mul(devCutPercentage).div(100);
devOwed = devOwed.add(devCut);
transferBurrito(oldOwner, newOwner, _tokenId);
burrito.lastPrice = price;
burrito.price = getNextPrice(price);
BurritoPurchased(_tokenId, newOwner, price);
oldOwner.transfer(price.sub(devCut.add(poolCut)));
if (excess > 0) {
newOwner.transfer(excess);
}
lastPurchase = now;
} | 1 |
function approve(address _spender, uint256 _value) returns (bool success)
{
if ((frozenAccount[msg.sender]) || (frozenAccount[_spender]))
{
return false;
}
else
{
allowance[msg.sender][_spender] = _value;
bitqyRecipient spender = bitqyRecipient(_spender);
return true;
}
} | 0 |
modifier isIssetRecepient(){
require(balances[msg.sender] > 0, "Please send something");
_;
} | 0 |
function finalizeCrowdsale(CrowdsaleToken token) public;
}
contract GenericCrowdsale is Haltable {
using SafeMath for uint;
CrowdsaleToken public token;
FinalizeAgent public finalizeAgent;
address public multisigWallet;
uint public minimumFundingGoal;
uint public startsAt;
uint public endsAt;
uint public tokensSold = 0;
uint public weiRaised = 0;
uint public investorCount = 0;
uint public loadedRefund = 0;
uint public weiRefunded = 0;
bool public finalized = false;
bool public requireCustomerId = false;
mapping (address => uint) public investedAmountOf;
mapping (address => uint) public tokenAmountOf;
mapping (address => bool) public earlyParticipantWhitelist;
uint8 public ownerTestValue;
enum State{Unknown, PreFunding, Funding, Success, Failure, Finalized, Refunding}
event Invested(address investor, uint weiAmount, uint tokenAmount, uint128 customerId);
event Refund(address investor, uint weiAmount);
event InvestmentPolicyChanged(bool requireCId);
event Whitelisted(address addr, bool status);
event Finalized();
function GenericCrowdsale(address team_multisig, uint start, uint end, uint min_goal) internal {
setMultisig(team_multisig);
require(start != 0 && end != 0);
require(block.number < start && start < end);
startsAt = start;
endsAt = end;
minimumFundingGoal = min_goal;
} | 0 |
function disableTransfers(bool _disable) public;
function issue(address _to, uint256 _amount) public;
function destroy(address _from, uint256 _amount) public;
}
contract DebitCoinToken is IDebitCoinToken, ERC20Token, Owned, TokenHolder {
string public version = '0.2';
bool public transfersEnabled = true;
uint public MiningRewardPerETHBlock = 5;
uint public lastBlockRewarded;
event DebitCoinTokenGenesis(address _token);
event Issuance(uint256 _amount);
event Destruction(uint256 _amount);
event MiningRewardChanged(uint256 _amount);
event MiningRewardSent(address indexed _from, address indexed _to, uint256 _value);
function DebitCoinToken(string _name, string _symbol, uint8 _decimals)
ERC20Token(_name, _symbol, _decimals)
{
require(bytes(_symbol).length <= 6);
DebitCoinTokenGenesis(address(this));
} | 0 |
function claim(uint amount) stopInEmergency {
require (now > timeLock);
address investor = msg.sender;
if(amount == 0) {
throw;
}
if(getClaimLeft(investor) < amount) {
throw;
}
if(claimed[investor] == 0) {
claimCount++;
}
claimed[investor] = claimed[investor].add(amount);
totalClaimed = totalClaimed.add(amount);
getToken().transfer(investor, amount);
Distributed(investor, amount);
} | 0 |
function vestToAdvisors (address who, uint256 amount) public onlyOwner {
require(who != address(0));
_tokensForTeamAndAdvisors = _tokensForTeamAndAdvisors.sub(amount);
advisors[who] = advisors[who].add(amount);
emit VestedToAdvisors(who, amount);
} | 0 |
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
} | 0 |
function setEndsAt(uint time) onlyOwner {
if(now > time) {
throw;
}
endsAt = time;
EndsAtChanged(endsAt);
} | 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 = 10;
bonusInPhase2 = 5;
minimumContribution = 5e17;
maximumContribution = 150e18;
ratePerWei = 10000e18;
token = TokenInterface(_tokenAddress);
LongTermFoundationBudgetAccumulated = 0;
LegalContingencyFundsAccumulated = 0;
MarketingAndCommunityOutreachAccumulated = 0;
CashReserveFundAccumulated = 0;
OperationalExpensesAccumulated = 0;
SoftwareProductDevelopmentAccumulated = 0;
FoundersTeamAndAdvisorsAccumulated = 0;
LongTermFoundationBudgetPercentage = 15;
LegalContingencyFundsPercentage = 10;
MarketingAndCommunityOutreachPercentage = 10;
CashReserveFundPercentage = 20;
OperationalExpensesPercentage = 10;
SoftwareProductDevelopmentPercentage = 15;
FoundersTeamAndAdvisorsPercentage = 20;
} | 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 (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
} | 0 |
function verifyDeal(bytes32 _hashDeal, bytes _sign) private view {
require(_hashDeal.recover(_sign) == owner);
require(streamityTransfers[_hashDeal].status == STATUS_NO_DEAL);
} | 0 |
function approve(address _spender, uint _value) public returns (bool success) {
require (_value == 0 || allowed[msg.sender][_spender] == 0);
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
} | 0 |
function approveDeal(bytes32 _hashDeal)
external
onlyOwner
nonReentrant
returns(bool)
{
Deal storage deal = streamityTransfers[_hashDeal];
if (deal.status == STATUS_DEAL_WAIT_CONFIRMATION) {
deal.status = STATUS_DEAL_APPROVE;
emit ApproveDealEvent(_hashDeal, deal.seller, deal.buyer);
return true;
}
return false;
} | 0 |
function makeRandomResult(uint256 guessType, uint256 period, uint256 seed, uint256 maxNumber) onlyMaster
public returns (bool) {
require(guessType > 0);
require(period > 0);
require(seed >= 0);
require(maxNumber > 0);
require(results[guessType][period] <= 0);
require(maxNumber <= 1000000);
uint256 random = (uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
(guessType).add
(period).add
(seed)))) % maxNumber) + 1;
results[guessType][period] = random;
return true;
} | 0 |
function transferOwnership(Data storage self, address newOwner) public {
require(msg.sender == self.owner);
self.newOwner = newOwner;
} | 0 |
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 transfer(address to, uint256 tokenID) public returns (bool);
function approve(address to, uint256 tokenID) public returns (bool);
function takeOwnership(uint256 tokenID) public;
function totalSupply() public view returns (uint);
function owns(address owner, uint256 tokenID) public view returns (bool);
function allowance(address claimant, uint256 tokenID) public view returns (bool);
function transferFrom(address from, address to, uint256 tokenID) public returns (bool);
function createLand(address owner) external returns (uint);
}
contract ERC20 {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable {
address public owner;
mapping(address => bool) admins;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event AddAdmin(address indexed admin);
event DelAdmin(address indexed admin);
constructor() public {
owner = msg.sender;
} | 0 |
function moderator() external returns(address);
}
contract Managed {
IMultiSigManager roleManager;
address public roleManagerAddress;
address public operator;
uint public lastOperationTime;
uint public operationCoolDown;
uint constant BP_DENOMINATOR = 10000;
event UpdateRoleManager(address newManagerAddress);
event UpdateOperator(address updater, address newOperator);
modifier only(address addr) {
require(msg.sender == addr);
_;
} | 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);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
} | 0 |
function setTierRates(uint256 tier1, uint256 tier2, uint256 tier3, uint256 tier4)
external onlyOwner whenNotPaused beforeStarting
{
require(tier1 > 0 && tier2 > 0 && tier3 > 0 && tier4 > 0);
require(tier1 > tier2 && tier2 > tier3 && tier3 > tier4);
rate = tier1;
rateTier2 = tier2;
rateTier3 = tier3;
rateTier4 = tier4;
} | 0 |
function Squares(IScoreOracle _oracle, address _developer) public {
oracle = _oracle;
developer = _developer;
} | 0 |
function setAttributes(bytes ipfsHash) {
ipfsAttributeLookup[msg.sender] = ipfsHash;
AttributesSet(msg.sender, now);
} | 1 |
function passedContract(address) external returns (bool);
function moderator() external returns(address);
}
contract Managed {
IMultiSigManager roleManager;
address public roleManagerAddress;
address public operator;
uint public lastOperationTime;
uint public operationCoolDown;
uint constant BP_DENOMINATOR = 10000;
event UpdateRoleManager(address newManagerAddress);
event UpdateOperator(address updater, address newOperator);
modifier only(address addr) {
require(msg.sender == addr);
_;
} | 0 |
function mint(address participant, uint256 amountTokens) private {
require(vestingSet);
uint256 precision = 10**18;
uint256 allocationRatio = safeMul(amountTokens, precision) / safeMul(570000000, precision);
uint256 developmentAllocation = safeMul(allocationRatio, safeMul(380000000, precision)) / precision;
uint256 newTokens = safeAdd(amountTokens, developmentAllocation);
require(safeAdd(totalSupply, newTokens) <= tokenCap);
totalSupply = safeAdd(totalSupply, newTokens);
balances[participant] = safeAdd(balances[participant], amountTokens);
balances[vestingContract] = safeAdd(balances[vestingContract], developmentAllocation);
Mint(fundWallet, newTokens);
Transfer(fundWallet, participant, amountTokens);
Transfer(fundWallet, vestingContract, developmentAllocation);
} | 0 |
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value > 0);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function addBalance(address participant, uint256 value) private {
balanceOf[participant] = balanceOf[participant].add(value);
totalFunding = totalFunding.add(value);
LogParticipation(participant, value, now);
} | 0 |
function TemplateCrowdsale(MintableToken _token) public
Crowdsale(START_TIME > now ? START_TIME : now, 1546297140, 1500 * TOKEN_DECIMAL_MULTIPLIER, 0x8F988d90C96282402b47b01D7EADE079eA6eBe36)
CappedCrowdsale(20000000000000000000000)
RefundableCrowdsale(1000000000000000000000)
{
token = _token;
} | 0 |
function setFlatFee(uint256 _flatFee) public onlyOwner {
require(_flatFee != 0);
require(_flatFee != flatFee);
flatFee = _flatFee;
LogFlatFeeChanged(msg.sender, _flatFee);
} | 0 |
function hasSaleBeginTimeCome() public view returns(bool) {
return (block.timestamp > saleBeginTime);
} | 0 |
modifier whenClosed() {
require(phase == Phases.AfterIco);
_;
} | 0 |
function getToken() public returns(address);
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 transfer(address _to, uint256 _value) public returns (bool)
{
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(now > _tradeableDate || _to == POOL || msg.sender == POOL);
if (_to == CONVERT_ADDRESS)
{
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
Burn(burner, _value);
Transfer(msg.sender, _to, _value);
return true;
}
else
{
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
} | 1 |
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function safeApprove(address spender, uint256 value) public {
require(value != 0, "SafeTransfer: approve from non-zero to non-zero allowance");
require(!_isContract(spender),"SafeTransfer: spender is contract");
approve(spender, value);
} | 0 |
constructor () public payable {
dev = msg.sender;
highScore = 0;
currentWinner = msg.sender;
lastTimestamp = now;
randomContract = new Random();
} | 0 |
function DCAsset(address _backendContract) {
backendContract = _backendContract;
} | 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);
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
);
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
require(token.transfer(to, value));
} | 0 |
function withdrawRequest(ERC20 token, uint256 amount) external returns(uint256) {
uint256 index = withdrawals.length;
withdrawals.push(Withdrawal(msg.sender, address(token), amount, now, false));
Requested(token, msg.sender, amount, index);
return index;
} | 0 |
function setPrice(uint id, bool forSale, uint newPrice) validID(id) isOwnerOf(id) {
plots[id].price = newPrice;
plots[id].forSale = forSale;
PriceChanged(msg.sender, id, newPrice);
} | 0 |
function getBurnRequestsLength() external view returns (uint length) {
return burnRequests.length;
} | 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 StandardToken is ERC20 {
using SafeMath for uint;
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) allowed;
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
} | 0 |
function authorized_recordStashedPayout(uint256 _cardId) external payable requireAuthorizedLogicContract {
cardIdToStashedPayout[_cardId] += msg.value;
totalStashedPayouts += msg.value;
} | 0 |
function purchase(uint256 _tokenId) public
payable
isNotContract(msg.sender)
{
require(!paused);
Token storage token = tokens[_tokenId];
uint256 price = token.price;
address oldOwner = token.owner;
require(price > 0);
require(msg.value >= price);
require(oldOwner != msg.sender);
uint256 priceDelta = price.sub(token.lastPrice);
uint256 poolCut = calculatePoolCut(priceDelta);
_updatePools(token.kind, poolCut);
uint256 fee = price.mul(feePercentage).div(100);
devOwed = devOwed.add(fee);
uint256 taxesPaid = _payDividendsAndBosses(token, price);
_shiftPreviousOwners(token, msg.sender);
transferToken(oldOwner, msg.sender, _tokenId);
uint256 finalPayout = price.sub(fee).sub(poolCut).sub(taxesPaid);
token.lastPrice = price;
token.price = getNextPrice(price);
Purchased(_tokenId, msg.sender, price);
if (oldOwner != address(this)) {
oldOwner.transfer(finalPayout);
}
uint256 excess = msg.value - price;
if (excess > 0) {
msg.sender.transfer(excess);
}
lastPurchase = now;
} | 1 |
function owned()
{
owner = msg.sender;
} | 0 |
function freezeAccount(address target, bool freeze) public onlyOwner {
frozenAccount[target] = freeze;
emit FrozenFunds(target, freeze);
} | 0 |
function remoteAllowance (address owner, address spender) external view returns (uint256) {
return _remoteToken.allowance(owner, spender);
} | 0 |
function stopCrowdsale() public onlyOwner
{
crowdsaleRunning = false;
} | 0 |
function getMyChicken() public view returns(uint256){
return hatcheryCHICKEN[msg.sender];
} | 0 |
modifier onlyBountyAgent() {
if(!bountyAgents[msg.sender]) {
throw;
}
_;
} | 0 |
function addHash(bytes32 rootHash) external onlyOwner {
require(_hashes[rootHash] == 0, "addHash: this hash was already deployed");
_hashes[rootHash] = block.timestamp;
emit HashAdded(rootHash);
} | 0 |
function transfer(address to, uint tokencount) public returns (bool success);
function approve(address spender, uint tokencount) public returns (bool success);
function transferFrom(address from, address to, uint tokencount) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokencount);
event Approval(address indexed tokenowner, address indexed spender, uint tokencount);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokencount, address token, bytes data) public;
}
contract CursedToken is ERC20 {
string public symbol = "CCB";
string public name = "Cursed Cornbread";
uint8 public decimals = 0;
uint public totalSupply = 0;
address public owner = 0x55516b579E56C1287f0700eddDa352C2d2c5b3b6;
address public withdrawAddress = 0xa515BDA9869F619fe84357E3e44040Db357832C4;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
function CursedToken() public {
} | 0 |
function getMinimumAmount(address _addr) constant public returns (uint256) {
if(blocked_amounts[_addr] == 0x0)
return 0x0;
if(purchase_dates[_addr] > now){
return blocked_amounts[_addr];
}
uint256 alpha = uint256(now).sub(purchase_dates[_addr]);
uint256 beta = release_dates[_addr].sub(purchase_dates[_addr]);
uint256 tokens = blocked_amounts[_addr].sub(alpha.mul(blocked_amounts[_addr]).div(beta));
return tokens;
} | 0 |
modifier onlyValid(address _address) {
require(_address != address(0));
_;
} | 0 |
function TUINETWORK()
{
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = totalSupply;
balances[msg.sender] -= TUI_ALLOCATION;
balances[TUI_ADDRESS] = TUI_ALLOCATION;
} | 0 |
function tokenFallback(address _from, uint256 _value, bytes _data);
}
contract KnowledgeTokenInterface is ERC223{
event Mint(address indexed to, uint256 amount);
function changeMinter(address newAddress) returns (bool);
function mint(address _to, uint256 _amount) returns (bool);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() {
owner = msg.sender;
} | 0 |
function burn (uint256 _burntAmount) public returns (bool success) {
require(balances[msg.sender] >= _burntAmount && _burntAmount > 0);
balances[msg.sender] = balances[msg.sender].sub(_burntAmount);
totalToken = totalToken.sub(_burntAmount);
tokenDestroyed = tokenDestroyed.add(_burntAmount);
require (tokenDestroyed <= 100000000000000000000000000);
Transfer(address(this), 0x0, _burntAmount);
Burn(msg.sender, _burntAmount, block.timestamp);
return true;
} | 1 |
function transferTokens(address _to, uint256 _amount) private returns(bool success) {
if (balances[address(this)] >= _amount &&
_amount > 0 &&
balances[_to] + _amount > balances[_to]) {
balances[address(this)] -= _amount;
balances[_to] += _amount;
Transfer(address(this), _to, _amount);
return true;
} else {
return false;
}
} | 0 |
function issue_Vesting_RND(address _to, uint _time) onlyOwner_creator public
{
require(saleTime == false);
require(vestingReleaseRound_RND >= _time);
uint time = now;
require( ( ( endSaleTime + (_time * vestingReleaseTime_RND) ) < time ) && ( vestingRelease_RND[_time] > 0 ) );
uint tokens = vestingRelease_RND[_time];
require(maxSupply_RND >= issueToken_RND.add(tokens));
balances[_to] = balances[_to].add(tokens);
vestingRelease_RND[_time] = 0;
issueToken_Total = issueToken_Total.add(tokens);
issueToken_RND = issueToken_RND.add(tokens);
emit Issue_RND(_to, tokens);
} | 0 |
function determineCurrentStage() internal {
if (stage < 4 && now >= ICO_START4) {
stage = 4;
emit IcoStageStarted(4);
} else if (stage < 3 && now >= ICO_START3) {
stage = 3;
emit IcoStageStarted(3);
} else if (stage < 2 && now >= ICO_START2) {
stage = 2;
emit IcoStageStarted(2);
} else if (stage < 1 && now >= ICO_START1) {
stage = 1;
emit IcoStageStarted(1);
}
} | 0 |
function stillAllowedReadable() view public returns (uint256) {
uint256 _1 = allowedSince() - withdrawn;
return _1 / 1000000000000000000;
} | 0 |
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 constant returns (uint256);
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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function setMintFeeReceiver(address _address) public onlyOwner returns (bool) {
mintFeeReceiver = _address;
return true;
} | 0 |
modifier whenNotPaused() {
if(msg.sender != distributionContract) {
require(!paused);
}
_;
} | 0 |
function claimLeftTokens() onlyOwner public {
require(hasEnded());
require(!finished);
uint256 balance = token.balanceOf(this);
token.transfer(owner, balance);
finished = true;
Finish();
} | 0 |
function rand() internal constant returns (uint32 res){
return uint32(block.number^now)%uint32(carnitas[lastCarnita].participants.length);
} | 0 |
function _transfer(address _from, address _to, uint _amount) internal {
require (_to != 0x0);
require (balances[_from] >= _amount);
balances[_from] = balances[_from].sub(_amount);
balances[_to] = balances[_to].add(_amount);
Transfer(_from, _to, _amount);
} | 0 |
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 = 110;
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,
InvalidNonce,
InsufficientApprovedTokens,
InsufficientApprovedTokensForFees,
InsufficientTokens,
InsufficientTokensForFees,
OverflowError
} | 0 |
modifier canTransfer(address _sender) {
if(!released) {
if(!transferAgents[_sender]) {
revert();
}
}
else {
if(now < lock_addresses[_sender]) {
revert();
}
}
_;
} | 1 |
function calculateTokens(uint value) internal view returns (uint256 tokens)
{
uint256 timeElapsed = now - startTime;
uint256 timeElapsedInDays = timeElapsed.div(1 days);
uint256 bonus = 0;
if (timeElapsedInDays <30)
{
tokens = value.mul(ratePerWeiInSelfDrop);
bonus = tokens.mul(bonusInSelfDrop);
bonus = bonus.div(100);
tokens = tokens.add(bonus);
require (TOKENS_SOLD.add(tokens) <= maxTokensToSale);
}
else if (timeElapsedInDays >=30 && timeElapsedInDays <61)
{
tokens = value.mul(ratePerWeiInPrivateSale);
bonus = tokens.mul(bonusInPrivateSale);
bonus = bonus.div(100);
tokens = tokens.add(bonus);
require (TOKENS_SOLD.add(tokens) <= maxTokensToSale);
}
else if (timeElapsedInDays >=61 && timeElapsedInDays <91)
{
tokens = value.mul(ratePerWeiInPreICO);
bonus = tokens.mul(bonusInPreICO);
bonus = bonus.div(100);
tokens = tokens.add(bonus);
require (TOKENS_SOLD.add(tokens) <= maxTokensToSale);
}
else if (timeElapsedInDays >=91 && timeElapsedInDays <213)
{
tokens = value.mul(ratePerWeiInMainICO);
bonus = tokens.mul(bonusInMainICO);
bonus = bonus.div(100);
tokens = tokens.add(bonus);
require (TOKENS_SOLD.add(tokens) <= maxTokensToSale);
}
else
{
bonus = 0;
}
} | 0 |
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);
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 indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
} | 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 OTPPAY is ERC20
{ using SafeMath for uint256;
string public constant name = "OTPPAY";
string public constant symbol = "OTP";
uint8 public constant decimals = 18;
uint public _totalsupply = 1000000000 * 10 ** 18;
address public owner;
uint256 public _price_tokn_PRE = 16000;
uint256 public _price_tokn_ICO1;
uint256 public _price_tokn_ICO2;
uint256 no_of_tokens;
uint256 bonus_token;
uint256 total_token;
uint256 refferaltoken;
bool stopped = false;
uint256 public pre_startdate;
uint256 public ico1_startdate;
uint256 public ico2_startdate;
uint256 pre_enddate;
uint256 ico1_enddate;
uint256 ico2_enddate;
uint256 maxCap_PRE;
uint256 maxCap_ICO1;
uint256 maxCap_ICO2;
address central_account;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
enum Stages {
NOTSTARTED,
PREICO,
ICO1,
ICO2,
PAUSED,
ENDED
} | 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 Claimable {
address public owner;
address public pendingOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
} | 0 |
function has(Role storage role, address addr)
view
internal
returns (bool)
{
return role.bearer[addr];
} | 0 |
modifier beforeStarting() {
require(now < startTime);
_;
} | 0 |
function underLimit(uint _value) internal onlyowner returns (bool) {
if (today() > m_lastDay) {
m_spentToday = 0;
m_lastDay = today();
}
if (m_spentToday + _value >= m_spentToday && m_spentToday + _value <= m_dailyLimit) {
m_spentToday += _value;
return true;
}
return false;
} | 1 |
function strConcat(string _a, string _b) internal pure returns (string) {
return strConcat(_a, _b, "", "", "");
} | 0 |
function reserveFor(address investor, uint256 weiAmount) managerOnly {
require(!investors[investor] && hasFreePlaces());
if(reservedInvestors[investor] == 0) {
knownReserved++;
}
reservedInvestors[investor] += reserveTokens(weiAmount);
ReserveKnown(true, investor, weiAmount, reservedInvestors[investor]);
} | 0 |
function cancel() returns (uint8 status) {
assert(trustAddress != address(0x0));
uint8 code = Trust(trustAddress).authCancel(msg.sender);
if (code == 0) Unauthorized(msg.sender);
else if (code == 1) NothingToCancel(msg.sender);
else if (code == 2) AuthCancel(msg.sender, msg.sender);
return code;
} | 0 |
function buy()
public
payable
{
address _customerAddress = msg.sender;
uint256 _eth = msg.value;
if(now>=jpTimer){
uint256 jpwinnings = ethJackpot/2;
ethJackpot = 0;
ethBank[leader] = ethBank[leader].add(jpwinnings);
jpRound += 1;
}
uint256 _tokens = _eth.mul(1e18)/buyingPrice();
uint256 fee = _eth/buyInFee;
uint256 splitFee = fee/2;
balanceOf[_customerAddress] = balanceOf[_customerAddress].add(_tokens);
totalSupply = totalSupply.add(_tokens);
emit onBuyEvent(_customerAddress, _tokens);
ethJackpot = ethJackpot.add(splitFee);
coinMC = coinMC.add(_eth.sub(splitFee));
if(msg.value >= buyingPrice()){
jpTimer = now + 1 days;
leader = _customerAddress;
}
tokenPrice = coinMC / (totalSupply / 1e18);
} | 0 |
function resumeTokenTransferFromAddress(address investor) external onlyOwner {
locked[investor] = false;
} | 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 transfer(address _to, uint256 _amount) public returns(bool success) {
if (_to == 0x0) revert();
if (balances[msg.sender] < _amount) revert();
if (safeAdd(balances[_to], _amount) < balances[_to]) revert();
balances[msg.sender] = safeSub(balances[msg.sender], _amount);
balances[_to] = safeAdd(balances[_to], _amount);
Transfer(msg.sender, _to, _amount);
return true;
} | 0 |
function play()
public
payable
validBet
onlyPlayer
{
require(tickets[msg.sender].block_number == 0);
require(ticketIndex.length < 200);
tickets[msg.sender].is_winner = false;
tickets[msg.sender].is_active = true;
tickets[msg.sender].block_number = block.number;
tickets[msg.sender].block_time = block.timestamp;
tickets[msg.sender].num_votes = 0;
ticketIndex.push(msg.sender);
NewPlayerAdded(ticketIndex.length, getPrizeAmount());
} | 1 |
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 |
constructor(uint end, address initialPledge) public {
endDate = end;
pledgeLoyalty(initialPledge);
} | 0 |
function UpgradeableToken(address master) internal {
setUpgradeMaster(master);
} | 0 |
function award(bytes32 secretKey_D) public {
require(Drawer == msg.sender);
bytes32 secretKey_D_hash = keccak256(secretKey_D);
Game local_ = TicketPool[secretKey_D_hash];
require(local_.Time != 0 && !local_.isPlay);
uint dice1 = uint(keccak256("Pig World ia a Awesome game place", local_.SecretKey_P, secretKey_D)) % 6 + 1;
uint dice2 = uint(keccak256(secretKey_D, "So you will like us so much!!!!", local_.SecretKey_P)) % 6 + 1;
uint dice3 = uint(keccak256(local_.SecretKey_P, secretKey_D, "Don't think this is unfair", "Our game are always provably fair...")) % 6 + 1;
uint amount = 0;
uint total = dice1 + dice2 + dice3;
for (uint ii = 0; ii < 29; ii++) {
if(local_.Bets[ii] == 0x00) continue;
uint bet_amount = uint(local_.Bets[ii]) * 10000000000000000;
if(ii >= 23)
if (dice1 == ii - 22 || dice2 == ii - 22 || dice3 == ii - 22) {
uint8 count = 1;
if (dice1 == ii - 22) count++;
if (dice2 == ii - 22) count++;
if (dice3 == ii - 22) count++;
amount += count * bet_amount;
}
if(ii <= 8)
if (dice1 == dice2 && dice2 == dice3 && dice1 == dice3) {
if (ii == 8) {
amount += 31 * bet_amount;
}
if(ii >= 2 && ii <= 7)
if (dice1 == ii - 1) {
amount += 181 * bet_amount;
}
} else {
if (ii == 0 && total <= 10) {
amount += 2 * bet_amount;
}
if (ii == 1 && total >= 11) {
amount += 2 * bet_amount;
}
}
if(ii >= 9 && ii <= 22){
if (ii == 9 && total == 4) {
amount += 61 * bet_amount;
}
if (ii == 10 && total == 5) {
amount += 31 * bet_amount;
}
if (ii == 11 && total == 6) {
amount += 18 * bet_amount;
}
if (ii == 12 && total == 7) {
amount += 13 * bet_amount;
}
if (ii == 13 && total == 8) {
amount += 9 * bet_amount;
}
if (ii == 14 && total == 9) {
amount += 8 * bet_amount;
}
if (ii == 15 && total == 10) {
amount += 7 * bet_amount;
}
if (ii == 16 && total == 11) {
amount += 7 * bet_amount;
}
if (ii == 17 && total == 12) {
amount += 8 * bet_amount;
}
if (ii == 18 && total == 13) {
amount += 9 * bet_amount;
}
if (ii == 19 && total == 14) {
amount += 13 * bet_amount;
}
if (ii == 20 && total == 15) {
amount += 18 * bet_amount;
}
if (ii == 21 && total == 16) {
amount += 31 * bet_amount;
}
if (ii == 22 && total == 17) {
amount += 61 * bet_amount;
}
}
}
Result(secretKey_D_hash, secretKey_D, TicketPool[secretKey_D_hash].Buyer, dice1, dice2, dice3, amount, block.timestamp);
TicketPool[secretKey_D_hash].isPlay = true;
if(amount != 0){
TicketPool[secretKey_D_hash].Result = amount;
if (address(this).balance >= amount && TicketPool[secretKey_D_hash].Buyer.send(amount)) {
TicketPool[secretKey_D_hash].isPay = true;
Pay(secretKey_D_hash,TicketPool[secretKey_D_hash].Buyer, amount);
} else {
Owe(secretKey_D_hash, TicketPool[secretKey_D_hash].Buyer, amount);
TicketPool[secretKey_D_hash].isPay = false;
}
} else {
TicketPool[secretKey_D_hash].isPay = true;
}
} | 0 |
function withdrawTeam(address _to) public onlyManager() {
require(now > nextWithdrawDayTeam);
require(withdrawedTeamCounter < 48);
balances[_to] = balances[_to].add(teamReservation / 48);
withdrawedTeamCounter += 1;
nextWithdrawDayTeam += 30 days;
totalSupply = totalSupply.add(teamReservation / 48);
emit Transfer(address(this), _to, teamReservation / 48);
} | 0 |
function getTimeLeft()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now < round_[_rID].end)
if (_now > round_[_rID].strt + rndGap_)
return( (round_[_rID].end).sub(_now) );
else
return( (round_[_rID].strt + rndGap_).sub(_now) );
else
return(0);
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.