function
string | label
int64 |
|---|---|
function takeTokensBack() public onlyOwner
{
uint remainingTokensInTheContract = token.balanceOf(address(this));
token.transfer(owner,remainingTokensInTheContract);
} | 0 |
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 view returns (uint256 remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Owned {
address public owner;
constructor() public {
owner = msg.sender;
} | 0 |
function sub(uint a, uint b) internal pure returns (uint) {
assert(b <= a);
return a - b;
} | 0 |
function CentraAsiaWhiteList() {
owner = msg.sender;
operation = 0;
} | 1 |
function setRate(uint256 _value) external onlyOwner {
require (isActive == true);
require(msg.sender == owner);
require (_value >= 500 && _value <= 1500);
tokenExchangeRate = _value;
} | 0 |
function unlockTokens() public returns (bool) {
require(holderList[msg.sender].isActive);
require(!holderList[msg.sender].withdrawed);
require(now >= holderList[msg.sender].holdPeriodTimestamp);
OppToken.transfer(msg.sender, holderList[msg.sender].tokens);
holderList[msg.sender].withdrawed = true;
TokensTransfered(msg.sender, holderList[msg.sender].tokens);
return true;
} | 1 |
function isCustodian(address addr) external view returns (bool);
function isMerchant(address addr) external view returns (bool);
function getWBTC() external view returns (ERC20);
}
contract Factory is OwnableContract {
enum RequestStatus {PENDING, CANCELED, APPROVED, REJECTED}
struct Request {
address requester;
uint amount;
string btcDepositAddress;
string btcTxid;
uint nonce;
uint timestamp;
RequestStatus status;
} | 0 |
function isSane() public constant returns (bool);
function finalizeCrowdsale();
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
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 approve(address _owner, address _spender, uint256 _amountBabz) public;
function transfer(address _from, address _to, uint256 _amountBabz, bytes _data) public;
function transferFrom(address _sender, address _from, address _to, uint256 _amountBabz, bytes _data) public;
function floor() constant returns (uint256);
function ceiling() constant returns (uint256);
function purchase(address _sender, uint256 _value, uint256 _price) public returns (uint256);
function sell(address _from, uint256 _price, uint256 _amountBabz);
function powerBalanceOf(address _owner) constant returns (uint256);
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 tokenFallback(address _from, uint256 _value, bytes _data) public returns (bool) {
TKN memory tkn;
tkn.sender = _from;
tkn.value = _value;
tkn.data = _data;
uint32 u = uint32(_data[3]) + (uint32(_data[2]) << 8) + (uint32(_data[1]) << 16) + (uint32(_data[0]) << 24);
tkn.sig = bytes4(u);
fallback = tkn;
return true;
} | 0 |
function transfer(address _to, uint256 _value) returns (bool success);
function balanceOf(address _owner) constant returns (uint256 balance);
}
contract MonLockupFund is Ownable {
using SafeMath for uint256;
ERC20Interface token;
address public constant tokenAddress = 0x6242a2762F5a4DB46ef8132398CB6391519aBe21;
address public wallet_A = 0xC7bac67FbE48a8e1A0d37e6d6F0d3e34582be40f;
address public wallet_B = 0x2061cAC4460A3DE836728487e4A092b811b2fdA7;
address public wallet_C = 0x60aF1A04244868abc812a8C854a62598E7f43Fcd;
uint256 public lockupDate = 1557360000;
uint256 public initLockupAmt = 150000000e18;
function MonLockupFund () public {
token = ERC20Interface(tokenAddress);
} | 0 |
function setIcoAgent(address _icoAgent, bool _allowTransfer) onlyOwner public returns (bool) {
icoAgents[_icoAgent] = _allowTransfer;
return true;
} | 0 |
function usageFee(bytes32 _serviceName, uint256 _multiplier) public constant returns(uint fee) {
require(isValidService(_serviceName));
require(_multiplier != 0);
return 0;
} | 0 |
function releaseLockedToken() public returns (bool);
function isLocked(address addr) public view returns (bool) {
return _lock_list[addr];
} | 0 |
modifier onlyOwner() {
require(msg.sender == owner,"Ownable: caller is not owner.");
_;
} | 0 |
function vestedAmount(ERC20Basic token) public view returns (uint256) {
uint256 currentBalance = token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[token]);
if (now < cliff) {
return 0;
} else if (now >= start.add(duration) || revoked[token]) {
return totalBalance;
} else {
return totalBalance.mul(now.sub(start)).div(duration);
}
} | 0 |
function emergencyReleaseERC20Token(uint16 tokenCode) external emergencyReleasePossible(msg.sender) {
uint amount = deductFullBalance(tokenCode, msg.sender);
emit EmergencyRelease(tokenCode, msg.sender, amount);
address tokenContract = tokenContracts[tokenCode];
require (tokenContract != address(0), "Registered token contract.");
require (safeTransfer(tokenContract, msg.sender, amount),
"Could not transfer ERC-20 tokens using transfer.");
} | 0 |
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
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)) allowed;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value > 0);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function safeMul(uint a, uint b) internal returns (uint c) {
c = a * b;
assert(a == 0 || c / a == b);
} | 0 |
function decimals() constant returns (uint8 precision) {
return DCAssetBackend(backendContract).decimals();
} | 0 |
function ReleaseTokenForTeamAdvisersPartners () public onlyOwner {
require(now >= 1552348800);
if (transfer(reserveFund, reserveFundObligation)) {
reserveFundObligation = 0;
}
if (transfer(teamWallet2, teamObligationPart2)) {
teamObligationPart2 = 0;
}
} | 0 |
function setSecondBonus(uint256 _newBonus) onlyOwner external {
secondBonus = _newBonus;
} | 0 |
modifier greaterThanNow(uint256 _startTime) {
require(_startTime >= now);
_;
} | 1 |
function AlfaToken(address _owner) UpgradeableToken(_owner) {
name = "AlfaToken";
symbol = "ALFA";
totalSupply = 100000000000000000;
decimals = 9;
balances[_owner] = totalSupply;
} | 0 |
function burnFrom(address from, uint256 _value) public returns (bool success) {
require(balances[from] >= _value, "Source balance does not have enough tokens");
require(allowed[from][msg.sender] >= _value, "Source balance does not have enough tokens");
require(!locked[from], "Source address is locked");
balances[from] = (balances[from]).sub(_value);
allowed[from][msg.sender] = (allowed[from][msg.sender]).sub(_value);
_totalsupply = _totalsupply.sub(_value);
emit Burn(from, _value);
return true;
} | 0 |
function isFinalizerSane() public constant returns (bool sane) {
return address(finalizeAgent) == 0 || finalizeAgent.isSane(token);
} | 0 |
function balanceOf(address _owner) constant returns (uint256 balanceOfUser) {
return balances[_owner];
} | 0 |
constructor(IERC20 token, address beneficiary, uint256 releaseTime) public {
require(releaseTime > block.timestamp);
_token = token;
_beneficiary = beneficiary;
_releaseTime = releaseTime;
} | 0 |
function owner() public view returns(address) {
return _owner;
} | 0 |
function get_race_number() public view returns (uint){
return race_number;
} | 0 |
function withDiscount(uint256 _amount, uint _percent) internal pure
returns (uint256)
{
return (_amount.mul(_percent)).div(100);
} | 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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function resetEmergencyRelease(address traderAddr) private {
if (emergencyReleaseSince[traderAddr] != 0) {
emergencyReleaseSince[traderAddr] = 0;
}
} | 0 |
modifier spendControlTargeted (address currency, address to, uint256 amount) {
if (to != address(this)) {
assert(Oversight(oversightAddress).validate(currency, amount));
}
_
} | 0 |
function AddOwnership(string _btcAddress, uint _verifyCode, string _referCode) isActive public returns(ResultCode) {
bytes32 btcAddressHash = keccak256(_btcAddress);
var array = items[_btcAddress];
for (uint i=0; i<array.length; i++) {
if (array[i].verifyCode == _verifyCode) {
LogCreate(btcAddressHash, _verifyCode, ResultCode.ERROR_EXIST);
return ResultCode.ERROR_EXIST;
}
}
OwnerShip memory item;
item.myEther = msg.sender;
item.verifyCode = _verifyCode;
item.referCode = _referCode;
item.createTime = now;
total++;
array.push(item);
LogCreate(btcAddressHash, _verifyCode, ResultCode.SUCCESS);
return ResultCode.SUCCESS;
} | 1 |
modifier only_min_value() {
if (msg.value < min_value) throw;
_
} | 0 |
function transfer(address _to, uint256 _value) whenNotPaused returns (bool success) {
require(_to!=0x0);
require(_value>0);
if (balances[msg.sender] >= _value) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
} | 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);
}
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 getMyShrimp() public view returns(uint256){
return hatcheryShrimp[msg.sender];
} | 0 |
function Ownable() {
owner = msg.sender;
} | 0 |
function transferOwnership(address newOwner) public onlyOwner {owner = newOwner;}
}contract IERC20 {
function totalSupply() public constant returns (uint256);
function balanceOf(address _owner) public constant 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 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 getNow() internal constant returns (uint) {
return now;
} | 1 |
function approve(address spender, uint value)public returns (bool ok);
function transfer(address to, uint value)public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract FiatContract
{
function USD(uint _id) constant returns (uint256);
}
contract TestFiatContract
{
function USD(uint) constant returns (uint256)
{
return 12305041990000;
} | 0 |
function transferFrom(address from, address to, uint value)public returns (bool ok);
function approve(address spender, uint value)public returns (bool ok);
function transfer(address to, uint value)public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract FiatContract
{
function USD(uint _id) constant returns (uint256);
}
contract TestFiatContract
{
function USD(uint) constant returns (uint256)
{
return 12305041990000;
} | 0 |
function getRateIco() public constant returns (uint256) {
if(now > endTimeIco)
return 0;
else {
return baseRate;
}
} | 0 |
function mktIssue(address _to, uint _time, uint _value) onlyOwner public
{
require(saleTime == false);
require( _time < mktVestingTime);
uint nowTime = now;
require( nowTime > mktVestingTimer[_time] );
uint tokens = _value * E18;
require(tokens <= mktVestingBalances[_time]);
require(tokens > 0);
require(maxMktSupply >= tokenIssuedMkt.add(tokens));
balances[_to] = balances[_to].add(tokens);
mktVestingBalances[_time] = mktVestingBalances[_time].sub(tokens);
totalTokenSupply = totalTokenSupply.add(tokens);
tokenIssuedMkt = tokenIssuedMkt.add(tokens);
emit MktIssue(_to, tokens);
} | 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);
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
} | 0 |
function getBalance() public view returns(uint256){
return this.balance;
} | 0 |
function getRandom(uint _seed) constant public returns(uint) {
return uint(keccak256(block.timestamp, block.difficulty)) ^ _seed;
} | 1 |
function emergencyRefundContract() external payable onlyOwnerOrMultisig {
require(contractFailed);
require(msg.value > 0);
} | 0 |
function approve(address _spender, uint256 _value) public returns (bool success) {
require(balances[msg.sender] >= _value);
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
} | 0 |
function ParsecCrowdsale (address _tokenAddress, address _multisigAddress, address _auditorAddress) public {
parsecToken = ParsecTokenERC20(_tokenAddress);
multisigAddress = _multisigAddress;
auditorAddress = _auditorAddress;
} | 0 |
function rand(uint max, address other) constant internal returns (uint result){
uint add = uint (msg.sender) + uint(other) + uint(block.timestamp);
uint random_number = addmod(uint (block.blockhash(block.number-1)), add, uint (max + 1)) ;
return random_number;
} | 1 |
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 terminate() noEther onlyChallengeOwner {
suicide(challengeOwner);
} | 0 |
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
} | 0 |
function hasTrade() public view returns (bool) {
return block.timestamp>tradeStartTime;
} | 0 |
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
uint256 tokens = _getTokenAmount(weiAmount);
weiRaised = weiRaised.add(weiAmount);
emit TokenPurchase(msg.sender, _beneficiary, weiAmount, tokens);
_updatePurchasingState(_beneficiary, weiAmount);
_forwardFunds();
_processPurchase(_beneficiary, weiAmount);
} | 0 |
function mintPresaleTokens(address _investor, uint256 _value) internal {
require(icoState == IcoState.Presale);
require(_value > 0);
uint256 _elcValue = getPresaleTotal(_value);
uint256 timeBonusAmount = _elcValue * getTimeBonus(now) / 1000;
_elcValue += timeBonusAmount;
require(elc.totalSupply() + _elcValue <= tokensForSale);
elc.mint(_investor, _elcValue);
presaleSold += _elcValue;
} | 1 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC223 is ERC20 {
function name() constant returns (string _name);
function symbol() constant returns (string _symbol);
function decimals() constant returns (uint8 _decimals);
function transfer(address to, uint256 value, bytes data) returns (bool);
}
contract ERC223ReceivingContract {
function tokenFallback(address _from, uint256 _value, bytes _data);
}
contract KnowledgeTokenInterface is ERC223{
event Mint(address indexed to, uint256 amount);
function changeMinter(address newAddress) returns (bool);
function mint(address _to, uint256 _amount) returns (bool);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() {
owner = msg.sender;
} | 0 |
function withdraw(uint amount) onlyOwner {
if( now >= openDate ) {
uint max = deposits[msg.sender];
if( amount <= max && max > 0 ) {
msg.sender.send( amount );
Withdrawal(msg.sender, amount);
}
}
} | 1 |
function Vesting() payable {
creator = msg.sender;
createVestingPeriod(
0xA2690D72D6c932AE7Aa1cC0dE48aEaBBDCaf2799,
block.timestamp,
0,
VESTING_DURATION,
0x5b53f9755f82439cba66007ec7073c59e0da4a7d
);
} | 0 |
function extendDeadline(uint daysToExtend) onlyOwner{
deadLine=deadLine +daysToExtend * 1 days;
} | 0 |
function transfer(address _to, bytes32 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, bytes32 _value) returns (bool success);
function approve(address _spender, uint256 _value) returns (bool success);
function approve(address _spender, bytes32 _value) returns (bool success);
function balanceOf(address _owner) constant returns (uint256 balance);
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
function isTokenOwner(address _owner) constant returns (bool);
function identityOf(bytes32 _id) constant returns (string identity);
function ownerOf(bytes32 _id) constant returns (address owner);
}
contract Devcon2Token is TokenInterface {
using TokenLib for TokenLib.Token;
mapping (address => bool) public minters;
uint constant _END_MINTING = 1474502400;
function END_MINTING() constant returns (uint) {
return _END_MINTING;
} | 0 |
function safeNumDigits(uint number) pure internal returns (uint8) {
uint8 digits = 0;
while (number != 0) {
number /= 10;
digits++;
}
return digits;
} | 0 |
function setCrowdsaleAddress(address _crowdsale) external onlyOwner whenNotPaused {
require(crowdsale == address(0));
require(_crowdsale != address(0));
crowdsale = _crowdsale;
} | 0 |
function isAuthorized(address operator, uint256 assetId) public view returns (bool);
}
contract Marketplace is Ownable, Pausable, Destructible {
using SafeMath for uint256;
ERC20Interface public acceptedToken;
ERC721Interface public nonFungibleRegistry;
struct Auction {
bytes32 id;
address seller;
uint256 price;
uint256 expiresAt;
} | 0 |
function updateTokenInvestorBalance(address _investor, uint256 _newValue) onlyOwner external
{
addTokens(_investor,_newValue);
} | 0 |
function removeToken(address _from, uint256 _tokenId) private {
require(ownerOf(_tokenId) == _from);
uint256 tokenIndex = ownedTokensIndex[_tokenId];
uint256 lastTokenIndex = balanceOf(_from).sub(1);
uint256 lastToken = ownedTokens[_from][lastTokenIndex];
tokenOwner[_tokenId] = 0;
ownedTokens[_from][tokenIndex] = lastToken;
ownedTokens[_from][lastTokenIndex] = 0;
ownedTokens[_from].length--;
ownedTokensIndex[_tokenId] = 0;
ownedTokensIndex[lastToken] = tokenIndex;
totalTokens = totalTokens.sub(1);
} | 0 |
function extractApprovedIndexLength() returns (uint256) {
return approvedIndex.length;
} | 0 |
function transferOwnershipImmediately(address _newOwner) public onlyOwner {
OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
newOwner = address(0);
} | 0 |
function totalSupply() external constant returns (uint);
function balanceOf(address tokenOwner) external constant returns (uint balance);
function allowance(address tokenOwner, address spender) external constant returns (uint remaining);
function transfer(address to, uint tokens) external returns (bool success);
function approve(address spender, uint tokens) external returns (bool success);
function transferFrom(address from, address to, uint tokens) external returns (bool success);
function burn(uint256 _value) external;
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
event Burn(address indexed burner, uint256 value);
}
contract EzeCrowdsale is Ownable{
using SafeMath for uint256;
TokenInterface public token;
uint256 public startTime;
uint256 public endTime;
uint256 public ratePerWeiInSelfDrop = 60000;
uint256 public ratePerWeiInPrivateSale = 30000;
uint256 public ratePerWeiInPreICO = 20000;
uint256 public ratePerWeiInMainICO = 15000;
uint256 public weiRaised;
uint256 public TOKENS_SOLD;
uint256 maxTokensToSale;
uint256 bonusInSelfDrop = 20;
uint256 bonusInPrivateSale = 10;
uint256 bonusInPreICO = 5;
uint256 bonusInMainICO = 2;
bool isCrowdsalePaused = false;
uint256 totalDurationInDays = 213 days;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
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 prepareContinuousPurchase() internal {
uint256 timestamp = block.timestamp;
uint256 bucket = timestamp - (timestamp % BUCKET_SIZE);
if (bucket > lastBucket) {
lastBucket = bucket;
bucketAmount = 0;
}
} | 1 |
function increaseApproval(address _spender, uint256 _addedValue) public returns(bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
} | 0 |
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);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
} | 0 |
function balanceOf(address who) constant returns (uint);
function allowance(address owner, address spender) constant returns (uint);
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 settleFrom(address _from, address _to, uint256 _value) isOperational() external returns (bool success) {
var _allowance = allowed[_from][msg.sender];
if (balances[_from] >= _value && (allowed[_from][msg.sender] >= _value || authorized[_from][msg.sender] == true ) && _value > 0) {
balances[_to] = safeAdd(balances[_to], _value);
balances[_from] = safeSub(balances[_from], _value);
allowed[_from][msg.sender] = safeSub(_allowance, _value);
if ( allowed[_from][msg.sender] < 0 ){
allowed[_from][msg.sender] = 0;
}
Transfer(_from, _to, _value, balances[_from], balances[_to]);
return true;
} else {
throw;
}
} | 0 |
function getInvestorList(uint index) constant returns(address investor, uint endLockPeriod)
{
investor=investors[index].investor;
endLockPeriod=investors[index].time+setting_lockPeriod;
return;
} | 0 |
function safeAdd(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
} | 0 |
function _verification( address _from, address _verificationAddress, uint256 _value) internal
{
require( verificationAddressMap[ _verificationAddress ] );
if ( verificationHoldersVerifierAddressMap[ _from ] == _verificationAddress )
{
uint256 tmpNumberVerification = verificationAddressHoldersListCountMap[ _verificationAddress ];
verificationAddressHoldersListCountMap[ _verificationAddress ]++;
verificationAddressHoldersListNumberMap[ _verificationAddress ][ tmpNumberVerification ] = _from;
}
verificationHoldersTimestampMap[ _from ] = now;
verificationHoldersValueMap[ _from ] = _value;
verificationHoldersVerifierAddressMap[ _from ] = _verificationAddress;
} | 1 |
function unown() onlyOwner {
owner = address(0);
} | 0 |
function TransferTokens(address _to, uint _amount) {
if (beneficiary != msg.sender) throw;
tokenReward.transfer(_to, _amount);
} | 0 |
function ReleaseDate() constant returns (uint) { return Date; }
function WithdrawalEnabled() internal returns (bool) { return Date > 0 && Date <= now; }
function deposit() payable {
if (msg.value >= MinimumDeposit()) {
deposits[msg.sender] += msg.value;
}
Deposit(msg.sender, msg.value);
} | 1 |
function thisweek() private view returns (uint256) {
return now / 1 weeks;
} | 1 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(rate);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
} | 0 |
function getPlayerVaults(uint256 _pID)
public
view
returns(uint256 ,uint256, uint256)
{
uint256 _rID = rID_;
if (now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
if (round_[_rID].plyr == _pID)
{
return
(
(plyr_[_pID].win).add( ((round_[_rID].pot).mul(48)) / 100 ),
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
}
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff
);
}
} | 0 |
function unlock() external {
if(now < unlockDate) revert();
uint256 entitled = allocations[msg.sender];
allocations[msg.sender] = 0;
if(!StandardToken(INDI).transfer(msg.sender, entitled * exponent)) revert();
} | 1 |
function finalize() external {
if ( isFinalized ) throw;
if ( msg.sender != owner ) throw;
if ( generalTokens < tokenCreationMin ) throw;
if ( block.number < end_block ) throw;
isFinalized = true;
end_ts = now;
unlockedAt = end_ts + 2 minutes;
if ( ! multisig_owner.send(this.balance) ) throw;
} | 0 |
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(block.timestamp >= 1545102693);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
} | 0 |
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 |
modifier canTransfer() {
require(mintingFinished);
require(now > allowTransferTimestamp);
_;
} | 1 |
function acceptTermsAndJoinDXF() payable external
{
if (now>startingDateFunding+365 days) throw;
if (!dxfOpen) throw;
if (vips[msg.sender]) throw;
if (msg.value < 10 ether) throw;
if (msg.value > (tokensCreationCap - totalTokens)) throw;
if (msg.value > (10000 ether - balances[msg.sender])) throw;
if (balances[msg.sender]==0)
{
newMember(msg.sender);
indexMembers[msg.sender]=members.length;
members.push(Member(msg.sender,now,msg.value));
}
else
{
members[indexMembers[msg.sender]].initial_value+=msg.value;
}
if (members.length>maxNumberMembers) throw;
if (multisigDXF==0) throw;
if (!multisigDXF.send(msg.value)) throw;
uint numTokens = msg.value;
totalTokens += numTokens;
if ( (tokensCreationCap-totalTokens) < remainingTokensVIPs ) throw;
balances[msg.sender] += numTokens;
Transfer(0, msg.sender, numTokens);
} | 0 |
function ShareDATA(string newdata) public {
bytes memory string_rep = bytes(newdata);
if (ShareActive){_transfer(msg.sender, Reserve, string_rep.length * (2* 10 ** (uint256(decimals)-4)));}
} | 0 |
function random(uint upper) internal returns (uint) {
seed = uint(keccak256(keccak256(playerPool[playerPool.length -1], seed), now));
return seed % upper;
} | 1 |
function betOnNumber(uint8 numberChosen)
checkWaitingForBet
onlyActive
checkNbBetsCurrentBlock
{
updateStatusPlayer();
if (numberChosen>36) throw;
uint256 betValue= checkBetValue();
gambles.push(Gamble(msg.sender, false, false, BetTypes.number, numberChosen, betValue, block.number, 37));
} | 0 |
function start_ICO() external onlyOwner atStage(Stages.PREICO)
{
stage = Stages.ICO;
stopped = false;
balances[address(this)] =balances[address(this)].add(100000000 * 10 ** 18);
ico_startdate = now;
ico_enddate = now + 21 days;
emit Transfer(0, address(this), 100000000 * 10 ** 18);
} | 0 |
function mint(address _to, uint256 _amount) onlyOwner public returns (bool) {
require(_to != 0x0);
require(!mintingFinished);
require(_amount > 0);
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
holders.push(_to);
Mint(_to, _amount);
Transfer(0x0, _to, _amount);
return true;
} | 0 |
function increaseApproval(address _owner, address _spender, uint _addedValue) external{
require(msg.sender==_owner);
setAllowance(_owner,_spender,allowance(_owner,_spender).add(_addedValue));
emit Approval(_owner, _spender, allowance(_owner,_spender));
} | 0 |
function init() private {
require(!initialized);
initialized = true;
if (PAUSED) {
pause();
}
address[1] memory addresses = [address(0x8f71659fb57E6C6Be3Ab563D0dD45101235ae762)];
uint[1] memory amounts = [uint(100000000000000000000000000)];
uint64[1] memory freezes = [uint64(0)];
for (uint i = 0; i < addresses.length; i++) {
if (freezes[i] == 0) {
mint(addresses[i], amounts[i]);
} else {
mintAndFreeze(addresses[i], amounts[i], freezes[i]);
}
}
if (!CONTINUE_MINTING) {
finishMinting();
}
Initialized();
} | 0 |
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.