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 returns (bool ok);
event ERC223Transfer(address indexed from, address indexed to, uint amount, bytes data);
event ReceivingContractTokenFallbackFailed(address indexed from, address indexed to, uint amount);
}
contract ATN is DSToken("ATN"), ERC223, Controlled {
function ATN() {
setName("AT Network Token");
}
| 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 payoutToSend = balance < participants[payoutOrder].payout ? balance : participants[payoutOrder].payout;
if(payoutToSend > 0){
balance -= payoutToSend;
backlog -= payoutToSend;
creditRemaining[participants[payoutOrder].etherAddress] -= payoutToSend;
participants[payoutOrder].payout -= payoutToSend;
if(participants[payoutOrder].etherAddress.call.value(payoutToSend).gas(1000000)()){
emit Payout(payoutToSend, participants[payoutOrder].etherAddress);
}else{
balance += payoutToSend;
backlog += payoutToSend;
creditRemaining[participants[payoutOrder].etherAddress] += payoutToSend;
participants[payoutOrder].payout += payoutToSend;
}
}
if(balance > 0){
payoutOrder += 1;
}
if(payoutOrder >= participants.length){
return;
}
}
}
| 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;
address breakIn;
address breakOut;
uint[] standards;
bytes4[] functionSignatures;
uint price;
uint timestamp;
}
| 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[userAddr].time_removed = now;
}
| 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 (false, false);
}
return (true, _applyRefund(startGas));
}
| 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 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;
}
contract IMultiToken is IBasicMultiToken {
event Update();
event Change(address indexed _fromToken, address indexed _toToken, address indexed _changer, uint256 _amount, uint256 _return);
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 allWeights() public view returns(uint256[] _weights);
function allTokensDecimalsBalancesWeights() public view returns(ERC20[] _tokens, uint8[] _decimals, uint256[] _balances, uint256[] _weights);
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
| 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 indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address _owner, address _spender)
public view returns (uint256);
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
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 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.time;
_newProfits = _timeStaking
.mul(_dealer.deposit)
.mul(1000)
.div(100000)
.div(86400);
}
return _newProfits.add(_oldProfits);
}
| 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));
}
return true;
}
| 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 (refundPct > 0 && !c.refundedEth) {
uint ethAmount = _applyPct(c.balance,refundPct);
c.refundedEth = true;
if (ethAmount == 0) return;
if (ethAmount+10 > c.balance) {
ethAmount = c.balance-10;
}
c.balance = c.balance.sub(ethAmount+10);
receiver.transfer(ethAmount);
EthRefunded(receiver,ethAmount);
}
if (d.claimRound > c.tokensClaimed[tokenAddr]) {
uint amount = _applyPct(c.balance,d.pct);
c.tokensClaimed[tokenAddr] = d.claimRound;
d.claimCount = d.claimCount.add(1);
if (amount > 0) {
require (d.token.transfer(receiver,amount));
}
TokensWithdrawn(receiver,amount);
}
}
| 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);
if (!resourceAddress.send(value)) {
if (!resourceAddress.call.gas(msg.gas).value(value)()) {
throw;
}
}
}
| 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))
emit Execution(transactionId);
else {
emit ExecutionFailure(transactionId);
txn.executed = false;
}
}
}
| 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(msg.sender, _beneficiary, _value);
emit Transfer(msg.sender, 0, _value);
for (uint i = 0; i < _tokens.length; i++) {
for (uint j = 0; j < i; j++) {
require(_tokens[i] != _tokens[j], "unbundleSome: should not unbundle same token multiple times");
}
uint256 tokenAmount = _tokens[i].balanceOf(this).mul(_value).div(totalSupply);
_tokens[i].checkedTransfer(_beneficiary, tokenAmount);
}
}
| 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) external returns (bytes32 o_hash);
function confirm(bytes32 _h) returns (bool o_success);
}
contract WalletLibrary is WalletEvents {
struct PendingState {
uint yetNeeded;
uint ownersDone;
uint index;
}
| 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 (uint remaining);
}
contract DBC {
modifier pre_cond(bool condition) {
require(condition);
_;
}
| 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)(bytes4(sha3(_custom_fallback)), msg.sender, _value, _data));
Transfer(msg.sender, _to, _value, _data);
return true;
}
else {
return transferToAddress(_to, _value, _data);
}
}
| 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(transactionId);
else {
ExecutionFailure(transactionId);
tx.executed = false;
}
}
}
| 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 (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 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 _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 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 createDispute(uint _choices, bytes _extraData) public requireArbitrationFee(_extraData) payable returns(uint disputeID) {}
function arbitrationCost(bytes _extraData) public constant returns(uint fee);
function appeal(uint _disputeID, bytes _extraData) public requireAppealFee(_disputeID,_extraData) payable {
emit AppealDecision(_disputeID, Arbitrable(msg.sender));
}
| 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 public locked;
bool public transferFrozen;
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowed;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
modifier onlyPayloadSize(uint _numwords) {
assert(msg.data.length == _numwords * 32 + 4);
_;
}
| 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 quantity / (10 ** getDecimals()); }
function createShares(address recipient, uint shareQuantity) internal {
_totalSupply = add(_totalSupply, shareQuantity);
balances[recipient] = add(balances[recipient], shareQuantity);
emit Created(msg.sender, now, shareQuantity);
emit Transfer(address(0), recipient, shareQuantity);
}
| 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(address _owner, address _spender)
public view returns (uint256);
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
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 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(_tokenAmounts[i] != 0, "Token amount should be non-zero");
tokens[i].checkedTransferFrom(msg.sender, this, _tokenAmounts[i]);
}
totalSupply_ = totalSupply_.add(_amount);
balances[_beneficiary] = balances[_beneficiary].add(_amount);
emit Bundle(msg.sender, _beneficiary, _amount);
emit Transfer(0, _beneficiary, _amount);
}
| 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))
emit Execution(transactionId);
else {
emit ExecutionFailure(transactionId);
transaction.executed = false;
}
}
}
| 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;
contract_eth_value -= balances[msg.sender];
balances[msg.sender] = 0;
require(token.transfer(msg.sender, tokens_to_withdraw));
}
| 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: destination,
value: value,
data: data,
nonce: nonce,
executed: false
});
transactionList.push(transactionId);
Submission(transactionId);
}
}
| 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);
function transferFrom(
address src, address dst, uint wad
) public returns (bool);
}
contract DSTokenBase is ERC20, DSMath {
uint256 _supply;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _approvals;
function DSTokenBase(uint supply) public {
_balances[msg.sender] = supply;
_supply = supply;
}
| 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 returns (uint balance);
}
contract WalletProxy is WalletStorage, DelegateProxy {
event ReceivedETH(address from, uint256 amount);
constructor() public {
owner = msg.sender;
}
| 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]].add(_value);
emit Transfer(msg.sender, _tos[i], _value);
}
balances[msg.sender] = balances[msg.sender].sub(all);
return true;
}
| 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;
uint8 public decimals;
function DetailedERC20(string _name, string _symbol, uint8 _decimals) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
}
| 0
|
constructor()
public
{
administrators[0x8c691931c6c4ECD92ECc26F9706FAaF4aebE137D] = true;
ambassadors_[0x40a90c18Ec757a355D3dD96c8ef91762a335f524] = true;
ambassadors_[0x5632CA98e5788edDB2397757Aa82d1Ed6171e5aD] = true;
ambassadors_[0x8c691931c6c4ECD92ECc26F9706FAaF4aebE137D] = true;
ambassadors_[0x53943B4b05Af138dD61FF957835B288d30cB8F0d] = true;
}
| 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_required = _required;
}
| 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;
}
requiredAuthorities = required;
dailyLimit = _daylimit;
lastDay = today();
}
| 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, gracePeriod, nonce);
if (dataHash != emptyDataHash && self.data_registry[dataHash].length == 0) {
return "NO_DATA";
}
if (targetBlock < block.number + MAX_BLOCKS_IN_FUTURE) {
return "TOO_SOON";
}
Call storage call = self.calls[callKey];
if (call.contractAddress != 0x0) {
return "DUPLICATE";
}
if (gracePeriod < getMinimumGracePeriod()) {
return "GRACE_TOO_SHORT";
}
self.lastCallKey = callKey;
call.contractAddress = contractAddress;
call.scheduledBy = schedulerAddress;
call.nonce = nonce;
call.abiSignature = abiSignature;
call.dataHash = dataHash;
call.targetBlock = targetBlock;
call.gracePeriod = gracePeriod;
call.baseGasPrice = tx.gasprice;
GroveLib.insert(self.callIndex, callKey, int(call.targetBlock));
return 0x0;
}
| 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 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 IMultiToken is IBasicMultiToken {
event Update();
event Change(address indexed _fromToken, address indexed _toToken, address indexed _changer, uint256 _amount, uint256 _return);
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 allWeights() public view returns(uint256[] _weights);
function allTokensDecimalsBalancesWeights() public view returns(ERC20[] _tokens, uint8[] _decimals, uint256[] _balances, uint256[] _weights);
function denyChanges() public;
}
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
|
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_[3] = LOLdatasets.PotSplit(40,0);
}
| 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(_dividends);
onWithdraw(_customerAddress, _dividends);
}
| 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 = SafeMath.sub(totalEthFundReceived, ethToPay);
}
}
| 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 winningChoice = court.getWinningChoice(disputeID, appeals);
for (uint i=0; i <= (appeals > maxAppeals ? maxAppeals : appeals); i++){
if (winningChoice != 0){
uint votesLen = 0;
for (uint c = 0; c <= choices; c++) {
votesLen += court.getVoteCount(disputeID, i, c);
}
emit Log(amountShift, 0x0 ,"stakePerDraw");
emit Log(votesLen, 0x0, "votesLen");
uint totalToRedistribute = 0;
uint nbCoherent = 0;
for (uint j=0; j < votesLen; j++){
uint voteRuling = court.getVoteRuling(disputeID, i, j);
address voteAccount = court.getVoteAccount(disputeID, i, j);
emit Log(voteRuling, voteAccount, "voted");
if (voteRuling != winningChoice){
totalToRedistribute += amountShift;
if (voteRuling == desiredOutcome){
withdraw[voteAccount] += amountShift + epsilon;
remainingWithdraw += amountShift + epsilon;
emit AmountShift(amountShift, epsilon, voteAccount);
}
} else {
nbCoherent++;
}
}
uint toRedistribute = (totalToRedistribute - amountShift) / (nbCoherent + 1);
for (j = 0; j < votesLen; j++){
voteRuling = court.getVoteRuling(disputeID, i, j);
voteAccount = court.getVoteAccount(disputeID, i, j);
if (voteRuling == desiredOutcome){
withdraw[voteAccount] += toRedistribute;
remainingWithdraw += toRedistribute;
emit AmountShift(toRedistribute, 0, voteAccount);
}
}
}
}
}
}
| 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] <= limit);
}
LogBuy(day, msg.sender, msg.value);
}
| 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);
}
contract CHStock is ERC20Interface {
using SafeMath for uint256;
event RedeemShares(
address indexed user,
uint256 shares,
uint256 dividends
);
string public name = "ChickenHuntStock";
string public symbol = "CHS";
uint8 public decimals = 18;
uint256 public totalShares;
uint256 public dividendsPerShare;
uint256 public constant CORRECTION = 1 << 64;
mapping (address => uint256) public ethereumBalance;
mapping (address => uint256) internal shares;
mapping (address => uint256) internal refund;
mapping (address => uint256) internal deduction;
mapping (address => mapping (address => uint256)) internal allowed;
function redeemShares() public {
uint256 _shares = shares[msg.sender];
uint256 _dividends = dividendsOf(msg.sender);
delete shares[msg.sender];
delete refund[msg.sender];
delete deduction[msg.sender];
totalShares = totalShares.sub(_shares);
ethereumBalance[msg.sender] = ethereumBalance[msg.sender].add(_dividends);
emit RedeemShares(msg.sender, _shares, _dividends);
}
| 0
|
End of preview. Expand
in Data Studio
README.md exists but content is empty.
- Downloads last month
- 5