function
string | label
int64 |
|---|---|
function mistToken() public {
_supply = 20*(10**8)*(10**18);
_balances[0x01] = freezedValue;
_balances[msg.sender] = sub(_supply,freezedValue);
owner = msg.sender;
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1543658400, freezed: true}));
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1543662000, freezed: true}));
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1543668600, freezed: true}));
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1543676400, freezed: true}));
} | 0 |
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
} | 0 |
function tradeStarttime(uint256 _startTime)public onlyOwner{
tradeStartTime=_startTime.add(1 years);
} | 0 |
function approve(address _spender, uint256 _amount) returns (bool success) {
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
} | 0 |
function collectedFees() public view onlyOwner returns (uint) {
return address(this).balance.sub(prize).sub(winningBid).sub(losingBid);
} | 0 |
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract FractionalERC20 is ERC20 {
uint public decimals;
}
contract Crowdsale is Haltable {
uint public MAX_INVESTMENTS_BEFORE_MULTISIG_CHANGE = 5;
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 presaleWeiRaised = 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 newRequireCustomerId, bool newRequiredSignedAddress, address newSignerAddress);
event Whitelisted(address addr, bool status);
event EndsAtChanged(uint newEndsAt);
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 airdrop()
private
view
returns(bool)
{
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.number)
)));
if((seed - ((seed / 1000) * 1000)) < airDropTracker_)
return(true);
else
return(false);
} | 0 |
function _mint(address _account, uint256 _amount) internal canMint {
require(_account != 0, "Address must not be zero");
totalSupply_ = totalSupply_.add(_amount);
balances[_account] = balances[_account].add(_amount);
emit Transfer(address(0), _account, _amount);
emit Mint(_account, _amount);
} | 0 |
function burn(uint256 value) public onlyOwner {
require(value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(value);
currentTotalSupply = currentTotalSupply.sub(value);
emit Burn(burner, value);
} | 0 |
function totalSupply() public view returns (uint256) {
return totalTokens;
} | 0 |
function saveContractEvent(string description, string mesg) private {
contractEvents.push(contractEvent(block.timestamp, description, mesg));
ContractEvent(description, mesg);
contracteventcount++;
} | 0 |
function transfer(address _to, uint256 _value) public returns (bool success) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else {
return false;
}
} | 0 |
modifier onlyExecBoard() {
require(msg.sender == execBoard);
_;
} | 0 |
function getLocked(bytes16 lockID) returns (uint) {
return lockedMoney[lockID].amount;
} | 0 |
modifier bridgeInitialized() {
require(address(bridge) != address(0x0));
_;
} | 0 |
function upgradeMe(address newSC) external {
require(upgrades[msg.sender] == address(0));
upgrades[msg.sender] = newSC;
} | 0 |
function isSuccessful()
public
constant
returns(bool)
{
return (
completed
);
} | 0 |
function setFounderLock(address _address, uint256 _value, uint _round, uint256 _period) internal{
founderLockance[_address].amount = _value;
founderLockance[_address].startTime = now;
founderLockance[_address].remainRound = _round;
founderLockance[_address].totalRound = _round;
founderLockance[_address].period = _period;
} | 0 |
modifier tradingIsEnabled() {
require(tradingEnabled);
_;
} | 0 |
function transferOwnership(address newOwner, bool replaceOwnerOne, bool replaceOwnerTwo) onlyOwner public {
require(newOwner != 0x0);
require(replaceOwnerOne || replaceOwnerTwo);
if(replaceOwnerOne) ownerOne = newOwner;
if(replaceOwnerTwo) ownerTwo = newOwner;
} | 0 |
function removeWallet(address _wallet) public onlyPrivilegedAddresses {
require(_wallet != address(0));
require(isWhitelisted(_wallet));
delete whitelist[_wallet];
whitelistLength--;
} | 0 |
function transfer(address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transfer(_to, _value);
} | 0 |
function publicSaleIssue(address _to) onlyOwner public
{
require(tokenIssuedSale == privateSaleSupply);
uint tokens = publicSaleSupply;
balances[_to] = balances[_to].add(tokens);
totalTokenSupply = totalTokenSupply.add(tokens);
tokenIssuedSale = tokenIssuedSale.add(tokens);
emit SaleIssue(_to, tokens);
} | 0 |
function add(Role storage role, address addr)
internal
{
role.bearer[addr] = true;
} | 0 |
function devFee(uint256 amount) public pure returns(uint256){
return amount.mul(4).div(100);
} | 0 |
constructor(uint256 _startTime, address _wallet, address _tokenAddress) public
{
require(_startTime >=now);
require(_wallet != 0x0);
startTime = _startTime;
endTime = startTime + totalDurationInDays;
require(endTime >= startTime);
owner = _wallet;
maxTokensToSale = uint(15000000000).mul( 10 ** uint256(18));
token = TokenInterface(_tokenAddress);
} | 0 |
function release(ERC20Basic token) public {
uint256 unreleased = releasableAmount(token);
require(unreleased > 0);
released[token] = released[token].add(unreleased);
token.safeTransfer(beneficiary, unreleased);
Released(unreleased);
} | 0 |
modifier only_editors() {
require(editAllowed[msg.sender], "only_editors: forbidden");
_;
} | 0 |
modifier onlyWhitelist() {
require(blacklist[msg.sender] == false);
_;
} | 1 |
function swapTeam() external onlyTeamMember {
require(_infos[msg.sender].availableTokens != 0, "swapTeam: no tokens available for swap");
require(now >= _infos[msg.sender].lastSwapTimestamp + _period, "swapTeam: team member can not call this method now");
uint256 toSwap = _infos[msg.sender].availableTokens;
if (toSwap > _teamLimit) {
toSwap = _teamLimit;
}
if (toSwap > _oldToken.balanceOf(msg.sender)) {
toSwap = _oldToken.balanceOf(msg.sender);
}
_swap(toSwap);
_update(toSwap);
emit TeamTokensSwapped(msg.sender, toSwap);
} | 0 |
function accessPolicy()
public
constant
returns (IAccessPolicy)
{
return _accessPolicy;
} | 0 |
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
} | 0 |
function updatePrice(uint256 newNumerator) external onlyManagingWallets {
require(newNumerator > 0);
require_limited_change(newNumerator);
currentPrice.numerator = newNumerator;
prices[previousUpdateTime] = currentPrice;
previousUpdateTime = currentTime();
PriceUpdate(newNumerator);
} | 0 |
function burn(uint value) public {
burnTokens(msg.sender, value);
} | 0 |
function WrapperLockEth(string _name, string _symbol, uint _decimals, address _transferProxy) Ownable() {
TRANSFER_PROXY = _transferProxy;
name = _name;
symbol = _symbol;
decimals = _decimals;
isSigner[msg.sender] = true;
} | 0 |
function ZeusShieldCoin()
{
} | 0 |
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 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 start_ICO() public onlyOwner
{
stage = Stages.ICO;
stopped = false;
startdate = now;
enddate = startdate + 30 days;
} | 0 |
function transferMaintainer(address newMaintainer) only_maintainer public {
require(newMaintainer != address(0));
maintainer = newMaintainer;
} | 1 |
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
require(a == 0 || c / a == b);
return c;
} | 0 |
constructor(bytes32 voucher_token, uint _lifetime) public {
token = voucher_token;
burnt = false;
created_at = now;
updated_at = now;
expires_at = created_at + (_lifetime * 60*60*24);
owner = msg.sender;
} | 0 |
function setContractSK(string intervener1, string intervener2){
date = now;
name1 = intervener1;
name2 = intervener2;
} | 0 |
modifier beforeSaleOpens() {
require(now < startTimestamp);
_;
} | 0 |
function registerAssetProxy(address assetProxy)
external;
function getAssetProxy(bytes4 assetProxyId)
external
view
returns (address);
}
contract IMatchOrders {
function matchOrders(
LibOrder.Order memory leftOrder,
LibOrder.Order memory rightOrder,
bytes memory leftSignature,
bytes memory rightSignature
)
public
returns (LibFillResults.MatchedFillResults memory matchedFillResults);
}
contract ISignatureValidator {
function preSign(
bytes32 hash,
address signerAddress,
bytes signature
)
external;
function setSignatureValidatorApproval(
address validatorAddress,
bool approval
)
external;
function isValidSignature(
bytes32 hash,
address signerAddress,
bytes memory signature
)
public
view
returns (bool isValid);
}
contract ITransactions {
function executeTransaction(
uint256 salt,
address signerAddress,
bytes data,
bytes signature
)
external;
}
contract IWrapperFunctions {
function fillOrKillOrder(
LibOrder.Order memory order,
uint256 takerAssetFillAmount,
bytes memory signature
)
public
returns (LibFillResults.FillResults memory fillResults);
function fillOrderNoThrow(
LibOrder.Order memory order,
uint256 takerAssetFillAmount,
bytes memory signature
)
public
returns (LibFillResults.FillResults memory fillResults);
function batchFillOrders(
LibOrder.Order[] memory orders,
uint256[] memory takerAssetFillAmounts,
bytes[] memory signatures
)
public
returns (LibFillResults.FillResults memory totalFillResults);
function batchFillOrKillOrders(
LibOrder.Order[] memory orders,
uint256[] memory takerAssetFillAmounts,
bytes[] memory signatures
)
public
returns (LibFillResults.FillResults memory totalFillResults);
function batchFillOrdersNoThrow(
LibOrder.Order[] memory orders,
uint256[] memory takerAssetFillAmounts,
bytes[] memory signatures
)
public
returns (LibFillResults.FillResults memory totalFillResults);
function marketSellOrders(
LibOrder.Order[] memory orders,
uint256 takerAssetFillAmount,
bytes[] memory signatures
)
public
returns (LibFillResults.FillResults memory totalFillResults);
function marketSellOrdersNoThrow(
LibOrder.Order[] memory orders,
uint256 takerAssetFillAmount,
bytes[] memory signatures
)
public
returns (LibFillResults.FillResults memory totalFillResults);
function marketBuyOrders(
LibOrder.Order[] memory orders,
uint256 makerAssetFillAmount,
bytes[] memory signatures
)
public
returns (LibFillResults.FillResults memory totalFillResults);
function marketBuyOrdersNoThrow(
LibOrder.Order[] memory orders,
uint256 makerAssetFillAmount,
bytes[] memory signatures
)
public
returns (LibFillResults.FillResults memory totalFillResults);
function batchCancelOrders(LibOrder.Order[] memory orders)
public;
function getOrdersInfo(LibOrder.Order[] memory orders)
public
view
returns (LibOrder.OrderInfo[] memory);
}
contract IExchange is
IExchangeCore,
IMatchOrders,
ISignatureValidator,
ITransactions,
IAssetProxyDispatcher,
IWrapperFunctions
{}
contract MExchangeCore is
IExchangeCore
{
event Fill(
address indexed makerAddress,
address indexed feeRecipientAddress,
address takerAddress,
address senderAddress,
uint256 makerAssetFilledAmount,
uint256 takerAssetFilledAmount,
uint256 makerFeePaid,
uint256 takerFeePaid,
bytes32 indexed orderHash,
bytes makerAssetData,
bytes takerAssetData
);
event Cancel(
address indexed makerAddress,
address indexed feeRecipientAddress,
address senderAddress,
bytes32 indexed orderHash,
bytes makerAssetData,
bytes takerAssetData
);
event CancelUpTo(
address indexed makerAddress,
address indexed senderAddress,
uint256 orderEpoch
);
function fillOrderInternal(
LibOrder.Order memory order,
uint256 takerAssetFillAmount,
bytes memory signature
)
internal
returns (LibFillResults.FillResults memory fillResults);
function cancelOrderInternal(LibOrder.Order memory order)
internal;
function updateFilledState(
LibOrder.Order memory order,
address takerAddress,
bytes32 orderHash,
uint256 orderTakerAssetFilledAmount,
LibFillResults.FillResults memory fillResults
)
internal;
function updateCancelledState(
LibOrder.Order memory order,
bytes32 orderHash
)
internal;
function assertFillableOrder(
LibOrder.Order memory order,
LibOrder.OrderInfo memory orderInfo,
address takerAddress,
bytes memory signature
)
internal
view;
function assertValidFill(
LibOrder.Order memory order,
LibOrder.OrderInfo memory orderInfo,
uint256 takerAssetFillAmount,
uint256 takerAssetFilledAmount,
uint256 makerAssetFilledAmount
)
internal
view;
function assertValidCancel(
LibOrder.Order memory order,
LibOrder.OrderInfo memory orderInfo
)
internal
view;
function calculateFillResults(
LibOrder.Order memory order,
uint256 takerAssetFilledAmount
)
internal
pure
returns (LibFillResults.FillResults memory fillResults);
}
contract MAssetProxyDispatcher is
IAssetProxyDispatcher
{
event AssetProxyRegistered(
bytes4 id,
address assetProxy
);
function dispatchTransferFrom(
bytes memory assetData,
address from,
address to,
uint256 amount
)
internal;
}
contract MMatchOrders is
IMatchOrders
{
function assertValidMatch(
LibOrder.Order memory leftOrder,
LibOrder.Order memory rightOrder
)
internal
pure;
function calculateMatchedFillResults(
LibOrder.Order memory leftOrder,
LibOrder.Order memory rightOrder,
uint256 leftOrderTakerAssetFilledAmount,
uint256 rightOrderTakerAssetFilledAmount
)
internal
pure
returns (LibFillResults.MatchedFillResults memory matchedFillResults);
}
contract MSignatureValidator is
ISignatureValidator
{
event SignatureValidatorApproval(
address indexed signerAddress,
address indexed validatorAddress,
bool approved
);
enum SignatureType {
Illegal,
Invalid,
EIP712,
EthSign,
Wallet,
Validator,
PreSigned,
NSignatureTypes
} | 0 |
function getTimestamp(address tokenAddress) public view returns (uint) {
return timestamps[msg.sender][tokenAddress];
} | 0 |
function AccessControlled(IAccessPolicy policy) internal {
require(address(policy) != 0x0);
_accessPolicy = policy;
} | 0 |
function balanceOf(address _owner) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
function allowance(address _owner, address _spender) public view returns (uint256);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract Owned {
address public owner;
constructor() public {
owner = msg.sender;
} | 0 |
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
uint256 tokens = _getTokenAmount(weiAmount);
weiRaised = weiRaised.add(weiAmount);
_processPurchase(_beneficiary, tokens);
emit TokenPurchase(msg.sender, _beneficiary, weiAmount, tokens);
_updatePurchasingState(_beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(_beneficiary, weiAmount);
} | 0 |
function getDay() constant returns (uint256) {
return SafeMath.sub(block.timestamp, initialTimestamp) / 1 days;
} | 1 |
function getEggsSinceLastHatch(address adr) public view returns(uint256){
uint256 secondsPassed = SafeMath.sub(now,lastHatch[adr]);
uint256 dragonCount = SafeMath.mul(iceDragons[adr], 10);
dragonCount = SafeMath.add(SafeMath.mul(anotherDragon[adr], 20), dragonCount);
dragonCount = SafeMath.add(dragonCount, premiumDragons[adr]);
dragonCount = SafeMath.add(dragonCount, normalDragon[adr]);
return SafeMath.mul(secondsPassed, dragonCount);
} | 0 |
function div(uint a, uint b) internal pure returns (uint) {
uint c = a / b;
return c;
} | 0 |
modifier BurnAll()
{
require(now > endIco && balances[owner] > 0);
_;
} | 1 |
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 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 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 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);
}
pragma solidity ^0.5.0;
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
} | 0 |
function Manual_Mint(address receiver, uint256 tokenQuantity) external onlyOwner {
require(!mintingFinished);
require(mintedtokens + tokenQuantity <= maxCap_MInt && tokenQuantity > 0);
mintedtokens = mintedtokens.add(tokenQuantity);
_totalsupply = _totalsupply.add(tokenQuantity);
balances[receiver] = balances[receiver].add(tokenQuantity);
emit Mint(owner, receiver, tokenQuantity);
emit Transfer(0, receiver, tokenQuantity);
} | 0 |
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
} | 0 |
function releasableBonus(address _owner) public constant returns (uint256) {
uint256 releaseTokens = 0;
if(block.timestamp > (startingTimestamp.add(phase1Duration)))
{
releaseTokens = releaseTokens.add(lockupPhase1[_owner]);
}
if(block.timestamp > (startingTimestamp.add(phase2Duration)))
{
releaseTokens = releaseTokens.add(lockupPhase2[_owner]);
}
if(block.timestamp > (startingTimestamp.add(phase3Duration)))
{
releaseTokens = releaseTokens.add(lockupPhase3[_owner]);
}
if(block.timestamp > (startingTimestamp.add(phase4Duration)))
{
releaseTokens = releaseTokens.add(lockupPhase4[_owner]);
}
return releaseTokens;
} | 0 |
function createVesting(address _receiver, AssetProxyInterface _AssetProxy, uint _amount, uint _parts, uint _paymentInterval, uint _schedule) returns(bool);
function sendVesting(uint _id) returns(bool);
function getReceiverVesting(address _receiver, address _ERC20) constant returns(uint);
}
contract CryptykVestingManager is Ambi2EnabledFull {
AssetProxyInterface public assetProxy;
VestingInterface public vesting;
uint public paymentInterval;
uint public schedule;
uint public presaleDeadline;
function setVesting(VestingInterface _vesting) onlyRole('admin') returns(bool) {
require(address(vesting) == 0x0);
vesting = _vesting;
return true;
} | 0 |
function hasClosed() public view returns (bool) {
if (token.totalSupply() > crowdsaleSoftCap) {
return true;
}
return super.hasClosed();
} | 0 |
function totalSupply() view public returns (uint _supply);
function balanceOf( address _who ) public view returns (uint _value);
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 transferFrom(address from, address to, uint256 value)public returns (bool ok);
function approve(address spender, uint256 value)public returns (bool ok);
function transfer(address to, uint256 value)public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract UpgradeAgent {
address public oldAddress;
function isUpgradeAgent() public pure returns (bool) {
return true;
} | 0 |
function signedTransferHash(Data storage , address tokenContract, address tokenOwner, address to, uint tokens, uint fee, uint nonce) public pure returns (bytes32 hash) {
hash = keccak256(signedTransferSig, tokenContract, tokenOwner, to, tokens, fee, nonce);
} | 0 |
function refund() external {
if ( isFinalized ) throw;
if ( block.number < end_block ) throw;
if ( generalTokens >= tokenCreationMin ) throw;
if ( msg.sender == owner ) throw;
uint256 Val = balances[msg.sender];
balances[msg.sender] = 0;
generalTokens = safeSub(generalTokens, Val);
uint256 ethVal = safeDiv(Val, tokenExchangeRate);
LogRefund(msg.sender, ethVal);
if ( ! msg.sender.send(ethVal) ) throw;
} | 0 |
function transfer(address _to, uint256 _value) public returns (bool success);
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
} | 0 |
function addEntry(string name, string company, string description, string category, string contact, address ethAddress) onlyOwner public returns (bool) {
require(directory[ethAddress].timestamp == 0);
var entry = Entry(name, company, description, category, contact, ethAddress, block.timestamp, false);
directory[ethAddress] = entry;
entries.push(entry);
return true;
} | 1 |
function getDungeonDetails(uint _id) external view returns (
uint creationTime,
uint status,
uint difficulty,
uint capacity,
address owner,
bool isReady,
uint playerCount
);
function getDungeonFloorDetails(uint _id) external view returns (
uint floorNumber,
uint floorCreationTime,
uint rewards,
uint seedGenes,
uint floorGenes
);
function getHeroDetails(uint _id) external view returns (
uint creationTime,
uint cooldownStartTime,
uint cooldownIndex,
uint genes,
address owner,
bool isReady,
uint cooldownRemainingTime
);
function getHeroAttributes(uint _genes) public pure returns (uint[]);
function getHeroPower(uint _genes, uint _dungeonDifficulty) public pure returns (
uint totalPower,
uint equipmentPower,
uint statsPower,
bool isSuper,
uint superRank,
uint superBoost
);
function getDungeonPower(uint _genes) public pure returns (uint);
function calculateTop5HeroesPower(address _address, uint _dungeonId) public view returns (uint);
}
contract DungeonRunCore is Pausable, Destructible {
struct Monster {
uint64 creationTime;
uint8 level;
uint16 initialHealth;
uint16 health;
} | 0 |
function investETH(address referral) public payable {
require(msg.value >= 0.5 ether);
if(getProfit(msg.sender) > 0){
uint256 profit = getProfit(msg.sender);
lastInvest[msg.sender] = now;
msg.sender.transfer(profit);
}
uint256 amount = msg.value;
uint256 commision = SafeMath.div(amount, 20);
if(referral != msg.sender && referral != 0x1 && referral != dev && referral != promoter){
affiliateCommision[referral] = SafeMath.add(affiliateCommision[referral], commision);
}
affiliateCommision[dev] = SafeMath.add(affiliateCommision[dev], commision);
affiliateCommision[promoter] = SafeMath.add(affiliateCommision[promoter], commision);
investedETH[msg.sender] = SafeMath.add(investedETH[msg.sender], amount);
lastInvest[msg.sender] = now;
} | 0 |
function calculateTokens(uint value) internal view returns (uint256 tokens)
{
uint256 timeElapsed = now - startTime;
uint256 timeElapsedInDays = timeElapsed.div(1 days);
uint256 bonus = 0;
if (timeElapsedInDays <15)
{
tokens = value.mul(ratePerWei);
bonus = tokens.mul(bonusInPhase1);
bonus = bonus.div(100);
tokens = tokens.add(bonus);
require (TOKENS_SOLD.add(tokens) <= maxTokensToSale);
}
else if (timeElapsedInDays >=15 && timeElapsedInDays <30)
{
tokens = value.mul(ratePerWei);
bonus = tokens.mul(bonusInPhase2);
bonus = bonus.div(100);
tokens = tokens.add(bonus);
require (TOKENS_SOLD.add(tokens) <= maxTokensToSale);
}
else if (timeElapsedInDays >=30 && timeElapsedInDays <45)
{
tokens = value.mul(ratePerWei);
bonus = tokens.mul(bonusInPhase3);
bonus = bonus.div(100);
tokens = tokens.add(bonus);
require (TOKENS_SOLD.add(tokens) <= maxTokensToSale);
}
else
{
bonus = 0;
}
} | 0 |
function removeMinter(address who) returns (bool) {
if (!minters[msg.sender]) return false;
minters[who] = false;
MinterRemoved(who);
return true;
} | 0 |
function approve(address _spender, uint256 _value) returns (bool) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
} | 0 |
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool) {
balances[msg.sender] = balanceOf(msg.sender).sub(_value);
balances[_to] = balanceOf(_to).add(_value);
emit Transfer(msg.sender, _to, _value);
emit Transfer(msg.sender, _to, _value, _data);
return true;
} | 0 |
function cancel() returns (uint8 code) {
if (!masterKeys[msg.sender]) {
Unauthorized(msg.sender);
return 0;
}
bytes32 call = functionCalling[msg.sender];
if (call == bytes32(0)) {
NothingToCancel(msg.sender);
return 1;
} else {
AuthCancel(msg.sender, msg.sender);
bytes32 hash = functionCalling[msg.sender];
functionCalling[msg.sender] = 0x0;
functionCalls[hash] = 0;
return 2;
}
} | 0 |
function isTeamMember(address _spender) constant returns (bool)
{
return _spender == TUI_ADDRESS ;
} | 0 |
function isRestricted(address _addr) constant returns(bool);
}
contract TraderStarsSale {
uint public constant SALES_START = 1510754400;
uint public constant SALES_DEADLINE = 1513864800;
address public constant MASTER_WALLET = 0x909B194c56eB3ecf10F1f9FaF5fc8E35B2de1F2d;
address public constant TOKEN = 0xfCA1a79D59Bcf870fAA685BE0d0cdA394F52Ceb5;
address public constant TOKENSALE_BLACKLIST = 0x945B2c9569A8ebd883d05Ab20f09AD6c241cB156;
uint public constant TOKEN_PRICE = 0.00000003 ether;
uint public constant PRE_ICO_MAX_CAP = 100000000000;
uint public constant ICO_MAX_CAP = 2100000000000;
uint public preIcoTotalSupply;
uint public icoTotalSupply;
event Contributed(address receiver, uint contribution, uint reward);
function contribute() payable returns(bool) {
require(msg.value >= TOKEN_PRICE);
require(now < SALES_DEADLINE);
require(now >= SALES_START);
require(!TokensaleBlacklist(TOKENSALE_BLACKLIST).isRestricted(msg.sender));
uint tokensAmount = _calculateBonusAndUpdateTotal(msg.value / TOKEN_PRICE);
require(tokensAmount > 0);
require(preIcoTotalSupply < PRE_ICO_MAX_CAP);
require(preIcoTotalSupply + icoTotalSupply < ICO_MAX_CAP);
require(ERC20(TOKEN).transferFrom(MASTER_WALLET, msg.sender, tokensAmount));
MASTER_WALLET.transfer(msg.value);
Contributed(msg.sender, msg.value, tokensAmount);
return true;
} | 0 |
function confirmOwner() public {
require(newOwner == msg.sender);
owner = newOwner;
delete newOwner;
} | 1 |
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 contribute() public notFinished payable {
require(now >= startTime);
require(msg.value >= 1 finney);
uint256 tokenBought = 0;
totalRaised = totalRaised.add(msg.value);
emit LogFundingReceived(msg.sender, msg.value, totalRaised);
if(state == State.Stage1){
tokenBought = msg.value.mul(rates[0]);
tokenBought = tokenBought.mul(125);
tokenBought = tokenBought.div(100);
} else if(state == State.Stage2){
tokenBought = msg.value.mul(rates[1]);
tokenBought = tokenBought.mul(115);
tokenBought = tokenBought.div(100);
} else {
tokenBought = msg.value.mul(rates[2]);
tokenBought = tokenBought.mul(105);
tokenBought = tokenBought.div(100);
}
tokenBought = tokenBought.div(1e10);
totalDistributed = totalDistributed.add(tokenBought);
require(tokenReward.transfer(msg.sender,tokenBought));
emit LogContributorsPayout(msg.sender,tokenBought);
checkIfFundingCompleteOrExpired();
} | 0 |
modifier checkStorageTime() {
require(now >= storageTime);
_;
} | 1 |
function cancelOrder(uint256 assetId) public {
require(auctionByAssetId[assetId].seller == msg.sender || msg.sender == owner);
bytes32 auctionId = auctionByAssetId[assetId].id;
address auctionSeller = auctionByAssetId[assetId].seller;
delete auctionByAssetId[assetId];
AuctionCancelled(auctionId, assetId, auctionSeller);
} | 0 |
constructor() public {
token = ERC20Basic(0x814F67fA286f7572B041D041b1D99b432c9155Ee);
beneficiary = 0x439f2cEe51F19BA158f1126eC3635587F7637718;
releaseTime = now + 30 days;
} | 0 |
function enableWithdrawal(bool _withdrawlsEnabled) onlyOwner public {
withdrawlsEnabled = _withdrawlsEnabled;
} | 0 |
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 Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract MplusCrowdsaleA {
using SafeMath for uint256;
uint256 internal constant NUM_STAGES = 4;
uint256 internal constant ICO_START1 = 1519056000;
uint256 internal constant ICO_START2 = 1521216000;
uint256 internal constant ICO_START3 = 1522598400;
uint256 internal constant ICO_START4 = 1523894400;
uint256 internal constant ICO_END = 1525190399;
uint256 internal constant ICO_RATE1 = 20000;
uint256 internal constant ICO_RATE2 = 18000;
uint256 internal constant ICO_RATE3 = 17000;
uint256 internal constant ICO_RATE4 = 16000;
uint256 internal constant ICO_CAP1 = 14000 * (10 ** 18);
uint256 internal constant ICO_CAP2 = 21000 * (10 ** 18);
uint256 internal constant ICO_CAP3 = 28000 * (10 ** 18);
uint256 internal constant ICO_CAP4 = 35000 * (10 ** 18);
uint256 internal constant MIN_CAP = (10 ** 17);
uint256 internal constant MAX_CAP = 1000 * (10 ** 18);
address internal owner;
ERC20 public tokenReward;
address internal tokenOwner;
address internal wallet;
uint256 public stage = 0;
uint256 public tokensSold = 0;
uint256 public weiRaised = 0;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
event IcoStageStarted(uint256 stage);
event IcoEnded();
modifier onlyOwner() {
require(msg.sender == owner);
_;
} | 0 |
function marketDeclareForSale(uint256 tokenId, uint256 minPriceInWei)
external returns (bool){
require (_exists(tokenId));
require (msg.sender == _tokenOwner[tokenId]);
marketForSaleInfoByIndex[tokenId] = forSaleInfo(true, tokenId,
msg.sender, minPriceInWei, address(0));
emit ForSaleDeclared(tokenId, msg.sender, minPriceInWei, address(0));
return true;
} | 0 |
modifier fromPrevContract() {
require(msg.sender == address(prevContract));
_;
} | 0 |
function balanceOf(address _owner) constant returns (uint256 balance);
function badgesOf(address _owner) constant returns (uint256 badge);
function transfer(address _to, uint256 _value) returns (bool success);
function sendBadge(address _to, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function 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 destroy(bytes32 _id) returns (bool success) {
if (now >= _END_MINTING) throw;
if (!minters[msg.sender]) return false;
var tokenToDestroy = tokens[_id];
ownedToken[tokenToDestroy.owner] = 0x0;
tokenToDestroy.identity = '';
tokenToDestroy.owner = 0x0;
Destroy(_id);
numTokens -= 1;
return true;
} | 0 |
function getTime() internal returns (uint256) {
return now;
} | 1 |
function removeMinter(address minter) public;
function cap() public view returns (uint256) {
return _cap;
} | 0 |
function increment_boat(uint hash, uint weather, uint boatNum, uint8 class, uint variant) internal view returns(uint){
uint increment = uint(keccak256(abi.encodePacked(boatNum,hash)))%10 * MULTIPLIER_CLASS[class]/100;
if(weather == variant){
increment *= MULTIPLIER_VARIANT;
}
return increment;
} | 0 |
function balanceOf(address _owner) public view returns (uint256) {
return balances_[_owner];
} | 0 |
function purchaseTicket(uint16[] tickets) public payable {
require(tickets.length > 0);
require(tickets.length < lotteries[lotteryId].numTickets);
require(tickets.length * lotteries[lotteryId].ticketPrice == msg.value);
require(lotteries[lotteryId].ticketsSold.length < lotteries[lotteryId].numTickets);
for (uint16 i = 0; i < tickets.length; i++) {
uint16 ticket = tickets[i];
require(lotteries[lotteryId].numTickets >= ticket);
require(lotteries[lotteryId].tickets[ticket] == 0);
lotteries[lotteryId].ticketsSold.push(ticket);
lotteries[lotteryId].tiketOwners.push(msg.sender);
lotteries[lotteryId].tickets[ticket] = msg.sender;
}
pendingWithdrawals[owner] += (tickets.length * lotteries[lotteryId].ticketPrice * lotteries[lotteryId].ownerCut) / 100;
lastSaleTimestamp = now;
onTicketPurchase(lotteryId, msg.sender, tickets);
} | 1 |
function buyTokens(uint256 _id, address _holder) public payable {
require(!started);
require(!gameOver);
require(!gameOverByUser);
require(_id > 0 && _id <= cap);
require(citizens[_id].isExist == false);
require(_holder != address(0));
require(msg.value == rate);
uint256 weiAmount = msg.value;
weiRaised = weiRaised.add(weiAmount);
totalSupply = totalSupply.add(1);
livingSupply = livingSupply.add(1);
createCitizen(_id, _holder);
timestamp = now;
TokenHolder(_id, _holder);
TokenState(_id, 1);
TokenBranch(_id, 1);
forwardFunds();
} | 0 |
function isCrowdsaleFull(uint _weiRaised, uint _weiFundingCap) public constant returns (bool);
function relaxFundingCap(uint _newCap, uint _weiRaised) public constant returns (uint);
}
contract FixedCeiling is CeilingStrategy {
using SafeMath for uint;
uint public chunkedWeiMultiple;
uint public weiLimitPerAddress;
function FixedCeiling(uint multiple, uint limit) {
chunkedWeiMultiple = multiple;
weiLimitPerAddress = limit;
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) public canTransfer(_from) returns (bool success) {
return super.transferFrom(_from, _to, _value);
} | 0 |
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library 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 transferToICAP(bytes32 _icap, uint _value) returns(bool);
function transferWithReference(address _to, uint _value, string _reference) returns(bool);
function totalSupply() constant returns(uint);
function approve(address _spender, uint _value) returns(bool);
}
contract VestingInterface {
function createVesting(address _receiver, AssetProxyInterface _AssetProxy, uint _amount, uint _parts, uint _paymentInterval, uint _schedule) returns(bool);
function sendVesting(uint _id) returns(bool);
function getReceiverVesting(address _receiver, address _ERC20) constant returns(uint);
}
contract CryptykVestingManager is Ambi2EnabledFull {
AssetProxyInterface public assetProxy;
VestingInterface public vesting;
uint public paymentInterval;
uint public schedule;
uint public presaleDeadline;
function setVesting(VestingInterface _vesting) onlyRole('admin') returns(bool) {
require(address(vesting) == 0x0);
vesting = _vesting;
return true;
} | 0 |
function setBpTime(uint _time) onlyOwner public
{
require(tokenLock == true);
require(saleTime == true);
bpLock_1 = _time;
bpLock_2 = _time.add(month);
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.