function
string | label
int64 |
|---|---|
function signedTransferFromHash(Data storage , address spender, address from, address to, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash) {
hash = keccak256(signedTransferFromSig, address(this), spender, from, to, tokens, fee, nonce);
} | 0 |
function getEggsToHatchDragon() public view returns (uint) {
uint256 timeSpent = SafeMath.sub(now,contractStarted);
timeSpent = SafeMath.div(timeSpent, 3600);
return SafeMath.mul(timeSpent, 10);
} | 0 |
function submit(bytes32 Bets, bytes32 secretKey_P, bytes32 secretKey_D_hash) payable public {
require(TicketPool[secretKey_D_hash].Time == 0);
require(msg.value >= LimitBottom && msg.value <= LimitTop);
uint bet_total_amount = 0;
for (uint i = 0; i < 29; i++) {
if(Bets[i] == 0x00) continue;
uint bet_amount_ = uint(Bets[i]).mul(10000000000000000);
bet_total_amount = bet_total_amount.add(bet_amount_);
}
if(bet_total_amount == msg.value){
SubmitTicket(secretKey_D_hash, msg.value, Bets, secretKey_P, msg.sender);
TicketPool[secretKey_D_hash] = Game(Bets,secretKey_P,false,false,0,block.timestamp,msg.sender);
}else{
revert();
}
} | 0 |
function authCall(address from, bytes32 hash) external returns (uint8 code) {
if (!masterKeys[from] && !trustedClients[msg.sender]) {
Unauthorized(from);
return 0;
}
if (functionCalling[from] == 0) {
if (functionCalls[hash] == 0x0) {
functionCalls[hash] = from;
functionCalling[from] = hash;
AuthInit(from);
return 1;
} else {
AuthComplete(functionCalls[hash], from);
resetAction(hash);
return 2;
}
} else {
AuthPending(from);
return 3;
}
} | 0 |
function balanceOf(address who)public view returns (uint256);
function allowance(address owner, address spender)public view returns (uint);
function transferFrom(address from, address to, uint value)public returns (bool ok);
function approve(address spender, uint value)public returns (bool ok);
function transfer(address to, uint value)public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract FiatContract
{
function USD(uint _id) constant returns (uint256);
}
contract TestFiatContract
{
function USD(uint) constant returns (uint256)
{
return 12305041990000;
} | 0 |
function cancelAgreement(uint256 agreementId) external validAgreement(agreementId) agreementPartiesOnly(agreementId) {
if (withdrawableAmount(agreementId) > 0) {
withdrawTokens(agreementId);
}
uint256 releasedAmount = agreements[agreementId].releasedAmount;
uint256 canceledAmount = agreements[agreementId].totalAmount.sub(releasedAmount);
(uint256 start, uint256 duration, address token) = decodeMeta(agreements[agreementId].meta);
agreements[agreementId].releasedAmount = agreements[agreementId].totalAmount;
if (canceledAmount > 0) {
IERC20(token).transfer(agreements[agreementId].sender, canceledAmount);
}
emit AgreementCanceled(
agreementId,
token,
agreements[agreementId].recipient,
agreements[agreementId].sender,
start,
duration,
releasedAmount,
canceledAmount,
block.timestamp
);
} | 0 |
constructor() public
{
owner = msg.sender;
balances[owner] = 40000000 * 10 **18;
_totalsupply = balances[owner];
lockstatus = true;
stage = Stages.NOTSTARTED;
emit Transfer(0, owner, balances[owner]);
} | 0 |
function recalcBonuses() internal;
function tokensPerWei(uint _amountWei) public view returns (uint256);
function isFinishedSuccessfully() public view returns (bool) {
return now >= endTime && totalWeiReceived >= minCapWei;
} | 0 |
function calculatePermillToRelease(uint256 _startTime) internal view returns (uint256 permill) {
uint periodsPassed = ((now.sub(_startTime)).div(Interval)).add(1);
permill = periodsPassed.mul(125);
} | 0 |
function calculate_fee(uint8 class, bool repellent) internal view returns(uint){
if(repellent){
return PRICE_CLASS[class] * (100 + PRICE_REPELLENT) / 100;
}else{
return PRICE_CLASS[class];
}
} | 0 |
function calculatePrice(uint weiAmount, address customer) internal constant returns (uint) {
uint investedAmount = investedAmountOf[customer].add(weiAmount);
uint decimalTokensPerWei;
if (investedAmount <= 20 * (10**18) && !discountedInvestors[customer]) {
decimalTokensPerWei = decimalTokensPerWei2Eth;
} else if (investedAmount <= 50 * (10**18)) {
decimalTokensPerWei = decimalTokensPerWei20Eth;
} else {
decimalTokensPerWei = decimalTokensPerWei50Eth;
}
uint decimalTokens = weiAmount.mul(decimalTokensPerWei);
return decimalTokens;
} | 0 |
function investETH(address referral) public payable {
require(now >= launchtime);
require(msg.value >= 0.1 ether);
uint256 timelimit = SafeMath.sub(now, launchtime);
if(timelimit < 1728000 && getProfit(msg.sender) > 0){
reinvestProfit();
}
if(timelimit > 1728000 && getProfit(msg.sender) > 0){
uint256 profit = getProfit(msg.sender);
lastInvest[msg.sender] = now;
lastWithdraw[msg.sender] = now;
userWithdrawals[msg.sender] += profit;
msg.sender.transfer(profit);
}
amount = msg.value;
uint256 commision = amount.mul(9).div(100);
uint256 commision1 = amount.mul(8).div(100);
uint256 _pot = amount.mul(3).div(100);
pot = pot.add(_pot);
uint256 amount = amount;
dev.transfer(commision1);
promoter1.transfer(commision1);
if(referral != msg.sender && referral != 0x1 && referral != promoter1){
affiliateCommision[referral] = SafeMath.add(affiliateCommision[referral], commision);
}
investedETH[msg.sender] = investedETH[msg.sender].add(amount);
lastInvest[msg.sender] = now;
userSequentialDeposits[msg.sender].push(amount);
if(pot >= maxpot){
uint256 winningReward = pot;
msg.sender.transfer(winningReward);
lastPotWinner = msg.sender;
emit PotWinner(msg.sender, winningReward);
pot = 0;
}
} | 0 |
function canAddToVault() external view canPoSMint returns(bool) {
return true;
} | 0 |
function StealResources(uint _planetId) {
require(addressPlanetsCount[msg.sender] > 0);
require(planets[_planetId].ownerAddress != msg.sender);
require(planets[_planetId].curResources > 0);
if(addressAttackCount[msg.sender] > addressDefenseCount[planets[_planetId].ownerAddress]) {
uint random = uint(keccak256(now, msg.sender, randNonce)) % 49;
randNonce++;
uint256 resourcesStealable = (planets[_planetId].curResources * (50 + random)) / 100;
msg.sender.transfer(resourcesStealable);
planets[_planetId].curResources = planets[_planetId].curResources - resourcesStealable;
}
} | 1 |
modifier not_upgraded() {
require(ptr == address(0), "upgrade pointer is non-zero");
_;
} | 0 |
function approveAllAndCall(address _spender, bytes _extraData) public returns (bool success) {
return approveAndCall(_spender, balanceOf[msg.sender], _extraData);
} | 0 |
function _setPayTo(address newPayTo) internal {
_payTo = newPayTo;
} | 0 |
function updateUsdEthRate(uint256 _rate) public onlyOwner {
require(_rate > 0);
require(rate != _rate);
emit UpdateUsdEthRate(_rate);
rate = _rate;
timestamp = now;
} | 0 |
function searchWhitelist(address _address) view public returns (string){
return (Whitelists[_address].Email);
} | 0 |
function isSuccessful()
public
constant
returns(bool)
{
return (
totalCollected >= hardCap ||
(block.timestamp >= endTimestamp && totalCollected >= minimalGoal)
);
} | 0 |
function disableMinting(Data storage self) public {
require(self.mintable);
require(msg.sender == self.minter || msg.sender == self.owner);
self.mintable = false;
if (self.minter != address(0)) {
MinterUpdated(self.minter, address(0));
self.minter = address(0);
}
MintingDisabled();
} | 0 |
function addBalance(address participant, uint256 value) private {
balanceOf[participant] = safeIncrement(balanceOf[participant], value);
totalFunding = safeIncrement(totalFunding, value);
LogParticipation(participant, value, now);
} | 0 |
function withdrawToWallet() public onlyOwner {
wallet.transfer(this.balance);
emit Withdrawn(wallet);
} | 0 |
function allowance(address _owner, address _spender) public constant returns (uint256 _allowance);
function transfer(address _to, uint256 _value) public returns (bool _succes);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _succes);
function approve(address _spender, uint256 _value) public returns (bool _succes);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StandardToken is ERC20, SafeMath {
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
function balanceOf(address _owner) public constant returns (uint256){
return balanceOf[_owner];
} | 0 |
function getBonus(uint256 _tokens, uint256 _weiAmount) public view returns (uint256) {
if (_weiAmount >= 30 ether) {
return _tokens.mul(secondBonus).div(100);
}
return _tokens.mul(firstBonus).div(100);
} | 0 |
function isTransformAgent() public constant returns (bool) {
return true;
} | 0 |
function totalSupply() external constant returns (uint256) {
return generalTokens + reservedTokens;
} | 0 |
function payoutAmount() public view returns(uint) {
uint persent = persentRate();
uint rate = userDeposit[msg.sender].mul(persent).div(100000);
uint interestRate = now.sub(userTime[msg.sender]).div(chargingTime);
uint withdrawalAmount = rate.mul(interestRate);
return (withdrawalAmount);
} | 0 |
function burn(uint256 _value) public {
require(_value > 0);
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
emit Burn(burner, _value);
emit Transfer(burner, 0x0, _value);
} | 0 |
function notarize(string sha256) {
if ( bytes(sha256).length == 64 ){
if ( proofs[sha256] == 0 ){
proofs[sha256] = block.timestamp;
}
}
} | 1 |
function approve(address _spender, uint _value) public returns (bool success);
}
contract StreamityEscrow is Ownable, ReentrancyGuard {
using SafeMath for uint256;
using ECRecovery for bytes32;
uint8 constant public STATUS_NO_DEAL = 0x0;
uint8 constant public STATUS_DEAL_WAIT_CONFIRMATION = 0x01;
uint8 constant public STATUS_DEAL_APPROVE = 0x02;
uint8 constant public STATUS_DEAL_RELEASE = 0x03;
TokenERC20 public streamityContractAddress;
uint256 public availableForWithdrawal;
uint32 public requestCancelationTime;
mapping(bytes32 => Deal) public streamityTransfers;
function StreamityEscrow(address streamityContract) public {
owner = msg.sender;
requestCancelationTime = 2 hours;
streamityContractAddress = TokenERC20(streamityContract);
} | 0 |
function endSale() onlyOwner public
{
require(saleTime == true);
require(maxSaleSupply == tokenIssuedSale);
saleTime = false;
uint nowTime = now;
endSaleTime = nowTime;
for(uint i = 0; i < advSptVestingTime; i++)
{
uint lockTime = endSaleTime + (advSptVestingDate * i);
advSptVestingTimer[i] = lockTime;
advSptVestingBalances[i] = advSptVestingBalances[i].add(advSptVestingSupplyPerTime);
}
for(uint i = 0; i < teamVestingTime; i++)
{
uint lockTime = endSaleTime + teamVestingDelayDate + (teamVestingDate * i);
teamVestingTimer[i] = lockTime;
teamVestingBalances[i] = teamVestingBalances[i].add(teamVestingSupplyPerTime);
}
for(uint i = 0; i < mktVestingTime; i++)
{
uint lockTime = endSaleTime + (mktVestingDate * i);
mktVestingTimer[i] = lockTime;
if(i == 0)
{
mktVestingBalances[i] = mktVestingBalances[i].add(mktVestingSupplyFirst);
}
else
{
mktVestingBalances[i] = mktVestingBalances[i].add(mktVestingSupplyPerTime);
}
}
for(uint i = 0; i < ecoVestingTime; i++)
{
uint lockTime = endSaleTime + (ecoVestingDate * i);
ecoVestingTimer[i] = lockTime;
if(i == 0)
{
ecoVestingBalances[i] = ecoVestingBalances[i].add(ecoVestingSupplyFirst);
}
else
{
ecoVestingBalances[i] = ecoVestingBalances[i].add(ecoVestingSupplyPerTime);
}
}
for(uint i = 0; i < fnfSaleLockTime; i++)
{
uint lockTime = endSaleTime + (fnfSaleLockDate * i);
fnfLockTimer[i] = lockTime;
}
for(uint i = 0; i < privateSaleLockTime; i++)
{
uint lockTime = endSaleTime + (privateSaleLockDate * i);
privateLockTimer[i] = lockTime;
}
emit EndSale(endSaleTime);
} | 0 |
function vestedAmount(ERC20Basic token) public constant returns (uint256) {
uint256 currentBalance = token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[token]);
if (now < cliff) {
return 0;
} else if (now >= startTime.add(duration) || revoked[token]) {
return totalBalance;
} else {
return totalBalance.mul(now.sub(startTime)).div(duration);
}
} | 0 |
function setBeneficiary(address newBeneficiary) ownerOnly {
beneficiary = newBeneficiary;
} | 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);
} | 0 |
function mint(address account, uint256 value) public onlyOwner{
require(value > 0);
require(now > nextminttime);
uint256 canminttokenamount = totalSupply().mul(2).div(100);
require(canminttokenamount >= value);
uint year = now.sub(nextminttime).div(365 days);
nextminttime += (year + 1) * 365 days;
_mint(account,value);
} | 0 |
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() {
owner = msg.sender;
} | 0 |
function unpause() external requireGod whenPaused {
paused = false;
} | 0 |
function reviewAudit(uint _id) external onlyOwner {
require(audits[_id].status == AuditStatus.InProgress);
require(block.timestamp >= audits[_id].endTime);
audits[_id].endTime = block.timestamp;
audits[_id].status = AuditStatus.InReview;
emit ReviewingAudit(_id);
} | 0 |
function AxiePresale() public {
priceIncrements[CLASS_BEAST] = priceIncrements[CLASS_AQUATIC] =
priceIncrements[CLASS_PLANT] = INITIAL_PRICE_INCREMENT;
currentPrices[CLASS_BEAST] = currentPrices[CLASS_AQUATIC] =
currentPrices[CLASS_PLANT] = INITIAL_PRICE;
} | 1 |
function close() public onlyOwner beforeEnd {
_burn(saleTokensAddress, balances[saleTokensAddress]);
_burn(bountyTokensAddress, balances[bountyTokensAddress]);
saleClosed = true;
} | 0 |
function numberOfDeployedTokens() public view returns (uint) {
return deployedTokens.length;
} | 0 |
function cancelOrder(Order memory order)
public
nonReentrant
{
cancelOrderInternal(order);
} | 0 |
function burnTokens(address account, uint value) internal;
event Burned(address account, uint value);
}
pragma solidity ^0.4.18;
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 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(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 {
assert(token.transfer(to, value));
} | 0 |
function distributePresaleTokens(address _buyer, uint tokens) external onlyOwner whenNotPaused {
require(_buyer != address(0));
require(tokens > 0 && tokens <= 10e24);
require(tokensDistributedPresale < 10e24);
tokensDistributedPresale = tokensDistributedPresale.add(tokens);
balances[_buyer] = balances[_buyer].add(tokens);
} | 0 |
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
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);
}
contract PhotochainVesting {
ERC20 public token;
address public beneficiary;
uint256 public releaseTime;
constructor(ERC20 _token, address _beneficiary, uint256 _releaseTime) public {
require(_releaseTime > block.timestamp, "Release time must be in future");
require(_releaseTime < block.timestamp + 3 * 365 days, "Release time must not exceed 3 years");
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
} | 0 |
function setReleaseAgent(address addr) onlyOwner inReleaseState(false) public {
if(releaseAgent != 0) {
throw;
}
releaseAgent = addr;
} | 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 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 approve(Data storage self, address spender, uint tokens) public returns (bool success) {
require(!self.accountLocked[msg.sender]);
self.allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
return true;
} | 0 |
modifier handleDerivativeTokens(address from) {
if (nextDerivativeTokenScheduled && now > nextDerivativeTokenTime) {
derivativeTokens.push(nextDerivativeToken);
nextDerivativeTokenScheduled = false;
delete nextDerivativeTokenTime;
delete nextDerivativeToken;
}
for (uint256 i = lastDerivativeTokens[from]; i < derivativeTokens.length; i++) {
derivativeTokens[i].mint(from, balances[from]);
DistributeDerivativeTokens(from, i, balances[from]);
}
lastDerivativeTokens[from] = derivativeTokens.length;
_;
} | 1 |
function approveCrowdsale(address _crowdsaleAddress) external;
function balanceOf(address _address) public constant returns (uint256 balance);
function vestedBalanceOf(address _address) public constant returns (uint256 balance);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
function transfer(address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _currentValue, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
}
contract CrowdsaleParameters {
struct AddressTokenAllocation {
address addr;
uint256 amount;
} | 0 |
function signedApproveAndCallCheck(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result) {
return data.signedApproveAndCallCheck(address(this), tokenOwner, spender, tokens, _data, fee, nonce, sig, feeAccount);
} | 0 |
function setupExportFee(address addr, uint256 fee) onlyOwnerUnlocked {
exportFee[addr] = fee;
activateExportFeeChargeRecord(addr);
FeeSetup(msg.sender, addr, fee);
} | 0 |
constructor(ReadableI _makerDAOMedianizer) public {
require(_makerDAOMedianizer != address(0));
makerDAOMedianizer = _makerDAOMedianizer;
weiPerUnitRate = convertToRate(_makerDAOMedianizer.read());
lastTimeUpdated = now;
} | 0 |
function changeMinContribution(uint256 _minContribution) public onlyOwner {
require(_minContribution > 0);
minContribution = _minContribution;
} | 0 |
function takeOwnership(uint256 _tokenId) public {
require(isApprovedFor(msg.sender, _tokenId));
clearApprovalAndTransfer(ownerOf(_tokenId), msg.sender, _tokenId);
} | 0 |
function transfer(address to, uint256 value) public returns (bool);
}
contract Bassdrops is EtherealFoundationOwned {
string public constant CONTRACT_NAME = "Bassdrops";
string public constant CONTRACT_VERSION = "A";
string public constant QUOTE = "It’s a permanent, perfect SIMULTANEOUS dichotomy of total insignificance and total significance merged as one into every single flashing second.";
string public constant name = "Bassdrops, a Currency of Omnitempo Maximalism";
string public constant symbol = "BASS";
uint256 public constant decimals = 11;
bool private tradeable;
uint256 private currentSupply;
mapping(address => uint256) private balances;
mapping(address => mapping(address=> uint256)) private allowed;
mapping(address => bool) private lockedAccounts;
event RecievedEth(address indexed _from, uint256 _value, uint256 timeStamp);
function () payable public {
RecievedEth(msg.sender, msg.value, now);
} | 1 |
function burn(uint256 _value) external;
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
event Burn(address indexed burner, uint256 value);
}
contract PVCCrowdsale is Ownable{
using SafeMath for uint256;
TokenInterface public token;
uint256 public startTime;
uint256 public endTime;
uint256 public ratePerWei = 1000;
uint256 public weiRaised;
uint256 public TOKENS_SOLD;
uint256 maxTokensToSale;
uint256 TokensForTeamVesting;
uint256 TokensForAdvisorVesting;
uint256 bonusInPreSalePhase1;
uint256 bonusInPreSalePhase2;
uint256 bonusInPublicSalePhase1;
uint256 bonusInPublicSalePhase2;
uint256 bonusInPublicSalePhase3;
bool isCrowdsalePaused = false;
uint256 totalDurationInDays = 75 days;
mapping(address=>bool) isAddressWhiteListed;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function PVCCrowdsale(uint256 _startTime, address _wallet, address _tokenAddress) public
{
require(_wallet != 0x0);
require(_startTime >=now);
startTime = _startTime;
endTime = startTime + totalDurationInDays;
require(endTime >= startTime);
owner = _wallet;
maxTokensToSale = 32500000 * 10 ** 18;
bonusInPreSalePhase1 = 30;
bonusInPreSalePhase2 = 25;
bonusInPublicSalePhase1 = 20;
bonusInPreSalePhase2 = 10;
bonusInPublicSalePhase3 = 5;
TokensForTeamVesting = 7000000 * 10 ** 18;
TokensForAdvisorVesting = 3000000 * 10 ** 18;
token = TokenInterface(_tokenAddress);
} | 0 |
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) internal _balances;
mapping (address => mapping (address => uint256)) internal _allowances;
uint256 internal _totalSupply;
constructor() internal {
} | 0 |
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 assignTokens(address receiver, uint tokenAmount) private {
token.mint(receiver, tokenAmount);
} | 0 |
function purchaseCity(uint256 _tokenId) public
payable
isNotContract(msg.sender)
{
City storage city = cityData[_tokenId];
uint256 price = city.price;
address oldOwner = city.owner;
address newOwner = msg.sender;
require(price > 0);
require(msg.value >= price);
require(oldOwner != msg.sender);
uint256 excess = msg.value.sub(price);
uint256 profit = price.sub(city.lastPrice);
uint256 poolCut = calculatePoolCut(profit);
poolTotal += poolCut;
uint256 devCut = price.mul(3).div(100);
devOwed = devOwed.add(devCut);
transferCity(oldOwner, newOwner, _tokenId);
city.lastPrice = price;
city.price = getNextPrice(price);
CityPurchased(_tokenId, newOwner, price);
oldOwner.transfer(price.sub(devCut.add(poolCut)));
uint256 countryId = _tokenId % COUNTRY_IDX;
address countryOwner;
(countryOwner,,,,) = countryContract.getCountryData(countryId);
require (countryOwner != address(0));
countryOwner.transfer(poolCut.mul(COUNTRY_PAYOUT).div(100));
if (excess > 0) {
newOwner.transfer(excess);
}
lastPurchase = now;
} | 1 |
function owner()
external
returns(address);
function updateContractAddress(
string _name,
address _address
)
external
returns (address);
function getContractAddress(
string _name
)
external
view
returns (address);
}
interface IBrickblockToken {
function transfer(
address _to,
uint256 _value
)
external
returns (bool);
function transferFrom(
address from,
address to,
uint256 value
)
external
returns (bool);
function balanceOf(
address _address
)
external
view
returns (uint256);
function approve(
address _spender,
uint256 _value
)
external
returns (bool);
}
interface IFeeManager {
function claimFee(
uint256 _value
)
external
returns (bool);
function payFee()
external
payable
returns (bool);
}
interface IAccessToken {
function lockBBK(
uint256 _value
)
external
returns (bool);
function unlockBBK(
uint256 _value
)
external
returns (bool);
function transfer(
address _to,
uint256 _value
)
external
returns (bool);
function distribute(
uint256 _amount
)
external
returns (bool);
function burn(
address _address,
uint256 _value
)
external
returns (bool);
}
contract BrickblockAccount is Ownable {
uint8 public constant version = 1;
uint256 public releaseTimeOfCompanyBBKs;
IRegistry private registry;
constructor
(
address _registryAddress,
uint256 _releaseTimeOfCompanyBBKs
)
public
{
require(_releaseTimeOfCompanyBBKs > block.timestamp);
releaseTimeOfCompanyBBKs = _releaseTimeOfCompanyBBKs;
registry = IRegistry(_registryAddress);
} | 0 |
modifier isNotTimeLocked() {
require(now >= timelockedAccounts[msg.sender]);
_;
} | 0 |
function setTreasuryAddress (address treasury) external onlyOwner {
_treasury = treasury;
} | 0 |
function secondaryICO(bool _icoOverride) onlyOwner public {
icoOverride = _icoOverride;
} | 0 |
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(_owner);
_owner = address(0);
} | 0 |
function upgradeFrom(address _from, uint256 _value) public;
}
contract CVEN is ERC20 {
using SafeMath for uint256;
string public constant name = "Concordia Ventures Stablecoin";
string public constant symbol = "CVEN";
uint8 public constant decimals = 18;
uint256 public _totalsupply;
uint256 public mintedTokens;
uint256 public totalUpgraded;
address public owner;
address public ethFundMain;
UpgradeAgent public upgradeAgent;
bool public lockstatus = false;
bool public stopped = false;
mapping(address => uint256) public balances;
mapping(address => mapping(address => uint256)) public allowed;
mapping(address => bool) public locked;
event Mint(address indexed from, address indexed to, uint256 amount);
event Burn(address indexed from, uint256 amount);
event Upgrade(address indexed _from, address indexed _to, uint256 _value);
event UpgradeAgentSet(address agent);
modifier onlyOwner() {
require(msg.sender == owner, "Only owner is allowed");
_;
} | 0 |
function stakeMaximum () external view returns (uint256) {
return _stakeMaximum;
} | 0 |
function totalSupply() external constant returns (uint);
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 returns (bool success);
function transferFrom(address from, address to, uint tokens) external returns (bool success);
function burn(uint256 _value) external;
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
event Burn(address indexed burner, uint256 value);
}
contract KRCPreSaleContract is Ownable{
using SafeMath for uint256;
TokenInterface public token;
uint256 public startTime;
uint256 public endTime;
uint256 public ratePerWei;
uint256 public weiRaised;
uint256 public TOKENS_SOLD;
uint256 maxTokensToSale;
uint256 bonusInPhase1;
uint256 bonusInPhase2;
uint256 minimumContribution;
uint256 maximumContribution;
bool isCrowdsalePaused = false;
uint256 totalDurationInDays = 23 days;
uint256 LongTermFoundationBudgetAccumulated;
uint256 LegalContingencyFundsAccumulated;
uint256 MarketingAndCommunityOutreachAccumulated;
uint256 CashReserveFundAccumulated;
uint256 OperationalExpensesAccumulated;
uint256 SoftwareProductDevelopmentAccumulated;
uint256 FoundersTeamAndAdvisorsAccumulated;
uint256 LongTermFoundationBudgetPercentage;
uint256 LegalContingencyFundsPercentage;
uint256 MarketingAndCommunityOutreachPercentage;
uint256 CashReserveFundPercentage;
uint256 OperationalExpensesPercentage;
uint256 SoftwareProductDevelopmentPercentage;
uint256 FoundersTeamAndAdvisorsPercentage;
struct Whitelist {
string Email;
} | 0 |
function approve(address _spender, uint256 _value) public returns (bool){
require(_value >= 0);
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
} | 0 |
function finishDeal(uint256 _dealId) public onlyOwner {
require(deals[_dealId].state == DealState.InProgress);
if (deals[_dealId].customerAns && deals[_dealId].beneficiaryAns) {
deals[_dealId].beneficiary.transfer(deals[_dealId].value);
deals[_dealId].agent.transfer(deals[_dealId].commission);
deals[_dealId].state = DealState.Finished;
} else {
require(now >= deals[_dealId].endtime);
deals[_dealId].state = DealState.InTrial;
}
} | 1 |
function nextForkBlockNumber()
public
constant
returns (uint256);
function lastSignedBlockNumber()
public
constant
returns (uint256);
function lastSignedBlockHash()
public
constant
returns (bytes32);
function lastSignedTimestamp()
public
constant
returns (uint256);
}
contract EthereumForkArbiter is
IEthereumForkArbiter,
AccessControlled,
AccessRoles,
Reclaimable
{
string private _nextForkName;
string private _nextForkUrl;
uint256 private _nextForkBlockNumber;
uint256 private _lastSignedBlockNumber;
bytes32 private _lastSignedBlockHash;
uint256 private _lastSignedTimestamp;
function EthereumForkArbiter(IAccessPolicy accessPolicy)
AccessControlled(accessPolicy)
Reclaimable()
public
{
} | 0 |
function hasStarted() public view returns (bool) {
return now >= startTime;
} | 0 |
modifier requireAuthorizedLogicContract() {
require(msg.sender == authorizedLogicContractAddress);
_;
} | 0 |
constructor() public {
totalSupply = 1000000000e8;
balances[investorsAllocation] = investorsTotal;
balances[teamAllocation] = teamTotal;
balances[advisorsAllocation] = advisorsTotal;
balances[bountyAllocation] = bountyTotal;
balances[liquidityPoolAllocation] = liquidityPoolTotal;
balances[contributorsAllocation] = contributorsTotal;
allowed[investorsAllocation][msg.sender] = investorsTotal;
allowed[bountyAllocation][msg.sender] = bountyTotal;
allowed[liquidityPoolAllocation][msg.sender] = liquidityPoolTotal;
allowed[contributorsAllocation][msg.sender] = contributorsTotal;
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
}
contract CrowdsaleParameters {
struct AddressTokenAllocation {
address addr;
uint256 amount;
} | 0 |
function hodl(uint256 _id, uint256 _value, uint256 _months) external {
require(_id > 0);
require(_value > 0);
require(_months == 3 || _months == 6 || _months == 12);
address _user = msg.sender;
Item storage item = items[_user][_id];
require(item.id != _id);
uint256 _seconds = _months.mul(2628000);
uint256 _releaseTime = now.add(_seconds);
require(_releaseTime > now);
uint256 balance = purpose.balanceOf(_user);
require(balance >= _value);
uint256 userPercentage = _months.div(3);
uint256 userDubiAmount = _value.mul(userPercentage).div(100);
uint256 ownerPercentage100 = _months.mul(5).div(3);
uint256 ownerDubiAmount = _value.mul(ownerPercentage100).div(10000);
items[_user][_id] = Item(_id, _user, _value, _releaseTime, false);
assert(purpose.hodlerTransfer(_user, _value));
assert(dubi.mint(_user, userDubiAmount));
assert(dubi.mint(owner, ownerDubiAmount));
} | 0 |
function transfer(address _to, uint _value)
public
canTransfer(msg.sender, _value)
returns (bool success)
{
return super.transfer(_to, _value);
} | 0 |
function multisigAddress() public constant returns(address){
return multisig;
} | 0 |
function time() public constant returns (uint)
{
return block.timestamp;
} | 1 |
function totalSupply() public view returns (uint256 total);
function balanceOf(address _owner) public view returns (uint256 balance);
function ownerOf(uint256 _tokenId) external view returns (address owner);
function approve(address _to, uint256 _tokenId) external;
function transfer(address _to, uint256 _tokenId) external;
function transferFrom(address _from, address _to, uint256 _tokenId) external;
event Transfer(address from, address to, uint256 tokenId);
event Approval(address owner, address approved, uint256 tokenId);
function supportsInterface(bytes4 _interfaceID) external view returns (bool);
}
contract Owned {
address public owner;
function Owned () public {
owner = msg.sender;
} | 0 |
function OBGAllocation(address _prospectors_team) internal {
obg = ProspectorsObligationToken(msg.sender);
unlockedAt = now + 1 days;
allocations[_prospectors_team] = 30000;
} | 0 |
modifier validateTrasfer() {
_;
assert(balances[founders] >= 100000000 ether || teamTransferFreeze < now);
} | 1 |
function signedApproveAndCall(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success) {
return data.signedApproveAndCall(address(this), tokenOwner, spender, tokens, _data, fee, nonce, sig, feeAccount);
} | 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
);
}
contract Crowdsale {
using SafeMath for uint256;
ERC20 public token;
address public wallet;
uint256 public rate;
uint256 public weiRaised;
event TokenPurchase(
address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount
);
constructor(uint256 _rate, address _wallet, ERC20 _token) public {
require(_rate > 0);
require(_wallet != address(0));
require(_token != address(0));
rate = _rate;
wallet = _wallet;
token = _token;
} | 0 |
function setApprovalForAll(address operator, bool _approved) public;
function isApprovedForAll(address owner, address operator) public view returns (bool);
function transferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
}
contract IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes memory data)
public returns (bytes4);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
} | 0 |
function destroyTokens(uint256 destroyAmount) multisig(sha3(msg.data)) {
assert(treasuryBalance >= destroyAmount);
treasuryBalance -= destroyAmount;
totalSupply -= destroyAmount;
} | 0 |
function _updatePurchasingState(address _beneficiary, uint256 _weiAmount) internal {
} | 0 |
function accountLocked(address tokenOwner) public view returns (bool) {
return data.accountLocked[tokenOwner];
} | 0 |
function mint(address tokenOwner, uint tokens, bool lockAccount) public returns (bool success) {
return data.mint(tokenOwner, tokens, lockAccount);
} | 0 |
function validBalanceOf(address addr) constant public returns (uint) {
FreezingNode[] memory nodes = c_freezing_list[addr];
uint length = nodes.length;
uint total_coins = balanceOf(addr);
for (uint i = 0; i < length; ++i) {
if (nodes[i].end_stamp > block.timestamp) {
total_coins = sub(total_coins, nodes[i].num_coins);
}
}
return total_coins;
} | 0 |
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
} | 0 |
function check(Role storage role, address addr)
view
internal
{
require(has(role, addr));
} | 0 |
function is_leap_year() private{
if(now >= _year + 31557600){
_year = _year + 31557600;
_year_count = _year_count + 1;
_currentMined = 0;
_miningReward = _miningReward/2;
if(((_year_count-2018)%5 == 0) && (_year_count != 2018)){
_maxMiningReward = _maxMiningReward/2;
}
if((_year_count%4 == 1) && ((_year_count-1)%100 != 0)){
_year = _year + 86400;
}
else if((_year_count-1)%400 == 0){
_year = _year + 86400;
}
}
} | 0 |
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
} | 0 |
function unhalt() onlyManager onContractStopped public {
halted = false;
} | 0 |
function receiveApproval(address from, uint256 amount, address currency, bytes extraData) external {
Token(currency).transferFrom(from, this, amount);
HotWalletDeposit(from, amount);
} | 0 |
function adjustFeeEntitlement(address account, uint preBalance)
internal
{
rolloverFee(account, lastTransferTimestamp[account], preBalance);
currentBalanceSum[account] = safeAdd(
currentBalanceSum[account],
safeMul(preBalance, now - lastTransferTimestamp[account])
);
lastTransferTimestamp[account] = now;
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.