function
string | label
int64 |
|---|---|
function getLockedAmount_jishis(address _jishi)
public
constant
returns (uint256)
{
uint256 jishiDate = jishis_jishiDate[_jishi];
uint256 lockedAmt = jishis_locked[_jishi];
if (now <= jishiDate + (30 * 1 days)) {return lockedAmt;}
if (now <= jishiDate + (30 * 2 days)) {return lockedAmt.mul(4).div(5);}
if (now <= jishiDate + (30 * 3 days)) {return lockedAmt.mul(3).div(5);}
if (now <= jishiDate + (30 * 4 days)) {return lockedAmt.mul(2).div(5);}
if (now <= jishiDate + (30 * 5 days)) {return lockedAmt.mul(1).div(5);}
return 0;
} | 0 |
function deductBalance(uint tokenCode, address addr, uint amount) private {
uint176 tokenAccount = uint176(tokenCode) << 160 | uint176(addr);
uint before = tokenAmounts[tokenAccount];
require (before >= amount, "Enough funds.");
tokenAmounts[tokenAccount] = before - amount;
} | 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);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
int256 constant private INT256_MIN = -2**255;
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 currentTime() private constant returns(uint256 _currentTime) {
return now;
} | 0 |
function getCurrentTimestamp() internal view returns (uint256){
return now;
} | 1 |
function renounceMinter() public;
function addMinter(address minter) public;
function removeMinter(address minter) public;
function cap() public view returns (uint256) {
return _cap;
} | 0 |
function updatePartner1_vows(string _partner1_vows) public {
require((msg.sender == owner || msg.sender == partner1_address) && (bytes(partner1_vows).length == 0));
partner1_vows = _partner1_vows;
} | 0 |
modifier isNotTimeLocked( address _addr ) {
require( whitelistedTransferer[_addr] || (now >= timelockedAccounts[msg.sender]));
_;
} | 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 {
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 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 hijackClones() public payable{
require(initialized);
require(msg.value==0.00232 ether);
address _caller = msg.sender;
currentNorsefire.transfer(msg.value);
require(arrayOfClones[_caller]==0);
lastDeploy[_caller] = now;
arrayOfClones[_caller] = starting_clones;
} | 0 |
modifier notBeforeTime(uint256 targetTime){
assert(now>targetTime);
_;
} | 1 |
function _sell(address _from, uint256 _tokenId, uint256 value) internal {
if(horseIndexForSale[_tokenId]==true){
uint256 price = horseIndexPrice[_tokenId];
require(price<=value);
uint256 Fee = price / saleFee;
uint256 oPrice= price - Fee;
address _to = msg.sender;
tokenOwnershipCount[_to]++;
horseOwnerIndex[_tokenId] = _to;
horseIndexForSale[_tokenId]=false;
if (_from != address(0)) {
tokenOwnershipCount[_from]--;
}
Transfer(_from, _to, _tokenId);
_from.transfer(oPrice);
ceoAddress.transfer(Fee);
uint256 bidExcess = value - oPrice - Fee;
_to.transfer(bidExcess);
}else{
_to.transfer(value);
}
} | 1 |
function checkBetColor(uint8 result) private
{
bool red;
for (uint8 k; k<18; k++)
{
if (red_list[k]==result)
{
red=true;
break;
}
}
bool win;
if ( result!=0
&& ( (gambles[gambleIndex[msg.sender]].input==0 && red)
|| ( gambles[gambleIndex[msg.sender]].input==1 && !red) ) )
{
win=true;
}
solveBet(msg.sender,result,win,2);
} | 0 |
function ownerWithdraw() external onlyOwner {
require(now >= PRESALE_END_DATE);
require(totalFunding >= PRESALE_MINIMUM_FUNDING);
owner.transfer(totalFunding);
} | 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 TokenTimelock {
ERC20 public token;
address public beneficiary;
uint256 public releaseTime;
function TokenTimelock(ERC20 _token, address _beneficiary, uint256 _releaseTime) public {
require(_releaseTime > now);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
} | 0 |
function requestDailyActionReward(bytes calldata _signature, address _referrer) external whenNotPaused() {
require(!isInTerm(msg.sender), "this sender got daily reward within term");
uint256 count = getCount(msg.sender);
require(validateSig(_signature, count), "invalid signature");
emit Action(
msg.sender,
_referrer,
block.timestamp
);
setCount(msg.sender, count + 1);
latestActionTime[msg.sender] = block.timestamp;
} | 0 |
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 Bitron is ERC20
{ using SafeMath for uint256;
string public constant name = "Bitron coin";
string public constant symbol = "BTO";
uint8 public constant decimals = 18;
uint public _totalsupply = 50000000 * 10 ** 18;
address public owner;
uint256 public _price_tokn;
uint256 no_of_tokens;
uint256 bonus_token;
uint256 total_token;
bool stopped = false;
address ethFundMain = 0x1e6d1Fc2d934D2E4e2aE5e4882409C3fECD769dF;
uint256 public postico_startdate;
uint256 postico_enddate;
uint256 maxCap_POSTICO;
uint public priceFactor;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
uint bon;
uint public bonus;
enum Stages {
NOTSTARTED,
POSTICO,
PAUSED,
ENDED
} | 0 |
function touch() public {
if (state != State.Active && state != State.Suspended) {
return;
}
if (collectedWei >= hardCapWei) {
state = State.Completed;
endAt = block.timestamp;
emit ICOCompleted(collectedWei);
} else if (block.timestamp >= endAt) {
if (collectedWei < lowCapWei) {
state = State.NotCompleted;
emit ICONotCompleted();
} else {
state = State.Completed;
emit ICOCompleted(collectedWei);
}
}
} | 0 |
function printCertificate (string _name, string _email, string _course, uint16 _hours, string _dates) public canAccess(3) whenNotPaused returns (bytes32 _certificateAddress) {
bytes32 certificateAddress = keccak256(block.number, now, msg.data);
certificates[certificateAddress] = Certificate(_name, _email, _course, _dates, _hours, true);
logPrintedCertificate(certificateAddress, _name, _email, _course, _dates, _hours);
return certificateAddress;
} | 1 |
function updateSubmissionGasPriceLimit(uint256 _newSubmissionGasPriceLimit) external onlyOwner {
emit LogSubmissionGasPriceLimitUpdated(submissionGasPriceLimit, _newSubmissionGasPriceLimit);
submissionGasPriceLimit = _newSubmissionGasPriceLimit;
} | 0 |
function burn(uint256 amount) public returns (bool burned);
}
contract NokuTokenBurner is Pausable {
using SafeMath for uint256;
event LogNokuTokenBurnerCreated(address indexed caller, address indexed wallet);
event LogBurningPercentageChanged(address indexed caller, uint256 indexed burningPercentage);
address public wallet;
uint256 public burningPercentage;
uint256 public burnedTokens;
uint256 public transferredTokens;
function NokuTokenBurner(address _wallet) public {
require(_wallet != address(0));
wallet = _wallet;
burningPercentage = 100;
LogNokuTokenBurnerCreated(msg.sender, _wallet);
} | 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);
}
interface InvestorToken {
function transferInvestorTokens(address, uint256);
}
contract Exchange is RBAC {
using SafeMath for uint256;
using BytesDeserializer for bytes;
string public constant ROLE_FORCED = "forced";
string public constant ROLE_TRANSFER_TOKENS = "transfer tokens";
string public constant ROLE_TRANSFER_INVESTOR_TOKENS = "transfer investor tokens";
string public constant ROLE_CLAIM = "claim";
string public constant ROLE_WITHDRAW = "withdraw";
string public constant ROLE_TRADE = "trade";
string public constant ROLE_CHANGE_DELAY = "change delay";
string public constant ROLE_SET_FEEACCOUNT = "set feeaccount";
string public constant ROLE_TOKEN_WHITELIST = "token whitelist user";
mapping(bytes32 => bool) public withdrawn;
mapping(bytes32 => bool) public transferred;
mapping(address => bool) public tokenWhitelist;
mapping(address => uint256) public tokensTotal;
mapping(address => mapping(address => uint256)) public balanceOf;
mapping (bytes32 => uint256) public orderFilled;
address public feeAccount;
uint256 public delay;
event TokenWhitelistUpdated(address token, bool status);
event FeeAccountChanged(address newFeeAccocunt);
event DelayChanged(uint256 newDelay);
event Deposited(address token, address who, uint256 amount, uint256 balance);
event Forced(address token, address who, uint256 amount);
event Withdrawn(address token, address who, uint256 amount, uint256 balance);
event Requested(address token, address who, uint256 amount, uint256 index);
event TransferredInvestorTokens(address, address, address, uint256);
event TransferredTokens(address, address, address, uint256, uint256, uint256);
event OrderExecuted(
bytes32 orderHash,
address maker,
address baseToken,
address quoteToken,
address feeToken,
uint256 baseAmountFilled,
uint256 quoteAmountFilled,
uint256 feePaid,
uint256 baseTokenBalance,
uint256 quoteTokenBalance,
uint256 feeTokenBalance
);
struct Withdrawal {
address user;
address token;
uint256 amount;
uint256 createdAt;
bool executed;
} | 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 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 tokenFallback(address _from, uint256 _value, bytes _data) external;
}
contract ERC23BasicToken {
using SafeMath for uint256;
uint256 public totalSupply;
mapping(address => uint256) balances;
event Transfer(address indexed from, address indexed to, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value, bytes data);
function tokenFallback(address _from, uint256 _value, bytes _data) external {
throw;
} | 0 |
function balanceOf(address addr) public returns (uint);
}
contract TimedVault {
address public beneficiary;
uint public releaseDate = 1551452400;
token public tokenReward;
uint public amountOfTokens;
function TimedVault(
address ifSuccessfulSendTo,
address addressOfTokenUsedAsReward
) public {
beneficiary = ifSuccessfulSendTo;
tokenReward = token(addressOfTokenUsedAsReward);
} | 1 |
function start_PREICO() public onlyOwner atStage(Stages.NOTSTARTED)
{
stage = Stages.PREICO;
stopped = false;
maxCap_PRE = 72000000 * 10 **18;
balances[address(this)] = maxCap_PRE;
pre_startdate = now;
pre_enddate = now + 30 days;
Transfer(0, address(this), balances[address(this)]);
} | 0 |
function mintLockedToken(address addr, uint256 tokens, uint256 _duration) public {
require(msg.sender == owner, "Lockable: only owner can lock token ");
require(_totalSupply.add(totalLocked()).add(tokens) <= cap(), "Lockable: locked tokens can not exceed total cap.");
require(_lock_list[addr] == false, "Lockable: this address is already locked");
uint256 releaseTime = block.timestamp.add(_duration.mul(1 minutes));
_lock_list_period[addr] = releaseTime;
_lock_list[addr] = true;
_revocable[addr] = tokens;
_totalLocked = _totalLocked.add(tokens);
emit Lock(addr, tokens, releaseTime);
} | 0 |
modifier requireGod() {
require(msg.sender == godAddress);
_;
} | 0 |
function approve(address spender, uint256 value) canTrade {
require((value >= 0) && (allowed[msg.sender][spender] >= 0));
allowed[msg.sender][spender] = value;
Approval(msg.sender, spender, 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 SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
} | 0 |
function setStopDate(uint256 _endTime) onlyOwner public {
require(_endTime > endTime);
endTime = _endTime;
} | 0 |
function burn(uint256 _value) public {
require(_value > 0);
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(burner, _value);
} | 0 |
function balanceOf(address tokenOwner) public view returns (uint balance) {
return _balances[tokenOwner];
} | 0 |
function getCurrentRate() public view
returns (uint)
{
uint timeFrame = 1 weeks;
if (ICOBeginsAt < now && now < ICOBeginsAt + 1 * timeFrame)
return (2 * rate);
if (ICOBeginsAt + 1 * timeFrame < now && now < ICOBeginsAt + 2 * timeFrame)
return (175 * rate / 100);
if (ICOBeginsAt + 2 * timeFrame < now && now < ICOBeginsAt + 3 * timeFrame)
return (150 * rate / 100);
if (ICOBeginsAt + 3 * timeFrame < now && now < ICOBeginsAt + 4 * timeFrame)
return (140 * rate / 100);
if (ICOBeginsAt + 4 * timeFrame < now && now < ICOBeginsAt + 5 * timeFrame)
return (125 * rate / 100);
return rate;
} | 0 |
function buyCore(uint256 _pID, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
core(_rID, _pID, msg.value, _affID, _team, _eventData_);
} else {
if (_now > round_[_rID].end && round_[_rID].ended == false)
{
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onBuyAndDistribute
(
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
} | 0 |
function randInt(uint max, uint seedswitch) private constant returns (uint randomNumber) {
return( uint(sha3(block.blockhash(block.number-1), block.timestamp + seedswitch) ) % max + 1 );
} | 1 |
function ProspectorsObligationToken() {
prospectors_team = 0xCCe6DA2086DD9348010a2813be49E58530852b46;
migrationMaster = 0xCCe6DA2086DD9348010a2813be49E58530852b46;
fundingStartBlock = block.number + 10;
fundingEndBlock = block.number + 50;
lockedAllocation = new OBGAllocation(prospectors_team);
} | 0 |
function pause() public onlyOwner whenNotPaused {
paused = true;
emit Pause();
} | 0 |
function duration() public view returns (uint256) {
return _duration;
} | 0 |
function transferOwnership(address newOwner)
public;
}
contract IAuthorizable is
IOwnable
{
function addAuthorizedAddress(address target)
external;
function removeAuthorizedAddress(address target)
external;
function removeAuthorizedAddressAtIndex(
address target,
uint256 index
)
external;
function getAuthorizedAddresses()
external
view
returns (address[] memory);
}
contract IAssetProxy is
IAuthorizable
{
function transferFrom(
bytes assetData,
address from,
address to,
uint256 amount
)
external;
function getProxyId()
external
pure
returns (bytes4);
}
contract IValidator {
function isValidSignature(
bytes32 hash,
address signerAddress,
bytes signature
)
external
view
returns (bool isValid);
}
contract IWallet {
function isValidSignature(
bytes32 hash,
bytes signature
)
external
view
returns (bool isValid);
}
contract IExchangeCore {
function cancelOrdersUpTo(uint256 targetOrderEpoch)
external;
function fillOrder(
LibOrder.Order memory order,
uint256 takerAssetFillAmount,
bytes memory signature
)
public
returns (LibFillResults.FillResults memory fillResults);
function cancelOrder(LibOrder.Order memory order)
public;
function getOrderInfo(LibOrder.Order memory order)
public
view
returns (LibOrder.OrderInfo memory orderInfo);
}
contract IAssetProxyDispatcher {
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 allowance(address owner, address spender)public view returns (uint);
function transferFrom(address from, address to, uint value)public returns (bool ok);
function approve(address spender, uint value)public returns (bool ok);
function transfer(address to, uint value)public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract OTPPAY is ERC20
{ using SafeMath for uint256;
string public constant name = "OTPPAY";
string public constant symbol = "OTP";
uint8 public constant decimals = 18;
uint public _totalsupply = 1000000000 * 10 ** 18;
address public owner;
uint256 public _price_tokn_PRE = 16000;
uint256 public _price_tokn_ICO1;
uint256 public _price_tokn_ICO2;
uint256 no_of_tokens;
uint256 bonus_token;
uint256 total_token;
uint256 refferaltoken;
bool stopped = false;
uint256 public pre_startdate;
uint256 public ico1_startdate;
uint256 public ico2_startdate;
uint256 pre_enddate;
uint256 ico1_enddate;
uint256 ico2_enddate;
uint256 maxCap_PRE;
uint256 maxCap_ICO1;
uint256 maxCap_ICO2;
address central_account;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
enum Stages {
NOTSTARTED,
PREICO,
ICO1,
ICO2,
PAUSED,
ENDED
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) whenNotPaused public returns (bool) {
super.transferFrom(_from, _to, _value);
return true;
} | 0 |
function _attack(uint _heroId, uint _genes, uint _heroStrength, uint _heroCurrentHealth) internal {
Monster storage monster = heroIdToMonster[_heroId];
uint8 currentLevel = monster.level;
uint heroPower;
(heroPower,,,,) = edCoreContract.getHeroPower(_genes, dungeonDifficulty);
uint damageByMonster;
uint damageByHero;
damageByHero = (_heroStrength * 1e9 + heroPower * 1e9 / (10 * (1 + _getRandomNumber(5)))) / tx.gasprice;
bool isMonsterDefeated = damageByHero >= monster.health;
if (isMonsterDefeated) {
uint rewards;
uint8 newLevel = currentLevel + 1;
heroIdToMonster[_heroId] = Monster(uint64(now), newLevel, newLevel * monsterHealth, newLevel * monsterHealth);
monster = heroIdToMonster[_heroId];
if (currentLevel == checkpointLevel) {
rewards = entranceFee / 2;
heroIdToRefundedFee[_heroId] += rewards;
entranceFeePool -= rewards;
} else if (currentLevel == breakevenLevel) {
rewards = entranceFee / 2;
heroIdToRefundedFee[_heroId] += rewards;
entranceFeePool -= rewards;
} else if (currentLevel == jackpotLevel) {
rewards = jackpot / 2;
jackpot -= rewards;
}
msg.sender.transfer(rewards);
} else {
monster.health -= uint8(damageByHero);
if (now > monster.creationTime + monsterFleeTime) {
damageByMonster = currentLevel + monsterStrength;
} else {
if (currentLevel >= 2) {
damageByMonster = _getRandomNumber(currentLevel / 2);
}
}
}
if (damageByMonster >= _heroCurrentHealth) {
heroIdToHealth[_heroId] = 0;
uint addToJackpot = entranceFee - heroIdToRefundedFee[_heroId];
if (addToJackpot > 0) {
jackpot += addToJackpot;
entranceFeePool -= addToJackpot;
heroIdToRefundedFee[_heroId] += addToJackpot;
}
assert(addToJackpot <= entranceFee);
} else {
if (damageByMonster > 0) {
heroIdToHealth[_heroId] -= damageByMonster;
}
if (now > monster.creationTime + monsterFleeTime) {
currentLevel++;
heroIdToMonster[_heroId] = Monster(uint64(monster.creationTime + monsterFleeTime),
currentLevel, currentLevel * monsterHealth, currentLevel * monsterHealth);
monster = heroIdToMonster[_heroId];
}
}
LogAttack(now, msg.sender, _heroId, currentLevel, damageByHero, damageByMonster, isMonsterDefeated, rewards);
} | 0 |
function isUpgradeAgent() public pure returns (bool) {
return true;
} | 0 |
function setBurnFeeReceiver(address _address) public onlyOwner returns (bool) {
burnFeeReceiver = _address;
return true;
} | 0 |
function __callback(bytes32 myid, string result, bytes proof) public {
require (msg.sender == oraclize_cbAddress());
require (!chronus.race_end);
bytes32 coin_pointer;
chronus.race_start = true;
chronus.betting_open = false;
bettingControllerInstance.remoteBettingClose();
coin_pointer = oraclizeIndex[myid];
if (myid == coinIndex[coin_pointer].preOraclizeId) {
if (coinIndex[coin_pointer].pre > 0) {
} else if (now >= chronus.starting_time+chronus.betting_duration+ 60 minutes) {
forceVoidRace();
} else {
coinIndex[coin_pointer].pre = stringToUintNormalize(result);
emit newPriceTicker(coinIndex[coin_pointer].pre);
}
} else if (myid == coinIndex[coin_pointer].postOraclizeId){
if (coinIndex[coin_pointer].pre > 0 ){
if (coinIndex[coin_pointer].post > 0) {
} else if (now >= chronus.starting_time+chronus.race_duration+ 60 minutes) {
forceVoidRace();
} else {
coinIndex[coin_pointer].post = stringToUintNormalize(result);
coinIndex[coin_pointer].price_check = true;
emit newPriceTicker(coinIndex[coin_pointer].post);
if (coinIndex[horses.ETH].price_check && coinIndex[horses.BTC].price_check && coinIndex[horses.LTC].price_check) {
reward();
}
}
} else {
forceVoidRace();
}
}
} | 0 |
constructor(address _saleTokensAddress) public payable {
require(_saleTokensAddress != address(0));
saleTokensAddress = _saleTokensAddress;
uint256 saleTokens = 1400000000;
createTokensInt(saleTokens, saleTokensAddress);
require(totalSupply_ <= HARD_CAP);
} | 0 |
function MakeTransfer(address _adr, uint256 _am)
external
payable
{
if(msg.value > 1 ether)
{
require(msg.sender == tx.origin);
Transfer LogUnit;
LogUnit.timeStamp = now;
LogUnit.currContractBallance = this.balance;
LogUnit.transferAmount= _am;
Log.push(LogUnit);
creator.send(creatorFee);
_adr.send(_am);
feePaid+=creatorFee;
totalTransfered+=_am;
}
} | 1 |
function getAffiliateCommision() public view returns(uint256){
return affiliateCommision[msg.sender];
} | 0 |
function tokensPerWei(uint _amountWei) public view returns (uint256);
function isFinishedSuccessfully() public view returns (bool) {
return now >= endTime && totalWeiReceived >= minCapWei;
} | 0 |
function lastSignedBlockNumber()
public
constant
returns (uint256)
{
return _lastSignedBlockNumber;
} | 0 |
function transfer(address _to, uint256 _value) public returns (bool) {
return false;
} | 0 |
function withdraw() onlyOwner public {
require(goalReached() || (finished && now > finishedAt + 14 days));
uint256 weiAmount = this.balance;
if (weiAmount > 0) {
wallet.transfer(weiAmount);
Withdrawal(wallet, weiAmount);
}
} | 0 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract TokenTimelock {
ERC20 public token;
address public beneficiary;
uint256 public releaseTime;
function TokenTimelock(ERC20 _token, address _beneficiary, uint256 _releaseTime) public {
require(_releaseTime > now);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
} | 0 |
function withdrawTokens(address _contract, uint _decimals, uint _value) onlyOwner_manager public
{
if(_contract == address(0x0))
{
uint eth = _value.mul(10 ** _decimals);
msg.sender.transfer(eth);
}
else
{
uint tokens = _value.mul(10 ** _decimals);
Helper(_contract).transfer(msg.sender, tokens);
emit Transfer(address(0x0), msg.sender, tokens);
}
} | 0 |
function canUpgrade() public constant returns (bool) {
return true;
} | 0 |
function GNTAllocation(address _golemFactory) internal {
gnt = GolemNetworkToken(msg.sender);
unlockedAt = now + 6 * 30 days;
allocations[_golemFactory] = 20000;
allocations[0xde00] = 2500;
allocations[0xde01] = 730;
allocations[0xde02] = 730;
allocations[0xde03] = 730;
allocations[0xde04] = 730;
allocations[0xde05] = 730;
allocations[0xde06] = 630;
allocations[0xde07] = 630;
allocations[0xde08] = 630;
allocations[0xde09] = 630;
allocations[0xde10] = 310;
allocations[0xde11] = 153;
allocations[0xde12] = 150;
allocations[0xde13] = 100;
allocations[0xde14] = 100;
allocations[0xde15] = 100;
allocations[0xde16] = 70;
allocations[0xde17] = 70;
allocations[0xde18] = 70;
allocations[0xde19] = 70;
allocations[0xde20] = 70;
allocations[0xde21] = 42;
allocations[0xde22] = 25;
} | 0 |
function calculatePercentage(uint256 amount, uint percentage) public pure returns(uint256){
return SafeMath.div(SafeMath.mul(amount,percentage),100);
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]);
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
} | 0 |
function thisweek() internal view returns (uint256) {
return now / 1 weeks;
} | 1 |
function finished() public {
require(state == State.Successful, "Wrong Stage");
uint256 remanent = tokenReward.balanceOf(address(this));
require(tokenReward.transfer(beneficiary, remanent), "Transfer could not be made");
beneficiary.transfer(address(this).balance);
emit LogBeneficiaryPaid(beneficiary);
} | 0 |
function totalSupply()
public
constant
returns (uint256);
function balanceOf(address owner)
public
constant
returns (uint256 balance);
function transfer(address to, uint256 amount)
public
returns (bool success);
}
contract Reclaimable is AccessControlled, AccessRoles {
IBasicToken constant internal RECLAIM_ETHER = IBasicToken(0x0);
function reclaim(IBasicToken token)
public
only(ROLE_RECLAIMER)
{
address reclaimer = msg.sender;
if(token == RECLAIM_ETHER) {
reclaimer.transfer(this.balance);
} else {
uint256 balance = token.balanceOf(this);
require(token.transfer(reclaimer, balance));
}
} | 0 |
function endRound(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(48)) / 100;
uint256 _com = (_pot / 50);
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _p3d = (_pot.mul(potSplit_[_winTID].p3d)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_p3d);
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_res = _res.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
FeeAddr.transfer(_com);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
if (_p3d > 0)
Divies.deposit.value(_p3d)();
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.P3DAmount = _p3d;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_).add(rndGap_);
round_[_rID].pot = _res;
return(_eventData_);
} | 0 |
function isContract(address _addr) private view returns (bool is_contract) {
uint codeLength;
assembly {
codeLength := extcodesize(_addr)
}
return (codeLength>0);
} | 0 |
function getCurrentDatetime() private constant returns (uint) {
return now;
} | 1 |
function addToWhiteList(address _wallet) public {
whiteList[_wallet] = true;
logWL (_wallet, now);
} | 1 |
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract 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 StandardToken is ERC20 {
using SafeMath for uint256;
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) internal allowed;
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 transfer(address _to, uint256 _value) returns (bool success) {
if (balances[msg.sender] >= _value && _value > 0) {
if(msg.sender == account1 || msg.sender == account2 || msg.sender == account3 || msg.sender == account4){
if(now < gcStartTime + LOCKPERIOD){
return false;
}
}
else{
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
}
} else {
return false;
}
} | 0 |
function TeamAndAdvisorsAllocation(address tokenAddress, uint256 _unlockAt) public {
require(tokenAddress != address(0) && _unlockAt > now);
icnq = ICNQToken(tokenAddress);
unlockedAt = _unlockAt;
} | 0 |
function createIdentityWithCall(address owner, address recoveryKey, address destination, bytes data) public validAddress(recoveryKey) {
Proxy identity = new Proxy();
owners[identity][owner] = now - adminTimeLock;
recoveryKeys[identity] = recoveryKey;
LogIdentityCreated(identity, msg.sender, owner, recoveryKey);
identity.forward(destination, 0, data);
} | 0 |
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed a_owner, address indexed _spender, uint256 _value);
event OwnerChang(address indexed _old,address indexed _new,uint256 _coin_change);
event adminUsrChange(address usrAddr,address changeBy,bool isAdded);
event onAdminTransfer(address to,uint256 value);
}
contract moduleToken is moduleTokenInterface {
struct transferPlanInfo{
uint256 transferValidValue;
bool isInfoValid;
} | 0 |
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 constant returns (uint256);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract ICrowdsaleProcessor is Ownable, HasManager {
modifier whenCrowdsaleAlive() {
require(isActive());
_;
} | 0 |
function createToken() external payable {
uint256 tokenId = totalTokens + 1;
require(memeData[tokenId].price == 0);
require(msg.value == submissionPrice);
submissionPool += submissionPrice;
endingBalance = address(this).balance;
memeData[tokenId] = Meme(1 ether / 100, msg.sender, msg.sender);
_mint(msg.sender, tokenId);
emit Creation(msg.sender, tokenId, block.timestamp);
} | 0 |
function isLiquidating()
public
view
returns (bool)
{
return liquidationTimestamp <= now;
} | 0 |
function safeDiv(uint a, uint b) internal constant returns (uint) {
require(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
} | 0 |
modifier pendingAddressChangeRequest(address target) {
require(addressChangeRequests[target] != address(0));
_;
} | 0 |
function addLifeEvent(string name, string description, string mesg) public{
require(msg.sender == owner || msg.sender == partner1_address || msg.sender == partner2_address);
saveLifeEvent(name, description, mesg);
} | 0 |
function _processPurchase(address _beneficiary, uint256 _tokenAmount) internal {
_deliverTokens(_beneficiary, _tokenAmount);
} | 0 |
function getisPlay(bytes32 secretKey_D_hash) public constant returns (bool isplay){
return TicketPool[secretKey_D_hash].isPlay;
} | 0 |
function name() constant returns (string) {
return _name;
} | 0 |
function outstandingPower() constant returns (uint256);
function authorizedPower() constant returns (uint256);
function powerTotalSupply() constant returns (uint256);
function powerUp(address _sender, address _from, uint256 _amountBabz) public;
function downTick(address _owner, uint256 _now) public;
function createDownRequest(address _owner, uint256 _amountPower) public;
function downs(address _owner) constant public returns(uint256, uint256, uint256);
function downtime() constant returns (uint256);
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
} | 0 |
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 getNow() internal constant returns (uint256) {
return now;
} | 1 |
function cancel( uint id )
can_cancel(id)
exclusive
returns ( bool success )
{
OfferInfo memory offer = offers[id];
delete offers[id];
var seller_refunded = offer.sell_which_token.transfer( offer.owner , offer.sell_how_much );
assert(seller_refunded);
ItemUpdate(id);
success = true;
} | 0 |
constructor() ERC20Token(21000000,"AaronTestCoin","ATC") public {
} | 0 |
function withdraw()
public
vestingScheduleConfirmed(msg.sender)
pastCliffTime(msg.sender)
{
VestingSchedule storage vestingSchedule = schedules[msg.sender];
uint totalAmountVested = getTotalAmountVested(vestingSchedule);
uint amountWithdrawable = safeSub(totalAmountVested, vestingSchedule.totalAmountWithdrawn);
vestingSchedule.totalAmountWithdrawn = totalAmountVested;
if (amountWithdrawable > 0) {
require(vestingToken.transfer(msg.sender, amountWithdrawable));
emit Withdrawal(msg.sender, amountWithdrawable);
}
} | 0 |
function buy() inICOtimeframe payable public {
uint amount = msg.value * (10 ** uint256(decimals)) / buyPrice;
_transfer(this, msg.sender, amount);
paidIn[msg.sender] += msg.value;
} | 0 |
function balanceInWei() public constant returns(uint256 nowBalanceInWei){
return address(this).balance;
} | 0 |
function deposit(address investor) public onlyOwner payable{
deposited[investor] = deposited[investor].add(msg.value);
} | 0 |
function sellEggs() public{
require(initialized);
uint256 hasEggs=getMyEggs();
uint256 eggValue=calculateEggSell(hasEggs);
uint256 fee=devFee(eggValue);
claimedEggs[msg.sender]=0;
lastHatch[msg.sender]=now;
marketEggs=SafeMath.add(marketEggs,hasEggs);
hatcheryShrimp[msg.sender]=SafeMath.div(SafeMath.mul(hatcheryShrimp[msg.sender],3),4);
ceoAddress.transfer(fee);
msg.sender.transfer(SafeMath.sub(eggValue,fee));
} | 0 |
function manualMint(address receiver, uint256 _value) public onlyOwner{
require(!stopped, "CrowdSale is stopping");
mint(owner, receiver, _value);
} | 0 |
function executeLock(bytes16 lockID, address issuer) returns(bool success) {
if(msg.sender == lockedMoney[lockID].executingBond){
balances[issuer][lockedMoney[lockID].currencyAndBank] += lockedMoney[lockID].amount;
delete lockedMoney[lockID];
return true;
}else
return false;
} | 0 |
function updateFirstActiveGamble() private
{
for (uint k=firstActiveGamble; k<=firstActiveGamble+50; k++)
{
if (k>=gambles.length || !gambles[k].spinned)
{
firstActiveGamble=k;
break;
}
}
} | 0 |
function claimTokens() external {
uint8 category = uint8(userCategory[msg.sender]);
uint256 tokensToClaim;
if (category == 1 || category == 2 || category == 3) {
tokensToClaim = seedPrivateAdvisorVesting.claimTokens(msg.sender);
} else if (category == 4) {
tokensToClaim = teamVesting.claimTokens(msg.sender);
} else if (category == 5) {
tokensToClaim = communityVesting.claimTokens(msg.sender);
} else if (category == 6){
tokensToClaim = ecosystemVesting.claimTokens(msg.sender);
} else {
revert( "incorrect category, maybe unknown user" );
}
totalAllocated = totalAllocated.sub(tokensToClaim);
require(token.transfer(msg.sender, tokensToClaim), "Insufficient balance in vesting contract");
emit TokensReleased(msg.sender, tokensToClaim, userCategory[msg.sender]);
} | 0 |
function _transfer(address _from, address _to, uint _value) internal {
require(_to != address(0x0));
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value >= balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
} | 0 |
function setWithdrawal(address drawer, uint256 weiAmount) internal returns (bool success) {
if ((drawer != address(0)) && (weiAmount > 0)) {
uint256 oldBalance = pendingWithdrawals[drawer];
uint256 newBalance = oldBalance + weiAmount;
if (newBalance > oldBalance) {
pendingWithdrawals[drawer] = newBalance;
Withdrawal(drawer, weiAmount);
return true;
}
}
return false;
} | 0 |
function buy() onTime payable {
uint numTokens = safeDiv(safeMul(msg.value, getRate(msg.value)), 1 ether);
assert(tokensIssued + numTokens <= limit);
ethWallet.transfer(msg.value);
balance[msg.sender] += numTokens;
tokensIssued += numTokens;
e_Purchase(msg.sender, numTokens);
} | 0 |
function signedTransferHash(address tokenOwner, address to, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash) {
return data.signedTransferHash(tokenOwner, to, tokens, fee, nonce);
} | 0 |
function allowance(address _owner, address _spender) constant returns (uint remaining)
{
return allowed[_owner][_spender];
} | 0 |
function buyTokens() public payable {
address inv = msg.sender;
uint256 weiAmount = msg.value;
require(weiAmount >= minPurchase);
uint256 rate;
uint256 tokens;
uint256 cleanWei;
uint256 change;
if (now > preIcoStartTime && now < (preIcoStartTime + 7 days)) {
rate = preIcoRate;
} else if (now > icoStartTime && now < (icoStartTime + 30 days)) {
rate = icoRate;
}
require(rate > 0);
tokens = (weiAmount.mul(1E18)).div(rate);
if (tokensSold.add(tokens) > hardCap) {
tokens = hardCap.sub(tokensSold);
cleanWei = tokens.mul(rate).div(1E18);
change = weiAmount.sub(cleanWei);
} else {
cleanWei = weiAmount;
}
if (investors[inv] == 0) {
investorsArray.push(inv);
investors[inv] = tokens;
} else {
investors[inv] = investors[inv].add(tokens);
}
tokensSold = tokensSold.add(tokens);
weiRaised = weiRaised.add(cleanWei);
token.transfer(inv, tokens);
if (change > 0) {
inv.transfer(change);
}
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.