function
string | label
int64 |
|---|---|
modifier onlyOwner() {
require(isOwner());
_;
}
| 0 |
function plus(uint a, uint b) public pure returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
| 0 |
function has(Role storage role, address addr)
view
internal
returns (bool)
{
return role.bearer[addr];
}
| 0 |
function AddTicket() public payable
{
require(msg.value == ticketPrice);
require(numtickets < maxTickets);
lastTicketTime = now;
numtickets += 1;
totalBounty += ticketPrice;
bool success = numtickets == maxTickets;
NewTicket(msg.sender, success);
if(success)
{
PayWinner(msg.sender);
}
}
| 1 |
function mul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
| 0 |
function LimitedSetup(uint _setupDuration)
public
{
constructionTime = now;
setupDuration = _setupDuration;
}
| 0 |
function end_ICO() external onlyOwner atStage(Stages.ICO)
{
require(now > ico_enddate);
stage = Stages.ENDED;
icoRunningStatus= false;
_totalsupply = (_totalsupply).sub(balances[address(this)]);
balances[address(this)] = 0;
Transfer(address(this), 0 , balances[address(this)]);
}
| 0 |
function TokenTimelock(ERC20Basic _token, address _beneficiary, uint _releaseTime) {
require(_releaseTime > now);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
}
| 0 |
modifier onlyOwner() {
require((msg.sender == owner) || (msg.sender == ownerMaster), "Only owner");
_;
}
| 0 |
function canUpgrade() public view returns(bool) {
return released && super.canUpgrade();
}
| 0 |
function activeUnLockGMI(uint64 timeStamp) public isOwer() {
activatedTime = timeStamp;
activated_ = true;
}
| 0 |
function setProfitAddress(address _profitAddress) onlyOwner external {
require(_profitAddress != address(0));
profitAddress = _profitAddress;
}
| 0 |
function getBalance() public view returns (uint256) {
return address(this).balance;
}
| 0 |
function setBackEndAddress(address newBackEndOperator) public onlyOwner {
backEndOperator = newBackEndOperator;
}
| 0 |
function unpause() onlyOwner whenPaused public {
require(now > startTime + lockPeriod);
super.unpause();
}
| 1 |
function frozen(address _target) view public returns (bool){
return frozenAccounts[_target];
}
| 0 |
function name() pure public returns (string _name) {
return TOKEN_NAME;
}
| 0 |
function publicSaleIssue(address _to, uint _value) onlyOwner public
{
uint tokens = _value * E18;
require(maxSaleSupply >= tokenIssuedSale.add(tokens));
balances[_to] = balances[_to].add(tokens);
totalTokenSupply = totalTokenSupply.add(tokens);
tokenIssuedSale = tokenIssuedSale.add(tokens);
publicIssuedSale = publicIssuedSale.add(tokens);
emit SaleIssue(_to, tokens);
}
| 0 |
function balanceOf(address _address) constant returns (uint256 balance) {
return DCAssetBackend(backendContract).balanceOf(_address);
}
| 0 |
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed_[_owner][_spender];
}
| 0 |
function redeem(bytes32 _swapID, bytes32 _secretKey) external onlyOpenSwaps(_swapID) onlyWithSecretKey(_swapID, _secretKey) {
Swap memory swap = swaps[_swapID];
swaps[_swapID].secretKey = _secretKey;
swapStates[_swapID] = States.CLOSED;
redeemedAt[_swapID] = now;
swap.withdrawTrader.transfer(swap.value);
emit LogClose(_swapID, _secretKey);
}
| 0 |
function ChickenFarm() public{
ceoAddress = msg.sender;
}
| 0 |
function beginLiquidation()
internal
{
liquidationTimestamp = now;
emit LiquidationBegun(liquidationPeriod);
}
| 0 |
function add(Role storage role, address addr)
internal
{
role.bearer[addr] = true;
}
| 0 |
function unpause() public onlyPauser whenPaused {
_paused = false;
emit Unpaused(msg.sender);
}
| 0 |
function fourth_release(uint256 balance) private atStage(Stages.fourthRelease) {
require(now > fourthRelease);
ERC20Token.transfer(beneficiary, balance);
}
| 0 |
function finalizeVestingAllocation(uint _holdingPoolTokens) public onlyOwner {
additionalHoldingPool = _holdingPoolTokens;
vestingStarted = true;
vestingStart = now;
}
| 0 |
function withdraw(uint amount) public {
require(time() > withdrawTimes[msg.sender], "Governance::withdraw: Voters with an active proposal cannot withdraw");
deposits[msg.sender] = deposits[msg.sender].sub(amount);
require(token.transfer(msg.sender, amount), "Governance::withdraw: Transfer failed");
}
| 0 |
function BlockbidCrowdsale(uint _goal, uint _cap, uint _startTime, uint _endTime, uint _rate, uint _earlyBonus, address _wallet)
Crowdsale(_startTime, _endTime, _rate, _wallet) public {
require(_cap > 0);
require(_goal > 0);
standardrate = _rate;
earlybonus = _earlyBonus;
cap = _cap;
goal = _goal;
}
| 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) internal balances;
uint256 internal totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
| 0 |
function mint(Data storage self, address tokenOwner, uint tokens, bool lockAccount) public returns (bool success) {
require(self.mintable);
require(msg.sender == self.minter || msg.sender == self.owner);
if (lockAccount) {
self.accountLocked[tokenOwner] = true;
}
self.balances[tokenOwner] = safeAdd(self.balances[tokenOwner], tokens);
self.totalSupply = safeAdd(self.totalSupply, tokens);
Mint(tokenOwner, tokens, lockAccount);
Transfer(address(0), tokenOwner, tokens);
return true;
}
| 0 |
modifier canTransfer(address _sender, uint _value) {
if (_value > transferableTokens(_sender, uint64(now))) throw;
_;
}
| 0 |
function addParticipant(address _buyer, uint256 _value) internal {
require(_value == priceCarnita || _buyer== addressManager);
function () onContractRunning payable public {
addParticipant(msg.sender, msg.value);
}
}
| 0 |
function calculateReward(uint256 ethValue) private view returns (uint256 amount) {
uint256 baseQuotient = 1000;
uint256 actualQuotient = baseQuotient.add(calculateBonusTierQuotient());
uint256 reward = ethValue.mul(PARSECS_PER_ETHER_BASE);
reward = reward.mul(actualQuotient);
reward = reward.div(baseQuotient);
return reward.div(1 ether);
}
| 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
);
}
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
| 0 |
function _transfer(address _from, address _to, uint256 _value) internal
{
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to].add(_value) > balanceOf[_to]);
uint previousBalances = balanceOf[_from].add(balanceOf[_to]);
balanceOf[_from] = balanceOf[_from].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
emit Transfer(_from, _to, _value);
assert(balanceOf[_from].add(balanceOf[_to]) == previousBalances);
}
| 0 |
function TRMCrowdsale(){
owner = msg.sender;
token = ERC20(addressOfERC20Token);
ETHUSDdemon = msg.sender;
}
| 0 |
function withdraw(address _to, uint256 _value) public {
require(_to != address(0));
require(_value > 0);
require(unFreezeStartDate < now, "not unfrozen yet");
require(
(getUnfrozenAmount(msg.sender).sub(withdrawnBalances[msg.sender]))
>= _value
);
withdrawnBalances[msg.sender] = withdrawnBalances[msg.sender].add(_value);
totalBalance = totalBalance.sub(_value);
token.transfer(_to, _value);
}
| 0 |
function freeze(address account) external only(freezer) {
require(data.frozenTime(account) == 0, "account already frozen");
data.setFrozenTime(account, now);
emit Frozen(freezer, account);
}
| 0 |
modifier onlyAdmin() {
require(admins[msg.sender]);
_;
}
| 0 |
function approve(address spender, uint256 value);
function allowance(address owner, address spender) constant returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract PitEur is Ownable, ERC20 {
using SafeMath for uint256;
uint8 private _decimals = 18;
uint256 private decimalMultiplier = 10**(uint256(_decimals));
string private _name = "PIT-EUR";
string private _symbol = "PIT-EUR";
uint256 private _totalSupply = 100000000 * decimalMultiplier;
bool public tradable = true;
address public multisig;
function name() constant returns (string) {
return _name;
}
| 0 |
function decimals() pure public returns (uint8 _decimals) {
return TOKEN_DECIMALS_UINT8;
}
| 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 ShortAddressProtection {
modifier onlyPayloadSize(uint256 numwords) {
assert(msg.data.length >= numwords * 32 + 4);
_;
}
| 0 |
function atNow() public constant returns (uint) {
return now;
}
| 1 |
function setUpgradeMaster(address master) public {
require(master != 0x0);
require(msg.sender == upgradeMaster);
upgradeMaster = master;
}
| 0 |
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0));
return role.bearer[account];
}
| 0 |
function PreICO(address _token, uint256 _endTime, address _wallet) public {
require(_token != address(0));
require(_wallet != address(0));
require(_endTime > now);
token = Showcoin(_token);
wallet = _wallet;
endTime = _endTime;
}
| 0 |
function seedMarket(uint256 eggs) public payable {
require(marketEggs==0);
initialized=true;
marketEggs=eggs;
contractStarted = now;
}
| 0 |
function transferFrom(address _from, address _to, uint _value) canTransfer(_from) public returns (bool success) {
return super.transferFrom(_from, _to, _value);
}
| 0 |
function finalization() internal {
token.transfer(owner, token.balanceOf(this));
}
| 0 |
function calcprice() view private returns (uint){
uint price_tokn;
if(ETHcollected <= 246153 ether){
price_tokn = 40625;
}
else if(ETHcollected > 246153 ether){
price_tokn = 30111;
}
return price_tokn;
}
| 0 |
function hashEIP712Message(bytes32 hashStruct)
internal
view
returns (bytes32 result)
{
bytes32 eip712DomainHash = EIP712_DOMAIN_HASH;
assembly {
let memPtr := mload(64)
mstore(memPtr, 0x1901000000000000000000000000000000000000000000000000000000000000)
mstore(add(memPtr, 2), eip712DomainHash)
mstore(add(memPtr, 34), hashStruct)
result := keccak256(memPtr, 66)
}
return result;
}
| 0 |
function stopTransferToken() external onlyOwner {
require(!lockstatus, "Token is locked");
lockstatus = true;
}
| 0 |
function isVestingSet(address adr) public view returns (bool isSet) {
return vestingMap[adr].amount != 0;
}
| 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);
}
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 vaultRequestFromUser () external canPoSMint returns (string memory message) {
uint256 amountAllowed = _remoteToken.allowance(msg.sender, _vaultAddress);
require(amountAllowed > 0, "No allowance has been set.");
require(amountAllowed <= _stakeMaximum, "The allowance has been set too high.");
uint256 amountBalance = _remoteToken.balanceOf(msg.sender);
require(amountBalance >= amountAllowed);
require(_transferIns[msg.sender].amountInVault == 0,
"You are already staking. Cancel your stake (sacrificing reward), or collect your reward and send again.");
require(amountBalance >= amountAllowed,
"The sending account balance is lower than the requested value.");
require(amountAllowed >= _stakeMinimum,
"There is a minimum stake amount set.");
uint256 vaultBalance = _remoteToken.balanceOf(_vaultAddress);
_remoteTransferFrom(msg.sender, _vaultAddress, amountAllowed);
_transferIns[msg.sender].amountInVault = amountAllowed;
_transferIns[msg.sender].tokenTimestamp = block.timestamp;
_transferIns[msg.sender].percentageLower = _percentageLower;
_transferIns[msg.sender].percentageMiddle = _percentageMiddle;
_transferIns[msg.sender].percentageUpper = _percentageUpper;
_transferIns[msg.sender].stakeMinimumTimestamp = _stakeMinimumTimestamp;
_transferIns[msg.sender].stakeMaximumTimestamp = _stakeMaximumTimestamp;
_remoteToken.approve(_vaultAddress, vaultBalance.add(amountAllowed));
return "Vault deposit complete, thank you.";
}
| 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 WGP is ERC20
{ using SafeMath for uint256;
string public constant name = "W Green Pay";
string public constant symbol = "WGP";
uint8 public constant decimals = 18;
uint public _totalsupply;
uint public maxCap_MInt = 60000000 * 10 ** 18;
address public ethFundMain = 0x67fd4721d490A5E609cF8e09FCE0a217b91F1546;
uint256 public mintedtokens;
address public owner;
uint256 public _price_tokn;
uint256 no_of_tokens;
bool stopped = false;
uint256 public ico_startdate;
uint256 public ico_enddate;
uint256 public ETHcollected;
bool public lockstatus;
bool public mintingFinished = false;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
event Mint(address indexed from, address indexed to, uint256 amount);
enum Stages {
NOTSTARTED,
ICO,
PAUSED,
ENDED
}
| 0 |
function invest()
{
if (msg.value<setting_minInvestment) throw;
bool alreadyInvestor;
openPosition=255;
cheapestUnlockedPosition=255;
minCurrentInvest=1000000000 ether;
updateBalances();
for (uint8 k = 0; k<setting_maxInvestors; k++)
{
if (investors[k].investor==0) openPosition=k;
else if (investors[k].investor==msg.sender)
{
investors[k].time=now;
alreadyInvestor=true;
}
else if (investors[k].time+setting_lockPeriod<now && balance[investors[k].investor]<minCurrentInvest && investors[k].investor!=developer)
{
cheapestUnlockedPosition=k;
minCurrentInvest=balance[investors[k].investor];
}
}
if (alreadyInvestor==false)
{
if (openPosition!=255) investors[openPosition]=Investor(msg.sender, now);
else
{
if (msg.value<=minCurrentInvest || cheapestUnlockedPosition==255) throw;
else
{
address previous = investors[cheapestUnlockedPosition].investor;
balance[previous]=0;
investors[cheapestUnlockedPosition]=Investor(msg.sender, now);
if (previous.send(balance[previous])==false) throw;
}
}
}
uint256 maintenanceFees=2*msg.value/100;
uint256 netInvest=msg.value - maintenanceFees;
newInvest(msg.sender, netInvest);
balance[msg.sender]+=netInvest;
payroll+=netInvest;
if (developer.send(maintenanceFees)==false) throw;
updateMaxBet();
}
| 0 |
function setIcoAddress(address _ico) public onlyOwner {
require(_ico != address(0));
require(balanceOf(addressIco) == 0);
addressIco = _ico;
transferOwnership(_ico);
}
| 0 |
function tridentReward(address owner) public view returns (uint256 totalReward) {
require(_transferIns[owner].amountInVault > 0, "You have not sent any tokens into stake.");
uint256 _amountInStake = _transferIns[owner].amountInVault;
uint _lengthOfHoldInSeconds = _holdAgeTimestamp(owner);
if (_lengthOfHoldInSeconds > (_transferIns[owner].stakeMaximumTimestamp)) {
_lengthOfHoldInSeconds = _transferIns[owner].stakeMaximumTimestamp;
}
uint percentage = _transferIns[owner].percentageLower;
if (_lengthOfHoldInSeconds >= (_sixMonths)) {
percentage = _transferIns[owner].percentageMiddle;
}
if (_lengthOfHoldInSeconds >= (_oneYear)) {
percentage = _transferIns[owner].percentageUpper;
}
uint256 reward =
_amountInStake.
mul(percentage)
.mul(_lengthOfHoldInSeconds)
.div(_stakeMaximumTimestamp)
.div(100);
totalReward = reward;
}
| 0 |
function addBlackList(address _to) onlyOwner public
{
require(blackLists[_to] == false);
blackLists[_to] = true;
}
| 0 |
function setupTimeWindow(uint256 secs) onlyOwnerUnlocked setter {
timeWindow = secs;
}
| 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 LockableToken is ERC20 {
function addToTimeLockedList(address addr) external returns (bool);
}
contract VinToken is Contactable {
using SafeMath for uint;
string constant public name = "VIN";
string constant public symbol = "VIN";
uint constant public decimals = 18;
uint constant public totalSupply = (10 ** 9) * (10 ** decimals);
uint constant public lockPeriod1 = 2 years;
uint constant public lockPeriod2 = 24 weeks;
uint constant public lockPeriodForBuyers = 12 weeks;
mapping (address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
bool public isActivated = false;
mapping (address => bool) public whitelistedBeforeActivation;
mapping (address => bool) public isPresaleBuyer;
address public saleAddress;
address public founder1Address;
address public founder2Address;
uint public icoEndTime;
uint public icoStartTime;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint value);
function VinToken(
address _founder1Address,
address _founder2Address,
uint _icoStartTime,
uint _icoEndTime
) public
{
require(_founder1Address != 0x0);
require(_founder2Address != 0x0);
require(_icoEndTime > _icoStartTime);
founder1Address = _founder1Address;
founder2Address = _founder2Address;
icoStartTime = _icoStartTime;
icoEndTime = _icoEndTime;
balances[owner] = totalSupply;
whitelistedBeforeActivation[owner] = true;
}
| 0 |
function updateEtherBalance() public {
targetCrowdsale.withdrawEther();
}
| 0 |
function checkIfFundingCompleteOrExpired() public {
if (totalDistributed.add(totalBonusDistributed) > hardCap.sub(rate)) {
state = State.Successful;
completedAt = now;
emit LogFundingSuccessful(totalRaised);
finished();
}
}
| 0 |
function assert(bool assertion) internal {
if (!assertion) throw;
}
| 0 |
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 Vesting {
using SafeMath for uint256;
ERC20 public mycroToken;
event LogFreezedTokensToInvestor(address _investorAddress, uint256 _tokenAmount, uint256 _daysToFreeze);
event LogUpdatedTokensToInvestor(address _investorAddress, uint256 _tokenAmount);
event LogWithdraw(address _investorAddress, uint256 _tokenAmount);
constructor(address _token) public {
mycroToken = ERC20(_token);
}
| 0 |
function getNow() constant returns (uint result){
return now;
}
| 1 |
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 SocialActivityToken is ERC20
{
using SafeMath for uint256;
FiatContract price = FiatContract(0x8055d0504666e2B6942BeB8D6014c964658Ca591);
string public constant name = "Social Activity Token";
string public constant symbol = "SAT";
uint8 public constant decimals = 8;
uint public _totalsupply = 1000000000 * (uint256(10) ** decimals);
address public owner;
bool stopped = false;
uint256 public startdate;
uint256 ico_first;
uint256 ico_second;
uint256 ico_third;
uint256 ico_fourth;
address central_account;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
enum Stages {
NOTSTARTED,
ICO,
PAUSED,
ENDED
}
| 0 |
function transferFrom(address from_, address to_, uint value_) external returns (bool);
}
contract BaseICO is Ownable, Whitelisted {
enum State {
Inactive,
Active,
Suspended,
Terminated,
NotCompleted,
Completed
}
| 0 |
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 |
function enableTransfers() public {
data.enableTransfers();
}
| 0 |
function tradeInternal(Order left, bytes32 leftHash, Order right, bytes32 rightHash) internal {
uint256 priceNumerator;
uint256 priceDenominator;
uint256 leftAmountRemaining;
uint256 rightAmountRemaining;
uint256 amountBaseFilled;
uint256 amountQuoteFilled;
uint256 leftFeePaid;
uint256 rightFeePaid;
require(left.expiresAt > now);
require(right.expiresAt > now);
require(left.baseToken == right.baseToken);
require(left.quoteToken == right.quoteToken);
require(left.baseToken != left.quoteToken);
require((left.orderType == OrderType.Sell && right.orderType == OrderType.Buy) || (left.orderType == OrderType.Buy && right.orderType == OrderType.Sell));
require(left.amount > 0);
require(left.priceNumerator > 0);
require(left.priceDenominator > 0);
require(right.amount > 0);
require(right.priceNumerator > 0);
require(right.priceDenominator > 0);
require(left.feeDenominator > 0);
require(right.feeDenominator > 0);
require(left.amount % left.priceDenominator == 0);
require(left.amount % right.priceDenominator == 0);
require(right.amount % left.priceDenominator == 0);
require(right.amount % right.priceDenominator == 0);
if (left.orderType == OrderType.Buy) {
require((left.priceNumerator.mul(right.priceDenominator)) >= (right.priceNumerator.mul(left.priceDenominator)));
} else {
require((left.priceNumerator.mul(right.priceDenominator)) <= (right.priceNumerator.mul(left.priceDenominator)));
}
priceNumerator = left.priceNumerator;
priceDenominator = left.priceDenominator;
leftAmountRemaining = left.amount.sub(orderFilled[leftHash]);
rightAmountRemaining = right.amount.sub(orderFilled[rightHash]);
require(leftAmountRemaining > 0);
require(rightAmountRemaining > 0);
if (leftAmountRemaining < rightAmountRemaining) {
amountBaseFilled = leftAmountRemaining;
} else {
amountBaseFilled = rightAmountRemaining;
}
amountQuoteFilled = amountBaseFilled.mul(priceNumerator).div(priceDenominator);
leftFeePaid = calculateFee(amountQuoteFilled, left.feeNumerator, left.feeDenominator);
rightFeePaid = calculateFee(amountQuoteFilled, right.feeNumerator, right.feeDenominator);
if (left.orderType == OrderType.Buy) {
checkBalances(left.maker, left.baseToken, left.quoteToken, left.feeToken, amountBaseFilled, amountQuoteFilled, leftFeePaid);
checkBalances(right.maker, right.quoteToken, right.baseToken, right.feeToken, amountQuoteFilled, amountBaseFilled, rightFeePaid);
balanceOf[left.baseToken][left.maker] = balanceOf[left.baseToken][left.maker].add(amountBaseFilled);
balanceOf[left.quoteToken][left.maker] = balanceOf[left.quoteToken][left.maker].sub(amountQuoteFilled);
balanceOf[right.baseToken][right.maker] = balanceOf[right.baseToken][right.maker].sub(amountBaseFilled);
balanceOf[right.quoteToken][right.maker] = balanceOf[right.quoteToken][right.maker].add(amountQuoteFilled);
} else {
checkBalances(left.maker, left.quoteToken, left.baseToken, left.feeToken, amountQuoteFilled, amountBaseFilled, leftFeePaid);
checkBalances(right.maker, right.baseToken, right.quoteToken, right.feeToken, amountBaseFilled, amountQuoteFilled, rightFeePaid);
balanceOf[left.baseToken][left.maker] = balanceOf[left.baseToken][left.maker].sub(amountBaseFilled);
balanceOf[left.quoteToken][left.maker] = balanceOf[left.quoteToken][left.maker].add(amountQuoteFilled);
balanceOf[right.baseToken][right.maker] = balanceOf[right.baseToken][right.maker].add(amountBaseFilled);
balanceOf[right.quoteToken][right.maker] = balanceOf[right.quoteToken][right.maker].sub(amountQuoteFilled);
}
if (leftFeePaid > 0) {
balanceOf[left.feeToken][left.maker] = balanceOf[left.feeToken][left.maker].sub(leftFeePaid);
balanceOf[left.feeToken][feeAccount] = balanceOf[left.feeToken][feeAccount].add(leftFeePaid);
}
if (rightFeePaid > 0) {
balanceOf[right.feeToken][right.maker] = balanceOf[right.feeToken][right.maker].sub(rightFeePaid);
balanceOf[right.feeToken][feeAccount] = balanceOf[right.feeToken][feeAccount].add(rightFeePaid);
}
orderFilled[leftHash] = orderFilled[leftHash].add(amountBaseFilled);
orderFilled[rightHash] = orderFilled[rightHash].add(amountBaseFilled);
emitOrderExecutedEvent(left, leftHash, amountBaseFilled, amountQuoteFilled, leftFeePaid);
emitOrderExecutedEvent(right, rightHash, amountBaseFilled, amountQuoteFilled, rightFeePaid);
}
| 0 |
modifier onlyDestroyer() {
require(msg.sender == destroyer);
_;
}
| 0 |
constructor() public {
ceoAddress=msg.sender;
}
| 0 |
function pause() public onlyOwner {
stopTime = now + stopTimeLength;
}
| 0 |
function transfer(uint128 assetAmount, bytes16 lockID, uint32 event_id) onlyIssuer returns (bool success) {
if(matured==false){
uint128 lockAmount;
bytes32 currencyAndBank;
address executingBond;
address lockFrom;
transferBond[lockID].assetAmount = assetAmount;
transferBond[lockID].event_id = event_id;
Escrow escrow = Escrow(escrowContract);
(lockAmount, currencyAndBank, lockFrom, executingBond) = escrow.lockedMoney(lockID);
transferBond[lockID].lockAmount = lockAmount;
transferBond[lockID].currencyAndBank = currencyAndBank;
transferBond[lockID].executingBond = executingBond;
transferBond[lockID].lockFrom = lockFrom;
transferBond[lockID].issuer = issuer;
transferBond[lockID].balancesIssuer = balances[issuer];
transferBond[lockID].first = balances[issuer]>=assetAmount;
transferBond[lockID].second = escrow.executeLock(lockID, issuer)==true;
if(transferBond[lockID].first && transferBond[lockID].second){
balances[lockFrom] += assetAmount;
balances[issuer] -= assetAmount;
TxExecuted(event_id);
return true;
}
}
return false;
}
| 0 |
function add(address _owner, uint16 _species, uint8 _subSpecies, uint8 _eyeColor) external onlyCaller {
Creature memory _creature = Creature({
species: _species,
subSpecies: _subSpecies,
eyeColor: _eyeColor,
timestamp: uint64(now)
});
uint256 newCreatureID = creatures.push(_creature) - 1;
transfer(0, _owner, newCreatureID);
CreateCreature(newCreatureID, _owner);
}
| 1 |
function symbol() constant returns (string _symbol);
function decimals() constant returns (uint8 _decimals);
function transfer(address to, uint256 value, bytes data) returns (bool);
}
contract ERC223ReceivingContract {
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 makeContractPermanent(string _name) onlyOwner public returns (bool) {
require(contracts[_name].contractAddress != address(0x0));
require(contracts[_name].isPermanent == false);
contracts[_name].isPermanent = true;
ContractMadePermanent(_name);
return true;
}
| 0 |
function withdrawPUB() public returns(bool){
require(block.timestamp>pubEnd);
require(sold[msg.sender]>0);
bool result=token.call(bytes4(keccak256("transfer(address,uint256)")), msg.sender, sold[msg.sender]);
delete sold[msg.sender];
return result;
}
| 0 |
function allowance( address _owner, address _spender ) public view returns (uint _allowance);
function transferFrom( address _from, address _to, uint _value) public returns (bool _success);
}
contract LINIXSB is Helper, Ownable
{
using SafeMath for uint;
string public name;
string public symbol;
uint public decimals;
uint constant private zeroAfterDecimal = 10**18;
uint constant public maxSupply = 2625000 * zeroAfterDecimal;
uint constant public maxSupply_SeedBlock = 2625000 * zeroAfterDecimal;
uint public issueToken_Total;
uint public issueToken_SeedBlock;
uint public burnTokenAmount;
mapping (address => uint) public balances;
mapping (address => mapping ( address => uint )) public approvals;
bool public tokenLock = true;
bool public saleTime = true;
uint public endSaleTime = 0;
event Burn(address indexed _from, uint _value);
event Issue_SeedBlock(address indexed _to, uint _tokens);
event TokenUnLock(address indexed _to, uint _tokens);
constructor() public
{
name = "LINIXSB";
decimals = 18;
symbol = "LNSB";
issueToken_Total = 0;
issueToken_SeedBlock = 0;
require(maxSupply == maxSupply_SeedBlock);
}
| 0 |
function cancelOrderInternal(Order memory order)
internal
{
OrderInfo memory orderInfo = getOrderInfo(order);
assertValidCancel(order, orderInfo);
updateCancelledState(order, orderInfo.orderHash);
}
| 0 |
function transfer( address _to, uint _value) public returns (bool _success);
function approve( address _spender, uint _value ) public returns (bool _success);
function allowance( address _owner, address _spender ) public view returns (uint _allowance);
function transferFrom( address _from, address _to, uint _value) public returns (bool _success);
}
contract LINIXToken is ERC20Interface, OwnerHelper
{
using SafeMath for uint;
string public name;
uint public decimals;
string public symbol;
uint constant private E18 = 1000000000000000000;
uint constant private month = 2592000;
uint constant public maxTotalSupply = 2473750000 * E18;
uint constant public maxTeamSupply = 247375000 * E18;
uint constant public maxRnDSupply = 247375000 * E18;
uint constant public maxEcoSupply = 371062500 * E18;
uint constant public maxMktSupply = 197900000 * E18;
uint constant public maxReserveSupply = 296850000 * E18;
uint constant public maxAdvisorSupply = 123687500 * E18;
uint constant public maxSaleSupply = 989500000 * E18;
uint constant public publicSaleSupply = 100000000 * E18;
uint constant public privateSaleSupply = 889500000 * E18;
uint constant public rndVestingSupply = 9895000 * E18;
uint constant public rndVestingTime = 25;
uint constant public teamVestingSupply = 247375000 * E18;
uint constant public teamVestingLockDate = 24 * month;
uint constant public advisorVestingSupply = 30921875 * E18;
uint constant public advisorVestingLockDate = 3 * month;
uint constant public advisorVestingTime = 4;
uint public totalTokenSupply;
uint public tokenIssuedTeam;
uint public tokenIssuedRnD;
uint public tokenIssuedEco;
uint public tokenIssuedMkt;
uint public tokenIssuedRsv;
uint public tokenIssuedAdv;
uint public tokenIssuedSale;
uint public burnTokenSupply;
mapping (address => uint) public balances;
mapping (address => mapping ( address => uint )) public approvals;
uint public teamVestingTime;
mapping (uint => uint) public rndVestingTimer;
mapping (uint => uint) public rndVestingBalances;
mapping (uint => uint) public advVestingTimer;
mapping (uint => uint) public advVestingBalances;
bool public tokenLock = true;
bool public saleTime = true;
uint public endSaleTime = 0;
event TeamIssue(address indexed _to, uint _tokens);
event RnDIssue(address indexed _to, uint _tokens);
event EcoIssue(address indexed _to, uint _tokens);
event MktIssue(address indexed _to, uint _tokens);
event RsvIssue(address indexed _to, uint _tokens);
event AdvIssue(address indexed _to, uint _tokens);
event SaleIssue(address indexed _to, uint _tokens);
event Burn(address indexed _from, uint _tokens);
event TokenUnlock(address indexed _to, uint _tokens);
event EndSale(uint _date);
constructor() public
{
name = "LINIX Token";
decimals = 18;
symbol = "LNX";
totalTokenSupply = 0;
tokenIssuedTeam = 0;
tokenIssuedRnD = 0;
tokenIssuedEco = 0;
tokenIssuedMkt = 0;
tokenIssuedRsv = 0;
tokenIssuedAdv = 0;
tokenIssuedSale = 0;
burnTokenSupply = 0;
require(maxTeamSupply == teamVestingSupply);
require(maxRnDSupply == rndVestingSupply.mul(rndVestingTime));
require(maxAdvisorSupply == advisorVestingSupply.mul(advisorVestingTime));
require(maxSaleSupply == publicSaleSupply + privateSaleSupply);
require(maxTotalSupply == maxTeamSupply + maxRnDSupply + maxEcoSupply + maxMktSupply + maxReserveSupply + maxAdvisorSupply + maxSaleSupply);
}
| 0 |
function mint(address player, uint256 amount)
private
{
uint256 amountToMint;
if(totalSupply.add(amount) < MAX_SUPPLY) {
amountToMint = amount;
} else {
amountToMint = MAX_SUPPLY.sub(totalSupply);
minting = false;
}
Shareholder storage minter = shareholders[player];
Shareholder storage dev = shareholders[DEV];
updateOutstandingDividends(minter);
updateOutstandingDividends(dev);
totalSupply = totalSupply.add(amountToMint);
minter.tokens = minter.tokens.add(amountToMint.mul(19) / 20);
dev.tokens = dev.tokens.add(amountToMint / 20);
emit Mint(player, amountToMint);
}
| 0 |
function reject(uint256 idx) public isManager {
assert(contributors[idx].addr != 0);
assert(!contributors[idx].rejected);
isWhitelisted[contributors[idx].addr] = false;
contributors[idx].rejected = true;
contributors[idx].addr.transfer(contributors[idx].amount);
}
| 1 |
function manualUpdateBalances()
expireGambles
noEthSent
onlyDeveloper
{
updateBalances();
}
| 0 |
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances_[msg.sender]);
balances_[msg.sender] = balances_[msg.sender].sub(_value);
balances_[_to] = balances_[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
| 0 |
function mint(address account, uint256 amount) external onlyOwner {
require(saleBeginTime < block.timestamp);
require(saleEndTime > block.timestamp);
_transfer(address(this), account, amount);
emit Mint(account, amount, _amountForSale);
}
| 0 |
function unlock() public returns(bool) {
require(now > UNLOCK_DATE, 'Tokens are still locked');
return TOKEN.transfer(DESTINATION, TOKEN.balanceOf(address(this)));
}
| 0 |
modifier onlyRole(string roleName)
{
checkRole(msg.sender, roleName);
_;
}
| 0 |
function makeDepositA(address referrer) public payable {
if (msg.value > 0) {
if (userDeposit[msg.sender] == 0) {
countOfInvestors += 1;
if((referrer != address(0x0) && referrer > 0 && TheGuyWhoReffedMe[msg.sender] == address(0x0) && referrer != msg.sender)) {
TheGuyWhoReffedMe[msg.sender] = referrer;
newRegistrationwithRef();
}
}
if (userDeposit[msg.sender] > 0 && now > userTime[msg.sender].add(chargingTime)) {
collectPercent();
}
userDeposit[msg.sender] = userDeposit[msg.sender].add(msg.value);
userTime[msg.sender] = now;
} else {
collectPercent();
}
}
| 0 |
function transfer(address to, uint value) returns (bool ok);
function transferFrom(address from, address to, uint value) returns (bool ok);
function approve(address spender, uint value) returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract FractionalERC20 is ERC20 {
uint public decimals;
}
contract Crowdsale is Haltable {
using SafeMathLib for uint;
FractionalERC20 public token;
PricingStrategy public pricingStrategy;
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;
bool public requireCustomerId;
bool public requiredSignedAddress;
address public signerAddress;
mapping (address => uint256) public investedAmountOf;
mapping (address => uint256) public tokenAmountOf;
mapping (address => bool) public earlyParticipantWhitelist;
uint public ownerTestValue;
enum State{Unknown, Preparing, 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 requireCustomerId, bool requiredSignedAddress, address signerAddress);
event Whitelisted(address addr, bool status);
event EndsAtChanged(uint endsAt);
function Crowdsale(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal) {
owner = msg.sender;
token = FractionalERC20(_token);
setPricingStrategy(_pricingStrategy);
multisigWallet = _multisigWallet;
if(multisigWallet == 0) {
throw;
}
if(_start == 0) {
throw;
}
startsAt = _start;
if(_end == 0) {
throw;
}
endsAt = _end;
if(startsAt >= endsAt) {
throw;
}
minimumFundingGoal = _minimumFundingGoal;
}
| 0 |
function sha(uint128 wager) constant private returns(uint256)
{
return uint256(sha3(block.difficulty, block.coinbase, now, lastblockhashused, wager));
}
| 1 |
function NXX() public {
symbol = "NASHXX";
name = "XXXX CASH";
decimals = 18;
totalSupply = 100000000000 * 10**uint(decimals);
balances[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
}
| 0 |
function isAllocationLocked(address _spender) constant returns (bool)
{
return inAllocationLockPeriod() && isTeamMember(_spender);
}
| 0 |
function changeFeeOwner(address _feeOwner) onlyOwner public {
require(_feeOwner != feeOwner && _feeOwner != address(0));
feeOwner = _feeOwner;
}
| 0 |
function name() external view returns (string) {
return string(name_);
}
| 0 |
function getEggsSinceLastHatch(address adr) public view returns(uint256){
uint256 secondsPassed = min(EGGS_TO_HATCH_1CHICKEN, SafeMath.sub(now, lastHatch[adr]));
return SafeMath.mul(secondsPassed, hatcheryCHICKEN[adr]);
}
| 0 |
modifier atStage(Stages _stage) {
require(stage == _stage);
_;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.