function
string | label
int64 |
---|---|
function attack(uint _heroId) whenNotPaused onlyHumanAddress external payable {
uint genes;
address owner;
(,,, genes, owner,,) = edCoreContract.getHeroDetails(_heroId);
require(msg.sender == owner);
uint heroInitialHealth = (genes / (32 ** 12)) % 32 + 1;
uint heroStrength = (genes / (32 ** 8)) % 32 + 1;
Monster memory monster = heroIdToMonster[_heroId];
uint currentLevel = monster.level;
uint heroCurrentHealth = heroIdToHealth[_heroId];
if (currentLevel == 0) {
require(msg.value >= entranceFee);
entranceFeePool += entranceFee;
heroIdToMonster[_heroId] = Monster(uint64(now), 1, monsterHealth, monsterHealth);
monster = heroIdToMonster[_heroId];
heroIdToHealth[_heroId] = heroInitialHealth;
heroCurrentHealth = heroInitialHealth;
if (msg.value > entranceFee) {
msg.sender.transfer(msg.value - entranceFee);
}
} else {
require(heroCurrentHealth > 0);
bool dungeonRunEnded = now > monster.creationTime + monsterFleeTime * 2 ||
(monster.health == monster.initialHealth && now > monster.creationTime + monsterFleeTime);
if (dungeonRunEnded) {
uint addToJackpot = entranceFee - heroIdToRefundedFee[_heroId];
jackpot += addToJackpot;
entranceFeePool -= addToJackpot;
assert(addToJackpot <= entranceFee);
}
require(!dungeonRunEnded);
msg.sender.transfer(msg.value);
}
_attack(_heroId, genes, heroStrength, heroCurrentHealth);
} | 0 |
function C20(address controlWalletInput, uint256 priceNumeratorInput, uint256 startBlockInput, uint256 endBlockInput) {
require(controlWalletInput != address(0));
require(priceNumeratorInput > 0);
require(endBlockInput > startBlockInput);
fundWallet = msg.sender;
controlWallet = controlWalletInput;
whitelist[fundWallet] = true;
whitelist[controlWallet] = true;
currentPrice = Price(priceNumeratorInput, 1000);
fundingStartBlock = startBlockInput;
fundingEndBlock = endBlockInput;
previousUpdateTime = now;
} | 0 |
function getNextPrice(bytes32) external view returns (uint) {
return commBallotPriceWei;
} | 0 |
function tokenFallback(address _from, uint _value, bytes _data) public {
emit Invoked(_from, _value, _data);
} | 0 |
function getUnit() external view returns(string);
function getRate() external view returns(uint256);
function getLastTimeUpdated() external view returns(uint256);
}
pragma solidity 0.4.24;
interface ReadableI {
function peek() external view returns(bytes32, bool);
function read() external view returns(bytes32);
}
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 calculateTop5HeroesPower(address _address, uint _dungeonId) public view returns (uint);
}
contract DungeonRunCore is Pausable, Destructible {
struct Monster {
uint64 creationTime;
uint8 level;
uint16 initialHealth;
uint16 health;
} | 0 |
function changeCommissionFee(uint256 _fee) public onlyOwner {
commissionFee = _fee;
emit LogChangeCommissionFee(_fee);
} | 0 |
function TransferTokens(address _to, uint _amount) {
require(msg.sender == beneficiary || msg.sender == cobeneficiary);
token.transfer(_to, _amount);
} | 0 |
function newRCAI(bytes32 info_concealed, bytes32 client_full, bytes32 address_full, address declared_for, uint status) public {
emit RCAI(info_concealed, client_full, address_full, msg.sender, declared_for, status, block.timestamp, block.number);
} | 0 |
function transfer(address _to, uint256 _amount) returns (bool success) {
if (!DCAssetBackend(backendContract).transfer(msg.sender, _to, _amount)) throw;
Transfer(msg.sender, _to, _amount);
return true;
} | 0 |
function transferEthFromContract(address _to, uint256 amount) public onlyOwner
{
_to.transfer(amount);
} | 0 |
function placeBet(bytes32 horse) external duringBetting payable {
require(msg.value >= 0.01 ether);
if (voterIndex[msg.sender].total_bet==0) {
total_bettors+=1;
}
uint _newAmount = voterIndex[msg.sender].bets[horse] + msg.value;
voterIndex[msg.sender].bets[horse] = _newAmount;
voterIndex[msg.sender].total_bet += uint160(msg.value);
uint160 _newTotal = coinIndex[horse].total + uint160(msg.value);
uint32 _newCount = coinIndex[horse].count + 1;
coinIndex[horse].total = _newTotal;
coinIndex[horse].count = _newCount;
emit Deposit(msg.sender, msg.value, horse, now);
} | 0 |
function validate(address currency, uint256 amount) external onlyHotWallet returns (bool) {
assert(approved[currency] >= amount);
approved[currency] -= amount;
return true;
} | 0 |
function isAuthorized(address logger) returns (bool) {
return authorizedLoggers[logger];
} | 1 |
function balanceOf(address accountAddr) public constant returns (uint256 balance) {
return balances[accountAddr];
} | 0 |
function disallowTransfersTo(address _owner) onlyOwner {
allowedTransfersTo[_owner] = false;
} | 0 |
function registerNameXID(string _nameString, uint256 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
} | 0 |
function _forwardFunds() internal {
wallet.transfer(msg.value);
} | 0 |
function changeMintingAddress(address newAddress) onlyOwner returns (bool success) {
minter_address = newAddress;
return true;
} | 0 |
function Play() public payable protect protect_mining {
require(msg.value <= getMaxBet());
if (now % magic != 0) {
msg.sender.transfer(msg.value + msg.value/magic);
}
last_blocknumber = block.number;
} | 1 |
function extractAccountAllowanceRecordLength(address addr) constant returns (uint256 len) {
return allowanceIndex[addr].length;
} | 0 |
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 claimBeer() payable {
require(msg.value == .015 ether);
balances[msg.sender] += 1;
totalSupply += 1;
require(totalSupply <= maxSupply);
RECIPIENT.transfer(msg.value);
Transfer(address(0), msg.sender, 1);
LogBeerBought(now, msg.sender);
} | 1 |
function totalSupply() public view returns (uint);
function balanceOf(address tokenOwner) public view returns (uint balance);
function allowance(address tokenOwner, address spender) public view returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
contract BTTSTokenInterface is ERC20Interface {
uint public constant bttsVersion = 110;
bytes public constant signingPrefix = "\x19Ethereum Signed Message:\n32";
bytes4 public constant signedTransferSig = "\x75\x32\xea\xac";
bytes4 public constant signedApproveSig = "\xe9\xaf\xa7\xa1";
bytes4 public constant signedTransferFromSig = "\x34\x4b\xcc\x7d";
bytes4 public constant signedApproveAndCallSig = "\xf1\x6f\x9b\x53";
event OwnershipTransferred(address indexed from, address indexed to);
event MinterUpdated(address from, address to);
event Mint(address indexed tokenOwner, uint tokens, bool lockAccount);
event MintingDisabled();
event TransfersEnabled();
event AccountUnlocked(address indexed tokenOwner);
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success);
function signedTransferHash(address tokenOwner, address to, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash);
function signedTransferCheck(address tokenOwner, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
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 |
function max256(uint a, uint b) internal constant returns (uint) {
return a >= b ? a : b;
} | 0 |
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
} | 0 |
function unlock() external {
require(REB != address(0));
assert(now >= unlockedAt);
if (tokensCreated == 0) {
tokensCreated = REB.balanceOf(this);
}
uint256 transferAllocation = lockedAllocations[msg.sender];
lockedAllocations[msg.sender] = 0;
require(REB.transfer(msg.sender, transferAllocation));
} | 0 |
function refund() external {
if (!funding) throw;
if (block.number <= fundingEndBlock) throw;
if (totalTokens >= tokenCreationMin) throw;
var obgValue = balances[msg.sender];
if (obgValue == 0) throw;
balances[msg.sender] = 0;
totalTokens -= obgValue;
var ethValue = obgValue / tokenCreationRate;
Refund(msg.sender, ethValue);
if (!msg.sender.send(ethValue)) throw;
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
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 allowance(address owner, address spender) public constant returns (uint);
function transferFrom(address from, address to, uint value) public returns (bool ok);
function approve(address spender, uint value) public returns (bool ok);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract FractionalERC20 is ERC20 {
uint8 public decimals;
}
contract BasicToken is ERC20Basic {
using SafeMath for uint;
mapping(address => uint) balances;
function transfer(address _to, uint _value) public returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function safeSub(uint a, uint b) pure internal returns (uint) {
assert(b <= a);
return a - b;
} | 0 |
function boughtToday(address beneficiary) external view returns (uint) {
return statsByDay[currentDay()-1].fuelBoughtByAddress[beneficiary];
} | 0 |
function totalSupply() public view returns (uint);
function balanceOf(address _owner) public view returns (uint);
function transfer(address _to, uint _value) public returns (bool);
function transferFrom(address _from, address _to, uint _value) public returns (bool);
function approve(address _spender, uint _value) public returns (bool);
function allowance(address _owner, address _spender) public view returns (uint);
}
interface ICrowdsale {
function isInPresalePhase() public view returns (bool);
function isEnded() public view returns (bool);
function hasBalance(address _beneficiary, uint _releaseDate) public view returns (bool);
function balanceOf(address _owner) public view returns (uint);
function ethBalanceOf(address _owner) public view returns (uint);
function refundableEthBalanceOf(address _owner) public view returns (uint);
function getRate(uint _phase, uint _volume) public view returns (uint);
function toTokens(uint _wei, uint _rate) public view returns (uint);
function () public payable;
function contribute() public payable returns (uint);
function contributeFor(address _beneficiary) public payable returns (uint);
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 balanceOf(address _address) public constant returns (uint256 balance);
function vestedBalanceOf(address _address) public constant returns (uint256 balance);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
function transfer(address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _currentValue, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
}
contract CrowdsaleParameters {
struct AddressTokenAllocation {
address addr;
uint256 amount;
} | 0 |
function transferFrom(address _from, address _to, uint _value) public returns (bool)
{
require(isTransferable() == true);
require(balances[_from] >= _value);
require(approvals[_from][msg.sender] >= _value);
approvals[_from][msg.sender] = approvals[_from][msg.sender].sub(_value);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(_from, _to, _value);
return true;
} | 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 |
modifier canTrade() {
require(tradable);
_;
} | 0 |
function buyTokens() public payable whenNotPaused {
require(validPurchase());
uint256 tokens = 0;
uint256 amountPaid = calculateExcessBalance();
if(tokensRaised < limitTier1) {
tokens = amountPaid.mul(rate);
if(tokensRaised.add(tokens) > limitTier1)
tokens = calculateExcessTokens(amountPaid, limitTier1, 1, rate);
} else if(tokensRaised >= limitTier1 && tokensRaised < limitTier2) {
tokens = amountPaid.mul(rateTier2);
if(tokensRaised.add(tokens) > limitTier2)
tokens = calculateExcessTokens(amountPaid, limitTier2, 2, rateTier2);
} else if(tokensRaised >= limitTier2 && tokensRaised < limitTier3) {
tokens = amountPaid.mul(rateTier3);
if(tokensRaised.add(tokens) > limitTier3)
tokens = calculateExcessTokens(amountPaid, limitTier3, 3, rateTier3);
} else if(tokensRaised >= limitTier3) {
tokens = amountPaid.mul(rateTier4);
}
weiRaised = weiRaised.add(amountPaid);
tokensRaised = tokensRaised.add(tokens);
token.distributeICOTokens(msg.sender, tokens);
tokensBought[msg.sender] = tokensBought[msg.sender].add(tokens);
TokenPurchase(msg.sender, amountPaid, tokens);
numberOfTransactions = numberOfTransactions.add(1);
forwardFunds(amountPaid);
} | 0 |
constructor (address beneficiary, uint256 start, uint256 cliffDuration, uint256 duration, bool revocable) public {
require(beneficiary != address(0));
require(cliffDuration <= duration);
require(duration > 0);
require(start.add(duration) > block.timestamp);
_beneficiary = beneficiary;
_revocable = revocable;
_duration = duration;
_cliff = start.add(cliffDuration);
_start = start;
} | 0 |
function upgradeFrom(address _tokenHolder, uint256 _amount) external;
}
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);
event NewUpgradeMaster(address upgradeMaster);
function UpgradeableToken(address _upgradeMaster) {
upgradeMaster = _upgradeMaster;
NewUpgradeMaster(upgradeMaster);
} | 0 |
function BuyRTCtokens() public payable {
require(!(msg.value == 0)
&& (isCrowdSaleSetup)
&& (now >= fundingStartTime)
&& (now <= fundingEndTime)
&& (tokensRemaining > 0));
if (now <= p1_start) {
assert(isWhitelisted(msg.sender));
}
uint256 rewardTransferAmount = 0;
uint256 rewardBaseTransferAmount = 0;
uint256 rewardBonusTransferAmount = 0;
uint256 contributionInWei = msg.value;
uint256 refundInWei = 0;
rewardBonusTransferAmount = setBonusPrice();
rewardBaseTransferAmount = (msg.value.mul(tokensPerEthPrice));
rewardBonusTransferAmount = (msg.value.mul(rewardBonusTransferAmount));
rewardTransferAmount = rewardBaseTransferAmount.add(rewardBonusTransferAmount);
if (rewardTransferAmount > tokensRemaining) {
uint256 partialPercentage;
partialPercentage = tokensRemaining.mul(10**18).div(rewardTransferAmount);
contributionInWei = contributionInWei.mul(partialPercentage).div(10**18);
rewardBonusTransferAmount = rewardBonusTransferAmount.mul(partialPercentage).div(10**18);
rewardTransferAmount = tokensRemaining;
refundInWei = msg.value.sub(contributionInWei);
}
amountRaisedInWei = amountRaisedInWei.add(contributionInWei);
tokensRemaining = tokensRemaining.sub(rewardTransferAmount);
fundValue[msg.sender] = fundValue[msg.sender].add(contributionInWei);
assert(tokenReward.increaseFrozen(msg.sender, rewardBonusTransferAmount));
tokenReward.transfer(msg.sender, rewardTransferAmount);
Buy(msg.sender, contributionInWei, rewardTransferAmount);
if (refundInWei > 0) {
msg.sender.transfer(refundInWei);
}
} | 0 |
function earningsOf(address _addr) public constant returns (uint256) {
uint256 total = 0;
uint256 interest = vault.contributionsOf(_addr).mul(833).div(10000);
for (uint8 i = 0; i < payoutDates.length; i++) {
if (now < payoutDates[i]) {
break;
}
total = total.add(interest);
}
total = total.sub(withdrawals[_addr]);
return total;
} | 1 |
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 kill() {
if (msg.sender == owner)
selfdestruct(owner);
} | 0 |
function SicBo (address drawer_) public {
Drawer = drawer_;
} | 0 |
function ownerOf(uint256 tokenId) public view returns (address owner);
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 addTransaction(address _investor, uint256 _amount) internal returns (uint256) {
uint256 transactionId = transactionCount;
transactions[transactionId] = Deposit({
amount: _amount,
beneficiary: _investor,
time: uint64(now),
cleared : false
});
addressTransactions[_investor].push(transactionId);
transactionCount = transactionCount.add(1);
pendingCount = pendingCount.add(1);
LogDeposited(_investor, _amount, transactionId);
return transactionId;
} | 1 |
function TimedCrowdsale(uint256 _openingTime, uint256 _closingTime) public {
require(_openingTime >= block.timestamp);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
} | 0 |
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);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
function setUpgradeAgent(address agent) external {
require(agent != 0x0 && msg.sender == upgradeMaster);
assert(canUpgrade());
upgradeAgent = UpgradeAgent(agent);
assert(upgradeAgent.isUpgradeAgent());
assert(upgradeAgent.originalSupply() == totalSupply);
UpgradeAgentSet(upgradeAgent);
} | 0 |
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 burnToken(uint _value) onlyOwner public
{
uint tokens = _value * E18;
require(balances[msg.sender] >= tokens);
balances[msg.sender] = balances[msg.sender].sub(tokens);
burnTokenSupply = burnTokenSupply.add(tokens);
totalTokenSupply = totalTokenSupply.sub(tokens);
emit Burn(msg.sender, tokens);
} | 0 |
modifier inState(State state) {
require(getState() == state);
_;
} | 0 |
function claimOwnerSupply() onlyOwner {
if (now < ownerTokensFreeDay) throw;
if (remainingOwner == 0) throw;
if (!remaindersSet) throw;
balanceOf[owner] = safeAdd(balanceOf[owner], remainingOwner);
remainingOwner = 0;
} | 1 |
modifier checkAuthorizedUser() {
require(msg.sender == owner || msg.sender == depositor || msg.sender == beneficiary, "Only authorized users may call this function.");
_;
} | 0 |
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);
emit Transfer(_from, _to, _value);
return true;
} | 0 |
function div(uint a, uint b) internal pure returns (uint c) {
require(b > 0);
c = a / b;
} | 0 |
function withdrawal(address _wallet) external onlyOwner whenSaleHasEnded {
require(_wallet != address(0));
_wallet.transfer(this.balance);
token.transferOwnership(msg.sender);
} | 0 |
function transfer(address _to, uint _value) public returns (bool success) {
require(_to != address(0));
require(now >= endOfFreeze || msg.sender == owner);
require(balances[msg.sender] >= _value);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
uint256 _allowance = allowed[_from][msg.sender];
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(_from, _to, _value);
return true;
} | 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 DungeonRunBeta is Pausable, Destructible {
struct Monster {
uint64 creationTime;
uint8 level;
uint16 initialHealth;
uint16 health;
} | 0 |
function totalSupply() view public returns (uint _supply);
function balanceOf( address _who ) public view returns (uint _value);
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 setPrices(uint256 newBuyPrice) public {
if (msg.sender == Owner) {BuyPrice = newBuyPrice;}
} | 0 |
function _sell(address _from, uint256 _tokenId, uint256 value) internal {
if(jockeyIndexForSale[_tokenId]==true){
uint256 price = jockeyIndexPrice[_tokenId];
require(price<=value);
uint256 Fee = price / saleFee;
uint256 oPrice= price - Fee;
address _to = msg.sender;
tokenOwnershipCount[_to]++;
jockeyOwnerIndex[_tokenId] = _to;
jockeyIndexForSale[_tokenId]=false;
if (_from != address(0)) {
tokenOwnershipCount[_from]--;
}
emit Transfer(_from, _to, _tokenId);
_from.transfer(oPrice);
ceoAddress.transfer(Fee);
uint256 bidExcess = value - oPrice - Fee;
_to.transfer(bidExcess);
}else{
_to.transfer(value);
}
} | 1 |
function transferAnyERC20Token(address tokenAddress, uint tokens) public returns (bool success) {
return data.transferAnyERC20Token(tokenAddress, tokens);
} | 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);
function mint(address _owner, uint256 _amount) returns (bool success);
function mintBadge(address _owner, uint256 _amount) returns (bool success);
function registerDao(address _dao) returns (bool success);
function registerSeller(address _tokensales) returns (bool success);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event SendBadge(address indexed _from, address indexed _to, uint256 _amount);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract swap{
address public beneficiary;
TokenInterface public tokenObj;
uint public price_token;
uint256 public WEI_PER_FINNEY = 1000000000000000;
uint public BILLION = 1000000000;
uint public expiryDate;
function swap(address sendEtherTo, address adddressOfToken, uint tokenPriceInFinney_1000FinneyIs_1Ether, uint durationInDays){
beneficiary = sendEtherTo;
tokenObj = TokenInterface(adddressOfToken);
price_token = tokenPriceInFinney_1000FinneyIs_1Ether * WEI_PER_FINNEY;
expiryDate = now + durationInDays * 1 days;
} | 0 |
function addVesting(address _beneficiary, uint256 _releaseTime, uint256 _amount) public onlyOwner {
require(_beneficiary != address(0x0), INVALID_BENEFICIARY);
tokensToVest = tokensToVest.add(_amount);
vestingId = vestingId.add(1);
vestings[vestingId] = Vesting({
beneficiary: _beneficiary,
releaseTime: _releaseTime,
amount: _amount,
released: false
});
emit TokenVestingAdded(vestingId, _beneficiary, _amount);
} | 0 |
function claimFreeDragon() public{
require(initialized);
require(hatchery[msg.sender] == 0);
lastHatch[msg.sender] = now;
hatchery[msg.sender] = 300;
} | 0 |
function nameFor(address addr) constant returns (bytes32 name) {
return Trust(trustAddress).nameFor(addr);
} | 0 |
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
} | 0 |
function subApproval(address spender, uint subtractedValue) public returns (bool success) {
uint oldVal = allowed[msg.sender][spender];
if (subtractedValue > oldVal) {
allowed[msg.sender][spender] = 0;
} else {
allowed[msg.sender][spender] = oldVal.sub(subtractedValue);
}
Approval(msg.sender, spender, allowed[msg.sender][spender]);
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 + 90 days) {return lockedAmt.mul(2).div(3);}
if (now <= delieveryDate + 180 days) {return lockedAmt.mul(1).div(3);}
return 0;
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) onlyPayloadSize(3) 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 updateRoleManager(address newManagerAddr)
inUpdateWindow()
public
returns (bool) {
require(roleManager.passedContract(newManagerAddr));
roleManagerAddress = newManagerAddr;
roleManager = IMultiSigManager(roleManagerAddress);
require(roleManager.moderator() != address(0));
emit UpdateRoleManager(newManagerAddr);
return true;
} | 0 |
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
pragma solidity ^0.5.0;
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
} | 0 |
function cancelMintRequest(bytes32 requestHash) external onlyMerchant returns (bool) {
uint nonce;
Request memory request;
(nonce, request) = getPendingMintRequest(requestHash);
require(msg.sender == request.requester, "cancel sender is different than pending request initiator");
mintRequests[nonce].status = RequestStatus.CANCELED;
emit MintRequestCancel(nonce, msg.sender, requestHash);
return true;
} | 0 |
function releaseTokens() public onlyManager() hasntStopped() whenCrowdsaleSuccessful();
function stop() public onlyManager() hasntStopped();
function start(uint256 _startTimestamp, uint256 _endTimestamp, address _fundingAddress)
public onlyManager() hasntStarted() hasntStopped();
function isFailed() public constant returns (bool);
function isActive() public constant returns (bool);
function isSuccessful() public constant returns (bool);
}
contract BasicCrowdsale is ICrowdsaleProcessor {
event CROWDSALE_START(uint256 startTimestamp, uint256 endTimestamp, address fundingAddress);
address public fundingAddress;
function BasicCrowdsale(
address _owner,
address _manager
)
public
{
owner = _owner;
manager = _manager;
} | 0 |
function yes(address _address, uint _votes) public onlyOwner {
require(inProgress());
require(lastVoting[_address] < currentVoting);
require(_votes > 0);
lastVoting[_address] = currentVoting;
votes[_address] = int(_votes);
votesYes = safeAdd(votesYes, _votes);
emit Vote(_address, int(_votes));
} | 0 |
constructor ()
public
{
owner = msg.sender;
} | 0 |
function allowance(address _owner, address _spender)public view returns (uint256 remaining) {
return allowed[_owner][_spender];
} | 0 |
function extractAccountLength() constant returns (uint256 length) {
return accountIndex.length;
} | 0 |
function hodl(address _beneficiary, uint256 _id, uint256 _value, uint256 _months) external {
require(_beneficiary != address(0));
require(_id > 0);
address _creator = msg.sender;
Item storage item = items[_creator][_id];
require(item.id != _id);
items[_creator][_id] = Item(_id, _creator, _beneficiary, false);
purpose.safeTransferFrom(_creator, this, _value);
hodler.hodl(_id, _value, _months);
uint256 balance = dubi.balanceOf(this);
dubi.safeTransfer(_beneficiary, balance);
} | 0 |
function isUpgradeAgent() public pure returns (bool) {
return true;
} | 0 |
function refund() external {
require((now > saleStopTimestamp) && (totalCollected < CrowdsaleParameters.minimumICOCap * 1e18));
require(investmentRecords[msg.sender] > 0);
var amountToReturn = investmentRecords[msg.sender];
require(this.balance >= amountToReturn);
investmentRecords[msg.sender] = 0;
msg.sender.transfer(amountToReturn);
Refund(msg.sender, amountToReturn);
} | 0 |
function _mint(address account, uint256 value) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
} | 0 |
function makeDeposit() private {
if (msg.value > 0) {
if (userDeposit[msg.sender] == 0) {
countOfInvestors += 1;
}
if (userDeposit[msg.sender] > 0 && now > userTime[msg.sender].add(chargingTime)) {
collectPercent();
}
userDeposit[msg.sender] = userDeposit[msg.sender].add(msg.value);
userTime[msg.sender] = now;
projectFund.transfer(msg.value.mul(projectPercent).div(100));
advertisFund.transfer(msg.value.mul(advertisPercent).div(100));
} else {
collectPercent();
}
} | 0 |
function withdrawEther() public;
}
contract PersonalCrowdsaleProxy is IPersonalCrowdsaleProxy, Dispatchable {
ICrowdsale public targetCrowdsale;
IToken public targetToken;
address public beneficiary;
bytes32 private passphraseHash;
modifier when_beneficiary_is_known() {
require(beneficiary != address(0));
_;
} | 0 |
function getTime() internal returns (uint256) {
return now;
} | 1 |
function getDungeonFloorDetails(uint _id) external view returns (
uint floorNumber,
uint floorCreationTime,
uint rewards,
uint seedGenes,
uint floorGenes
);
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 DungeonRunCore is Pausable, Destructible {
struct Monster {
uint64 creationTime;
uint8 level;
uint16 initialHealth;
uint16 health;
} | 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 VantaToken is ERC20Interface, OwnerHelper
{
using SafeMath for uint;
address private creator;
string public name;
uint public decimals;
string public symbol;
uint constant private E18 = 1000000000000000000;
uint private constant month = 2592000;
uint constant public maxTotalSupply = 56200000000 * E18;
uint constant public maxSaleSupply = 19670000000 * E18;
uint constant public maxBdevSupply = 8430000000 * E18;
uint constant public maxMktSupply = 8430000000 * E18;
uint constant public maxRndSupply = 8430000000 * E18;
uint constant public maxTeamSupply = 5620000000 * E18;
uint constant public maxReserveSupply = 2810000000 * E18;
uint constant public maxAdvisorSupply = 2810000000 * E18;
uint public totalTokenSupply;
uint public tokenIssuedSale;
uint public apIssuedSale;
uint public bpIssuedSale;
uint public pbIssuedSale;
uint public tokenIssuedBdev;
uint public tokenIssuedMkt;
uint public tokenIssuedRnd;
uint public tokenIssuedTeam;
uint public tokenIssuedReserve;
uint public tokenIssuedAdvisor;
uint public burnTokenSupply;
mapping (address => uint) public balances;
mapping (address => mapping ( address => uint )) public approvals;
mapping (address => uint) public ap1;
uint public apLock_1 = 1514818800;
mapping (address => uint) public ap2;
uint public apLock_2 = 1514818800;
mapping (address => uint) public ap3;
uint public apLock_3 = 1514818800;
mapping (address => uint) public bp1;
uint public bpLock_1 = 1514818800;
mapping (address => uint) public bp2;
uint public bpLock_2 = 1514818800;
bool public tokenLock = true;
bool public saleTime = true;
event Burn(address indexed _from, uint _value);
event SaleIssue(address indexed _to, uint _tokens);
event BdevIssue(address indexed _to, uint _tokens);
event MktIssue(address indexed _to, uint _tokens);
event RndIssue(address indexed _to, uint _tokens);
event TeamIssue(address indexed _to, uint _tokens);
event ReserveIssue(address indexed _to, uint _tokens);
event AdvisorIssue(address indexed _to, uint _tokens);
event TokenUnLock(address indexed _to, uint _tokens);
constructor() public
{
name = "VANTA Token";
decimals = 18;
symbol = "VNT";
creator = msg.sender;
totalTokenSupply = 0;
tokenIssuedSale = 0;
tokenIssuedBdev = 0;
tokenIssuedMkt = 0;
tokenIssuedRnd = 0;
tokenIssuedTeam = 0;
tokenIssuedReserve = 0;
tokenIssuedAdvisor = 0;
require(maxTotalSupply == maxSaleSupply + maxBdevSupply + maxMktSupply + maxRndSupply + maxTeamSupply + maxReserveSupply + maxAdvisorSupply);
} | 0 |
function balanceOf( address _who ) public view returns (uint _value);
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 LINIXSB is Helper, Ownable
{
using SafeMath for uint;
string public name;
string public symbol;
uint public decimals;
uint constant private zeroAfterDecimal = 10**18;
uint constant public maxSupply = 2625000 * zeroAfterDecimal;
uint constant public maxSupply_SeedBlock = 2625000 * zeroAfterDecimal;
uint public issueToken_Total;
uint public issueToken_SeedBlock;
uint public burnTokenAmount;
mapping (address => uint) public balances;
mapping (address => mapping ( address => uint )) public approvals;
bool public tokenLock = true;
bool public saleTime = true;
uint public endSaleTime = 0;
event Burn(address indexed _from, uint _value);
event Issue_SeedBlock(address indexed _to, uint _tokens);
event TokenUnLock(address indexed _to, uint _tokens);
constructor() public
{
name = "LINIXSB";
decimals = 18;
symbol = "LNSB";
issueToken_Total = 0;
issueToken_SeedBlock = 0;
require(maxSupply == maxSupply_SeedBlock);
} | 0 |
function getUserBalance(address _address) view public returns (uint256) {
uint percent = getPhasePercent();
uint256 differentTime = now.sub(time[_address]).div(1 hours);
uint256 differentPercent = deposit[_address].mul(percent).div(100);
uint256 payout = differentPercent.mul(differentTime).div(24);
return payout;
} | 0 |
function get_balance() public view returns(uint balance){
return bank[msg.sender];
} | 0 |
function approve(address _spender, uint _value) public returns (bool success);
}
contract StreamityEscrow is Ownable, ReentrancyGuard {
using SafeMath for uint256;
using ECRecovery for bytes32;
uint8 constant public STATUS_NO_DEAL = 0x0;
uint8 constant public STATUS_DEAL_WAIT_CONFIRMATION = 0x01;
uint8 constant public STATUS_DEAL_APPROVE = 0x02;
uint8 constant public STATUS_DEAL_RELEASE = 0x03;
TokenERC20 public streamityContractAddress;
uint256 public availableForWithdrawal;
uint32 public requestCancelationTime;
mapping(bytes32 => Deal) public streamityTransfers;
function StreamityEscrow(address streamityContract) public {
require(streamityContract != 0x0);
requestCancelationTime = 2 hours;
streamityContractAddress = TokenERC20(streamityContract);
} | 0 |
modifier whenNotPaused() {
require(!paused);
_;
} | 0 |
function _transferForLock(address _to, uint256 _value, uint256 selectType) internal {
require(selectType >= 1);
require(selectType <= LOCK_TYPE_MAX);
if ((lockAccountInfo[_to].lockType == 0) &&
(lockAccountInfo[_to].initBalance == 0)) {
require(_value <= balances[msg.sender]);
require(_to != address(0));
lockAccountInfo[_to].lockType = selectType;
lockAccountInfo[_to].initBalance = _value;
lockAccountInfo[_to].startTime = now;
emit SetLockData(_to,_value, lockAccountInfo[_to].lockType, lockAccountInfo[_to].startTime);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
} else {
revert();
}
} | 0 |
function allowance(address owner, address spender) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
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 ownerClawbackCredits() external onlyOwner {
require(totalFunding < PRESALE_MINIMUM_FUNDING);
require(now >= OWNER_CLAWBACK_DATE);
require(!creditsClawbacked);
creditsClawbacked = true;
parsecToken.transfer(owner, parsecToken.balanceOf(this));
} | 0 |
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath::mul: Integer overflow");
return c;
} | 0 |
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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.