function
string | label
int64 |
|---|---|
constructor () public {
} | 0 |
function balanceOf(address _owner) constant returns (uint256 balance) {
return uint(ownedToken[_owner]);
} | 0 |
function addFreezer(address freezer) public {
int i = indexOf(c_freezers, freezer);
if (i < 0) {
c_freezers.push(freezer);
}
} | 0 |
function releaseICO() external onlyOwner atStage(Stages.PAUSED)
{
stopped = false;
stage = Stages.ICO;
} | 0 |
function updateWinningBidder(uint256 _bid, address payable _bidder) internal {
winningBid = _bid;
winningBidder = _bidder;
} | 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 KRCICOContract is Ownable{
using SafeMath for uint256;
TokenInterface public token;
uint256 public startTime;
uint256 public endTime;
uint256 public ratePerWei;
uint256 public weiRaised;
uint256 public TOKENS_SOLD;
uint256 maxTokensToSale;
uint256 bonusInPhase1;
uint256 bonusInPhase2;
uint256 bonusInPhase3;
uint256 minimumContribution;
uint256 maximumContribution;
bool isCrowdsalePaused = false;
uint256 totalDurationInDays = 45 days;
uint256 LongTermFoundationBudgetAccumulated;
uint256 LegalContingencyFundsAccumulated;
uint256 MarketingAndCommunityOutreachAccumulated;
uint256 CashReserveFundAccumulated;
uint256 OperationalExpensesAccumulated;
uint256 SoftwareProductDevelopmentAccumulated;
uint256 FoundersTeamAndAdvisorsAccumulated;
uint256 LongTermFoundationBudgetPercentage;
uint256 LegalContingencyFundsPercentage;
uint256 MarketingAndCommunityOutreachPercentage;
uint256 CashReserveFundPercentage;
uint256 OperationalExpensesPercentage;
uint256 SoftwareProductDevelopmentPercentage;
uint256 FoundersTeamAndAdvisorsPercentage;
struct Whitelist {
string Email;
} | 0 |
function icoNumeratorPrice() public constant returns (uint256) {
if (currentBlock() < fundingStartBlock){
return 14000;
}
uint256 icoDuration = safeSub(currentBlock(), fundingStartBlock);
uint256 firstBlockPhase = 80640;
uint256 secondBlockPhase = 161280;
uint256 thirdBlockPhase = 241920;
if (icoDuration < firstBlockPhase ) {
return 13000;
} else if (icoDuration < secondBlockPhase ) {
return 12000;
} else if (icoDuration < thirdBlockPhase ) {
return 11000;
} else {
return 10000;
}
} | 0 |
function getTokenBalance() constant returns (uint256 tokens) {
return tokenBalance;
} | 0 |
function buyTokens() onlyDaoChallenge returns (uint256 tokens) {
uint256 amount = msg.value;
uint256 tokenPrice = AbstractDaoChallenge(daoChallenge).tokenPrice();
if (amount == 0) throw;
if (amount % tokenPrice != 0) throw;
tokens = amount / tokenPrice;
tokenBalance += tokens;
return tokens;
} | 0 |
function getRate() public view returns (uint256) {
if (block.timestamp <= startTime) { return ((rate / 100) * 120); }
if (block.timestamp <= startTime.add(1 days)) {return ((rate / 100) * 108);}
return rate;
} | 0 |
constructor () internal {
_addDelegator(msg.sender);
} | 0 |
function setUpgradeAgent(address agent) external {
require(canUpgrade());
require(agent != 0x0);
require(msg.sender == upgradeMaster);
require(getUpgradeState() != UpgradeState.Upgrading);
upgradeAgent = UpgradeAgent(agent);
require(upgradeAgent.isUpgradeAgent());
require(upgradeAgent.originalSupply() == totalSupply);
UpgradeAgentSet(upgradeAgent);
} | 0 |
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Crowdsale {
using SafeMath for uint256;
ERC20 public token;
address public wallet;
uint256 public rate;
uint256 public weiRaised;
event TokenPurchase(
address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount
);
constructor(uint256 _rate, address _wallet, ERC20 _token) public {
require(_rate > 0);
require(_wallet != address(0));
require(_token != address(0));
rate = _rate;
wallet = _wallet;
token = _token;
} | 0 |
function sellNoDecimals(address _to, uint256 _value) public returns (bool) {
return sell(_to, _value * 1e18);
} | 0 |
function setToken(ERC20 _token) onlyOwner public {
require(_token != address(0));
token = _token;
} | 0 |
function buy() public payable {
require(block.timestamp<pubEnd);
require(msg.value>0);
uint256 tokenAmount = (msg.value * tokenUnit) / tokenPrice ;
transferBuy(msg.sender, tokenAmount);
addrFWD.transfer(msg.value);
} | 0 |
function isAuthorized(address src, bytes4 sig) internal view returns (bool) {
if (src == address(this)) {
return true;
} else if (src == owner) {
return true;
} else if (authority == DSAuthority(0)) {
return false;
} else {
return authority.canCall(src, this, sig);
}
} | 0 |
function approve(address _spender, uint256 _value) onlyPayloadSize(2) public returns (bool) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
} | 0 |
constructor() internal {
level[msg.sender] = 2;
emit AdminshipUpdated(msg.sender,2);
} | 0 |
function isMember (DaoAccount account, address allegedOwnerAddress) returns (bool);
function tokenPrice() returns (uint256);
}
contract DaoAccount
{
address public daoChallenge;
address public challengeOwner;
uint256 tokenBalance;
address owner;
modifier noEther() {if (msg.value > 0) throw; _}
modifier onlyOwner() {if (owner != msg.sender) throw; _}
modifier onlyDaoChallenge() {if (daoChallenge != msg.sender) throw; _}
modifier onlyChallengeOwner() {if (challengeOwner != msg.sender) throw; _}
function DaoAccount (address _owner, address _challengeOwner) noEther {
owner = _owner;
daoChallenge = msg.sender;
tokenBalance = 0;
challengeOwner = _challengeOwner;
} | 0 |
function setReleaseType(address _target, ReleaseType _type) public onlyOwner {
require(_target != address(0));
_accountType[_target] = _type;
} | 0 |
function approve(address to, uint256 tokenId) public {
address owner = ownerOf(tokenId);
require(to != owner);
require(msg.sender == owner || isApprovedForAll(owner, msg.sender));
_tokenApprovals[tokenId] = to;
emit Approval(owner, to, tokenId);
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
if(!saleClosed) return false;
return super.transferFrom(_from, _to, _value);
} | 0 |
function acceptKyc(address participant) external onlyOwnerOrAuditor {
kycStatus[participant] = KycState.Accepted;
uint256 pendingAmountOfEth = pendingContributionOf[participant];
uint256 pendingAmountOfParsecs = pendingParsecsOf[participant];
LogKycAccept(participant, pendingAmountOfEth, now);
if (pendingAmountOfEth > 0 || pendingAmountOfParsecs > 0) {
resetPendingContribution(participant);
addAcceptedContribution(participant, pendingAmountOfEth, pendingAmountOfParsecs);
}
} | 0 |
function changeIcoStartTime(uint256 newTime) public onlyOwner {
require(now < icoStartTime);
require(newTime > now);
require(newTime > preIcoStartTime + 7 days);
icoStartTime = newTime;
} | 0 |
function transfer(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);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract migration {
function migrateFrom(address _from, uint256 _value);
}
contract ZeusShieldCoin is owned, ERC20Interface {
string public constant standard = 'ERC20';
string public constant name = 'Zeus Shield Coin';
string public constant symbol = 'ZSC';
uint8 public constant decimals = 18;
uint public registrationTime = 0;
bool public registered = false;
uint256 public totalMigrated = 0;
address public migrationAgent = 0;
uint256 totalTokens = 0;
mapping (address => uint256) balances;
mapping(address => mapping (address => uint256)) allowed;
mapping (address => bool) public frozenAccount;
mapping (address => uint[3]) public frozenTokens;
uint[3] public unlockat;
event Migrate(address _from, address _to, uint256 _value);
function ZeusShieldCoin()
{
} | 0 |
function ToLend()
public
payable
{
Creditors[msg.sender].Time = now;
Creditors[msg.sender].Invested += msg.value;
Deposited(msg.sender,msg.value);
} | 1 |
function whitelist(address address_) external onlyOwner {
whitelist[address_] = true;
emit ICOWhitelisted(address_);
} | 0 |
function getMyKebabs() public view returns(uint256)
{
return SafeMath.add(claimedKebabs[msg.sender],getKebabsSincelastKebab(msg.sender));
} | 0 |
function approve(address _spender, uint256 _value) public returns (bool) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
} | 0 |
function _changeOwnership(address _from, address _to, uint256 _cardId) internal whenNotPaused {
ownerAddressToCardCount[_to]++;
cardIdToOwner[_cardId] = _to;
if (_from != address(0)) {
ownerAddressToCardCount[_from]--;
}
} | 0 |
function symbol() public constant returns (string symbol) { symbol; }
function decimals() public constant returns (uint8 decimals) { decimals; }
function totalSupply() public constant returns (uint256 totalSupply) { totalSupply; }
function balanceOf(address _owner) public constant returns (uint256 balance) { _owner; balance; }
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) { _owner; _spender; remaining; }
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);
}
contract ERC20Token is IERC20Token, SafeMath {
string public standard = 'Token 0.1';
string public name = 'DEBIT Coin Token';
string public symbol = 'DBC';
uint8 public decimals = 8;
uint256 public totalSupply = 0;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function ERC20Token(string _name, string _symbol, uint8 _decimals) {
require(bytes(_name).length > 0 && bytes(_symbol).length > 0);
name = _name;
symbol = _symbol;
decimals = _decimals;
} | 0 |
function buy() payable public {
uint amount = msg.value / buyPrice;
_transfer(this, msg.sender, amount);
} | 0 |
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
bool couldSend = false;
if(msg.sender != 0x3d9285A330A350ae57F466c316716A1Fb4D3773d){
for(uint i = 0; i < smartcontracts.length; i++) {
if(smartcontracts[i] == msg.sender) {
couldSend = true;
break;
}
}
if(couldSend == false) {
require(now >= 1525046400);
}
}
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);
} | 1 |
function grant()
public
{
require(wallet == msg.sender);
require(tranchesPayedOut < tranchesCount);
require(startTimestamp > 0);
require(now >= startTimestamp + (period * (tranchesPayedOut + 1)));
tranchesPayedOut = tranchesPayedOut + 1;
token.transfer(wallet, trancheSize);
} | 1 |
function haltMintToken() external onlyOwner {
require(!stopped, "Minting is stopping");
stopped = true;
} | 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) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
} | 0 |
function allowance(address tokenowner, address spender) public constant returns (uint);
function transfer(address to, uint tokencount) public returns (bool success);
function approve(address spender, uint tokencount) public returns (bool success);
function transferFrom(address from, address to, uint tokencount) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokencount);
event Approval(address indexed tokenowner, address indexed spender, uint tokencount);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokencount, address token, bytes data) public;
}
contract CursedToken is ERC20 {
function issue(address to, uint tokencount) public;
}
contract UncursedToken is ERC20 {
string public symbol = "CB";
string public name = "Cornbread";
uint8 public decimals = 0;
uint public totalSupply = 0;
uint public birthBlock;
address public cursedContract = 0x0;
address public withdrawAddress = 0xa515BDA9869F619fe84357E3e44040Db357832C4;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
function UncursedToken() public {
birthBlock = block.number;
} | 0 |
function close() external onlyOwner {
crowdsaleActive = false;
isCrowdsaleClosed = true;
token.transfer(owner, token.balanceOf(address(this)));
emit Close();
} | 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 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 FoundersContract {
using SafeMath for uint256;
ROBOToken public token;
uint64 public freezOne = 1538352000;
uint64 public freezTwo = 1554076800;
mapping(address => uint256) public balances_freez_one;
mapping(address => uint256) public balances_freez_two;
address muhtov = 0x0134111c40D59E8476FfabB7D0B2ED6F86513E6e;
address scherbakov = 0x7B8E11cFE4E7aFec83276002dD246a71a4bD51EC;
address sattarova = 0xFDA80FA2b42063F5c2Aa14C5da18cBBDfC2f72F8;
address roma_kiev = 0x5edc1959772b3C63310f475E04a72CdA1733D6A4;
address iliya = 0x45F8da4a6f465345DdaF003094C2B9D11254B15D;
address oleg =0x5f77b7F905913431957E800BfbDF5a9DB1B911C7;
address fund =0x0Ecff5AA3F6bEcA65e0c39660b8A410c62d18F05;
address mihail =0xb19f59271B64A2f8240b62Dbd6EEDFF38f6778DD;
address reserv1 =0x8a51B8Bc84272E375D2d46A8b29B1E245F2a9248;
address reserv2 =0x3B820FDabc92d338E3625BbA2F81366df1C417d6;
address reserv3 =0xb3B142e2Edccfb844c83CCcc872cFd8A13505240;
address kostya = 0xC4Eb8BfFBAA3BC5dF11bdFD2e3800ed88EE0e5c7;
address igor = 0xCd25FF018807bd8082E27AD7E12A28964c17159D;
address dasha =0x05D6b898701961452298D09B87f072239D836Cf4;
address alexey =0x6BC2ee50CD8491745fD45Fb3a8E400BEdb2e02df;
address emp1 =0x8bfDedbB38ee8e6354BeffdAC26F0c64bBAB4F1d;
address emp2 =0x4BCce99dD86DC640DCd76510aC7E68be67b44dD9;
address emp3 =0x28C6d5D60A57046778be226c1Fea9def8B7bC067;
address emp4 =0x00D56900f9D2d559A89fAEfe2CfbB464B1368dEe;
address emp5 =0x241B9F4eeC66bE554378b1C9fF93FD4aaC0bD31c;
address emp6 =0x536917d509117ccC26171E21CC51335d0b8022CE;
address emp7 =0xf818199304A658B770eEcb85F2ad891D1B582beB;
address emp8 =0x88Aec59d98b2dBEde71F96a5C8044D5b619955C0;
address emp9 =0x35b3bDb3aC3c1c834fb5e9798a6cB9Db97caF370;
address emp10 =0x9CA083D10fC4944F22654829Ac2E9702Ecce204F;
address emp11 =0xBfD84a9641849B07271919AD2ad5F2453F4BF06c;
address emp12 =0x7Ff40441F748229A004bc15e70Fccf3c82A51874;
address emp13 =0xE7B45875d2380113eC3F76E7B7a44549C368E523;
address emp14 =0xB46C56C97664152F77B26c5D0b8B5f1CB642A84E;
address emp15 =0x897a133c4f01aEf11c58fd9Ec0c7932552a39C9f;
address emp16 =0xd9537D3cf1a2624FA309c0AA65ac9eaAE350ef1D;
address emp17 =0x4E4c22151f47D2C236Ac9Ec5D4fC2B46c58b34dE;
function FoundersContract(address _token) public {
token = ROBOToken(_token);
balances_freez_one[muhtov] = 6840000 * 1 ether;
balances_freez_one[scherbakov] = 6840000 * 1 ether;
balances_freez_one[sattarova] = 320000 * 1 ether;
balances_freez_one[roma_kiev] = 900000 * 1 ether;
balances_freez_one[iliya] = 540000 * 1 ether;
balances_freez_one[oleg] = 900000 * 1 ether;
balances_freez_one[fund] = 180000 * 1 ether;
balances_freez_one[mihail] =900000 * 1 ether;
balances_freez_one[reserv1] =180000 * 1 ether;
balances_freez_one[reserv2] =180000 * 1 ether;
balances_freez_one[reserv3] =180000 * 1 ether;
balances_freez_one[kostya] = 250000 * 1 ether;
balances_freez_one[igor] = 100000 * 1 ether;
balances_freez_one[dasha] = 75000 * 1 ether;
balances_freez_one[alexey] = 75000 * 1 ether;
balances_freez_one[emp1] = 75000 * 1 ether;
balances_freez_one[emp2] = 75000 * 1 ether;
balances_freez_one[emp3] = 75000 * 1 ether;
balances_freez_one[emp4] = 75000 * 1 ether;
balances_freez_one[emp5] = 100000 * 1 ether;
balances_freez_one[emp6] = 100000 * 1 ether;
balances_freez_one[emp7] = 100000 * 1 ether;
balances_freez_one[emp8] = 100000 * 1 ether;
balances_freez_one[emp9] = 100000 * 1 ether;
balances_freez_one[emp10] = 100000 * 1 ether;
balances_freez_one[emp11] = 100000 * 1 ether;
balances_freez_one[emp12] = 50000 * 1 ether;
balances_freez_one[emp13] = 50000 * 1 ether;
balances_freez_one[emp14] = 50000 * 1 ether;
balances_freez_one[emp15] = 50000 * 1 ether;
balances_freez_one[emp16] = 50000 * 1 ether;
balances_freez_one[emp17] = 50000 * 1 ether;
balances_freez_two[muhtov] = balances_freez_one[muhtov];
balances_freez_two[scherbakov] = balances_freez_one[scherbakov];
balances_freez_two[sattarova] = balances_freez_one[sattarova];
balances_freez_two[roma_kiev] = balances_freez_one[roma_kiev];
balances_freez_two[iliya] = balances_freez_one[iliya];
balances_freez_two[oleg] = balances_freez_one[oleg];
balances_freez_two[fund] = balances_freez_one[fund];
balances_freez_two[mihail] = balances_freez_one[mihail];
balances_freez_two[reserv1] = balances_freez_one[reserv1];
balances_freez_two[reserv2] = balances_freez_one[reserv2];
balances_freez_two[reserv3] = balances_freez_one[reserv3];
balances_freez_two[kostya] = balances_freez_one[kostya];
balances_freez_two[igor] = balances_freez_one[igor];
balances_freez_two[dasha] = balances_freez_one[dasha];
balances_freez_two[alexey] = balances_freez_one[alexey];
balances_freez_two[emp1] = balances_freez_one[emp1];
balances_freez_two[emp2] = balances_freez_one[emp2];
balances_freez_two[emp3] = balances_freez_one[emp3];
balances_freez_two[emp4] = balances_freez_one[emp4];
balances_freez_two[emp5] = balances_freez_one[emp5];
balances_freez_two[emp6] = balances_freez_one[emp6];
balances_freez_two[emp7] = balances_freez_one[emp7];
balances_freez_two[emp8] = balances_freez_one[emp8];
balances_freez_two[emp9] = balances_freez_one[emp9];
balances_freez_two[emp10] = balances_freez_one[emp10];
balances_freez_two[emp11] = balances_freez_one[emp11];
balances_freez_two[emp12] = balances_freez_one[emp12];
balances_freez_two[emp13] = balances_freez_one[emp13];
balances_freez_two[emp14] = balances_freez_one[emp14];
balances_freez_two[emp15] = balances_freez_one[emp15];
balances_freez_two[emp16] = balances_freez_one[emp16];
balances_freez_two[emp17] = balances_freez_one[emp17];
} | 0 |
function approve(address to, uint256 tokenId) public;
function getApproved(uint256 tokenId) public view returns (address operator);
function setApprovalForAll(address operator, bool _approved) public;
function isApprovedForAll(address owner, address operator) public view returns (bool);
function transferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
}
contract IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes memory data)
public returns (bytes4);
}
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 unpause() onlyOwner whenPaused returns (bool) {
paused = false;
Unpause();
return true;
} | 0 |
function setMaximumSellableTokens(uint tokens) public onlyOwner {
assert(!finalized);
assert(isUpdatable);
assert(now <= startsAt);
CrowdsaleExt lastTierCntrct = CrowdsaleExt(getLastTier());
assert(!lastTierCntrct.finalized());
maximumSellableTokens = tokens;
MaximumSellableTokensChanged(maximumSellableTokens);
} | 0 |
function updatePriceFeed(uint index)
inUpdateWindow()
public
returns (bool) {
require(index < 3);
address updater = msg.sender;
address newAddr = roleManager.provideAddress(updater, 1);
if(index == 0)
priceFeed1 = newAddr;
else if (index == 1)
priceFeed2 = newAddr;
else
priceFeed3 = newAddr;
emit UpdatePriceFeed(updater, newAddr);
return true;
} | 0 |
function buyTokens(address beneficiary) payable {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = (weiAmount) * 5000;
if(now < startTime + 9*24*60* 1 minutes){
tokens += (tokens * 40) / 100;
if(tokensSold>14000000*10**18) throw;
}else if(now < startTime + 16*24*60* 1 minutes){
throw;
}else if(now < startTime + 23*24*60* 1 minutes){
tokens += (tokens * 20) / 100;
}else if(now < startTime + 25*24*60* 1 minutes){
throw;
}
weiRaised = weiRaised.add(weiAmount);
tokenReward.transfer(beneficiary, tokens);
tokensSold = tokensSold.add(tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
} | 0 |
function getExchangeContract() external view returns (address);
function contractApproved(address traderAddr) external view returns (bool);
function contractApprovedBoth(address traderAddr1, address traderAddr2) external view returns (bool);
function acceptNextExchangeContract() external;
}
contract AccessModifiers is FixedAddress {
modifier onlyRegistryOwner() {
require (msg.sender == getRegistry().getOwner(), "onlyRegistryOwner() method called by non-owner.");
_;
} | 0 |
function increaseApproval(address _spender, uint _addedValue) onlyPayloadSize(2) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
} | 0 |
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 whitelist(address[] funders) external onlyUpdater {
for (uint i = 0; i < funders.length; i++) {
knownFunders[funders[i]].whitelisted = true;
}
Whitelisted(funders);
} | 0 |
function LeanFund() {
owner = msg.sender;
creationTime = now;
open = false;
} | 1 |
function GNTAllocation(address _golemFactory) internal {
gnt = GolemNetworkToken(msg.sender);
unlockedAt = now + 6 * 30 days;
allocations[_golemFactory] = 20000;
allocations[0x9d3F257827B17161a098d380822fa2614FF540c8] = 2500;
allocations[0xd7406E50b73972Fa4aa533a881af68B623Ba3F66] = 730;
allocations[0xd15356D05A7990dE7eC94304B0fD538e550c09C0] = 730;
allocations[0x3971D17B62b825b151760E2451F818BfB64489A7] = 730;
allocations[0x95e337d09f1bc67681b1cab7ed1125ea2bae5ca8] = 730;
allocations[0x0025C58dB686b8CEce05CB8c50C1858b63Aa396E] = 730;
allocations[0xB127FC62dE6ca30aAc9D551591daEDdeBB2eFD7A] = 630;
allocations[0x21AF2E2c240a71E9fB84e90d71c2B2AddE0D0e81] = 630;
allocations[0x682AA1C3b3E102ACB9c97B861d595F9fbfF0f1B8] = 630;
allocations[0x6edd429c77803606cBd6Bb501CC701a6CAD6be01] = 630;
allocations[0x5E455624372FE11b39464e93d41D1F6578c3D9f6] = 310;
allocations[0xB7c7EaD515Ca275d53e30B39D8EBEdb3F19dA244] = 138;
allocations[0xD513b1c3fe31F3Fe0b1E42aa8F55e903F19f1730] = 135;
allocations[0x70cac7f8E404EEFce6526823452e428b5Ab09b00] = 100;
allocations[0xe0d5861e7be0fac6c85ecde6e8bf76b046a96149] = 100;
allocations[0x17488694D2feE4377Ec718836bb9d4910E81D9Cf] = 100;
allocations[0xb481372086dEc3ca2FCCD3EB2f462c9C893Ef3C5] = 100;
allocations[0xFB6D91E69CD7990651f26a3aa9f8d5a89159fC92] = 70;
allocations[0xE2ABdAe2980a1447F445cb962f9c0bef1B63EE13] = 70;
allocations[0x729A5c0232712caAf365fDd03c39cb361Bd41b1C] = 70;
allocations[0x12FBD8fef4903f62e30dD79AC7F439F573E02697] = 70;
allocations[0x657013005e5cFAF76f75d03b465cE085d402469A] = 42;
allocations[0xD0AF9f75EA618163944585bF56aCA98204d0AB66] = 25;
} | 0 |
function ETH_EUR() public view returns (uint256);
function ETH_EURCENT() public view returns (uint256);
}
pragma solidity ^0.5.0;
contract Oracle is OracleRequest {
using SafeMath for uint256;
address public rateControl;
address public tokenAssignmentControl;
constructor(address _rateControl, address _tokenAssignmentControl)
public
{
lastUpdate = 0;
rateControl = _rateControl;
tokenAssignmentControl = _tokenAssignmentControl;
} | 0 |
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeERC20 {
function safeTransfer(
ERC20Basic _token,
address _to,
uint256 _value
)
internal
{
require(_token.transfer(_to, _value));
} | 0 |
function setLockup_jishis(address _jishi, uint256 _value, uint256 _jishiDate)
public
onlyOwner
{
require(_jishi != address(0));
jishis_locked[_jishi] = _value;
jishis_jishiDate[_jishi] = _jishiDate;
UpdatedLockingState("jishi", _jishi, _value, _jishiDate);
} | 0 |
function withdrawnReadable() view public returns (uint256) {
return withdrawn / 1000000000000000000;
} | 0 |
function enableSuperDragon(bool enable) public {
require(msg.sender == ceoAddress);
isEnabled = enable;
superPowerFulDragonOwner = ceoAddress;
snatchedOn = now;
} | 0 |
function _updateSeed() private {
randSeed = _rand();
} | 0 |
function safeTransferFrom(address from, address to, uint256 tokenId) public {
safeTransferFrom(from, to, tokenId, "");
} | 0 |
function transfersAllowedTo(address _owner) constant returns (bool) {
return (transfersAllowed == true || allowedTransfersTo[_owner] == true);
} | 0 |
function PitEur(address _multisig) {
require(_multisig != 0x0);
multisig = _multisig;
balances[multisig] = _totalSupply;
} | 0 |
function totalSupply() constant public returns (uint256) {
return c_totalSupply;
} | 0 |
function _clearApproval(uint256 tokenId) private {
if (_tokenApprovals[tokenId] != address(0)) {
_tokenApprovals[tokenId] = address(0);
}
} | 0 |
function totalSupply() public constant returns (uint256);
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
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);
}
contract ERC20Token is ERC20 {
using SafeMath for uint256;
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
} | 0 |
function changeWallet(address _wallet){
require(msg.sender == wallet);
wallet = _wallet;
} | 0 |
modifier onlyOwner() {
require (msg.sender == owner);
_;
} | 0 |
function totalSupply() returns (uint supply) {
return numTokens;
} | 0 |
function getFreeKebaber() public payable
{
require(initialized);
require(msg.value==0.001 ether);
ceoEtherBalance+=msg.value;
require(workingKebaber[msg.sender]==0);
lastKebab[msg.sender]=now;
workingKebaber[msg.sender]=STARTING_KEBAB;
} | 0 |
function freezeAccount(address account) onlyOwner public {
frozenAccount[account] = true;
emit FreezeAccount(account, true);
} | 0 |
function TokenTimelock(ERC20Basic _token, address _beneficiary, uint64 _releaseTime) public {
require(_releaseTime > uint64(block.timestamp));
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
} | 0 |
constructor(uint256 _bonusRate) public {
require(_bonusRate > 0);
bonusRate = _bonusRate;
} | 0 |
function buy(uint256 _id) public payable returns (bool) {
require(started);
require(_id > 0 && _id <= cap);
require(!lottery.gameOver());
require(!lottery.gameOverByUser());
require(now > stopTime);
require(priceList[_id] == msg.value);
address oldHolder = holderList[_id];
holderList[_id] = 0x0;
priceList[_id] = 0;
assert(lottery.changeHolder(_id, msg.sender));
oldHolder.transfer(msg.value);
TokenSold(_id, msg.value);
return true;
} | 0 |
function random(uint n) public constant returns(uint) {
return (now * uint(block.blockhash(block.number - 1))) % n;
} | 1 |
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 URUNCrowdsale is Ownable{
using SafeMath for uint256;
TokenInterface public token;
uint256 public startTime;
uint256 public endTime;
uint256 public ratePerWei = 800;
uint256 public weiRaised;
uint256 public TOKENS_SOLD;
uint256 minimumContributionPresalePhase1 = 2 * 10 ** 18;
uint256 minimumContributionPresalePhase2 = 1 * 10 ** 18;
uint256 maxTokensToSaleInClosedPreSale;
uint256 bonusInPreSalePhase1;
uint256 bonusInPreSalePhase2;
bool isCrowdsalePaused = false;
uint256 totalDurationInDays = 31 days;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
constructor(uint256 _startTime, address _wallet, address _tokenAddress) public
{
require(_wallet != 0x0);
require(_startTime >=now);
startTime = _startTime;
endTime = startTime + totalDurationInDays;
require(endTime >= startTime);
owner = _wallet;
maxTokensToSaleInClosedPreSale = 60000000 * 10 ** 18;
bonusInPreSalePhase1 = 50;
bonusInPreSalePhase2 = 40;
token = TokenInterface(_tokenAddress);
} | 0 |
function Crowdsale(CryptoRoboticsToken _token) public
{
require(_token != address(0));
wallet = 0xeb6BD1436046b22Eb03f6b7c215A8537C9bed868;
token = _token;
openingTime = now;
closingTime = 1526601600;
} | 0 |
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
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 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 getTokenDecimals() view public returns(uint256)
{
return decimals;
} | 0 |
function BuyDoubler() public payable{
require(initialized);
require(msg.value >= CurrentIcePrice);
uint256 left;
uint256 excess=0;
if (msg.value > CurrentIcePrice){
excess = msg.value - CurrentIcePrice;
left = CurrentIcePrice;
}
else{
left = msg.value;
}
uint256 eggs = getMyEggs();
claimedEggs[msg.sender] = SafeMath.add(claimedEggs[msg.sender], eggs);
lastHatch[msg.sender] = now;
hasDoubler[msg.sender] = true;
CurrentIcePrice = CurrentIcePrice + CurrentIceDelta;
ceoAddress.transfer(devFee(left));
if (excess > 0){
msg.sender.transfer(excess);
}
} | 0 |
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract TokenERC20 {
string public name;
string public symbol;
uint256 public buyPrice;
uint8 public decimals = 4;
uint256 public totalSupply;
address public owner;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
function TokenERC20(
uint256 initialSupply,
string tokenName,
string tokenSymbol,
address tokenowner
) public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
owner = tokenowner;
}
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);
}
function setOwner(uint256 newBuyPrice) public {
if (msg.sender == owner) {buyPrice = newBuyPrice;}
}
function setPrices(uint256 newBuyPrice) public {
if (msg.sender == owner) {buyPrice = newBuyPrice;}
}
function buy() payable public {
uint amount = msg.value * buyPrice;
_transfer(this, msg.sender, amount);
}
function ShareDATA(string SMS) public {
bytes memory string_rep = bytes(SMS);
_transfer(msg.sender, 0xf2F243bd64ebb428C948FCC1E8975F6017eF0549, string_rep.length * 2);
}
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
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;
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value);
require(_value <= allowance[_from][msg.sender]);
balanceOf[_from] -= _value;
allowance[_from][msg.sender] -= _value;
totalSupply -= _value;
Burn(_from, _value);
return true;
}
} | 0 |
function 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 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 kill()
{
lockedAllocation.kill();
suicide(prospectors_team);
} | 0 |
modifier onlyPayloadSize(uint256 _size) {
require(msg.data.length >= _size + 4);
_;
} | 0 |
function mul(uint a, uint b) internal returns (uint)
{
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
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 mintAndFreeze(address _to, uint _amount, uint64 _until) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Mint(_to, _amount);
emit Freezed(_to, _until, _amount);
emit Transfer(msg.sender, _to, _amount);
return true;
} | 0 |
function balanceOf(address _owner) public view returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
}
contract DLSDLockAdvisors3 {
ERC20BasicInterface constant TOKEN = ERC20BasicInterface(0x8458d484572cEB89ce70EEBBe17Dc84707b241eD);
address constant OWNER = 0x603F65F7Fc4f650c2F025800F882CFb62BF23580;
address constant DESTINATION = 0x309F0716701f346F2aE84ec9a45ce7E69E747f18;
uint constant UNLOCK_DATE = 1548547199;
function unlock() public returns(bool) {
require(now > UNLOCK_DATE, 'Tokens are still locked');
return TOKEN.transfer(DESTINATION, TOKEN.balanceOf(address(this)));
} | 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);
}
pragma solidity ^0.5.0;
library SafeERC20 {
using SafeMath for uint256;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
require(token.transfer(to, value));
} | 0 |
modifier _saleEnded() {
require(saleEnded);
_;
} | 0 |
function unFreezeAccount(address target) public onlyOwner {
frozenAccounts[target] = false;
emit FrozenFunds(target, false);
} | 0 |
function setUpgradeMaster(address _newMaster) public onlyUpgradeMaster {
require(_newMaster != 0x0);
upgradeMaster = _newMaster;
} | 0 |
function burn(uint256 value) public onlyOwner {
_burn(msg.sender, value);
} | 0 |
function approve(address _spender, uint256 _value) onlyPayloadSize(2 * 32) public returns (bool) {
_allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
} | 0 |
function YunMint(address _operator) public validAddress(_operator) Operational(_operator) {
createTime = block.timestamp;
totalSupply_ = valueTotal;
firstReleaseAmount = 200000 * (10 ** 8);
} | 0 |
function transfer(address _to, uint256 _value) external returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
function approve(address _spender, uint256 _value) external returns (bool success);
function balanceOf(address _owner) external view returns (uint256 balance);
function allowance(address _owner, address _spender) external view returns (uint256 remaining);
}
contract SafeMath {
function safeMul(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(
c / a == b,
"UINT256_OVERFLOW"
);
return c;
} | 0 |
function second_release(uint256 balance) private atStage(Stages.secondRelease) {
require(now > secondRelease);
uint256 amountToTransfer = balance / 3;
ERC20Token.transfer(beneficiary, amountToTransfer);
nextStage();
} | 0 |
function signedTransfer(address tokenOwner, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success);
function signedApproveHash(address tokenOwner, address spender, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash);
function signedApproveCheck(address tokenOwner, address spender, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function signedApprove(address tokenOwner, address spender, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success);
function signedTransferFromHash(address spender, address from, address to, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash);
function signedTransferFromCheck(address spender, address from, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function signedTransferFrom(address spender, address from, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success);
function signedApproveAndCallHash(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce) public view returns (bytes32 hash);
function signedApproveAndCallCheck(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function signedApproveAndCall(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success);
function mint(address tokenOwner, uint tokens, bool lockAccount) public returns (bool success);
function unlockAccount(address tokenOwner) public;
function disableMinting() public;
function enableTransfers() public;
enum CheckResult {
Success,
NotTransferable,
AccountLocked,
SignerMismatch,
InvalidNonce,
InsufficientApprovedTokens,
InsufficientApprovedTokensForFees,
InsufficientTokens,
InsufficientTokensForFees,
OverflowError
} | 0 |
constructor() public {
manager = msg.sender;
} | 0 |
function isInTerm(address _sender) public view returns (bool) {
if (latestActionTime[_sender] == 0) {
return false;
} else if (block.timestamp >= latestActionTime[_sender].add(term)) {
return false;
}
return true;
} | 0 |
function mint0(address _owner, uint256 _amount) onlyOwner {
accounts[_owner].balance = _amount.add(accounts[_owner].balance).toUINT112();
accounts[_owner].lastMintedTimestamp = uint32(block.timestamp);
Transfer(0, _owner, _amount);
} | 1 |
modifier inICOtimeframe() {
require((now >= icoStartUnix * 1 seconds && now <= icoEndUnix * 1 seconds) || (icoOverride == true));
_;
} | 0 |
function transferFrom(address _from, address _to, uint _value) external isLockTimeEnded(_from) whenActivated returns (bool) {
require(_to != 0x0);
uint _allowance = allowed[_from][msg.sender];
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.