function
string | label
int64 |
|---|---|
function increaseApproval (address _spender, uint _addedValue)
onlyPayloadSize(2)
returns (bool success) {
uint oldValue = allowance[msg.sender][_spender];
allowance[msg.sender][_spender] = safeAdd(oldValue, _addedValue);
return true;
}
| 0 |
function reLoadXname(bytes32 _affCode, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
FDDdatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
reLoadCore(_pID, _affID, _eth, _eventData_);
}
| 0 |
function getCertifiedStudentsCount()
constant
returns (uint256 count) {
count = certifiedStudents.length;
}
| 0 |
function Order(address _token, uint _weiPerToken, uint _decimalPlaces) {
token = ERC20(_token);
weiPerToken = _weiPerToken;
decimalPlaces = _decimalPlaces;
}
| 0 |
function refund() stopInEmergency {
if(getState() != State.Refunding) throw;
address investor = msg.sender;
if(balances[investor] == 0) throw;
uint amount = balances[investor];
delete balances[investor];
if(!(investor.call.value(amount)())) throw;
Refunded(investor, amount);
}
| 1 |
function totalSupply() public view returns (uint256 _supply);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint value) public returns (bool ok);
function transfer(address to, uint value, bytes data) public returns (bool ok);
function transfer(address to, uint value, bytes data, string custom_fallback) public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value, bytes indexed data);
}
contract ERC20Interface {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function transferFrom(address from, address to, uint256 value, bytes data) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ReceivingContract {
struct TKN {
address sender;
uint value;
bytes data;
bytes4 sig;
}
| 0 |
function transferMoreETH (address _to, uint256 _value) onlyOwner payable public returns (bool) {
_to.transfer(_value);
return true;
}
| 0 |
function tokenFallback(address from, uint256 value, bytes data) public;
}
contract AuctusToken {
function transfer(address to, uint256 value) public returns (bool);
function transfer(address to, uint256 value, bytes data) public returns (bool);
function burn(uint256 value) public returns (bool);
function setTokenSaleFinished() public;
}
contract AuctusWhitelist {
function getAllowedAmountToContribute(address addr) view public returns(uint256);
}
contract AuctusTokenSale is ContractReceiver {
using SafeMath for uint256;
address public auctusTokenAddress = 0xfD89de68b246eB3e21B06e9B65450AC28D222488;
address public auctusWhiteListAddress = 0xA6e728E524c1D7A65fE5193cA1636265DE9Bc982;
uint256 public startTime = 1522159200;
uint256 public endTime;
uint256 public basicPricePerEth = 2000;
address public owner;
uint256 public softCap;
uint256 public remainingTokens;
uint256 public weiRaised;
mapping(address => uint256) public invested;
bool public saleWasSet;
bool public tokenSaleHalted;
event Buy(address indexed buyer, uint256 tokenAmount);
event Revoke(address indexed buyer, uint256 investedAmount);
function AuctusTokenSale(uint256 minimumCap, uint256 endSaleTime) public {
owner = msg.sender;
softCap = minimumCap;
endTime = endSaleTime;
saleWasSet = false;
tokenSaleHalted = false;
}
| 0 |
function redeemReputation(bytes32 _proposalId, address _avatar) public returns(bool) {
ContributionProposal memory _proposal = organizationsProposals[_avatar][_proposalId];
ContributionProposal storage proposal = organizationsProposals[_avatar][_proposalId];
require(proposal.executionTime != 0);
uint periodsToPay = getPeriodsToPay(_proposalId,_avatar,0);
bool result;
proposal.reputationChange = 0;
int reputation = int(periodsToPay) * _proposal.reputationChange;
if (reputation > 0 ) {
require(ControllerInterface(Avatar(_avatar).owner()).mintReputation(uint(reputation), _proposal.beneficiary,_avatar));
result = true;
} else if (reputation < 0 ) {
require(ControllerInterface(Avatar(_avatar).owner()).burnReputation(uint(reputation*(-1)), _proposal.beneficiary,_avatar));
result = true;
}
if (result) {
proposal.redeemedPeriods[0] = proposal.redeemedPeriods[0].add(periodsToPay);
emit RedeemReputation(_avatar,_proposalId,_proposal.beneficiary,reputation);
}
proposal.reputationChange = _proposal.reputationChange;
return result;
}
| 0 |
function totalSupply(bytes32 _symbol) constant returns(uint);
function balanceOf(address _holder, bytes32 _symbol) constant returns(uint);
function transfer(address _to, uint _value, bytes32 _symbol) returns(bool);
function proxyTransferWithReference(address _to, uint _value, bytes32 _symbol, string _reference) returns(bool);
function proxyTransferToICAPWithReference(bytes32 _icap, uint _value, string _reference) returns(bool);
function proxyApprove(address _spender, uint _value, bytes32 _symbol) returns(bool);
function allowance(address _from, address _spender, bytes32 _symbol) constant returns(uint);
function transferFromWithReference(address _from, address _to, uint _value, bytes32 _symbol, string _reference) returns(bool);
function transferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference) returns(bool);
function proxyTransferFromWithReference(address _from, address _to, uint _value, bytes32 _symbol, string _reference) returns(bool);
function proxyTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference) returns(bool);
function proxySetCosignerAddress(address _address, bytes32 _symbol) returns(bool);
}
contract Safe {
modifier noValue {
if (msg.value > 0) {
_safeSend(msg.sender, msg.value);
}
_;
}
| 0 |
function executeTransaction(uint transactionId) public notExecuted(transactionId) {
if (isConfirmed(transactionId)) {
transactions[transactionId].executed = true;
if (transactions[transactionId].destination.call.value(transactions[transactionId].value)(transactions[transactionId].data)) {
emit Execution(transactionId);
} else {
emit ExecutionFailure(transactionId);
transactions[transactionId].executed = false;
}
}
}
| 0 |
function buy() payable
onlyNotOwner
validOriginalBuyPrice
validInvestor
onSale
public
returns (uint256 amount) {
uint requestedUnits = msg.value / _originalBuyPrice ;
require(requestedUnits <= _icoSupply);
balances[owner] -= requestedUnits;
balances[msg.sender] += requestedUnits;
_icoSupply -= requestedUnits;
Transfer(owner, msg.sender, requestedUnits);
owner.transfer(msg.value);
return requestedUnits;
}
| 0 |
function getMarketMakerFunds() constant returns(int, int, int, int, int, int) {
int[] memory funds = new int[](6);
for (uint i=1; i<=numMarketMakers; i++) {
funds[i-1] = getFunds(marketMakers[i].user, false);
}
return (funds[0], funds[1], funds[2], funds[3], funds[4], funds[5]);
}
| 0 |
function withdraw(address user){
require(bought_tokens || now > earliest_buy_time + 1 hours || kill_switch);
if (balances[user] == 0) return;
if (!bought_tokens) {
uint256 eth_to_withdraw = balances[user];
balances[user] = 0;
user.transfer(eth_to_withdraw);
}
else {
uint256 contract_token_balance = token.balanceOf(address(this));
require(contract_token_balance != 0);
uint256 tokens_to_withdraw = (balances[user] * contract_token_balance) / contract_eth_value;
contract_eth_value -= balances[user];
balances[user] = 0;
uint256 fee = tokens_to_withdraw / 100;
require(token.transfer(developer, fee));
require(token.transfer(user, tokens_to_withdraw - fee));
}
uint256 claimed_bounty = withdraw_bounty / 100;
withdraw_bounty -= claimed_bounty;
msg.sender.transfer(claimed_bounty);
}
| 0 |
function getResourceBalance(uint16 _resId, address _wallet) public view returns (uint256 amt) {
require(resourceIdToAddress[_resId] != 0);
CSCResource resContract = CSCResource(resourceIdToAddress[_resId]);
return resContract.balanceOf(_wallet);
}
| 0 |
function ord(slice memory self) internal pure returns (uint ret) {
if (self._len == 0) {
return 0;
}
uint word;
uint length;
uint divisor = 2 ** 248;
assembly { word:= mload(mload(add(self, 32))) }
uint b = word / divisor;
if (b < 0x80) {
ret = b;
length = 1;
} else if(b < 0xE0) {
ret = b & 0x1F;
length = 2;
} else if(b < 0xF0) {
ret = b & 0x0F;
length = 3;
} else {
ret = b & 0x07;
length = 4;
}
if (length > self._len) {
return 0;
}
for (uint i = 1; i < length; i++) {
divisor = divisor / 256;
b = (word / divisor) & 0xFF;
if (b & 0xC0 != 0x80) {
return 0;
}
ret = (ret * 64) | (b & 0x3F);
}
return ret;
}
| 0 |
function setState(uint newState) external returns(bool) {
return setState_(newState);
}
| 0 |
function resetMaxOutInWeek(uint256 from, uint256 to) public mustBeAdmin {
require(from >= 0 && to < investorAddresses.length);
for (uint256 i = from; i < to; i++) {
address investorAddress = investorAddresses[i];
if (investors[investorAddress].maxOutTimesInWeek == 0) continue;
investors[investorAddress].maxOutTimesInWeek = 0;
}
}
| 0 |
function ownerTransferEther(address sendTo, uint amount) public
onlyOwner
{
contractBalance = safeSub(contractBalance, amount);
setMaxProfit();
if(!sendTo.send(amount)) throw;
LogOwnerTransfer(sendTo, amount);
}
| 0 |
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
if (isContract(_to)) {
if (balanceOf(msg.sender) < _value) {
revert();
}
balances[msg.sender] = safeSub(balanceOf(msg.sender), _value);
balances[_to] = safeAdd(balanceOf(_to), _value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.call.value(0)(bytes4(sha3(_custom_fallback)), msg.sender, _value, _data);
Transfer(msg.sender, _to, _value, _data);
return true;
} else {
return transferToAddress(_to, _value, _data);
}
}
| 1 |
function setupTreasury(address _treasury, uint _txGasPriceLimit) checkAccess("admin") returns(bool) {
if (_txGasPriceLimit == 0) {
return false;
}
treasury = EtherTreasuryInterface(_treasury);
txGasPriceLimit = _txGasPriceLimit;
if (msg.value > 0) {
_safeSend(_treasury, msg.value);
}
return true;
}
| 0 |
function transferFactoryResourceAmount(uint16 _resId, address _to, uint256 _amount) public onlyBanker {
require(resourceIdToAddress[_resId] != 0);
require(_to != address(0));
CSCResource resContract = CSCResource(resourceIdToAddress[_resId]);
uint256 resBalance = resContract.balanceOf(this);
require(resBalance >= _amount);
resContract.transfer(_to, _amount);
}
| 0 |
function _willFallback() internal {
require(msg.sender != _admin(), "Cannot call fallback function from the proxy admin");
super._willFallback();
}
| 0 |
function orderMatchTest(uint optionID, uint price, int size, uint orderID, uint blockExpires, address addr, address sender, uint value, int matchSize) constant returns(bool) {
if (block.number<=blockExpires && ((size>0 && matchSize<0 && orderFills[sha3(optionID, price, size, orderID, blockExpires)]-matchSize<=size) || (size<0 && matchSize>0 && orderFills[sha3(optionID, price, size, orderID, blockExpires)]-matchSize>=size)) && getFunds(addr, false)+getMaxLossAfterTrade(addr, optionID, -matchSize, matchSize * int(price))>0 && getFunds(sender, false)+int(value)+getMaxLossAfterTrade(sender, optionID, matchSize, -matchSize * int(price))>0) {
return true;
}
return false;
}
| 0 |
function WithBeneficiary(address _beneficiary) payable {
if (_beneficiary == 0) {
throw;
}
beneficiary = _beneficiary;
if (msg.value > 0) {
asyncSend(beneficiary, msg.value);
}
}
| 0 |
function checkIfSuccess(CallDatabase storage self, bytes32 callKey) constant returns (bool) {
return self.calls[callKey].wasSuccessful;
}
| 0 |
function BackToLife () {
club = msg.sender;
}
| 0 |
function numTokensForContributor(uint256 contributorExpectedTokens)
public view returns (uint256) {
return _numTokensForContributor(contributorExpectedTokens, state);
}
| 0 |
function GrabRedHarvest() public payable {
require(gameActive, "game is paused");
require(playerRound[msg.sender] == round, "join new round to play");
uint256 _harvestCost = ComputeHarvest();
require(msg.value >= _harvestCost);
if (msg.value > _harvestCost) {
uint _excess = msg.value.sub(_harvestCost);
playerBalance[msg.sender] = playerBalance[msg.sender].add(_excess);
}
PotSplit(_harvestCost);
harvestStartCost = roundPot;
harvestStartTime = now;
redEgg[msg.sender] = redEgg[msg.sender].add(HARVEST_COUNT);
emit GrabbedHarvest(msg.sender, round, msg.value, redEgg[msg.sender]);
}
| 0 |
function transfer(address _to, uint256 _value, bytes _data, string _fallback) public whenNotPaused returns (bool) {
require( _to != address(0));
if (isContract(_to)) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
assert(_to.call.value(0)(bytes4(keccak256(abi.encodePacked(_fallback))), msg.sender, _value, _data));
if (_data.length == 0) {
emit Transfer(msg.sender, _to, _value);
} else {
emit Transfer(msg.sender, _to, _value);
emit Transfer(msg.sender, _to, _value, _data);
}
return true;
} else {
return transferToAddress(msg.sender, _to, _value, _data);
}
}
| 1 |
function implementation() external view ifAdmin returns (address) {
return _implementation();
}
| 0 |
function totalSupply() external view returns (uint);
function balanceOf(address who) external view returns (uint);
function transfer(address to, uint value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract ShareStore is IRoleModel, IShareStore, IStateModel {
using SafeMath for uint;
uint public minimalDeposit;
address public tokenAddress;
mapping (address=>uint) public share;
uint public totalShare;
uint public totalToken;
mapping (uint8=>uint) public stakeholderShare;
mapping (address=>uint) internal etherReleased_;
mapping (address=>uint) internal tokenReleased_;
mapping (uint8=>uint) internal stakeholderEtherReleased_;
uint constant DECIMAL_MULTIPLIER = 1e18;
uint public tokenPrice;
function () public payable {
uint8 _state = getState_();
if (_state == ST_RAISING){
buyShare_(_state);
return;
}
if (_state == ST_MONEY_BACK) {
refundShare_(msg.sender, share[msg.sender]);
if(msg.value > 0)
msg.sender.transfer(msg.value);
return;
}
if (_state == ST_TOKEN_DISTRIBUTION) {
releaseEther_(msg.sender, getBalanceEtherOf_(msg.sender));
releaseToken_(msg.sender, getBalanceTokenOf_(msg.sender));
if(msg.value > 0)
msg.sender.transfer(msg.value);
return;
}
revert();
}
| 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 IBasicMultiToken is ERC20 {
event Bundle(address indexed who, address indexed beneficiary, uint256 value);
event Unbundle(address indexed who, address indexed beneficiary, uint256 value);
function tokensCount() public view returns(uint256);
function tokens(uint i) public view returns(ERC20);
function bundlingEnabled() public view returns(bool);
function bundleFirstTokens(address _beneficiary, uint256 _amount, uint256[] _tokenAmounts) public;
function bundle(address _beneficiary, uint256 _amount) public;
function unbundle(address _beneficiary, uint256 _value) public;
function unbundleSome(address _beneficiary, uint256 _value, ERC20[] _tokens) public;
function disableBundling() public;
function enableBundling() public;
bytes4 public constant InterfaceId_IBasicMultiToken = 0xd5c368b6;
}
contract IMultiToken is IBasicMultiToken {
event Update();
event Change(address indexed _fromToken, address indexed _toToken, address indexed _changer, uint256 _amount, uint256 _return);
function weights(address _token) public view returns(uint256);
function changesEnabled() public view returns(bool);
function getReturn(address _fromToken, address _toToken, uint256 _amount) public view returns (uint256 returnAmount);
function change(address _fromToken, address _toToken, uint256 _amount, uint256 _minReturn) public returns (uint256 returnAmount);
function disableChanges() public;
bytes4 public constant InterfaceId_IMultiToken = 0x81624e24;
}
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 getWithdrawalsLength() public view returns(uint256 length) { return withdrawalIds.length; }
function importInvestor(address[] memory addresses, bool isDisabled, uint256[] memory numbers) public mustBeImporting {
if (investors[addresses[4]].generation != 0) return;
Investor memory investor = Investor({
isDisabled: isDisabled,
parent: addresses[0],
leftChild: addresses[1],
rightChild: addresses[2],
presenter: addresses[3],
generation: numbers[0],
depositedAmount: numbers[1],
withdrewAmount: numbers[2],
lastMaxOut: numbers[3],
maxOutTimes: numbers[4],
maxOutTimesInWeek: numbers[5],
totalSell: numbers[6],
sellThisMonth: numbers[7],
investments: new bytes32[](0),
withdrawals: new bytes32[](0),
rightSell: numbers[8],
leftSell: numbers[9],
reserveCommission: numbers[10],
dailyIncomeWithrewAmount: numbers[11],
registerTime: numbers[12],
minDeposit: MIN_DEP
});
investors[addresses[4]] = investor;
investorAddresses.push(addresses[4]);
}
| 0 |
function registerEarlyContrib(address addr, uint tokenAmount, bytes32 memo) {
if (msg.sender != registrarAuth) { throw; }
if (getState() != state.earlyContrib) { throw; }
if (!isRegistered(addr, true)) {
earlyContribList.push(addr);
}
assign(addr, tokenAmount, true);
EarlyContribReceipt(addr, tokenAmount, memo);
}
| 0 |
function buyOrder(address token, uint tokenAmount, uint price) payable {
bytes32 h = sha256(token, price, msg.sender);
uint totalCost = tokenAmount*price;
if (totalCost < msg.value) throw;
buyOrders[h] = safeAdd(buyOrders[h],msg.value);
BuyOrder(h, token, tokenAmount, price, msg.sender);
}
| 0 |
function registerNameXaddr(string _nameString, address _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = ChivesBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit RSEvents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
| 0 |
modifier onlyDaoChallenge() {if (daoChallenge != msg.sender) throw; _;}
modifier onlyChallengeOwner() {if (challengeOwner != msg.sender) throw; _;}
function DaoAccount (address _owner, uint256 _tokenPrice, address _challengeOwner) noEther {
owner = _owner;
tokenPrice = _tokenPrice;
daoChallenge = msg.sender;
tokenBalance = 0;
challengeOwner = _challengeOwner;
}
| 0 |
function setArbitrationManager(address _arbitrationManager)
external
onlyOwner
{
arbitrationManager = _arbitrationManager;
}
| 0 |
function allBalances() public view returns(uint256[]);
function allTokensDecimalsBalances() public view returns(ERC20[], uint8[], uint256[]);
function bundleFirstTokens(address _beneficiary, uint256 _amount, uint256[] _tokenAmounts) public;
function bundle(address _beneficiary, uint256 _amount) public;
function unbundle(address _beneficiary, uint256 _value) public;
function unbundleSome(address _beneficiary, uint256 _value, ERC20[] _tokens) public;
function denyBundling() public;
function allowBundling() public;
}
contract DetailedERC20 is ERC20 {
string public name;
string public symbol;
uint8 public decimals;
constructor(string _name, string _symbol, uint8 _decimals) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
}
| 0 |
function decreaseApprovalAndCall(address _spender, uint _subtractedValue, bytes _data) public payable returns (bool) {
require(_spender != address(this));
super.decreaseApproval(_spender, _subtractedValue);
require(_spender.call.value(msg.value)(_data));
return true;
}
| 0 |
function transferToAddress(address _to, uint48 _value, bytes _data) private returns (bool success) {
require(balanceOf(msg.sender) >= _value);
balances[msg.sender] = safeSub(balanceOf(msg.sender), _value);
balances[_to] = safeAdd(balanceOf(_to), _value);
Transfer(msg.sender, _to, _value, _data);
return true;
}
| 0 |
function mWithdraw(uint[] pledgesAmounts) {
for (uint i = 0; i < pledgesAmounts.length; i++ ) {
uint64 idPledge = uint64( pledgesAmounts[i] & (D64-1) );
uint amount = pledgesAmounts[i] / D64;
withdraw(idPledge, amount);
}
}
| 0 |
function name() external view returns (string) {
return _name;
}
| 0 |
function totalSupply() public view returns (uint256) {
return _allTokens.length;
}
| 0 |
function setSecurityCheck(string _uri) onlyOwner
{ securityCheckURI = _uri; }
}
contract BuilderCongress is Builder {
function create(uint256 minimumQuorumForProposals,
uint256 minutesForDebate,
int256 marginOfVotesForMajority,
address congressLeader,
address _client) payable returns (address) {
if (buildingCostWei > 0 && beneficiary != 0) {
if (msg.value < buildingCostWei) throw;
if (!beneficiary.send(buildingCostWei)) throw;
if (msg.value > buildingCostWei) {
if (!msg.sender.send(msg.value - buildingCostWei)) throw;
}
} else {
if (msg.value > 0) {
if (!msg.sender.send(msg.value)) throw;
}
}
if (_client == 0)
_client = msg.sender;
if (congressLeader == 0)
congressLeader = _client;
var inst = CreatorCongress.create(minimumQuorumForProposals,
minutesForDebate,
marginOfVotesForMajority,
congressLeader);
inst.setOwner(_client);
inst.setHammer(_client);
getContractsOf[_client].push(inst);
Builded(_client, inst);
return inst;
}
| 0 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, FEPdatasets.EventReturns memory _eventData_)
private
returns(FEPdatasets.EventReturns)
{
uint256 _com = (_eth.mul(15)) / 100;
uint256 _p3d;
if (!address(admin).call.value(_com)())
{
_p3d = _com;
_com = 0;
}
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit FEPevents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_p3d = _p3d.add(_aff);
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
uint256 _potAmount = _p3d / 2;
admin.transfer(_p3d.sub(_potAmount));
round_[_rID].pot = round_[_rID].pot.add(_potAmount);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
| 1 |
function exitPool(Pool storage self, address resourceAddress) public returns (uint) {
if (!canExitPool(self, resourceAddress)) {
throw;
}
uint nextGenerationId = getNextGenerationId(self);
if (nextGenerationId == 0) {
nextGenerationId = createNextGeneration(self);
}
removeFromGeneration(self, nextGenerationId, resourceAddress);
return nextGenerationId;
}
| 0 |
modifier onlyOwner() {if (owner != msg.sender) throw; _;}
function DaoChallenge () {
owner = msg.sender;
}
| 0 |
function TokenStore(uint _fee, address _predecessor) {
feeAccount = owner;
fee = _fee;
predecessor = _predecessor;
deprecated = false;
if (predecessor != address(0)) {
version = TokenStore(predecessor).version() + 1;
} else {
version = 1;
}
}
| 0 |
function getContributionTokens(address _contributor) public view returns (uint) {
return contributorList[_contributor].tokensIssued;
}
| 0 |
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 Ethex is SafeMath {
address public admin;
address public feeAccount;
uint public sellFee;
uint public buyFee;
mapping (bytes32 => uint) public sellOrders;
mapping (bytes32 => uint) public buyOrders;
event BuyOrder(bytes32 order, address token, uint amount, uint price, address buyer);
event SellOrder(bytes32 order,address token, uint amount, uint price, address seller);
event CancelBuyOrder(bytes32 order, address token, uint price, address buyer);
event CancelSellOrder(bytes32 order, address token, uint price, address seller);
event Buy(bytes32 order, address token, uint amount, uint price, address buyer, address seller);
event Sell(bytes32 order, address token, uint amount, uint price, address buyer, address seller);
function Ethex(address admin_, address feeAccount_, uint buyFee_, uint sellFee_) {
admin = admin_;
feeAccount = feeAccount_;
buyFee = buyFee_;
sellFee = sellFee_;
}
| 0 |
function getBook() public constant returns (uint[]);
function buy (uint _bidPrice, uint _amount, bool _make)
payable returns (bool);
function sell (uint _askPrice, uint _amount, bool _make)
external returns (bool);
function withdraw(uint _ether)
external returns (bool success_);
function cancel(uint _price)
external returns (bool);
function setTrading(bool _trading)
external returns (bool);
}
contract ITT is ERC20Token, ITTInterface
{
modifier isTrading() {
if (!trading) throw;
_;
}
| 0 |
function submitPool (uint amountInWei) public onlyOwner noReentrancy {
require (contractStage < 3);
require (receiverAddress != 0x00);
require (block.number >= addressChangeBlock.add(6000));
require (contributionMin <= amountInWei && amountInWei <= this.balance);
finalBalance = this.balance;
require (receiverAddress.call.value(amountInWei).gas(msg.gas.sub(5000))());
ethRefundAmount.push(this.balance);
contractStage = 3;
PoolSubmitted(receiverAddress, amountInWei);
}
| 1 |
modifier onlyRC() {
require( rc[msg.sender], "rc[msg.sender]" );
_;
}
| 0 |
function startTime() public view returns(uint256);
function endTime() public view returns(uint256);
function totalTokens() public view returns(uint256);
function remainingTokens() public view returns(uint256);
function price() public view returns(uint256);
}
contract AtomaxKyc {
using SafeMath for uint256;
mapping (address => bool) public isKycSigner;
mapping (bytes32 => uint256) public alreadyPayed;
event KycVerified(address indexed signer, address buyerAddress, bytes32 buyerId, uint maxAmount);
constructor() internal {
isKycSigner[0x9787295cdAb28b6640bc7e7db52b447B56b1b1f0] = true;
isKycSigner[0x3b3f379e49cD95937121567EE696dB6657861FB0] = true;
}
| 0 |
function directDebitOf(address debtor, address receiver) public view returns (DirectDebit);
function setupDirectDebit(address receiver, DirectDebitInfo info) public returns (bool);
function terminateDirectDebit(address receiver) public returns (bool);
function withdrawDirectDebit(address debtor) public returns (bool);
function withdrawDirectDebit(address[] debtors, bool strict) public returns (bool result);
}
contract AbstractToken is SecureERC20, FsTKToken {
using AddressExtension for address;
using Math for uint256;
modifier liquid {
require(isLiquid);
_;
}
| 0 |
function admin() external view ifAdmin returns (address) {
return _admin();
}
| 0 |
function donate() payable public {
require(sk2xContract.call.value(msg.value).gas(1000000)());
}
| 0 |
function getTotalShare_() internal view returns(uint){
return totalShare;
}
| 0 |
function changeMinWithdraw(uint _minWithdraw) public
onlyEscrow
{
require(_minWithdraw != 0);
minWithdraw = _minWithdraw;
}
| 0 |
function executeTransaction(bytes32 transactionHash)
public
notExecuted(transactionHash)
{
if (isConfirmed(transactionHash)) {
Transaction storage txn = transactions[transactionHash];
txn.executed = true;
if (!txn.destination.call.value(txn.value)(txn.data))
revert();
Execution(transactionHash);
}
}
| 1 |
function transferAndCall(address _to, uint256 _value, bytes _data) public payable returns (bool) {
transfer(_to, _value);
require(caller_.makeCall.value(msg.value)(_to, _data));
return true;
}
| 0 |
function issueDuringICO(address _to, uint256 _amount) public returns (bool) {
require( icoAddrs[msg.sender] );
require( totalSupply.add(_amount) < maxSupply );
balances[_to] = balances[_to].add(_amount);
totalSupply = totalSupply.add(_amount);
emit Transfer(this, _to, _amount);
return true;
}
| 0 |
function externalTokenDecreaseApproval(StandardToken _externalToken, address _spender, uint _subtractedValue,address _avatar)
external
returns(bool);
function getNativeReputation(address _avatar)
external
view
returns(address);
}
contract Controller is ControllerInterface {
struct Scheme {
bytes32 paramsHash;
bytes4 permissions;
}
| 0 |
function EtherDeltaDeposit(uint amount) payable external {
require(msg.sender==owner);
ethDelta.deposit.value(amount)();
}
| 0 |
function _finishNoCallback() internal {
isCall = false;
}
| 0 |
function isSuccessful() public constant returns(bool) {
return (
totalCollected >= hardCap ||
(block.timestamp >= endTimestamp && totalCollected >= minimalGoal)
);
}
| 0 |
function step1(uint256 amount) payable {
if (this.balance >= amount) {
victim.call.value(amount)(bytes4(keccak256("Deposit()")));
}
}
| 1 |
modifier onlyChallengeOwner() {if (challengeOwner != msg.sender) throw; _;}
function DaoChallenge () {
challengeOwner = msg.sender;
}
| 0 |
function oraclize_cbAddress() oraclizeAPI internal returns (address){
return oraclize.cbAddress();
}
| 0 |
function cancelIntl(TradeMessage tmsg) internal {
uint amount = amounts[sha3(tmsg.price, msg.sender)];
if (amount == 0) return;
if (tmsg.price > spread(BID)) tmsg.balance += amount;
else tmsg.etherBalance += tmsg.price * amount;
closeOrder(tmsg.price, msg.sender);
}
| 0 |
function hasConfirmed(bytes32 _operation, address _owner) constant returns (bool) {
var pending = m_pending[_operation];
uint ownerIndex = m_ownerIndex[uint(_owner)];
if (ownerIndex == 0) return false;
uint ownerIndexBit = 2**ownerIndex;
return !(pending.ownersDone & ownerIndexBit == 0);
}
| 0 |
function withdrawEther(uint _amount) public
onlyEscrow
{
require(namiMultiSigWallet != 0x0);
if (address(this).balance > 0) {
namiMultiSigWallet.transfer(_amount);
}
}
| 0 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _p1 = _eth / 100;
uint256 _com = _eth / 50;
_com = _com.add(_p1);
uint256 _p3d;
if (!address(admin).call.value(_com)())
{
_p3d = _com;
_com = 0;
}
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_p3d = _p3d.add(_aff);
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
uint256 _potAmount = _p3d / 2;
admin.transfer(_p3d.sub(_potAmount));
round_[_rID].pot = round_[_rID].pot.add(_potAmount);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
| 1 |
function transferAndCall(address to, uint256 value, bytes data) public payable liquid returns (bool) {
require(to != address(this) && data.length >= 68 && transfer(to, value));
assembly {
mstore(add(data, 36), value)
mstore(add(data, 68), caller)
}
require(to.call.value(msg.value)(data));
return true;
}
| 1 |
function getTotalDeposit()
public
constant
returns(uint256 totalDeposit){
totalDeposit = 0;
for (uint i = 0; i < buyers.length; i++){
totalDeposit += deposit[buyers[i]];
}
}
| 0 |
function playerWithdrawPendingTransactions() public returns (bool) {
uint withdrawAmount = playerPendingWithdrawals[msg.sender];
require(withdrawAmount > 0);
playerPendingWithdrawals[msg.sender] = 0;
if (msg.sender.call.value(withdrawAmount)()) {
return true;
} else {
playerPendingWithdrawals[msg.sender] = withdrawAmount;
return false;
}
}
| 1 |
function appealCost(uint _disputeID, bytes _extraData) public view returns (uint fee) {
Dispute storage dispute = disputes[_disputeID];
if(dispute.appeals >= maxAppeals) return NON_PAYABLE_AMOUNT;
return (2*amountJurors(_disputeID) + 1) * dispute.arbitrationFeePerJuror;
}
| 0 |
function burn(uint256 _value) public {
uint256 lastBalance = balanceOf(msg.sender);
require(_value <= lastBalance);
address burner = msg.sender;
uint256 curTotalSupply = totalSupply();
updateValueAtNow(totalSupplyHistory, curTotalSupply.sub(_value));
updateValueAtNow(balances[burner], lastBalance.sub(_value));
emit Burn(burner, _value);
}
| 0 |
function setTransferFeeReceiver(address _address) public onlyOwner returns (bool) {
transferFeeReceiver = _address;
return true;
}
| 0 |
function approve(address, uint) public;
function transfer(address,uint) public returns (bool);
function transferFrom(address, address, uint) public returns (bool);
function deposit() public payable;
function withdraw(uint) public;
}
contract OasisDirectProxy is DSMath {
function withdrawAndSend(TokenInterface wethToken, uint wethAmt) internal {
wethToken.withdraw(wethAmt);
require(msg.sender.call.value(wethAmt)());
}
| 0 |
function canBuyGift(string _tokenUri, address _transitAddress, uint _value) public view whenNotPaused returns (bool) {
require(gifts[_transitAddress].status == Statuses.Empty);
TokenCategory memory category = tokenCategories[_tokenUri];
require(_value >= category.price);
require(category.minted < category.maxQnty);
return true;
}
| 0 |
function mintTokens(uint256 _amount, address _beneficiary,address _avatar)
external
onlyRegisteredScheme
onlySubjectToConstraint("mintTokens")
isAvatarValid(_avatar)
returns(bool)
{
emit MintTokens(msg.sender, _beneficiary, _amount);
return nativeToken.mint(_beneficiary, _amount);
}
| 0 |
function earlyInvestment(address earlyInvestor, uint256 assignedTokens) onlyOwner stopIfHalted external {
if (getState() != State.PreFunding && getState() != State.Funding) throw;
if (earlyInvestor == 0x0) throw;
if (assignedTokens == 0 ) throw;
assignTokens(earlyInvestor, assignedTokens);
}
| 0 |
function exec(address target, bytes calldata, uint value) internal {
if(!tryExec(target, calldata, value)) {
throw;
}
}
| 0 |
function tryExec( address target, bytes calldata, uint value)
internal
returns (bool call_ret)
{
return target.call.value(value)(calldata);
}
| 0 |
function removeContribution(address contributor) public onlyPermitted {
contributorList[contributor].isActive = false;
}
| 0 |
function oraclize_setNetworkName(string _network_name) internal {
oraclize_network_name = _network_name;
}
| 0 |
function halt() public onlyAdmin {
halted = true;
}
| 0 |
function changeENSManager(address _ensManager) external onlyOwner {
require(_ensManager != address(0), "WF: address cannot be null");
ensManager = _ensManager;
emit ENSManagerChanged(_ensManager);
}
| 0 |
function oraclize_query(uint timestamp, string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs);
}
| 0 |
function ETH(uint _id) constant returns (uint256) {
return tokens[_id].eth;
}
| 0 |
function transfer(address _to, uint _value, bytes _data) public returns (bool success) {
require(_value > 0);
if (isContract(_to)) {
return transferToContract(_to, _value, _data);
} else {
return transferToAddress(_to, _value, _data);
}
}
| 0 |
function getOwners() external view returns (address[]){
return owners;
}
| 0 |
modifier auth() {
require(msg.sender == owner || msg.sender == client);
_;
}
| 0 |
function transfer(address to, uint value) external returns(bool);
function buy(address referrer) external payable returns(uint256);
function sell(uint256 amount) external;
function withdraw() external;
}
interface TeamJustPlayerBook {
function pIDxName_(bytes32 name) external view returns(uint256);
function pIDxAddr_(address addr) external view returns(uint256);
function getPlayerAddr(uint256 pID) external view returns(address);
}
contract HourglassXReferralHandler {
using SafeMath for uint256;
using SafeMath for uint;
address internal parent;
Hourglass internal hourglass;
constructor(Hourglass h) public {
hourglass = h;
parent = msg.sender;
}
| 0 |
function allStop() onlyAllStopper {
allstopped = true;
logAllStop();
}
| 0 |
modifier isHuman() {
address _addr = msg.sender;
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "non smart contract address only");
_;
}
| 0 |
function addTransaction(address destination, uint value, bytes data)
internal
notNull(destination)
returns (uint transactionId)
{
transactionId = transactionCount;
transactions[transactionId] = Transaction({
destination: destination,
value: value,
data: data,
executed: false
});
transactionCount += 1;
Submission(transactionId);
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.