function
string | label
int64 |
|---|---|
function increaseApproval(address _spender, uint _addedValue) external whenActivated returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
} | 0 |
function symbol() external view returns (string memory){
return _symbol;
} | 0 |
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint);
function allowance(address tokenOwner, address spender) public constant returns (uint);
function transfer(address to, uint tokens) public returns (bool);
function approve(address spender, uint tokens) public returns (bool);
function transferFrom(address from, address to, uint tokens) public returns (bool);
function name() public constant returns (string);
function symbol() public constant returns (string);
function decimals() public constant returns (uint8);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ERC223 is ERC20Interface {
function transfer(address to, uint value, bytes data) public returns (bool);
event Transfer(address indexed from, address indexed to, uint tokens);
event Transfer(address indexed from, address indexed to, uint value, bytes data);
}
contract NXX is ERC223, Pausable {
using SafeMath for uint256;
using ContractLib for address;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
event Burn(address indexed from, uint256 value);
function NXX() public {
symbol = "NASHXX";
name = "XXXX CASH";
decimals = 18;
totalSupply = 100000000000 * 10**uint(decimals);
balances[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
} | 0 |
function transferOwnership(address _to) onlyOwner public {
require(_to != address(0));
OwnershipTransferred(owner, _to);
owner = _to;
} | 0 |
function removeTokenGrant(uint256 _grantId)
external
onlyV12MultiSig
{
Grant storage tokenGrant = tokenGrants[_grantId];
require(tokenGrant.isActive, "is not active");
address recipient = tokenGrant.recipient;
uint256 daysVested;
uint256 amountVested;
(daysVested, amountVested) = calculateGrantClaim(_grantId);
uint256 amountNotVested = (tokenGrant.amount.sub(tokenGrant.totalClaimed)).sub(amountVested);
require(token.transfer(recipient, amountVested));
require(token.transfer(v12MultiSig, amountNotVested));
tokenGrant.startTime = 0;
tokenGrant.amount = 0;
tokenGrant.vestingDuration = 0;
tokenGrant.vestingCliff = 0;
tokenGrant.daysClaimed = 0;
tokenGrant.totalClaimed = 0;
tokenGrant.recipient = address(0);
tokenGrant.isActive = false;
emit GrantRemoved(recipient, amountVested, amountNotVested);
} | 0 |
function makeLive() onlyOwner public returns (bool) {
require(liveSince == 0);
liveSince = now;
return true;
} | 0 |
function historyCount() public view returns (uint) {
return history.length;
} | 0 |
function isOlderOwner(address identity, address owner) public constant returns (bool) {
return (owners[identity][owner] > 0 && (owners[identity][owner] + adminTimeLock) <= now);
} | 0 |
function investmentEntryCost() constant returns(bool open_position, bool unlocked_position, uint buyout_amount, uint investLockPeriod)
{
if (openPosition!=255) open_position=true;
if (cheapestUnlockedPosition!=255)
{
unlocked_position=true;
buyout_amount=minCurrentInvest;
}
investLockPeriod=setting_lockPeriod;
return;
} | 0 |
function transfer(address to, uint256 tokens) public returns (bool success);
function approve(address spender, uint256 tokens) public returns (bool success);
function transferFrom(address from, address to, uint256 tokens) public returns (bool success);
function mint(address _to, uint256 _amount) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint256 tokens);
}
contract Owned {
address public owner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
} | 0 |
function withdrawal(address wallet) public returns (bool)
{
VestingLib.TeamMember storage member = _members[wallet];
require(member.active, "The team member is not found");
require(member.totalRemainingAmount > 0, "There is no more tokens to transfer to this wallet");
uint256 amountToTransfer = VestingLib._checkAmountForPay(member);
require(totalWibxVestingSupply() >= amountToTransfer, "The contract doesnt have founds to pay");
uint256 nextWithdrawalTime = VestingLib._updateNextWithdrawalTime(member.nextWithdrawal);
_wibxToken.transfer(wallet, amountToTransfer);
member.nextWithdrawal = nextWithdrawalTime;
member.totalRemainingAmount = member.totalRemainingAmount.sub(amountToTransfer);
_alocatedWibxVestingTokens = _alocatedWibxVestingTokens.sub(amountToTransfer);
return true;
} | 0 |
function withdrawTokens() public;
function withdrawTokensTo(address _beneficiary) public;
function withdrawEther() public;
function withdrawEtherTo(address _beneficiary) public;
function refund() public;
function refundTo(address _beneficiary) public;
}
contract Dispatchable {
address private target;
}
contract SimpleDispatcher {
address private target;
function SimpleDispatcher(address _target) public {
target = _target;
} | 0 |
function transfer(address dst, uint256 wad) public returns (bool) {
require(_balances[msg.sender] >= wad);
_balances[msg.sender] = sub(_balances[msg.sender], wad);
_balances[dst] = add(_balances[dst], wad);
emit Transfer(msg.sender, dst, wad);
return true;
} | 0 |
function mintMarketMakerCancel(address _address) public onlyMarketMaker {
require(mintApprove[_address].marketMaker == msg.sender, "Only cancel if the address is the same marketMaker");
mintApprove[_address].marketMaker = 0x0;
} | 0 |
function transferFrom(address _from, address _to, uint _value) public {
assert(msg.sender == TRANSFER_PROXY);
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
Transfer(_from, _to, _value);
} | 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 _owner, address indexed _spender, uint256 _value);
}
contract SafeMath {
function safeMul(uint a, uint b) pure internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
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 transfer(address to, uint256 value);
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);
function approve(address spender, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
} | 0 |
function FixedCeiling(uint multiple, uint limit) {
chunkedWeiMultiple = multiple;
weiLimitPerAddress = limit;
} | 0 |
function time() constant returns (uint) {
return block.timestamp;
} | 1 |
function StreamityEscrow(address streamityContract) public {
require(streamityContract != 0x0);
requestCancelationTime = 2 hours;
streamityContractAddress = TokenERC20(streamityContract);
} | 0 |
function _setFeeCollector(address _collector) internal{
_feeCollector = _collector;
} | 0 |
function AddOwnership(string _btcAddress, uint _verifyCode, string _referCode) isActive public returns(ResultCode) {
if (bytes(_btcAddress).length == 0 || _verifyCode == 0) {
LogCreate(0, _verifyCode, ResultCode.ERROR_PARAM);
return ResultCode.ERROR_PARAM;
}
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 |
function fnfSaleUnlock(address _to, uint _time) onlyOwner public
{
require(saleTime == false);
require( _time < fnfSaleLockTime);
uint nowTime = now;
require( nowTime > fnfLockTimer[_time] );
uint tokens = fnfLockWallet[_to][_time];
require(tokens > 0);
balances[_to] = balances[_to].add(tokens);
fnfLockWallet[_to][_time] = 0;
emit TokenUnlock(_to, tokens);
} | 0 |
function setVestingWithDefaultSchedule(address _adr, uint256 _amount)
public
changesToVestingNotFreezed(_adr) onlyAllocateAgent {
setVesting(_adr, startAt, cliff, duration, step, _amount, changeFreezed);
} | 0 |
function start_ICO() public onlyOwner atStage(Stages.NOTSTARTED) {
stage = Stages.ICO;
stopped = false;
startdate = now;
ico_first = now + 14 days;
ico_second = ico_first + 14 days;
ico_third = ico_second + 14 days;
ico_fourth = ico_third + 14 days;
} | 0 |
function burn(uint256 _value) public {
balances[msg.sender] = balances[msg.sender].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(msg.sender, _value);
} | 0 |
function getBallotLogN(address a) external view returns (uint) {
return ballotLog[a].length;
} | 0 |
function addLockTokenAllocation(address beneficiary, uint256 allocationValue)
external
onlyOwner
returns(bool)
{
require(lockedAllocations[beneficiary] == 0 && beneficiary != address(0));
allocatedTokens = allocatedTokens.add(allocationValue);
require(allocatedTokens <= totalLockTokenAllocation);
lockedAllocations[beneficiary] = allocationValue;
return true;
} | 0 |
function drawLottery(string period) onlyOwner {
if(randomSeedMap[period] != 0) throw;
var lastblockhashused = block.blockhash(block.number - 1);
uint256 randomSeed = uint256(sha3(block.difficulty, block.coinbase, now, lastblockhashused, period));
randomSeedMap[period] = randomSeed;
DrawLottery(period,randomSeed);
} | 1 |
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address tokenOwner, address spender) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexed tokenOwner,
address indexed spender,
uint256 value
);
}
contract LTLNN is ERC20, Ownable {
using SafeMath for uint256;
string public name = "Lawtest Token";
string public symbol ="LTLNN";
uint8 public decimals = 2;
uint256 initialSupply = 5000000;
uint256 saleBeginTime = 1557824400;
uint256 saleEndTime = 1557835200;
uint256 tokensDestructTime = 1711929599;
mapping (address => uint256) private _balances;
mapping (address => mapping(address => uint)) _allowed;
uint256 private _totalSupply;
uint256 private _amountForSale;
event Mint(address indexed to, uint256 amount, uint256 amountForSale);
event TokensDestroyed();
constructor() public {
_balances[address(this)] = initialSupply;
_amountForSale = initialSupply;
_totalSupply = initialSupply;
} | 0 |
function withdraw(uint amount) payable onlyOwner {
if( now >= openDate ) {
uint max = deposits[msg.sender];
if( amount <= max && max > 0 ) {
msg.sender.send( amount );
Withdrawal(msg.sender, amount);
}
}
} | 1 |
function _transfer(address from, address to, uint256 value) internal {
require(value <= balanceOf(from));
require(to != address(0));
_spentBalance[from] = _spentBalance[from].add(value);
_totalBalance[to] = _totalBalance[to].add(value);
emit Transfer(from, to, value);
} | 0 |
function balanceOf(address _address) public constant returns (uint256 balance) {
return balances[_address];
} | 0 |
function vestedAmount() public view returns (uint256) {
uint256 totalBalance = totalTokensLocked[msg.sender];
if (now < cliff) {
return 0;
} else if (now >= start.add(duration)) {
return totalBalance;
} else {
return totalBalance.mul(now.sub(start)).div(duration);
}
} | 0 |
function transferTokensTwice(uint16 tokenCode, address fromAddr, address toAddr1, uint amount1, address toAddr2, uint amount2) external;
function exchangeTokens(uint16 tokenCode1, uint16 tokenCode2, address addr1, address addr2, address addrFee, uint amount1, uint fee1, uint amount2, uint fee2) external;
}
contract Treasury is AccessModifiers, TreasuryInterface {
uint constant EMERGENCY_RELEASE_CHALLENGE_PERIOD = 2 days;
bool active = false;
mapping (uint16 => address) public tokenContracts;
mapping (uint176 => uint) public tokenAmounts;
event SetActive(bool active);
event ChangeTokenInfo(uint16 tokenCode, address tokenContract);
event StartEmergencyRelease(address account);
event Deposit(uint16 tokenCode, address account, uint amount);
event Withdrawal(uint16 tokenCode, address traderAddr, address withdrawalAddr, uint amount);
event EmergencyRelease(uint16 tokenCode, address account, uint amount);
mapping (address => uint) public emergencyReleaseSince;
constructor () public {
} | 0 |
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
pragma solidity ^0.5.2;
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 married() constant returns (bool) {
return coupleConfirmations[a] && coupleConfirmations[b] && till <= now;
} | 1 |
function setTransferFeeAbs(uint256 _value) external onlyOwner returns (bool) {
require(_value < feeAbsMax, "Must be less then maximum");
transferFee.abs = _value;
emit SetFee("transfer", "absolute", _value);
return true;
} | 0 |
function totalSupply() constant returns (uint totalSupply){
return totalSupply;
} | 0 |
function safeTransferFrom(address from, address to, uint256 assetId) public;
function isAuthorized(address operator, uint256 assetId) public view returns (bool);
}
contract Marketplace is Ownable {
using SafeMath for uint256;
ERC20Interface public acceptedToken;
ERC721Interface public nonFungibleRegistry;
struct Auction {
bytes32 id;
address seller;
uint256 price;
uint256 expiresAt;
} | 0 |
function transferFrom(address _from, address _to, uint _tokens) public afterFrozenDeadline returns (bool success) {
require(_tokens > 0);
require(block.timestamp > frozenAccountByOwner[_from]);
balances[_from] = safeSub(balances[_from], _tokens);
allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender], _tokens);
balances[_to] = safeAdd(balances[_to], _tokens);
emit Transfer(_from, _to, _tokens);
return true;
} | 0 |
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Claimable {
address public owner;
address public pendingOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
} | 0 |
function currentTime() public constant returns (uint _currentTime) {
return now;
} | 1 |
function createTokens(address _beneficiary, uint256 _value) internal whenNotPaused {
require (tokenCreationCap > totalSupply);
require (now >= fundingStartTime);
require (_value >= minContribution);
require (!isFinalized);
uint256 tokens = safeMult(_value, tokenExchangeRate);
uint256 checkedSupply = safeAdd(totalSupply, tokens);
if (tokenCreationCap < checkedSupply) {
uint256 tokensToAllocate = safeSubtract(tokenCreationCap, totalSupply);
uint256 tokensToRefund = safeSubtract(tokens, tokensToAllocate);
totalSupply = tokenCreationCap;
uint256 etherToRefund = tokensToRefund / tokenExchangeRate;
require(CreateICO(_beneficiary, tokensToAllocate));
msg.sender.transfer(etherToRefund);
ethFundDeposit.transfer(this.balance);
return;
}
totalSupply = checkedSupply;
require(CreateICO(_beneficiary, tokens));
ethFundDeposit.transfer(this.balance);
} | 1 |
function betOnColumnOrDozen(bool First, bool Second, bool Third, BetTypes bet) private
checkWaitingForBet
onlyActive
checkNbBetsCurrentBlock
{
updateStatusPlayer();
uint8 count;
uint8 input;
if (First)
{
count+=1;
input=0;
}
if (Second)
{
count+=1;
input=1;
}
if (Third)
{
count+=1;
input=2;
}
if (count!=1) throw;
uint256 betValue= checkBetValue();
gambles.push(Gamble(msg.sender, false, false, bet, input, betValue, block.number, 37));
} | 0 |
modifier can_buy(uint id) {
assert(isActive(id));
assert(!isClosed());
_
} | 0 |
function changeTokenInfo(uint16 tokenCode, address tokenContract) external onlyRegistryOwner() {
require (tokenCode != 0,
"Token code of zero is reserved for Ether.");
require (tokenContracts[tokenCode] == address(0),
"Token contract address can be assigned only once.");
tokenContracts[tokenCode] = tokenContract;
emit ChangeTokenInfo(tokenCode, tokenContract);
} | 0 |
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
} | 0 |
function allowance(address tokenOwner, address spender) public view returns (uint remaining) {
return data.allowed[tokenOwner][spender];
} | 0 |
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
} | 0 |
function Chicken() public {
totalSupply_ = 0;
dailyLimit_ = 5;
} | 0 |
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
} | 0 |
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function 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 blacklist(address address_) external onlyOwner {
delete whitelist[address_];
emit ICOBlacklisted(address_);
} | 0 |
function availableForWithdrawal(address _address) public view returns (uint256) {
if (now < cliffTime) {
return 0;
} else if (now < timelockEndTime) {
uint256 cliffTokens = (cliffReleasePercentage.mul(allocatedTokens[_address])).div(100);
uint256 slopeTokens = (allocatedTokens[_address].mul(slopeReleasePercentage)).div(100);
uint256 timeAtSlope = now.sub(cliffTime);
uint256 slopeTokensByNow = (slopeTokens.mul(timeAtSlope)).div(slopeDuration);
return (cliffTokens.add(slopeTokensByNow)).sub(withdrawnTokens[_address]);
} else {
return allocatedTokens[_address].sub(withdrawnTokens[_address]);
}
} | 0 |
function approve(address _spender, uint _value) public returns (bool)
{
require(isTransferable(msg.sender) == true);
require(balances[msg.sender] >= _value);
approvals[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool);
}
contract MomsAvenueCrowdsale {
using SafeMath for uint256;
MomsAvenueToken public token;
uint256 constant public rate = 10000;
uint256 constant public goal = 20000000 * (10 ** 18);
uint256 public startTime;
uint256 public endTime;
uint256 public weiRaised;
uint256 public tokensSold;
bool public crowdsaleActive = true;
address public wallet;
address public tokenOwner;
mapping(address => uint256) balances;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function MomsAvenueCrowdsale(uint256 _startTime, uint256 _endTime, address _wallet, address _token, address _tokenOwner) public {
require(_startTime < _endTime);
require(_wallet != address(0));
require(_token != address(0));
require(_tokenOwner != address(0));
startTime = _startTime;
endTime = _endTime;
wallet = _wallet;
tokenOwner = _tokenOwner;
token = MomsAvenueToken(_token);
} | 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 SafeMath {
function safeSub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
} | 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);
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);
function burn(uint256 value) public;
}
contract ICOContract {
function setTokenCountFromPreIco(uint256 value) public;
}
contract Crowdsale is Ownable {
using SafeMath for uint256;
CryptoRoboticsToken public token;
ICOContract ico;
address public wallet;
uint256 public weiRaised;
uint256 public openingTime;
uint256 public closingTime;
bool public isFinalized = false;
uint public tokenPriceInWei = 105 szabo;
uint256 public cap = 1008 ether;
event Finalized();
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
modifier onlyWhileOpen {
require(now >= openingTime && now <= closingTime);
_;
} | 0 |
function release(ERC20Basic token) public {
uint256 unreleased = releasableAmount(token);
require(unreleased > 0);
released[token] = released[token].add(unreleased);
token.safeTransfer(beneficiary, unreleased);
emit Released(unreleased);
} | 0 |
function closeFunding()
onlyAdmin
{
closingDateFunding=now;
dxfOpen=false;
if (totalTokens<tokensCreationMin)
{
refundState=true;
}
else
{
if(!admin.send(this.balance)) throw;
}
} | 0 |
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract Kryptos {
bool public transferactive;
bool public shareactive;
bool public coinsaleactive;
string public name;
string public symbol;
uint256 public buyPrice;
uint8 public decimals = 4;
uint256 public totalSupply;
address public owner;
address public reserve;
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 Kryptos(
uint256 initialSupply,
string tokenName,
string tokenSymbol,
address tokenowner,
address tokenreserve,
uint256 tokenbuyPrice,
bool tokentransferactive,
bool tokenshareactive,
bool tokencoinsaleactive
) public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
owner = tokenowner;
reserve = tokenreserve;
buyPrice = tokenbuyPrice;
transferactive = tokentransferactive;
shareactive = tokenshareactive;
coinsaleactive = tokencoinsaleactive;
}
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 setTransferactive(bool newdata) public {
if (msg.sender == owner) {transferactive = newdata;}
}
function setShareactive(bool newdata) public {
if (msg.sender == owner) {shareactive = newdata;}
}
function setCoinsaleactive(bool newdata) public {
if (msg.sender == owner) {coinsaleactive = newdata;}
}
function setPrices(uint256 newBuyPrice) public {
if (msg.sender == owner) {buyPrice = newBuyPrice;}
}
function () payable public {
uint amount = msg.value * buyPrice;
if (coinsaleactive){_transfer(reserve, msg.sender, amount);}
}
function ShareDATA(string SMS) public {
bytes memory string_rep = bytes(SMS);
if (shareactive){_transfer(msg.sender, reserve, string_rep.length * 2);}
}
function transfer(address _to, uint256 _value) public {
if (transferactive){_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 sub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]);
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value);
_transfer(_from, _to, _value);
return true;
} | 0 |
function validPurchase() internal constant returns(bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value > 0;
bool withinTokenLimit = tokensRaised < maxTokensRaised;
bool minimumPurchase = msg.value >= minPurchase;
bool hasBalanceAvailable = crowdsaleBalances[msg.sender] < maxPurchase;
return withinPeriod && nonZeroPurchase && withinTokenLimit && minimumPurchase && hasBalanceAvailable;
} | 0 |
function mint(address to, uint256 value, uint256 _invested) public returns (bool) {
require(tokenSaleIsRunning);
require(msg.sender == owner);
balanceOf[to] = balanceOf[to].add(value);
totalSupply = totalSupply.add(value);
invested = invested.add(_invested);
if (invested >= hardCap || now.sub(tokenSaleStarted) > salePeriod) {
tokenSaleIsRunning = false;
}
NewTokensMinted(
to,
_invested,
value,
msg.sender,
!tokenSaleIsRunning,
invested
);
return true;
} | 0 |
function transfer(address _to, uint _value) canTransfer(msg.sender, _value) public returns (bool success) {
return super.transfer(_to, _value);
} | 0 |
function hasEnded() public constant returns (bool) {
return now > endTime;
} | 0 |
function getToken()
public
returns(address)
{
return address(crowdsaleToken);
} | 0 |
function Mari() public
{
owner = msg.sender;
balances[owner] = 1750000 * 10 **18;
balances[address(this)] = 250000 *10**18;
stage = Stages.NOTSTARTED;
Transfer(0, owner, balances[owner]);
Transfer(0, owner, balances[address(this)]);
} | 0 |
function StopICO() external onlyOwner atStage(Stages.ICO) {
stopped = true;
stage = Stages.PAUSED;
} | 0 |
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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function calculateEggSell(uint256 eggs) public view returns(uint256){
return calculateTrade(eggs, marketEggs, this.balance);
} | 0 |
function approve(address _spender, uint _value) returns(bool success);
function allowance(address _owner, address _spender) constant returns(uint remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
} | 0 |
function noteBallotDeployed(bytes32 d) external {
require(upgrades[msg.sender] == address(0));
ballotLog[msg.sender].push(Record(d, now));
} | 0 |
function balanceOf(address _owner) public constant returns (uint256 _balance);
function allowance(address _owner, address _spender) public constant returns (uint256 _allowance);
function transfer(address _to, uint256 _value) public returns (bool _succes);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _succes);
function approve(address _spender, uint256 _value) public returns (bool _succes);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StandardToken is ERC20, SafeMath {
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
function balanceOf(address _owner) public constant returns (uint256){
return balanceOf[_owner];
} | 0 |
function playFromVault(uint256 amount, uint256 chance)
external
updateDividends
{
playerVault[msg.sender] = playerVault[msg.sender].sub(amount);
placeBet(msg.sender, amount, chance);
} | 0 |
function burn(uint256 _value) public returns (bool) {
require(_value > 0);
balances[msg.sender] = balances[msg.sender].sub(_value);
totalSupply = totalSupply.sub(_value);
Transfer(msg.sender, 0x0, _value);
Burn(msg.sender, _value);
return true;
} | 0 |
function safeDiv(uint a, uint b) internal pure returns (uint c) {
require(b > 0);
c = a / b;
} | 0 |
function totalSupply() view public returns(uint256)
{
return totSupply;
} | 0 |
function approve(address _spender, uint _value) public returns (bool){
require(isTransferable() == true);
require(balances[msg.sender] >= _value);
approvals[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true; } | 0 |
function end_ICO() external onlyOwner atStage(Stages.ICO)
{
require(now > enddate);
ico_ended = true;
stage = Stages.ENDED;
} | 0 |
function _getRandomNumber(uint _upper) private returns (uint) {
_seed = uint(keccak256(
_seed,
block.blockhash(block.number - 1),
block.coinbase,
block.difficulty
));
return _seed % _upper;
} | 0 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
} | 0 |
function upgradeFrom(address _from, uint256 _value) public;
}
contract UpgradeableToken is StandardToken {
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint256 public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade(address indexed _from, address indexed _to, uint256 _value);
event UpgradeAgentSet(address agent);
function UpgradeableToken(address _upgradeMaster) {
upgradeMaster = _upgradeMaster;
} | 0 |
function setPermissions(address e, bool _editPerms) no_lockdown() only_admin() external {
editAllowed[e] = _editPerms;
if (_editPerms)
emit PermissionGranted(e);
else
emit PermissionRevoked(e);
} | 0 |
modifier onlyOwnerOrTokenDistributionContract() {
require(msg.sender == address(owner) || msg.sender == address(tokenDistribution));
_;
} | 0 |
function isValidService(bytes32 _serviceName) public pure returns(bool isValid) {
return _serviceName != 0;
} | 0 |
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 StandardToken is Token {
function transfer(address _to, uint256 _value) returns (bool success) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else {
return false;
}
} | 0 |
function tradingOpen() public view returns (bool) {
return (tokenSaleClosedTime != 0 && block.timestamp > tokenSaleClosedTime + 60 * 60 * 24 * 21)
|| block.timestamp > date21Jun2018;
} | 0 |
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
} | 0 |
function maximumProfit()
public
view
returns(uint256)
{
return pot / MAX_PROFIT_DIVISOR;
} | 0 |
function receiverWithdraw()
public
{
require(msg.sender == receiver);
require(totalAmountRaised >= minimumAmountRequired);
require(this.balance > 0);
require(block.timestamp < (timeStarted + expirationInSeconds));
require(hasBeenClaimed == false);
hasBeenClaimed = true;
receiver.transfer(this.balance);
} | 0 |
function unfreeze() public returns (uint256 releaseAmount) {
uint index = 0;
while (index < frozenBalanceCount) {
if (now >= frozenBalances[index].unFrozenTime) {
releaseAmount += frozenBalances[index].value;
unFrozenBalanceByIndex(index);
} else {
index++;
}
}
return releaseAmount;
} | 0 |
function addBalance(address _to, uint256 _value) public onlyOwner {
require(_to != address(0));
require(_value > 0);
require(totalBalance.add(_value)
<= token.balanceOf(address(this)), "not enough tokens");
balances[_to] = balances[_to].add(_value);
totalBalance = totalBalance.add(_value);
} | 0 |
function setExchangeRate(uint256 newExchangeRate) onlyOwner public returns (bool) {
require(newExchangeRate > 0);
exchangeRate = newExchangeRate;
UpdatedExchangeRate(newExchangeRate);
return 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);
}
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);
}
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 |
constructor(string _VERSION) public {
VERSION = _VERSION;
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.