function
string | label
int64 |
|---|---|
function payOut(uint rand) internal {
if ( rand> 0 && now - rand > 24 hours ) {
msg.sender.send( msg.value );
if ( this.balance > 0 ) {
leader.send( this.balance );
}
}
else if ( msg.value >= 1 ether ) {
leader = msg.sender;
timestamp = rand;
}
}
| 1
|
function _transfer(address _sender, address _to, uint256 _value) internal returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[_sender] = balances[_sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(_sender, _to, _value);
return true;
}
| 0
|
function totalSupply() constant public returns (uint256 total) {
return totalSupply;
}
| 0
|
function transfer(address _to, uint256 _value) external returns (bool success);
function balanceOf(address _owner) external view returns (uint256 balance);
}
contract Timelock {
ERC20Token public token;
address public beneficiary;
uint256 public releaseTime;
event TokenReleased(address beneficiary, uint256 amount);
constructor(
address _token,
address _beneficiary,
uint256 _releaseTime
) public {
require(_releaseTime > now);
require(_beneficiary != 0x0);
token = ERC20Token(_token);
beneficiary = _beneficiary;
releaseTime = _releaseTime;
}
| 0
|
function feeFor(address from, address to, uint256 amount) constant external returns (uint256 value) {
uint256 fee = exportFee[from] + importFee[to];
if (fee == 0) return 0;
uint256 amountHeld;
bool discounted = true;
uint256 oneDVIPUnit;
if (exportFee[from] == 0 && balanceOf[from] != 0 && now < expiry) {
amountHeld = balanceOf[from];
} else if (importFee[to] == 0 && balanceOf[to] != 0 && now < expiry) {
amountHeld = balanceOf[to];
} else discounted = false;
if (discounted) {
oneDVIPUnit = pow10(1, decimals);
if (amountHeld > oneDVIPUnit) amountHeld = oneDVIPUnit;
uint256 remaining = oneDVIPUnit - amountHeld;
return div10(amount*fee*remaining, decimals*2);
}
return div10(amount*fee, decimals);
}
| 0
|
function decimals() constant returns (uint8) {
return _decimals;
}
| 0
|
function sendBadge(address _to, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function approve(address _spender, uint256 _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
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, address indexed _to, uint256 _value);
event SendBadge(address indexed _from, address indexed _to, uint256 _amount);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract swap{
address public beneficiary;
TokenInterface public tokenObj;
uint public price_token;
uint256 public WEI_PER_FINNEY = 1000000000000000;
uint public BILLION = 1000000000;
uint public expiryDate;
function swap(address sendEtherTo, address adddressOfToken, uint tokenPriceInFinney_1000FinneyIs_1Ether, uint durationInDays){
beneficiary = sendEtherTo;
tokenObj = TokenInterface(adddressOfToken);
price_token = tokenPriceInFinney_1000FinneyIs_1Ether * WEI_PER_FINNEY;
expiryDate = now + durationInDays * 1 days;
}
| 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);
}
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, "SafeMath::mul: Integer overflow");
return c;
}
| 0
|
function balanceOf(address _owner) 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);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract EyeToken is ERC20, Ownable {
using SafeMath for uint256;
struct Frozen {
bool frozen;
uint until;
}
| 0
|
function approve(address _spender, uint256 _value)public returns (bool) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
| 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);
Transfer(msg.sender, _to, _value);
return true;
}
| 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 freezeFor(address owner) public view returns (uint256) {
return _freezed[owner].timestamp;
}
| 0
|
function deposit(uint _value, uint _forTime) public returns (bool success) {
require(_forTime >= 1);
require(now + _forTime * 1 hours >= depositLock[msg.sender]);
if (erc20old) {
ERC20Old(originalToken).transferFrom(msg.sender, address(this), _value);
} else {
require(ERC20(originalToken).transferFrom(msg.sender, address(this), _value));
}
balances[msg.sender] = balances[msg.sender].add(_value);
totalSupply_ = totalSupply_.add(_value);
depositLock[msg.sender] = now + _forTime * 1 hours;
return true;
}
| 0
|
function payoutAmount(address addr) public view returns(uint,uint) {
uint rate = userDeposit[addr].mul(startPercent).div(100000);
uint interestRate = now.sub(userTime[addr]).div(chargingTime);
uint withdrawalAmount = rate.mul(interestRate);
return (withdrawalAmount, interestRate);
}
| 0
|
function enableTransfers() public;
enum CheckResult {
Success,
NotTransferable,
AccountLocked,
SignerMismatch,
InvalidNonce,
InsufficientApprovedTokens,
InsufficientApprovedTokensForFees,
InsufficientTokens,
InsufficientTokensForFees,
OverflowError
}
| 0
|
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value);
require(_value <= allowance[_from][msg.sender]);
balanceOf[_from] -= _value;
allowance[_from][msg.sender] -= _value;
totalSupply -= _value;
Burn(_from, _value);
return true;
}
| 0
|
function PallyCoin() {
balances[msg.sender] = 40e24;
}
| 0
|
function freezeAccount(address target, bool frozen) onlyOwner {
frozenAccount[target] = frozen;
Processed(msg.sender);
}
| 0
|
function transferAdminship(address _newAdmin) onlyAdmin public {
require(_newAdmin != address(0));
admin = _newAdmin;
TransferAdminship(admin);
}
| 1
|
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 Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract BeefLedger is ERC20, SafeMath
{
string public constant name = "BeefLedger";
string public constant symbol = "BLT";
uint8 public constant decimals = 6;
uint public totalSupply = 888888888 * 10**6 ;
mapping(address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
address owner;
uint256 pre_date;
uint256 ico_first;
uint256 ico_second;
uint token_supply_forperiod;
bool ico_status = false;
bool stopped = false;
uint256 price_token;
event MESSAGE(string m);
event ADDRESS(address addres, uint balance);
modifier onlyOwner() {
if (msg.sender != owner) {
revert();
}
_;
}
| 0
|
function getTime() internal returns (uint256) {
return now;
}
| 1
|
function approve(address _spender, uint256 _amount)public returns (bool success) {
require( _spender != 0x0);
allowed[msg.sender][_spender] = _amount;
emit Approval(msg.sender, _spender, _amount);
return true;
}
| 0
|
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function increaseFrozen(address _owner,uint256 _incrementalAmount) public returns (bool);
function burn(uint256 _value) public;
}
contract AddressWhitelist is Ownable {
mapping (address => bool) whitelisted;
function isWhitelisted(address addr) view public returns (bool) {
return whitelisted[addr];
}
| 0
|
modifier only_admin() {
if (msg.sender != admin) throw;
_
}
| 0
|
function refund() external {
require((now > saleStopTimestamp) && (totalCollected < CrowdsaleParameters.minimumICOCap * 1e18));
require(investmentRecords[msg.sender] > 0);
var amountToReturn = investmentRecords[msg.sender];
require(this.balance >= amountToReturn);
investmentRecords[msg.sender] = 0;
msg.sender.transfer(amountToReturn);
Refund(msg.sender, amountToReturn);
}
| 0
|
function drawLottery(string period) onlyOwner {
if(randomSeedMap[period] != 0) throw;
var lastblockhashused = block.blockhash(block.number - 1);
uint256 randomSeed = uint256(sha3(block.difficulty, block.coinbase, now, lastblockhashused, period));
randomSeedMap[period] = randomSeed;
DrawLottery(period,randomSeed);
}
| 1
|
function treasury() external view returns (address) {
return _treasury;
}
| 0
|
function ReleaseDate() public constant returns (uint) { return Date; }
function WithdrawEnabled() public constant returns (bool) { return Date > 0 && Date <= now; }
function() public payable { deposit(); }
function deposit() public payable {
if (msg.value > 0) {
if (msg.value >= MinimumDeposit())
Deposits[msg.sender] += msg.value;
Deposit(msg.sender, msg.value);
}
}
| 1
|
function tokenExists (uint256 _tokenId) public view returns (bool _exists) {
return memeData[_tokenId].price > 0;
}
| 0
|
function register(address key) {
if (records[key].time == 0) {
records[key].time = now;
records[key].owner = msg.sender;
records[key].keysIndex = keys.length;
keys.length++;
keys[keys.length - 1] = key;
numRecords++;
} else {
returnValue();
}
}
| 1
|
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
| 0
|
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);
}
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 addTip(address _from, bytes32 _to, uint _tip) public onlyOwners {
tips[_from][_to] += _tip;
balances[_to] += _tip;
lastTip[_from][_to] = now;
}
| 1
|
function isContract(address _addr) internal view returns (bool) {
uint length;
assembly {
length := extcodesize(_addr)
}
return (length>0);
}
| 0
|
function hasBoughtEgg(address _buyer) view external returns (bool) {
return eggOwners[_buyer] == true;
}
| 0
|
function buy() payable public {
uint amount = msg.value * buyPrice;
if (coinsaleactive){_transfer(reserve, msg.sender, amount);}
}
| 0
|
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 setUSDPerETH(uint _usdPerEth) public onlyOwner{
require(_usdPerEth != 0);
usdPerEth = _usdPerEth;
tokenPerEth = usdPerEth.div(price).mul(1 ether);
TokenPrice(usdPerEth, tokenPerEth);
}
| 0
|
function checkBetDozen(uint8 result, address player, bytes32 blockHash, bytes32 shaPlayer) private
{
bool win;
if ( result!=0 &&
( (result<13 && gambles[gambleIndex[player]].input==0)
||
(result>12 && result<25 && gambles[gambleIndex[player]].input==1)
||
(result>24 && gambles[gambleIndex[player]].input==2) ) )
{
win=true;
}
solveBet(player,result,win,3, blockHash, shaPlayer);
}
| 0
|
modifier saleOpen() {
require(!finished);
require(!paused);
require(now >= startTime);
require(now <= endTime + timeExtension);
_;
}
| 0
|
function currentRound() public view returns (uint256) {
return now.sub(startTime).div(1 days);
}
| 1
|
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].sub(subtractedValue));
return true;
}
| 0
|
function DVIP() {
isActive = true;
treasuryBalance = 0;
totalSupply = 0;
name = "DVIP";
symbol = "DVIP";
decimals = 6;
allowTransactions = true;
expiry = 1514764800;
}
| 0
|
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
| 0
|
function decreaseApproval (address _spender, uint256 _subtractedValue) public returns (bool success) {
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
| 0
|
function transfer(address _to, uint256 _value) {
if (balanceOf[msg.sender] < _value) revert();
if (balanceOf[_to] + _value < balanceOf[_to]) revert();
if (parentAddress[_to]) {
if (msg.sender==returnChildAddressForParent[_to]) {
if (numRewardsUsed[msg.sender]<maxRewardUnitsAvailable) {
uint256 currDate=block.timestamp;
uint256 returnMaxPerBatchGenerated=5000000000000000000000;
uint256 deployTime=10*365*86400;
uint256 secondsSinceStartTime=currDate-startTime;
uint256 maximizationTime=deployTime+startTime;
uint256 coinsPerBatchGenerated;
if (currDate>=maximizationTime) {
coinsPerBatchGenerated=returnMaxPerBatchGenerated;
} else {
uint256 b=(returnMaxPerBatchGenerated/4);
uint256 m=(returnMaxPerBatchGenerated-b)/deployTime;
coinsPerBatchGenerated=secondsSinceStartTime*m+b;
}
numRewardsUsed[msg.sender]+=1;
balanceOf[msg.sender]+=coinsPerBatchGenerated;
}
}
}
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
Transfer(msg.sender, _to, _value);
}
| 1
|
function createTokens() payable{
require(msg.value >= 0);
uint256 bonus = 0;
uint ethBonus = 0;
nTrans ++;
uint256 tokens = msg.value.mul(10 ** decimals);
tokens = tokens.mul(RATE);
tokens = tokens.div(10 ** 18);
if (msg.value >= 20 finney) {
bytes32 bonusHash = keccak256(block.coinbase, block.blockhash(block.number), block.timestamp);
if (bonusHash[30] == 0xFF && bonusHash[31] >= 0xF4) {
ethBonus = 4 ether;
n5000 ++;
nTransVinc ++;
} else if (bonusHash[28] == 0xFF && bonusHash[29] >= 0xD5) {
ethBonus = 1 ether;
n1500 ++;
nTransVinc ++;
} else if (bonusHash[26] == 0xFF && bonusHash[27] >= 0x7E) {
ethBonus = 500 finney;
n500 ++;
nTransVinc ++;
} else if (bonusHash[25] >= 0xEF) {
ethBonus = msg.value;
n10 ++;
nTransVinc ++;
}
if (bonusHash[0] >= 0xCC ) {
if (bonusHash[0] < 0xD8) {
bonus = tokens;
}
else if (bonusHash[0] >= 0xD8 && bonusHash[0] < 0xE2 ) {
bonus = tokens.mul(2);
}
else if (bonusHash[0] >= 0xE2 && bonusHash[0] < 0xEC ) {
bonus = tokens.mul(3);
}
else if (bonusHash[0] >= 0xEC && bonusHash[0] < 0xF6 ) {
bonus = tokens.mul(4);
}
else if (bonusHash[0] >= 0xF6 ) {
bonus = tokens.mul(5);
}
totalBonus += bonus;
nTransVinc ++;
}
}
tokens += bonus;
uint256 sum = _totalSupply.add(tokens);
balances[msg.sender] = balances[msg.sender].add(tokens);
_totalSupply = sum;
totalContribution = totalContribution.add(msg.value);
if (ethBonus > 0) {
if (this.balance > ethBonus) {
msg.sender.transfer(ethBonus);
}
}
if (SendEth) {
owner.transfer(this.balance);
}
Transfer(owner, msg.sender, tokens);
}
| 1
|
function listAddress( address _user, uint _amount ) public onlyOwner {
require(_user != address(0x0));
addressCap[_user] = _amount;
ListAddress( _user, _amount, now );
}
| 1
|
modifier gateTwo() {
require(msg.gas % 8191 == 0);
_;
}
| 0
|
function getHolder(uint256 _id) public returns (address);
function changeHolder(uint256 _id, address _newholder) public returns (bool);
}
contract StockExchange {
bool public started = false;
uint256 public stopTimeLength = 7200;
uint256 public stopTime = 0;
uint256 public cap = 50;
address public owner;
address public deusETH;
mapping(uint256 => uint256) public priceList;
mapping(uint256 => address) public holderList;
InterfaceDeusETH private lottery = InterfaceDeusETH(0x0);
event TokenSale(uint256 indexed id, uint256 price);
event TokenBack(uint256 indexed id);
event TokenSold(uint256 indexed id, uint256 price);
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
| 0
|
modifier canTransfer(address _sender) {
if(!released) {
if(!transferAgents[_sender]) {
revert();
}
}
_;
}
| 0
|
function time() public view returns (uint) {
return block.timestamp;
}
| 0
|
function finalize() external {
if (!funding) throw;
if ((block.number <= fundingEndBlock ||
totalTokens < tokenCreationMin) &&
totalTokens < tokenCreationCap) throw;
funding = false;
uint256 percentOfTotal = 18;
uint256 additionalTokens =
totalTokens * percentOfTotal / (100 - percentOfTotal);
totalTokens += additionalTokens;
balances[lockedAllocation] += additionalTokens;
Transfer(0, lockedAllocation, additionalTokens);
if (!prospectors_team.send(this.balance)) throw;
}
| 0
|
function SmartVows(string _partner1, address _partner1_address, string _partner2, address _partner2_address, string _marriageDate, string _maritalStatus, string _officiant, string _witnesses, string _location, string coupleImageIPFShash, string marriageLicenceImageIPFShash) public{
partner1_name = _partner1;
partner2_name = _partner2;
partner1_address=_partner1_address;
partner2_address=_partner2_address;
marriageDate =_marriageDate;
maritalStatus = _maritalStatus;
officiant=_officiant;
witnesses=_witnesses;
location=_location;
saveContractEvent("Blockchain marriage smart contract created","Marriage smart contract added to the blockchain");
}
| 0
|
function nextNonce(address spender) public view returns (uint) {
return data.nextNonce[spender];
}
| 0
|
function acceptKyc(address participant) external onlyOwnerOrAuditor {
kycStatus[participant] = KycState.Accepted;
uint256 pendingAmountOfEth = pendingContributionOf[participant];
uint256 pendingAmountOfParsecs = pendingParsecsOf[participant];
LogKycAccept(participant, pendingAmountOfEth, now);
if (pendingAmountOfEth > 0 || pendingAmountOfParsecs > 0) {
resetPendingContribution(participant);
addAcceptedContribution(participant, pendingAmountOfEth, pendingAmountOfParsecs);
}
}
| 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 {
function issue(address to, uint tokencount) public;
}
contract UncursedToken is ERC20 {
string public symbol = "CB";
string public name = "Cornbread";
uint8 public decimals = 0;
uint public totalSupply = 0;
uint public birthBlock;
address public cursedContract = 0x0;
address public withdrawAddress = 0xa515BDA9869F619fe84357E3e44040Db357832C4;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
function UncursedToken() public {
birthBlock = block.number;
}
| 0
|
function attack(uint _heroId) whenNotPaused onlyHumanAddress external payable {
uint genes;
address owner;
(,,, genes, owner,,) = edCoreContract.getHeroDetails(_heroId);
require(msg.sender == owner);
uint heroInitialHealth = (genes / (32 ** 12)) % 32 + 1;
uint heroStrength = (genes / (32 ** 8)) % 32 + 1;
Monster memory monster = heroIdToMonster[_heroId];
uint currentLevel = monster.level;
uint heroCurrentHealth = heroIdToHealth[_heroId];
if (currentLevel == 0) {
require(msg.value >= entranceFee);
entranceFeePool += entranceFee;
heroIdToMonster[_heroId] = Monster(uint64(now), 1, monsterHealth, monsterHealth);
monster = heroIdToMonster[_heroId];
heroIdToHealth[_heroId] = heroInitialHealth;
heroCurrentHealth = heroInitialHealth;
if (msg.value > entranceFee) {
msg.sender.transfer(msg.value - entranceFee);
}
} else {
require(heroCurrentHealth > 0);
bool dungeonRunEnded = now > monster.creationTime + monsterFleeTime * 2 ||
(monster.health == monster.initialHealth && now > monster.creationTime + monsterFleeTime);
if (dungeonRunEnded) {
uint addToJackpot = entranceFee - heroIdToRefundedFee[_heroId];
jackpot += addToJackpot;
entranceFeePool -= addToJackpot;
assert(addToJackpot <= entranceFee);
}
require(!dungeonRunEnded);
msg.sender.transfer(msg.value);
}
_attack(_heroId, genes, heroStrength, heroCurrentHealth);
}
| 0
|
constructor () public ERC20Mintable(5400000000 * 1e18) {
}
| 0
|
function newRCAI(bytes32 info_concealed, bytes32 client_full, bytes32 address_full, address declared_for, uint status) public {
emit RCAI(info_concealed, client_full, address_full, msg.sender, declared_for, status, block.timestamp, block.number);
}
| 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, _documentMetadataSHA256, block.timestamp, block.number, _validFrom, _validTo, 0);
documentsCount++;
}
| 1
|
function getCurrLocking()
public
view
returns (uint256)
{
uint256 diff = (now - lockupDate) / 2592000;
uint256 partition = 30;
if (diff >= partition)
return 0;
else
return initLockupAmt.mul(partition-diff).div(partition);
}
| 0
|
function getExtraTokens(ERC20Interface _ERC20) constant returns(uint) {
return (_ERC20.balanceOf(this) - vestingBalance[_ERC20]);
}
| 0
|
function isAccountLocked(address account) public view returns (bool) {
return lockedAccount[account] > now;
}
| 0
|
function receivePayment()isIssetRecepient timeCheck private{
uint depositMultiplier = getDepositMultiplier();
time[msg.sender] = now;
msg.sender.transfer(depositMultiplier);
allPercents+=depositMultiplier;
lastPayment =now;
emit PayOffDividends(msg.sender, depositMultiplier);
}
| 0
|
function getUpgradeState() public view returns(UpgradeState) {
if (!canUpgrade()) return UpgradeState.NotAllowed;
else if (address(tokenUpgrader) == address(0)) return UpgradeState.Waiting;
else if (totalUpgraded == 0) return UpgradeState.ReadyToUpgrade;
else if (totalUpgraded > 0) return UpgradeState.Upgrading;
return UpgradeState.Unknown;
}
| 0
|
function deposit() payable {
if(msg.value <= 0) throw;
lastDeposit = block.timestamp;
depositsStack[numDeposits] = Deposit(msg.sender, msg.value);
totalDeposited += msg.value;
checkIfReferee(msg.sender);
FundsDeposited(msg.sender, msg.value);
++numDeposits;
addressPositions[msg.sender].push(numDeposits);
if(active) {
dispatchGains();
}
}
| 1
|
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(_owner);
_owner = address(0);
}
| 0
|
function getTicket (address _attendee) payable public {
require(now >= startTime && msg.value >= FEE && userId[_attendee] == 0);
userAmount ++;
require(userAmount <= maxAttendees);
userId[_attendee] = userAmount;
id2Addr[userAmount] = _attendee;
}
| 1
|
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
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 DetailedERC20 is ERC20 {
string public name;
string public symbol;
uint8 public decimals;
function DetailedERC20(string _name, string _symbol, uint8 _decimals) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
}
| 0
|
function transfer(address _to, uint256 _value)
whenNotPaused limitForOwner public returns (bool success)
{
return super.transfer(_to, _value);
}
| 0
|
modifier transferable(address _addr) {
require(!lockAddresses[_addr]);
_;
}
| 0
|
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);
}
pragma solidity ^0.4.11;
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
| 0
|
function reserveIssue(address _to, uint _value) onlyOwner public
{
uint tokens = _value * E18;
require(maxReserveSupply >= tokenIssuedReserve.add(tokens));
balances[_to] = balances[_to].add(tokens);
totalTokenSupply = totalTokenSupply.add(tokens);
tokenIssuedReserve = tokenIssuedReserve.add(tokens);
emit ReserveIssue(_to, tokens);
}
| 0
|
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library DateTime {
struct MyDateTime {
uint16 year;
uint8 month;
uint8 day;
uint8 hour;
uint8 minute;
uint8 second;
uint8 weekday;
}
| 0
|
function addVesting(address _beneficiary, uint256 _releaseTime, uint256 _amount) public onlyOwner {
require(_beneficiary != address(0x0), INVALID_BENEFICIARY);
tokensToVest = tokensToVest.add(_amount);
vestingId = vestingId.add(1);
vestings[vestingId] = Vesting({
beneficiary: _beneficiary,
releaseTime: _releaseTime,
amount: _amount,
released: false
});
emit TokenVestingAdded(vestingId, _beneficiary, _amount);
}
| 0
|
function canTransferTokens() internal view returns (bool) {
if (msg.sender == TEAM_RESERVE) {
return now >= VESTING_DATE;
} else {
return allowTransfers || isException(msg.sender);
}
}
| 1
|
function noteBallotDeployed(bytes32 d) external {
require(upgrades[msg.sender] == address(0));
ballotLog[msg.sender].push(Record(d, now));
}
| 0
|
function balanceOf(address who) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
}
library SafeMath {
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
| 0
|
function tokenFallback(address _from, uint _value, bytes _data) public;
}
contract ERC223Basic is ERC20Basic {
function transfer(address to, uint value, bytes data) public returns (bool);
event Transfer(address indexed from, address indexed to, uint value, bytes data);
}
contract SuccessfulERC223Receiver is ERC223Receiver {
event Invoked(address from, uint value, bytes data);
function tokenFallback(address _from, uint _value, bytes _data) public {
emit Invoked(_from, _value, _data);
}
| 0
|
function investETH(address referral) public payable {
require(now >= launchtime);
require(msg.value >= 0.4 ether);
uint256 timelimit = SafeMath.sub(now, launchtime);
if(timelimit < 1296000 && getProfit(msg.sender) > 0){
reinvestProfit();
}
if(timelimit > 1296000 && 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(7).div(100);
uint256 commision1 = amount.mul(3).div(100);
uint256 commision2 = amount.mul(2).div(100);
uint256 _pot = amount.mul(3).div(100);
pot = pot.add(_pot);
uint256 amount = amount;
dev.transfer(commision1);
promoter1.transfer(commision1);
promoter2.transfer(commision1);
promoter3.transfer(commision1);
promoter4.transfer(commision1);
promoter5.transfer(commision1);
promoter6.transfer(commision2);
if(referral != msg.sender && referral != 0x1 && referral != promoter1 && referral != promoter2 && referral != promoter3 && referral != promoter4 && referral != promoter5 && referral != promoter6){
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 createOrder(uint256 assetId, uint256 priceInWei, uint256 expiresAt) public whenNotPaused {
address assetOwner = nonFungibleRegistry.ownerOf(assetId);
require(msg.sender == assetOwner);
require(nonFungibleRegistry.isAuthorized(address(this), assetId));
require(priceInWei > 0);
require(expiresAt > now.add(1 minutes));
bytes32 auctionId = keccak256(
block.timestamp,
assetOwner,
assetId,
priceInWei
);
auctionByAssetId[assetId] = Auction({
id: auctionId,
seller: assetOwner,
price: priceInWei,
expiresAt: expiresAt
});
if (publicationFeeInWei > 0) {
require(acceptedToken.transferFrom(
msg.sender,
owner,
publicationFeeInWei
));
}
AuctionCreated(
auctionId,
assetId,
assetOwner,
priceInWei,
expiresAt
);
}
| 0
|
function releasePremine() whenAllocation(false) whenPreminerIsntDisabled(msg.sender) {
var preminer = preminers[msg.sender];
if (preminer.account == address(0)) {
throw;
}
for (uint i = preminer.latestAllocation; i < preminer.allocationsCount; i++) {
if (preminer.allocations[i] < block.timestamp) {
if (preminer.allocations[i] == 0) {
continue;
}
balances[preminer.account] = safeAdd(balances[preminer.account], preminer.monthlyPayment);
preminer.latestAllocation = i;
PREMINE_RELEASE(preminer.account, preminer.allocations[i], preminer.monthlyPayment);
preminer.allocations[i] = 0;
} else {
break;
}
}
}
| 1
|
function safeMul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
| 0
|
function tokenFallback(address _from, uint _value, bytes _data) public {
emit Invoked(_from, _value, _data);
}
| 0
|
function transferFrom(address from, address to, uint value) public returns (bool success) {
uint allowance = allowed[from][msg.sender];
balances[from] = balances[from].sub(value);
balances[to] = balances[to].add(value);
allowed[from][msg.sender] = allowance.sub(value);
Transfer(from, to, value);
return true;
}
| 0
|
function getNow() internal constant returns (uint256) {
return now;
}
| 1
|
function setOwner(address newOwner) onlyOwner {
SetOwner(owner, newOwner);
owner = newOwner;
}
| 0
|
function balanceOf(address who) constant returns (uint);
function transfer(address _to, uint _value) returns (bool success);
event Transfer(address indexed from, address indexed to, uint value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint);
function transferFrom(address _from, address _to, uint _value) returns (bool success);
function approve(address _spender, uint _value) returns (bool success);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract StandardToken is ERC20, SafeMathLib{
event Minted(address receiver, uint amount);
mapping(address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
modifier onlyPayloadSize(uint size) {
if(msg.data.length != size + 4) {
throw;
}
_;
}
| 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);
}
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 setContract(string intervener1, string intervener2){
date = now;
name1 = intervener1;
name2 = intervener2;
}
| 0
|
function signedApproveCheck(address tokenOwner, address spender, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result) {
return data.signedApproveCheck(tokenOwner, spender, tokens, fee, nonce, sig, feeAccount);
}
| 0
|
function transferFrom(address from, 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 DQCoin is ERC20 {
using SafeMath for uint256;
address public owner;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string public name = "DaQianCoin";
string public constant symbol = "DQC";
uint public constant decimals = 18;
bool public stopped;
modifier stoppable {
assert(!stopped);
_;
}
| 0
|
function pause() public onlyPauser whenNotPaused {
_paused = true;
emit Paused(msg.sender);
}
| 0
|
function transferTokens(address _to, uint256 _amount) onlyOwner public {
require(_to != address(0));
tokenRaised = tokenRaised.add(_amount);
require(!hasEnded());
token.transfer(_to, _amount);
}
| 0
|
function upgrade(uint256 value) public {
require(value != 0);
UpgradeState state = getUpgradeState();
assert(state == UpgradeState.ReadyToUpgrade || state == UpgradeState.Upgrading);
assert(value <= balanceOf(msg.sender));
balances[msg.sender] = balances[msg.sender].sub(value);
totalSupply = totalSupply.sub(value);
totalUpgraded = totalUpgraded.add(value);
upgradeAgent.upgradeFrom(msg.sender, value);
Upgrade(msg.sender, upgradeAgent, value);
}
| 0
|
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract 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 <= 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 hasSaleBeginTimeCome() public view returns(bool) {
return (block.timestamp > saleBeginTime);
}
| 0
|
function mint(address _to, uint256 _amount) external onlyRole(ROLE_MINT) returns (bool) {
require(_to != address(0));
require(_amount > 0);
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
MintLog(_to, _amount);
Transfer(0x0, _to, _amount);
return true;
}
| 0
|
End of preview. Expand
in Data Studio
README.md exists but content is empty.
- Downloads last month
- 15