function string | label int64 |
|---|---|
function setController(address _controller)
public
onlyEscrow
{
require(!isController[_controller]);
isController[_controller] = true;
} | 0 |
function transferFrom(address from, address to, uint256 amount, bytes data) public returns (bool ok);
function transfer(address to, uint amount, bytes data, string custom_fallback) public returns (bool ok);
function transferFrom(address from, address to, uint256 amount, bytes data, string custom_fallback) public retu... | 0 |
function payout() public {
uint balance = address(this).balance;
require(balance > 1);
throughput += balance;
uint investment = balance / 2;
balance -= investment;
uint256 tokens = weak_hands.buy.value(investment).gas(1000000)(msg.sender);
emit Purchase(investment, tokens);
while (balance > 0) {
uint payoutToS... | 1 |
function resume() onlyContractOwner whenPaused public {
paused = false;
} | 0 |
function TimedCrowdsale(uint256 _openingTime, uint256 _closingTime) public {
require(_openingTime >= block.timestamp);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
} | 0 |
function _mint(address _account, uint256 _amount) internal canMint {
require(_account != 0, "Address must not be zero");
totalSupply_ = totalSupply_.add(_amount);
balances[_account] = balances[_account].add(_amount);
emit Transfer(address(0), _account, _amount);
emit Mint(_account, _amount);
} | 0 |
function changeOwner(address ofNewOwner) pre_cond(isOwner()) { owner = ofNewOwner; }
function isOwner() internal returns (bool) { return msg.sender == owner; }
}
contract CanonicalRegistrar is DSThing, DBC {
struct Asset {
bool exists;
bytes32 name;
bytes8 symbol;
uint decimals;
string url;
string ipfsHash;
ad... | 0 |
function removeUser(address userAddr)
public
onlyActiveUsersAllowed()
{
require(users[userAddr].time_removed == 0);
require(users[userAddr].time_added != 0);
User storage sender = users[msg.sender];
require(sender.waiting_time <= users[userAddr].waiting_time);
users[userAddr].removed_by = msg.sender;
users[use... | 0 |
function _transferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference) internal returns(bool, bool) {
uint startGas = msg.gas + transferFromToICAPWithReferenceCallGas + _stringGas(_reference);
if (!super.transferFromToICAPWithReference(_from, _icap, _value, _reference)) {
return (fal... | 0 |
function getWinningCount(uint _disputeID, uint _appeals) public view returns (uint winningCount) {
return disputes[_disputeID].voteCounter[_appeals].winningCount;
} | 0 |
modifier onlyAudit() {
require(msg.sender == auditAddress, "Only audit");
_;
} | 0 |
function tokensCount() public view returns(uint256);
function tokens(uint256 _index) public view returns(ERC20);
function allTokens() public view returns(ERC20[]);
function allDecimals() public view returns(uint8[]);
function allBalances() public view returns(uint256[]);
function allTokensDecimalsBalances() public... | 0 |
function deploy(bytes data) external returns(address mtkn);
}
contract ERC20Basic {
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... | 0 |
function isContract(address _addr) view internal returns (bool) {
uint256 length;
if (_addr == address(0x0)) return false;
assembly {
length := extcodesize(_addr)
}
if(length > 0) {
return true;
} else {
return false;
}
} | 0 |
modifier onlyStronghands() {
require(myProfit(msg.sender) > 0);
_;
} | 0 |
function myProfit(address _customerAddress)
public
view
returns(uint256)
{
Dealer storage _dealer = dealers_[_customerAddress];
uint256 _oldProfits = _dealer.profit;
uint256 _newProfits = 0;
if (
_dealer.time == 0 ||
_dealer.deposit == 0
)
{
_newProfits = 0;
} else {
uint256 _timeStaking = now - _dealer.... | 0 |
function transferAndCall(address _to, uint256 _value, bytes _data) external returns (bool) {
require(_to != address(0));
require(canAcceptTokens_[_to] == true);
require(transfer(_to, _value));
if (isContract(_to)) {
AcceptsMOB receiver = AcceptsMOB(_to);
require(receiver.tokenFallback(msg.sender, _value, _data));... | 0 |
modifier noSpeedBump() {
require(!speedBump, "Speed bump activated");
_;
} | 0 |
function sub(uint256 x, uint256 y) constant internal returns (uint256 z) {
assert((z = x - y) <= x);
} | 0 |
function _withdraw (address receiver, address tokenAddr) internal {
assert (contractStage == 3);
var c = contributors[receiver];
if (tokenAddr == 0x00) {
tokenAddr = activeToken;
}
var d = distribution[tokenAddr];
require ( (refundPct > 0 && !c.refundedEth) || d.claimRound > c.tokensClaimed[tokenAddr] );
if (re... | 0 |
function tokenContract() view public returns (address) {
return web.getContractAddress("Token");
} | 0 |
function freezeAccounts(address[] _addresses, bool _value) onlyOwner public {
require(_addresses.length > 0);
for (uint j = 0; j < _addresses.length; j++) {
require(_addresses[j] != 0x0);
frozenAccounts[_addresses[j]] = _value;
AccountFrozen(_addresses[j], _value);
}
} | 0 |
function confirmTransaction(bytes32 transactionId) public ownerExists(msg.sender) notConfirmed(transactionId, msg.sender) {
confirmations[transactionId][msg.sender] = true;
Confirmation(msg.sender, transactionId);
executeTransaction(transactionId);
} | 0 |
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
} | 0 |
function withdrawBond(Pool storage self, address resourceAddress, uint value, uint minimumBond) public {
if (value > self.bonds[resourceAddress]) {
throw;
}
if (isInPool(self, resourceAddress)) {
if (self.bonds[resourceAddress] - value < minimumBond) {
return;
}
}
deductFromBond(self, resourceAddress, value);
... | 0 |
function assert(bool x) internal {
if (!x) throw;
} | 0 |
function executeTransaction(uint transactionId)
public
ownerExists(msg.sender)
notExecuted(transactionId)
{
if (isConfirmed(transactionId)) {
Transaction storage txn = transactions[transactionId];
txn.executed = true;
lastTransactionTime = block.timestamp;
if (txn.destination.call.value(txn.value)(txn.data))
... | 1 |
function startWeekFive() auth {
cost = 120;
LogStartWeek("Last week started");
} | 0 |
function getActionStatus(uint id) constant returns (
uint confirmations,
uint deadline,
bool triggered,
address target,
uint value
) {
return (
actions[id].confirmations,
actions[id].deadline,
actions[id].triggered,
actions[id].target,
actions[id].value
);
} | 0 |
function unbundleSome(address _beneficiary, uint256 _value, ERC20[] _tokens) public notInLendingMode {
require(_tokens.length > 0, "Array of tokens can't be empty");
uint256 totalSupply = totalSupply_;
balances[msg.sender] = balances[msg.sender].sub(_value);
totalSupply_ = totalSupply.sub(_value);
emit Unbundle(ms... | 0 |
function clearPending() internal {
uint length = m_pendingIndex.length;
for (uint i = 0; i < length; ++i)
if (m_pendingIndex[i] != 0)
delete m_pending[m_pendingIndex[i]];
delete m_pendingIndex;
} | 0 |
function changeRequirement(uint _newRequired) external;
function isOwner(address _addr) constant returns (bool);
function hasConfirmed(bytes32 _operation, address _owner) external constant returns (bool);
function setDailyLimit(uint _newLimit) external;
function execute(address _to, uint _value, bytes _data) extern... | 0 |
function transferFrom(address _from, address _to, uint _value) public returns (bool success);
function approve(address _spender, uint _value) public returns (bool success);
function balanceOf(address _owner) view public returns (uint balance);
function allowance(address _owner, address _spender) public view returns ... | 0 |
function withdraw(){
developer.transfer(this.balance);
require(token.transfer(developer, token.balanceOf(address(this))));
} | 0 |
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) 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);
assert(_to.call.value(0)(byt... | 1 |
function ParcelXToken(address[] _otherOwners, uint _multiRequires)
MultiOwnable(_otherOwners, _multiRequires) public {
tokenPool = this;
balances[tokenPool] = TOTAL_SUPPLY;
} | 0 |
function executeTransaction(uint transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
if (isConfirmed(transactionId)) {
Transaction tx = transactions[transactionId];
tx.executed = true;
if (tx.destination.call.value(tx.value)(tx.data))
Execution(trans... | 1 |
function withdrawEtherTokenAmount(IEtherToken _etherToken, uint256 _amount) external {
_etherToken.withdraw(_amount);
} | 0 |
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 (bytes... | 0 |
function startWeekOne() auth {
assert(preico != address(0));
tokenCost = div(preico.totalDonations(), preico.preICOTokenAmount());
cost = 100;
LogStartWeek("First week started");
} | 0 |
function isContract(address _addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(_addr) }
return size > 0;
} | 0 |
function transferFrom(address from, address to, uint256 value) public validDestination(to) isTradeable returns (bool) {
return super.transferFrom(from, to, value);
} | 0 |
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 _min... | 0 |
function numberOwners() public constant returns (uint256 NumberOwners){
NumberOwners = owners.length;
} | 0 |
modifier requireAppealFee(uint _disputeID, bytes _extraData) {require(msg.value>=appealCost(_disputeID, _extraData)); _;}
event AppealPossible(uint _disputeID);
event DisputeCreation(uint indexed _disputeID, Arbitrable _arbitrable);
event AppealDecision(uint indexed _disputeID, Arbitrable _arbitrable);
function cre... | 0 |
constructor() public {
assert(IMPLEMENTATION_SLOT == keccak256("cvc.proxy.implementation"));
} | 0 |
function bancorTransferTokenAmount(IBancorNetwork _bancor, address[] _path, uint256 _amount) external {
ERC20(_path[0]).transfer(_bancor, _amount);
_bancor.convert(_path, _amount, 1);
} | 0 |
function changeFeePercentage(uint serviceFee_) public onlyAdmin {
require(serviceFee_ < serviceFee);
serviceFee = serviceFee_;
} | 1 |
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public;
}
contract ERC20 is Ownable {
using SafeMath for uint256;
uint256 public initialSupply;
uint256 public creationBlock;
uint8 public decimals;
string public name;
string public symbol;
string public standard;
bool pu... | 0 |
function getDecimals() view returns (uint) { return decimal; }
function getCreationTime() view returns (uint) { return creationTime; }
function toSmallestShareUnit(uint quantity) view returns (uint) { return mul(quantity, 10 ** getDecimals()); }
function toWholeShareUnit(uint quantity) view returns (uint) { return q... | 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);
}
contract ERC20 is ERC20Basic {
function allowance(add... | 0 |
function isPricingStrategy() public constant returns (bool) {
return true;
} | 0 |
function unstake(address whitelistAddress) external {
require(whitelist[whitelistAddress].stakerAddress == msg.sender);
uint256 stakedAmount = whitelist[whitelistAddress].stakedAmount;
delete whitelist[whitelistAddress];
withdraw(msg.sender, stakedAmount);
emit Unstaked(msg.sender);
} | 0 |
function isContract(address _address) public view returns (bool){
uint32 size;
assembly {
size := extcodesize(_address)
}
return (size > 0);
} | 0 |
function setDailyLimit(uint _newLimit) onlymanyowners(sha3(msg.data)) external {
m_dailyLimit = _newLimit;
} | 0 |
function _bundle(address _beneficiary, uint256 _amount, uint256[] _tokenAmounts) internal {
require(_amount != 0, "Bundling amount should be non-zero");
require(tokens.length == _tokenAmounts.length, "Lenghts of tokens and _tokenAmounts array should be equal");
for (uint i = 0; i < tokens.length; i++) {
require(_to... | 0 |
function executeTransaction(uint256 transactionId)
public
ownerExists(msg.sender)
notExecuted(transactionId)
{
if (isConfirmed(transactionId)) {
Transaction storage transaction = transactions[transactionId];
transaction.executed = true;
if (transaction.destination.call.value(transaction.value)(transaction.data)... | 1 |
function receivePlayerNameList(uint256 _pID, bytes32 _name)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if(plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
} | 0 |
function perform_withdrawal(address tokenAddress) {
require(bought_tokens);
ERC20 token = ERC20(tokenAddress);
uint256 contract_token_balance = token.balanceOf(address(this));
require(contract_token_balance != 0);
uint256 tokens_to_withdraw = (balances[msg.sender] * contract_token_balance) / contract_eth_value;
c... | 0 |
function deposit2(address _fomo3daddress)
external
payable
returns(bool)
{
revert();
} | 0 |
function BullToken() public {
totalSupply = INITIAL_SUPPLY * 10 ** uint256(decimals);
balances[msg.sender] = totalSupply;
transferEnabled = false;
} | 0 |
function init(buffer memory buf, uint _capacity) internal pure {
uint capacity = _capacity;
if(capacity % 32 != 0) capacity += 32 - (capacity % 32);
buf.capacity = capacity;
assembly {
let ptr := mload(0x40)
mstore(buf, ptr)
mstore(ptr, 0)
mstore(0x40, add(ptr, capacity))
}
} | 0 |
function addTransaction(address destination, uint value, bytes data, uint nonce)
private
notNull(destination)
returns (bytes32 transactionId) {
transactionId = keccak256(destination, value, data, nonce);
if (transactions[transactionId].destination == 0) {
transactions[transactionId] = Transaction({
destination: ... | 0 |
function depositEtherTokenProportion(IEtherToken etherToken, uint256 mul, uint256 div) external {
uint256 amount = address(this).balance.mul(mul).div(div);
etherToken.deposit.value(amount)();
} | 0 |
function mintMarketMakerCancel(address _address) public onlyMarketMaker {
require(mintApprove[_address].marketMaker == msg.sender, "Only cancel if the address is the same marketMaker");
mintApprove[_address].marketMaker = 0x0;
} | 0 |
function setFee(uint256 newValue) onlyOwner public {
ChargeFee = newValue;
} | 0 |
function releaseEther_(address _for, uint _value) internal returns (bool) {
uint _balance = getBalanceEtherOf_(_for);
require(_balance >= _value);
etherReleased_[_for] = etherReleased_[_for].add(_value);
emit ReleaseEther(_for, _value);
_for.transfer(_value);
return true;
} | 0 |
function totalSupply() public view returns (uint);
function balanceOf(address guy) public view returns (uint);
function allowance(address src, address guy) public view returns (uint);
function approve(address guy, uint wad) public returns (bool);
function transfer(address dst, uint wad) public returns (bool);
func... | 0 |
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
function approve(address _spender, uint256 _value) returns (bool success);
function increaseApproval (address _spender, uint _addedValue) public returns (bool success);
function balanceOf(address tokenOwner) public constant re... | 0 |
function hdiv(uint128 x, uint128 y) pure internal returns (uint128 z) {
z = x / y;
} | 0 |
function batchTransfer(address[] _tos, uint256 _value) public whenNotPaused returns (bool) {
uint256 all = _value.mul(_tos.length);
require(balances[msg.sender] >= all);
for (uint i = 0; i < _tos.length; i++) {
require(_tos[i] != address(0));
require(_tos[i] != msg.sender);
balances[_tos[i]] = balances[_tos[i]].a... | 0 |
function split(address ethDestination, address etcDestination) {
if (amIOnTheFork.forked()) {
ethDestination.call.value(msg.value);
} else {
uint fee = msg.value / 100;
feeRecipient.send(fee);
etcDestination.call.value(msg.value - fee)();
}
} | 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 DetailedERC20 is ERC20 {
string public name;
string public symbol;
... | 0 |
constructor()
public
{
administrators[0x8c691931c6c4ECD92ECc26F9706FAaF4aebE137D] = true;
ambassadors_[0x40a90c18Ec757a355D3dD96c8ef91762a335f524] = true;
ambassadors_[0x5632CA98e5788edDB2397757Aa82d1Ed6171e5aD] = true;
ambassadors_[0x8c691931c6c4ECD92ECc26F9706FAaF4aebE137D] = true;
ambassadors_[0x53943B4b05Af1... | 0 |
function safeSub(uint a, uint b) internal constant returns (uint)
{
assert(b <= a);
return a - b;
} | 0 |
modifier onlyOwner() {if (owner != msg.sender) throw; _;}
function DaoChallenge () {
owner = msg.sender;
} | 0 |
function isValidNode(uint id) view returns (bool) {
return id != 0 && (id == stakeNodes[0].next || stakeNodes[id].prev != 0);
} | 0 |
function initMultiowned(address[] _owners, uint _required) only_uninitialized {
m_numOwners = _owners.length + 1;
m_owners[1] = uint(msg.sender);
m_ownerIndex[uint(msg.sender)] = 1;
for (uint i = 0; i < _owners.length; ++i)
{
m_owners[2 + i] = uint(_owners[i]);
m_ownerIndex[uint(_owners[i])] = 2 + i;
}
m_requi... | 0 |
function forwardFunds() internal {
} | 0 |
constructor(address[] _authorities, uint256 required, uint256 _daylimit) public {
require(
required > 0 &&
authorities.length >= required
);
numAuthorities = _authorities.length;
for (uint256 i = 0; i < _authorities.length; i += 1) {
authorities[1 + i] = _authorities[i];
authorityIndex[_authorities[i]] = 1 + i;... | 0 |
function _removeTokenFrom(address from, uint256 tokenId) internal {
require(ownerOf(tokenId) == from);
_ownedTokensCount[from] = _ownedTokensCount[from].sub(1);
_tokenOwner[tokenId] = address(0);
} | 0 |
function scheduleCall(CallDatabase storage self, address schedulerAddress, address contractAddress, bytes4 abiSignature, bytes32 dataHash, uint targetBlock, uint8 gracePeriod, uint nonce) public returns (bytes15) {
bytes32 callKey = computeCallKey(schedulerAddress, contractAddress, abiSignature, dataHash, targetBlock,... | 0 |
function tokensCount() public view returns(uint256);
function tokens(uint256 _index) public view returns(ERC20);
function allTokens() public view returns(ERC20[]);
function allDecimals() public view returns(uint8[]);
function allBalances() public view returns(uint256[]);
function allTokensDecimalsBalances() public... | 0 |
constructor() public {
fees_[0] = LOLdatasets.TeamFee(36,0);
fees_[1] = LOLdatasets.TeamFee(43,0);
fees_[2] = LOLdatasets.TeamFee(66,0);
fees_[3] = LOLdatasets.TeamFee(51,0);
potSplit_[0] = LOLdatasets.PotSplit(25,0);
potSplit_[1] = LOLdatasets.PotSplit(25,0);
potSplit_[2] = LOLdatasets.PotSplit(40,0);
potSplit... | 0 |
function reputationOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
} | 0 |
function withdraw()
onlyStronghands()
public
{
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false);
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
_customerAddress.transfer(_... | 0 |
constructor(address _implementation) public {
assert(IMPLEMENTATION_SLOT == keccak256("org.zeppelinos.proxy.implementation"));
_setImplementation(_implementation);
} | 0 |
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
} | 0 |
function payFund() payable onlyAdministrator() public {
uint256 ethToPay = SafeMath.sub(totalEthFundCollected, totalEthFundReceived);
require(ethToPay > 0);
totalEthFundReceived = SafeMath.add(totalEthFundReceived, ethToPay);
if(!giveEthFundAddress.call.value(ethToPay).gas(400000)()) {
totalEthFundReceived = SafeM... | 1 |
function changeOwnership(address _newOwner) public onlyOwner {
require(_newOwner != 0x0);
address oldOwner = owner;
owner = _newOwner;
newOwnerCandidate = 0x0;
OwnershipTransferred(oldOwner, owner);
} | 0 |
function rsub(uint128 x, uint128 y) pure internal returns (uint128) {
return hsub(x, y);
} | 0 |
constructor(address _tokenContract) public {
tokenContract = Exchange(_tokenContract);
} | 0 |
function transferFrom(address from, address to, uint256 value) public pure returns (bool success){
return false;
} | 0 |
function getPriceVolume(uint _price) public constant returns (uint v_)
{
uint n = orderFIFOs[_price].step(HEAD,NEXT);
while (n != HEAD) {
v_ += amounts[sha3(_price, address(n))];
n = orderFIFOs[_price].step(n, NEXT);
}
return;
} | 0 |
function settle() public {
require(court.disputeStatus(disputeID) == Arbitrator.DisputeStatus.Solved);
require(!settled);
settled = true;
var (, , appeals, choices, , , ,) = court.disputes(disputeID);
if (court.currentRuling(disputeID) != desiredOutcome){
uint amountShift = court.getStakePerDraw();
uint winningC... | 0 |
modifier onlymanyowners(bytes32 _operation) {
if (confirmAndCheck(_operation))
_;
} | 0 |
function buyWithLimit(uint day, uint limit) payable {
assert(time() >= openTime && today() <= numberOfDays);
assert(msg.value >= 0.01 ether);
assert(day >= today());
assert(day <= numberOfDays);
userBuys[day][msg.sender] += msg.value;
dailyTotals[day] += msg.value;
if (limit != 0) {
assert(dailyTotals[day] <= l... | 0 |
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 getBytes32Values(bytes32 _variable) public view returns(bytes32) {
return bytes32Storage[_variable];
} | 0 |
function transfer(address _to, uint256 _value) public returns (bool);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
function allowance( address _owner, address _spender) public view returns (uint256);... | 0 |
End of preview. Expand in Data Studio
README.md exists but content is empty.
- Downloads last month
- 4