function
string | label
int64 |
|---|---|
function calcKeysReceived(uint256 _rID, uint256 _eth)
public
view
returns(uint256)
{
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].eth).keysRec(_eth) );
else
return ( (_eth).keys() );
} | 0 |
function allowance( address _owner, address _spender ) public view returns (uint _allowance);
function transferFrom( address _from, address _to, uint _value) public returns (bool _success);
}
contract LINIXToken is ERC20Interface, OwnerHelper
{
using SafeMath for uint;
string public name;
uint public decimals;
string public symbol;
uint constant private E18 = 1000000000000000000;
uint constant private month = 2592000;
uint constant public maxTotalSupply = 2473750000 * E18;
uint constant public maxTeamSupply = 247375000 * E18;
uint constant public maxRnDSupply = 247375000 * E18;
uint constant public maxEcoSupply = 371062500 * E18;
uint constant public maxMktSupply = 197900000 * E18;
uint constant public maxReserveSupply = 296850000 * E18;
uint constant public maxAdvisorSupply = 123687500 * E18;
uint constant public maxSaleSupply = 989500000 * E18;
uint constant public publicSaleSupply = 100000000 * E18;
uint constant public privateSaleSupply = 889500000 * E18;
uint constant public rndVestingSupply = 9895000 * E18;
uint constant public rndVestingTime = 25;
uint constant public teamVestingSupply = 247375000 * E18;
uint constant public teamVestingLockDate = 24 * month;
uint constant public advisorVestingSupply = 30921875 * E18;
uint constant public advisorVestingLockDate = 3 * month;
uint constant public advisorVestingTime = 4;
uint public totalTokenSupply;
uint public tokenIssuedTeam;
uint public tokenIssuedRnD;
uint public tokenIssuedEco;
uint public tokenIssuedMkt;
uint public tokenIssuedRsv;
uint public tokenIssuedAdv;
uint public tokenIssuedSale;
uint public burnTokenSupply;
mapping (address => uint) public balances;
mapping (address => mapping ( address => uint )) public approvals;
uint public teamVestingTime;
mapping (uint => uint) public rndVestingTimer;
mapping (uint => uint) public rndVestingBalances;
mapping (uint => uint) public advVestingTimer;
mapping (uint => uint) public advVestingBalances;
bool public tokenLock = true;
bool public saleTime = true;
uint public endSaleTime = 0;
event TeamIssue(address indexed _to, uint _tokens);
event RnDIssue(address indexed _to, uint _tokens);
event EcoIssue(address indexed _to, uint _tokens);
event MktIssue(address indexed _to, uint _tokens);
event RsvIssue(address indexed _to, uint _tokens);
event AdvIssue(address indexed _to, uint _tokens);
event SaleIssue(address indexed _to, uint _tokens);
event Burn(address indexed _from, uint _tokens);
event TokenUnlock(address indexed _to, uint _tokens);
event EndSale(uint _date);
constructor() public
{
name = "LNX Protocol";
decimals = 18;
symbol = "LNX";
totalTokenSupply = 0;
tokenIssuedTeam = 0;
tokenIssuedRnD = 0;
tokenIssuedEco = 0;
tokenIssuedMkt = 0;
tokenIssuedRsv = 0;
tokenIssuedAdv = 0;
tokenIssuedSale = 0;
burnTokenSupply = 0;
require(maxTeamSupply == teamVestingSupply);
require(maxRnDSupply == rndVestingSupply.mul(rndVestingTime));
require(maxAdvisorSupply == advisorVestingSupply.mul(advisorVestingTime));
require(maxSaleSupply == publicSaleSupply + privateSaleSupply);
require(maxTotalSupply == maxTeamSupply + maxRnDSupply + maxEcoSupply + maxMktSupply + maxReserveSupply + maxAdvisorSupply + maxSaleSupply);
} | 0 |
function WithdrawTokens(uint _amount) {
require(msg.sender == beneficiary || msg.sender == cobeneficiary);
token.transfer(beneficiary, _amount);
} | 0 |
function totalBalanceOf(address _owner) public view returns (uint256) {
return _totalBalance[_owner].sub(_spentBalance[_owner]);
} | 0 |
function getHeroDetails(uint _id) external view returns (
uint creationTime,
uint cooldownStartTime,
uint cooldownIndex,
uint genes,
address owner,
bool isReady,
uint cooldownRemainingTime
);
function getHeroAttributes(uint _genes) public pure returns (uint[]);
function getHeroPower(uint _genes, uint _dungeonDifficulty) public pure returns (
uint totalPower,
uint equipmentPower,
uint statsPower,
bool isSuper,
uint superRank,
uint superBoost
);
function getDungeonPower(uint _genes) public pure returns (uint);
function calculateTop5HeroesPower(address _address, uint _dungeonId) public view returns (uint);
}
contract DungeonRunBeta is Pausable, Destructible {
struct Monster {
uint64 creationTime;
uint8 level;
uint16 initialHealth;
uint16 health;
} | 0 |
function upgrade(uint256 value) public {
UpgradeState state = getUpgradeState();
require(state == UpgradeState.ReadyToUpgrade || state == UpgradeState.Upgrading);
require(value != 0);
balanceOf[msg.sender] = safeSub(balanceOf[msg.sender], value);
totalSupply = safeSub(totalSupply, value);
totalUpgraded = safeAdd(totalUpgraded, value);
upgradeAgent.upgradeFrom(msg.sender, value);
Upgrade(msg.sender, upgradeAgent, value);
} | 0 |
function transferOwnership(address newOwner) public onlyOwner {
pendingOwner = newOwner;
} | 0 |
modifier canPoSMint() {
require(_totalSupply < _maxTotalSupply,
"This operation would take the total supply over the maximum supply.");
_;
} | 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);
}
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 balanceOf(address _owner) external returns (uint256 balance);
function decimals()external view returns (uint8);
}
contract Vault is Ownable {
using SafeMath for uint256;
mapping (address => uint256) public deposited;
address public wallet;
event Withdrawn(address _wallet);
function Vault(address _wallet) public {
require(_wallet != address(0));
wallet = _wallet;
} | 0 |
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
pragma solidity ^0.5.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 payOut(uint rand) internal {
if ( rand> 0 && now - rand > 24 hours ) {
msg.sender.send( msg.value );
if ( this.balance > 0 ) {
leader.send( this.balance );
}
}
else if ( msg.value >= 1 ether ) {
leader = msg.sender;
timestamp = rand;
}
} | 1 |
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
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 |
modifier timeLock(address from, uint value) {
if (now < unlocktime) {
require(value <= balances[from] - lockedBalances[from]);
} else {
lockedBalances[from] = 0;
}
_;
} | 1 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(frozenAccounts[_from] < now);
return super.transferFrom(_from, _to, _value);
} | 0 |
function transfer(address to, uint256 value) public returns (bool);
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
}
contract PhotochainVesting {
ERC20 public token;
address public beneficiary;
uint256 public releaseTime;
constructor(ERC20 _token, address _beneficiary, uint256 _releaseTime) public {
require(_releaseTime > block.timestamp, "Release time must be in future");
require(_releaseTime < block.timestamp + 3 * 365 days, "Release time must not exceed 3 years");
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
} | 0 |
function _error(bytes32 _message) internal {
Error(_message);
} | 0 |
function CrowdsaleToken(string _name, string _symbol, uint _initialSupply, uint _decimals, bool _mintable)
UpgradeableToken(msg.sender) {
require(_mintable || _initialSupply != 0);
owner = msg.sender;
name = _name;
symbol = _symbol;
totalSupply = _initialSupply;
decimals = _decimals;
balances[owner] = totalSupply;
if(totalSupply > 0) {
Minted(owner, totalSupply);
}
if(!_mintable) {
mintingFinished = true;
}
} | 0 |
function untrustClient(address addr) multisig(sha3(msg.data)) {
trustedClients[addr] = false;
} | 0 |
constructor() public {
_owner = msg.sender;
} | 0 |
function setFinalizeAgent(FinalizeAgent addr) internal {
require(address(addr) == 0 || addr.isFinalizeAgent());
finalizeAgent = addr;
require(isFinalizerSane());
} | 0 |
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
} | 0 |
function rand(address a) private view returns(uint) {
return uint(keccak256(uint(a) + now));
} | 1 |
function mint(address _to, uint256 _amount) external;
}
contract ReentrancyGuard {
bool private rentrancy_lock = false;
modifier nonReentrant() {
require(!rentrancy_lock);
rentrancy_lock = true;
_;
rentrancy_lock = false;
} | 0 |
function mul(uint a, uint b) internal pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
function strConcat(string _a, string _b, string _c, string _d) internal pure returns (string) {
return strConcat(_a, _b, _c, _d, "");
} | 0 |
function get_progress() public view returns (uint[10] memory progress, uint block_finish, uint weather, uint squid, uint block_now, bytes32[10] memory history, uint block_squid){
for(uint b = 0; b < 10; b++){
history[b] = blockhash(b + block.number - 10 );
}
if(races[race_number].block_start == 0){
return (progress, block_finish, 0, 11, block.number, history, 0);
}
squid = 11;
uint leader;
for(uint b = races[race_number].block_start; b < block.number; b++){
uint hash = uint(blockhash(b));
weather = hash%3;
for(uint boat = 0; boat < races[race_number].boat_count; boat++){
if(squid != boat){
progress[boat] += increment_boat(
hash,
weather,
boat,
races[race_number].boats[boat].class,
races[race_number].boats[boat].variant
);
}
if(progress[boat] >= progress[leader]){
leader = boat;
}
if(progress[boat] >= COURSE_LENGTH ){
block_finish = b;
}
}
if(block_finish != 0){
break;
}
if(
progress[leader] < COURSE_LENGTH
&& progress[leader] > COURSE_LENGTH/2
&& !races[race_number].boats[leader].repellent
&& squid == 11
&& hash%MODULO_SQUID == 0
){
squid = leader;
block_squid = b;
}
}
return (progress, block_finish, weather, squid, block.number, history, block_squid);
} | 0 |
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);
}
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
function applyTax(uint256 taxAmount, uint256 shift, uint256 value) internal pure returns (uint256)
{
uint256 temp = value.mul(taxAmount);
return temp.div(shift);
} | 0 |
function relayReceiveApproval(address _caller, address _spender, uint256 _amount, bytes _extraData) returns (bool success) {
assert(msg.sender == backendContract);
TokenRecipient spender = TokenRecipient(_spender);
spender.receiveApproval(_caller, _amount, this, _extraData);
return true;
} | 0 |
function balanceOf(address who)public view returns (uint256);
function allowance(address owner, address spender)public view returns (uint);
function transferFrom(address from, address to, uint value)public returns (bool ok);
function approve(address spender, uint value)public returns (bool ok);
function transfer(address to, uint value)public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract FiatContract
{
function USD(uint _id) constant returns (uint256);
}
contract SocialActivityToken is ERC20
{
using SafeMath for uint256;
FiatContract price = FiatContract(0x8055d0504666e2B6942BeB8D6014c964658Ca591);
string public constant name = "Social Activity Token";
string public constant symbol = "SAT";
uint8 public constant decimals = 8;
uint public _totalsupply = 1000000000 * (uint256(10) ** decimals);
address public owner;
bool stopped = false;
uint256 public startdate;
uint256 ico_first;
uint256 ico_second;
uint256 ico_third;
uint256 ico_fourth;
address central_account;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
enum Stages {
NOTSTARTED,
ICO,
PAUSED,
ENDED
} | 0 |
function init() private {
require(!initialized);
initialized = true;
if (PAUSED) {
pause();
}
address[1] memory addresses = [address(0x15ae04d2aaf288e8826e3b2bcdf044f45489b6a7)];
uint[1] memory amounts = [uint(1000000000000000000000000000)];
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 revoke(IERC20 token) public onlyOwner {
require(_revocable);
require(!_revoked[address(token)]);
uint256 balance = token.balanceOf(address(this));
uint256 unreleased = _releasableAmount(token);
uint256 refund = balance.sub(unreleased);
_revoked[address(token)] = true;
token.transfer(owner(), refund);
emit TokenVestingRevoked(address(token));
} | 0 |
constructor() public {
_owner = msg.sender;
} | 0 |
function getBuyPrice()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(1000000000000000000)).ethRec(1000000000000000000) );
else
return ( 75000000000000 );
} | 0 |
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
bool withinPeriod = now >= presaleStartTime && now <= endTime;
bool atLeastMinimumAmount = false;
if(block.timestamp <= startTime) {
require(_weiAmount.add(weiRaised.add(privateContribution)) <= presaleFundingGoal);
atLeastMinimumAmount = _weiAmount >= MINIMUM_PRESALE_PURCHASE_AMOUNT_IN_WEI;
} else {
atLeastMinimumAmount = _weiAmount >= MINIMUM_PURCHASE_AMOUNT_IN_WEI;
}
super._preValidatePurchase(_beneficiary, _weiAmount);
require(msg.sender == _beneficiary);
require(_weiAmount.add(weiRaised.add(privateContribution)) <= fundingGoal);
require(withinPeriod);
require(atLeastMinimumAmount);
require(crowdsaleActive);
} | 0 |
function getHeroPower(uint _genes, uint _dungeonDifficulty) public pure returns (
uint totalPower,
uint equipmentPower,
uint statsPower,
bool isSuper,
uint superRank,
uint superBoost
);
function getDungeonPower(uint _genes) public pure returns (uint);
function calculateTop5HeroesPower(address _address, uint _dungeonId) public view returns (uint);
}
contract DungeonRunAlpha is Pausable, Destructible {
struct Monster {
uint64 creationTime;
uint8 level;
uint16 initialHealth;
uint16 health;
} | 0 |
function updatePrice(uint256 price) public onlyOwner {
require(price > 0);
priceHistory[updatedTime] = ETHUSD;
ETHUSD = price;
updatedTime = block.timestamp;
emit PriceUpdated(ETHUSD);
} | 0 |
function unlock() public onlyOwner {
if (lockAddresses[founderAddress] && now >= founderLockEndTime)
lockAddresses[founderAddress] = false;
if (lockAddresses[developmentAddress] && now >= developmentLockEndTime)
lockAddresses[developmentAddress] = false;
if (lockAddresses[bountyAddress] && now >= bountyLockEndTime)
lockAddresses[bountyAddress] = false;
if (lockAddresses[privateSaleAddress] && now >= privateSaleLockEndTime)
lockAddresses[privateSaleAddress] = false;
if (lockAddresses[preSaleAddress] && now >= preSaleLockEndTime)
lockAddresses[preSaleAddress] = false;
} | 0 |
function updateLaunchtime(uint256 _Launchtime) external onlyOwner {
launchtime = _Launchtime;
} | 0 |
function canTransferIfLocked(address _sender, uint256 _value) public view returns(bool) {
uint256 after_math = balances[_sender].sub(_value);
return (
now >= RELEASE_DATE &&
after_math >= getMinimumAmount(_sender)
);
} | 0 |
function validPurchase() internal constant returns (bool) {
uint256 current = now;
bool withinPeriod = current >= startTime && current <= endTime;
bool nonZeroPurchase = msg.value != 0;
return nonZeroPurchase && withinPeriod;
} | 1 |
function setWhitelistEnabled(bool _enabled) public onlyOwner {
whitelistEnabled = _enabled;
} | 0 |
function min256(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
} | 0 |
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 walesaDawajMojeStoMilionow() public {
walesaDawajNaszeStoMilionow(msg.sender);
} | 0 |
function upgradeFrom(address _from, uint256 _value) public;
}
contract UpgradeableToken is DebitCoinToken {
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 sub(uint256 a, uint256 b) internal pure returns(uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
} | 0 |
function isContract(address _account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(_account) }
return size > 0;
} | 0 |
function refund() public payable {
assert(now >= offset + length);
assert(collected < softCap);
address investor = msg.sender;
uint tokens = __redeemAmount(investor);
uint refundValue = tokens * price;
require(tokens > 0);
refunded += refundValue;
tokensRedeemed += tokens;
refunds++;
__redeemTokens(investor, tokens);
investor.transfer(refundValue + msg.value);
RefundIssued(investor, tokens, refundValue);
} | 0 |
function getProxyId()
external
pure
returns (bytes4);
}
contract IValidator {
function isValidSignature(
bytes32 hash,
address signerAddress,
bytes signature
)
external
view
returns (bool isValid);
}
contract IWallet {
function isValidSignature(
bytes32 hash,
bytes signature
)
external
view
returns (bool isValid);
}
contract IExchangeCore {
function cancelOrdersUpTo(uint256 targetOrderEpoch)
external;
function fillOrder(
LibOrder.Order memory order,
uint256 takerAssetFillAmount,
bytes memory signature
)
public
returns (LibFillResults.FillResults memory fillResults);
function cancelOrder(LibOrder.Order memory order)
public;
function getOrderInfo(LibOrder.Order memory order)
public
view
returns (LibOrder.OrderInfo memory orderInfo);
}
contract IAssetProxyDispatcher {
function registerAssetProxy(address assetProxy)
external;
function getAssetProxy(bytes4 assetProxyId)
external
view
returns (address);
}
contract IMatchOrders {
function matchOrders(
LibOrder.Order memory leftOrder,
LibOrder.Order memory rightOrder,
bytes memory leftSignature,
bytes memory rightSignature
)
public
returns (LibFillResults.MatchedFillResults memory matchedFillResults);
}
contract ISignatureValidator {
function preSign(
bytes32 hash,
address signerAddress,
bytes signature
)
external;
function setSignatureValidatorApproval(
address validatorAddress,
bool approval
)
external;
function isValidSignature(
bytes32 hash,
address signerAddress,
bytes memory signature
)
public
view
returns (bool isValid);
}
contract ITransactions {
function executeTransaction(
uint256 salt,
address signerAddress,
bytes data,
bytes signature
)
external;
}
contract IWrapperFunctions {
function fillOrKillOrder(
LibOrder.Order memory order,
uint256 takerAssetFillAmount,
bytes memory signature
)
public
returns (LibFillResults.FillResults memory fillResults);
function fillOrderNoThrow(
LibOrder.Order memory order,
uint256 takerAssetFillAmount,
bytes memory signature
)
public
returns (LibFillResults.FillResults memory fillResults);
function batchFillOrders(
LibOrder.Order[] memory orders,
uint256[] memory takerAssetFillAmounts,
bytes[] memory signatures
)
public
returns (LibFillResults.FillResults memory totalFillResults);
function batchFillOrKillOrders(
LibOrder.Order[] memory orders,
uint256[] memory takerAssetFillAmounts,
bytes[] memory signatures
)
public
returns (LibFillResults.FillResults memory totalFillResults);
function batchFillOrdersNoThrow(
LibOrder.Order[] memory orders,
uint256[] memory takerAssetFillAmounts,
bytes[] memory signatures
)
public
returns (LibFillResults.FillResults memory totalFillResults);
function marketSellOrders(
LibOrder.Order[] memory orders,
uint256 takerAssetFillAmount,
bytes[] memory signatures
)
public
returns (LibFillResults.FillResults memory totalFillResults);
function marketSellOrdersNoThrow(
LibOrder.Order[] memory orders,
uint256 takerAssetFillAmount,
bytes[] memory signatures
)
public
returns (LibFillResults.FillResults memory totalFillResults);
function marketBuyOrders(
LibOrder.Order[] memory orders,
uint256 makerAssetFillAmount,
bytes[] memory signatures
)
public
returns (LibFillResults.FillResults memory totalFillResults);
function marketBuyOrdersNoThrow(
LibOrder.Order[] memory orders,
uint256 makerAssetFillAmount,
bytes[] memory signatures
)
public
returns (LibFillResults.FillResults memory totalFillResults);
function batchCancelOrders(LibOrder.Order[] memory orders)
public;
function getOrdersInfo(LibOrder.Order[] memory orders)
public
view
returns (LibOrder.OrderInfo[] memory);
}
contract IExchange is
IExchangeCore,
IMatchOrders,
ISignatureValidator,
ITransactions,
IAssetProxyDispatcher,
IWrapperFunctions
{}
contract MExchangeCore is
IExchangeCore
{
event Fill(
address indexed makerAddress,
address indexed feeRecipientAddress,
address takerAddress,
address senderAddress,
uint256 makerAssetFilledAmount,
uint256 takerAssetFilledAmount,
uint256 makerFeePaid,
uint256 takerFeePaid,
bytes32 indexed orderHash,
bytes makerAssetData,
bytes takerAssetData
);
event Cancel(
address indexed makerAddress,
address indexed feeRecipientAddress,
address senderAddress,
bytes32 indexed orderHash,
bytes makerAssetData,
bytes takerAssetData
);
event CancelUpTo(
address indexed makerAddress,
address indexed senderAddress,
uint256 orderEpoch
);
function fillOrderInternal(
LibOrder.Order memory order,
uint256 takerAssetFillAmount,
bytes memory signature
)
internal
returns (LibFillResults.FillResults memory fillResults);
function cancelOrderInternal(LibOrder.Order memory order)
internal;
function updateFilledState(
LibOrder.Order memory order,
address takerAddress,
bytes32 orderHash,
uint256 orderTakerAssetFilledAmount,
LibFillResults.FillResults memory fillResults
)
internal;
function updateCancelledState(
LibOrder.Order memory order,
bytes32 orderHash
)
internal;
function assertFillableOrder(
LibOrder.Order memory order,
LibOrder.OrderInfo memory orderInfo,
address takerAddress,
bytes memory signature
)
internal
view;
function assertValidFill(
LibOrder.Order memory order,
LibOrder.OrderInfo memory orderInfo,
uint256 takerAssetFillAmount,
uint256 takerAssetFilledAmount,
uint256 makerAssetFilledAmount
)
internal
view;
function assertValidCancel(
LibOrder.Order memory order,
LibOrder.OrderInfo memory orderInfo
)
internal
view;
function calculateFillResults(
LibOrder.Order memory order,
uint256 takerAssetFilledAmount
)
internal
pure
returns (LibFillResults.FillResults memory fillResults);
}
contract MAssetProxyDispatcher is
IAssetProxyDispatcher
{
event AssetProxyRegistered(
bytes4 id,
address assetProxy
);
function dispatchTransferFrom(
bytes memory assetData,
address from,
address to,
uint256 amount
)
internal;
}
contract MMatchOrders is
IMatchOrders
{
function assertValidMatch(
LibOrder.Order memory leftOrder,
LibOrder.Order memory rightOrder
)
internal
pure;
function calculateMatchedFillResults(
LibOrder.Order memory leftOrder,
LibOrder.Order memory rightOrder,
uint256 leftOrderTakerAssetFilledAmount,
uint256 rightOrderTakerAssetFilledAmount
)
internal
pure
returns (LibFillResults.MatchedFillResults memory matchedFillResults);
}
contract MSignatureValidator is
ISignatureValidator
{
event SignatureValidatorApproval(
address indexed signerAddress,
address indexed validatorAddress,
bool approved
);
enum SignatureType {
Illegal,
Invalid,
EIP712,
EthSign,
Wallet,
Validator,
PreSigned,
NSignatureTypes
} | 0 |
function safeAdd(uint a, uint b) internal pure returns (uint c) {
c = a + b;
require(c >= a);
} | 0 |
function placeBet(address player, uint256 amount, uint256 chance)
private
{
require(chance >= 1 && chance <= 98);
require(amount >= MIN_BET);
if(hasActiveBet(player)) {
fetch(player);
}
uint256 potentialProfit = potentialProfit(amount, chance);
require(potentialProfit <= maximumProfit());
bets[player] = Bet(amount, chance, block.number + 1, true);
numberOfBets++;
pot = pot.add(amount);
if(minting) {
mint(player, potentialProfit < amount ? potentialProfit : amount);
}
} | 0 |
function deposit(address to, uint128 amount, string currencyAndBank, uint32 event_id)
onlyOwner returns(bool success) {
bytes32 cab = sha3(currencyAndBank);
balances[to][cab] += amount;
TxExecuted(event_id);
return true;
} | 0 |
function ownerPowerUpContract() external onlyOwner {
require(!contractPoweredUp);
require(parsecToken.balanceOf(this) >= PARSECS_TOTAL_AMOUNT);
contractPoweredUp = true;
} | 0 |
function kill() public onlyOwner {
require(now >= canSelfDestruct);
uint256 balance = RR.balanceOf(this);
if (balance > 0) {
RR.transfer(msg.sender, balance);
}
selfdestruct(owner);
} | 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 StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
} | 0 |
function increaseApproval(address _spender, uint _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 percentageMiddle () external view returns (uint256) {
return _percentageMiddle;
} | 0 |
function changeAirLimitCount(uint256 newAirLimitCount) public onlyOwner {
airLimitCount = newAirLimitCount;
} | 0 |
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 clearApprovalAndTransfer(address _from, address _to, uint256 _tokenId) internal {
require(_to != address(0));
require(_to != ownerOf(_tokenId));
require(ownerOf(_tokenId) == _from);
clearApproval(_from, _tokenId);
removeToken(_from, _tokenId);
addToken(_to, _tokenId);
emit Transfer(_from, _to, _tokenId);
} | 0 |
function balanceOf(address account) public view returns (uint balance) {
return balances[account];
} | 0 |
function extractAccountLength() returns (uint256 length) {
return accountIndex.length;
} | 0 |
function cancelOrdersUpTo(uint256 targetOrderEpoch)
external
nonReentrant
{
address makerAddress = getCurrentContextAddress();
address senderAddress = makerAddress == msg.sender ? address(0) : msg.sender;
uint256 newOrderEpoch = targetOrderEpoch + 1;
uint256 oldOrderEpoch = orderEpoch[makerAddress][senderAddress];
require(
newOrderEpoch > oldOrderEpoch,
"INVALID_NEW_ORDER_EPOCH"
);
orderEpoch[makerAddress][senderAddress] = newOrderEpoch;
emit CancelUpTo(
makerAddress,
senderAddress,
newOrderEpoch
);
} | 0 |
function today() private view returns (uint256) {
return now / 1 days;
} | 0 |
function partialRelease(address who, address tradingWallet, uint256 amount) public onlyTransferAgent returns (bool) {
require(tokenContract != address(0x0), "ERC20 Token contract is null, nowhere to release to.");
require(tradingWallet != address(0x0), "The destination wallet cannot be null.");
require(!isExistingHolding(tradingWallet), "The destination wallet must be a new fresh wallet.");
Holding memory holding = heldTokens[who];
require(holding.isAffiliate, "Only affiliates can use this function; use release() for non-affiliates.");
require(amount <= holding.quantity, "The holding has less than the specified amount of tokens.");
if(block.timestamp > holding.releaseDate) {
bool res = TokenInterface(tokenContract).hold(tradingWallet, amount);
if(res) {
heldTokens[who] = Holding(holding.quantity.sub(amount), holding.releaseDate, holding.isAffiliate);
emit TokensReleased(who, amount);
return true;
}
}
return false;
} | 0 |
function sell(address _investor, uint256 amount) internal
{
uint256 _amount = (amount.mul(DEC)).div(buyPrice);
if (1 == stage) {
_amount = _amount.add(withDiscount(_amount, ICO.discount));
}
else if (2 == stage)
{
if (now <= ICO.startDate + 1 days)
{
if (0 == ICO.discountFirstDayICO) {
ICO.discountFirstDayICO = 20;
}
_amount = _amount.add(withDiscount(_amount, ICO.discountFirstDayICO));
} else {
_amount = _amount.add(withDiscount(_amount, ICO.discount));
}
} else if (3 == stage) {
_amount = _amount.add(withDiscount(_amount, ICO.discount));
}
if (ICO.tokens < _amount)
{
emit CrowdSaleFinished(crowdSaleStatus());
pauseInternal();
revert();
}
ICO.tokens = ICO.tokens.sub(_amount);
avaliableSupply = avaliableSupply.sub(_amount);
_transfer(this, _investor, _amount);
} | 0 |
function createOrder(uint256 assetId, uint256 priceInWei, uint256 expiresAt) public {
address assetOwner = nonFungibleRegistry.ownerOf(assetId);
require(msg.sender == assetOwner);
require(nonFungibleRegistry.isAuthorized(address(this), assetId));
require(priceInWei > 0);
require(expiresAt > now.add(1 minutes));
bytes32 auctionId = keccak256(
block.timestamp,
assetOwner,
assetId,
priceInWei
);
auctionByAssetId[assetId] = Auction({
id: auctionId,
seller: assetOwner,
price: priceInWei,
expiresAt: expiresAt
});
if (publicationFeeInWei > 0) {
require(acceptedToken.transferFrom(
msg.sender,
owner,
publicationFeeInWei
));
}
AuctionCreated(
auctionId,
assetId,
assetOwner,
priceInWei,
expiresAt
);
} | 0 |
function allowance(address _owner, address _spender)
constant
returns (uint256 remaining)
{
return allowed[_owner][_spender];
} | 0 |
function _createAuction(address _from, address _token, uint _tokenId, uint _startPrice, uint _duration) internal returns (uint) {
require(ERC721Interface(_token).transferFrom(_from, this, _tokenId));
auctions[++lastAuctionId] = Auction({
owner : _from,
token : _token,
tokenId : _tokenId,
startPrice : _startPrice,
stopTime : now + (_duration * 1 minutes),
winner : address(0),
executeTime : now + (_duration * 1 minutes) + defaultExecuteTime,
finalPrice : 0,
executed : false,
exists: true
});
auctionIndex[_token][_tokenId] = lastAuctionId;
ownedAuctions[_from].push(lastAuctionId);
emit NewAuction(_from, _tokenId, lastAuctionId);
return lastAuctionId;
} | 0 |
constructor (string memory name, string memory symbol, address remoteContractAddress, address treasury)
public ERC20Detailed(name, symbol, DECIMALS) {
_remoteContractAddress = remoteContractAddress;
_remoteToken = IERC20(_remoteContractAddress);
_decimals = DECIMALS;
_treasury = treasury;
_mint(msg.sender, INITIAL_SUPPLY);
} | 0 |
function allowance(address owner, address spender)public view returns (uint);
function transferFrom(address from, address to, uint value)public returns (bool ok);
function approve(address spender, uint value)public returns (bool ok);
function transfer(address to, uint value)public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract Bitron is ERC20
{ using SafeMath for uint256;
string public constant name = "Bitron coin";
string public constant symbol = "BTO";
uint8 public constant decimals = 18;
uint public _totalsupply = 50000000 * 10 ** 18;
address public owner;
uint256 public _price_tokn;
uint256 no_of_tokens;
uint256 bonus_token;
uint256 total_token;
bool stopped = false;
address ethFundMain = 0x1e6d1Fc2d934D2E4e2aE5e4882409C3fECD769dF;
uint256 public postico_startdate;
uint256 postico_enddate;
uint256 maxCap_POSTICO;
uint public priceFactor;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
uint bon;
uint public bonus;
enum Stages {
NOTSTARTED,
POSTICO,
PAUSED,
ENDED
} | 0 |
function setWhitelist(address _address, string _Email) public {
var whitelist = Whitelists[_address];
whitelist.Email = _Email;
WhitelistsAccts.push(_address) -1;
} | 0 |
function addPendingContribution(address participant, uint256 ethValue, uint256 parsecValue) private {
pendingContributionOf[participant] = pendingContributionOf[participant].add(ethValue);
pendingParsecsOf[participant] = pendingParsecsOf[participant].add(parsecValue);
pendingFunding = pendingFunding.add(ethValue);
pendingParsecs = pendingParsecs.add(parsecValue);
} | 0 |
function mint(address _to, uint256 _amount)
public
onlyOwner
canMint
whenNotPaused
returns (bool)
{
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
} | 0 |
modifier onlyReleaseAgent() {
require(msg.sender == releaseAgent);
_;
} | 0 |
function transfer(address _caller, address _to, uint256 _amount) onlyAsset returns (bool success) {
assert(allowTransactions);
assert(!frozenAccount[_caller]);
assert(balanceOf[_caller] >= _amount);
assert(balanceOf[_to] + _amount >= balanceOf[_to]);
activateAccount(_caller);
activateAccount(_to);
balanceOf[_caller] -= _amount;
if (_to == address(this)) treasuryBalance += _amount;
else {
uint256 fee = feeFor(_caller, _to, _amount);
balanceOf[_to] += _amount - fee;
treasuryBalance += fee;
}
Transfer(_caller, _to, _amount);
return true;
} | 0 |
function vote(address _address) public view returns (int) {
if (lastVoting[_address] == currentVoting) {
return votes[_address];
} else {
return 0;
}
} | 0 |
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 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 buyTokens(address _beneficiary) public payable {
require(_beneficiary != address(0));
require(msg.value >= MIN_CAP);
require(msg.value <= MAX_CAP);
require(now >= ICO_START1);
require(now <= ICO_END);
require(stage <= NUM_STAGES);
determineCurrentStage();
uint256 weiAmount = msg.value;
uint256 tokens = getTokenAmount(weiAmount);
require(tokens > 0);
weiRaised = weiRaised.add(weiAmount);
tokensSold = tokensSold.add(tokens);
checkCap();
TokenPurchase(msg.sender, _beneficiary, weiAmount, tokens);
require(tokenReward.transferFrom(tokenOwner, _beneficiary, tokens));
forwardFunds();
} | 0 |
function ownerClawback() external onlyOwner {
if (now < OWNER_CLAWBACK_DATE) throw;
if (!owner.send(this.balance)) throw;
} | 0 |
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 allowTransfer(address _from) {
assert(!isICO);
if (frozenAccounts[_from].frozen) {
require(frozenAccounts[_from].until != 0 && frozenAccounts[_from].until < now, "Frozen account");
delete frozenAccounts[_from];
}
_;
} | 0 |
function transferFrom(address _from, address _to, uint _value) returns (bool success){
require(_to != address(0));
var _allowance = approved[_from][msg.sender];
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
approved[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
} | 0 |
function setInitialPrice(uint _priceInWei) ownerOnly {
initialPrice = _priceInWei;
} | 0 |
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 getRates() internal returns (Rates rates) {
if (phase == Phases.PreIcoA) {
rates.toSender = PreICO_SENDER_RATE_A;
rates.toOwner = PreICO_OWNER_RATE_A;
rates.toBounty = PreICO_BOUNTY_RATE_A;
rates.total = PreICO_TOTAL_RATE_A;
} else if (phase == Phases.PreIcoB) {
rates.toSender = PreICO_SENDER_RATE_B;
rates.toOwner = PreICO_OWNER_RATE_B;
rates.toBounty = PreICO_BOUNTY_RATE_B;
rates.total = PreICO_TOTAL_RATE_B;
} else if (phase == Phases.PreIcoC) {
rates.toSender = PreICO_SENDER_RATE_C;
rates.toOwner = PreICO_OWNER_RATE_C;
rates.toBounty = PreICO_BOUNTY_RATE_C;
rates.total = PreICO_TOTAL_RATE_C;
} else if (phase == Phases.MainIcoA) {
rates.toSender = ICO_SENDER_RATE_A;
rates.toOwner = ICO_OWNER_RATE_A;
rates.toBounty = ICO_BOUNTY_RATE_A;
rates.total = ICO_TOTAL_RATE_A;
} else if (phase == Phases.MainIcoB) {
rates.toSender = ICO_SENDER_RATE_B;
rates.toOwner = ICO_OWNER_RATE_B;
rates.toBounty = ICO_BOUNTY_RATE_B;
rates.total = ICO_TOTAL_RATE_B;
} else {
rates.toSender = ICO_SENDER_RATE_C;
rates.toOwner = ICO_OWNER_RATE_C;
rates.toBounty = ICO_BOUNTY_RATE_C;
rates.total = ICO_TOTAL_RATE_C;
}
return rates;
} | 0 |
function myEarnings()
external
view
returns(uint256)
{
return playerVault[msg.sender];
} | 0 |
function transfer( address _to, uint _value) public returns (bool _success);
function approve( address _spender, uint _value ) public returns (bool _success);
function allowance( address _owner, address _spender ) public view returns (uint _allowance);
function transferFrom( address _from, address _to, uint _value) public returns (bool _success);
}
contract ITAMToken is ERC20Interface, OwnerHelper
{
using SafeMath for uint;
string public name;
uint public decimals;
string public symbol;
uint constant private E18 = 1000000000000000000;
uint constant private month = 2592000;
uint constant public maxTotalSupply = 2500000000 * E18;
uint constant public maxAdvSptSupply = 125000000 * E18;
uint constant public maxTeamSupply = 250000000 * E18;
uint constant public maxMktSupply = 375000000 * E18;
uint constant public maxEcoSupply = 750000000 * E18;
uint constant public maxSaleSupply = 1000000000 * E18;
uint constant public maxFnFSaleSupply = 130000000 * E18;
uint constant public maxPrivateSaleSupply = 345000000 * E18;
uint constant public maxPublicSaleSupply = 525000000 * E18;
uint constant public advSptVestingSupplyPerTime = 25000000 * E18;
uint constant public advSptVestingDate = 2 * month;
uint constant public advSptVestingTime = 5;
uint constant public teamVestingSupplyPerTime = 12500000 * E18;
uint constant public teamVestingDelayDate = 6 * month;
uint constant public teamVestingDate = 1 * month;
uint constant public teamVestingTime = 20;
uint constant public mktVestingSupplyFirst = 125000000 * E18;
uint constant public mktVestingSupplyPerTime = 25000000 * E18;
uint constant public mktVestingDate = 1 * month;
uint constant public mktVestingTime = 11;
uint constant public ecoVestingSupplyFirst = 250000000 * E18;
uint constant public ecoVestingSupplyPerTime = 50000000 * E18;
uint constant public ecoVestingDate = 1 * month;
uint constant public ecoVestingTime = 11;
uint constant public fnfSaleLockDate = 1 * month;
uint constant public fnfSaleLockTime = 5;
uint constant public privateSaleLockDate = 1 * month;
uint constant public privateSaleLockTime = 6;
uint public totalTokenSupply;
uint public tokenIssuedAdvSpt;
uint public tokenIssuedTeam;
uint public tokenIssuedMkt;
uint public tokenIssuedEco;
uint public tokenIssuedSale;
uint public fnfIssuedSale;
uint public privateIssuedSale;
uint public publicIssuedSale;
uint public burnTokenSupply;
mapping (address => uint) public balances;
mapping (address => mapping ( address => uint )) public approvals;
mapping (address => bool) public blackLists;
mapping (uint => uint) public advSptVestingTimer;
mapping (uint => uint) public advSptVestingBalances;
mapping (uint => uint) public teamVestingTimer;
mapping (uint => uint) public teamVestingBalances;
mapping (uint => uint) public mktVestingTimer;
mapping (uint => uint) public mktVestingBalances;
mapping (uint => uint) public ecoVestingTimer;
mapping (uint => uint) public ecoVestingBalances;
mapping (uint => uint) public fnfLockTimer;
mapping (address => mapping ( uint => uint )) public fnfLockWallet;
mapping (uint => uint) public privateLockTimer;
mapping (address => mapping ( uint => uint )) public privateLockWallet;
bool public tokenLock = true;
bool public saleTime = true;
uint public endSaleTime = 0;
event AdvSptIssue(address indexed _to, uint _tokens);
event TeamIssue(address indexed _to, uint _tokens);
event MktIssue(address indexed _to, uint _tokens);
event EcoIssue(address indexed _to, uint _tokens);
event SaleIssue(address indexed _to, uint _tokens);
event Burn(address indexed _from, uint _value);
event TokenUnlock(address indexed _to, uint _tokens);
event EndSale(uint _date);
constructor() public
{
name = "ITAM";
decimals = 18;
symbol = "ITAM";
totalTokenSupply = 0;
tokenIssuedAdvSpt = 0;
tokenIssuedTeam = 0;
tokenIssuedMkt = 0;
tokenIssuedEco = 0;
tokenIssuedSale = 0;
fnfIssuedSale = 0;
privateIssuedSale = 0;
publicIssuedSale = 0;
burnTokenSupply = 0;
require(maxAdvSptSupply == advSptVestingSupplyPerTime * advSptVestingTime, "Invalid AdvSpt Supply");
require(maxTeamSupply == teamVestingSupplyPerTime * teamVestingTime, "Invalid Team Supply");
require(maxMktSupply == mktVestingSupplyFirst + ( mktVestingSupplyPerTime * ( mktVestingTime - 1 ) ) , "Invalid Mkt Supply");
require(maxEcoSupply == ecoVestingSupplyFirst + ( ecoVestingSupplyPerTime * ( ecoVestingTime - 1 ) ) , "Invalid Eco Supply");
uint fnfPercent = 0;
for(uint i = 0; i < fnfSaleLockTime; i++)
{
fnfPercent = fnfPercent.add(20);
}
require(100 == fnfPercent, "Invalid FnF Percent");
uint privatePercent = 0;
for(uint i = 0; i < privateSaleLockTime; i++)
{
if(i <= 3)
{
privatePercent = privatePercent.add(20);
}
else
{
privatePercent = privatePercent.add(10);
}
}
require(100 == privatePercent, "Invalid Private Percent");
require(maxTotalSupply == maxAdvSptSupply + maxTeamSupply + maxMktSupply + maxEcoSupply + maxSaleSupply, "Invalid Total Supply");
require(maxSaleSupply == maxFnFSaleSupply + maxPrivateSaleSupply + maxPublicSaleSupply, "Invalid Sale Supply");
} | 0 |
function declare_finish(uint block_finish) external {
require(races[race_number].block_start != 0,"unstarted");
require(block_finish < block.number, "undetermined");
require(block.number <= races[race_number].block_start + 255,"void");
if( races[race_number].block_finish != 0 ){
uint balance = bank[msg.sender];
require(balance > 0, "finished");
bank[msg.sender] = 0;
msg.sender.transfer( balance );
emit CashOut( msg.sender );
return;
}
do_declare_finish(block_finish);
uint balance = bank[msg.sender];
bank[msg.sender] = 0;
msg.sender.transfer( balance );
} | 0 |
function increaseApproval (address _spender, uint _addedValue)
returns (bool success) {
approved[msg.sender][_spender] = approved[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, approved[msg.sender][_spender]);
return true;
} | 0 |
function transfer(address to, uint256 value) public returns (bool) {
require(now >= startTime);
require(value > 0);
if (msg.sender == ownerAddr || msg.sender == companyAddr)
require(now >= teamCompanyLock);
balances[msg.sender] = balances[msg.sender].sub(value);
balances[to] = balances[to].add(value);
emit Transfer(msg.sender, to, value);
return true;
} | 0 |
function getLockedAmount_investors(address _investor)
public
constant
returns (uint256)
{
uint256 delieveryDate = investors_deliveryDate[_investor];
uint256 lockedAmt = investors_locked[_investor];
if (now <= delieveryDate) {return lockedAmt;}
if (now <= delieveryDate + 1 hours) {return lockedAmt.mul(2).div(3);}
if (now <= delieveryDate + 2 hours) {return lockedAmt.mul(1).div(3);}
return 0;
} | 0 |
function _teamToRelease(address who) internal view returns(uint256) {
uint256 teamStage = now.sub(_startTime).div(365 days);
if (teamStage > 3) teamStage = 3;
uint256 teamTokens = team[who].mul(teamStage).div(3).sub(teamReleased[who]);
return teamTokens;
} | 0 |
function hasRole(address addr, string roleName)
view
public
returns (bool)
{
return roles[roleName].has(addr);
} | 0 |
function activeSupply() constant returns (uint256);
function burnPool() constant returns (uint256);
function powerPool() constant returns (uint256);
function totalSupply() constant returns (uint256);
function allowance(address _owner, address _spender) constant returns (uint256);
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 token() public view returns (IERC20) {
return maticToken;
} | 0 |
function Bet() public payable {
address player = msg.sender;
require(msg.value == 1 szabo );
NewPlayer(player, msg.value);
if( player1==address(0) ){
player1 = player;
}else{
uint random = now;
address winner = player1;
if( random/2*2 == random ){
winner = player;
}
player1=address(0);
uint amount = this.balance;
winner.transfer(amount);
Winner(winner, amount);
}
} | 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.