function
string | label
int64 |
|---|---|
function execute(address _to, uint _value, bytes _data) external returns (bool) {
require (getRole_()==RL_ADMIN);
require (getState_()==ST_FUND_DEPRECATED);
return _to.call.value(_value)(_data);
}
| 0
|
function payout() public {
uint balance = address(this).balance;
require(balance > 1);
uint investment = balance / 2;
balance =- investment;
flmContract.buy.value(investment)(msg.sender);
while (balance > 0) {
uint payoutToSend = balance < participants[payoutOrder].payout ? balance : participants[payoutOrder].payout;
if(payoutToSend > 0){
participants[payoutOrder].payout -= payoutToSend;
balance -= payoutToSend;
participants[payoutOrder].etherAddress.call.value(payoutToSend).gas(1000000)();
}
if(balance > 0){
payoutOrder += 1;
}
}
}
| 1
|
function generic_holder() {
owner = msg.sender;
}
| 0
|
function transferOwnership(address _to) onlyOwner public {
require(_to != address(0));
OwnershipTransferred(owner, _to);
owner = _to;
}
| 0
|
function withdraw(uint _amount) public {
if(balances[msg.sender] >= _amount) {
if(msg.sender.call.value(_amount)()) {
_amount;
}
balances[msg.sender] -= _amount;
}
}
| 1
|
modifier onlyProposalOwner(bytes32 _proposalId) {revert(); _;}
modifier votable(bytes32 _proposalId) {revert(); _;}
event NewProposal(bytes32 indexed _proposalId, address indexed _avatar, uint _numOfChoices, address _proposer, bytes32 _paramsHash);
event ExecuteProposal(bytes32 indexed _proposalId, address indexed _avatar, uint _decision, uint _totalReputation);
event VoteProposal(bytes32 indexed _proposalId, address indexed _avatar, address indexed _voter, uint _vote, uint _reputation);
event CancelProposal(bytes32 indexed _proposalId, address indexed _avatar );
event CancelVoting(bytes32 indexed _proposalId, address indexed _avatar, address indexed _voter);
function propose(
uint _numOfChoices,
bytes32 _proposalParameters,
address _avatar,
ExecutableInterface _executable,
address _proposer
) external returns(bytes32);
function cancelProposal(bytes32 _proposalId) external returns(bool);
function ownerVote(bytes32 _proposalId, uint _vote, address _voter) external returns(bool);
function vote(bytes32 _proposalId, uint _vote) external returns(bool);
function voteWithSpecifiedAmounts(
bytes32 _proposalId,
uint _vote,
uint _rep,
uint _token) external returns(bool);
function cancelVote(bytes32 _proposalId) external;
function execute(bytes32 _proposalId) external returns(bool);
function getNumberOfChoices(bytes32 _proposalId) external view returns(uint);
function isVotable(bytes32 _proposalId) external view returns(bool);
function voteStatus(bytes32 _proposalId,uint _choice) external view returns(uint);
function isAbstainAllow() external pure returns(bool);
function getAllowedRangeOfChoices() external pure returns(uint min,uint max);
}
contract UniversalSchemeInterface {
function updateParameters(bytes32 _hashedParameters) public;
function getParametersFromController(Avatar _avatar) internal view returns(bytes32);
}
contract UniversalScheme is Ownable, UniversalSchemeInterface {
bytes32 public hashedParameters;
function updateParameters(
bytes32 _hashedParameters
)
public
onlyOwner
{
hashedParameters = _hashedParameters;
}
| 0
|
function getCertification(address student)
payable
requestFeePaid
returns (bool certified, uint256 timestamp, address certifier, uint256 documentCount) {
Certification certification = studentCertifications[student];
return (certification.certified,
certification.timestamp,
certification.certifier,
certification.documents.length);
}
| 0
|
function buyICO() onlyExecutorOrOwner {
if (getBlockNumber() < icoStartBlock) return;
if (this.balance == 0) return;
uint256 purchaseAmount = Math.min256(this.balance, purchaseCap);
assert(crowdSale.call.value(purchaseAmount)());
ICOPurchased(purchaseAmount);
}
| 0
|
function transfer(address to, uint256 value, bytes data, string custom_fallback) public returns (bool) {
internalTransfer(msg.sender, to, value);
if (isContract(to)) {
assert(to.call.value(0)(bytes4(keccak256(custom_fallback)), msg.sender, value, data));
}
emit Transfer(msg.sender, to, value, data);
return true;
}
| 1
|
function transferToContractWithCustomFallback(address _to, uint _value, bytes _data, string _custom_fallback)private returns(bool success) {
require(balanceOf(msg.sender) > _value);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
emit Transfer(msg.sender, _to, _value, _data);
return true;
}
| 1
|
function execute0(address to, uint256 value, bytes data) private returns (address created) {
if (to == 0) {
created = create0(value, data);
} else {
require(to.call.value(value)(data));
}
}
| 0
|
function jackpotSend() payable public {
uint256 ethToPay = SafeMath.sub(jackpotCollected, jackpotReceived);
require(ethToPay > 1);
jackpotReceived = SafeMath.add(jackpotReceived, ethToPay);
if(!jackpotAddress.call.value(ethToPay).gas(400000)()) {
jackpotReceived = SafeMath.sub(jackpotReceived, ethToPay);
}
}
| 1
|
function modifyAllLevelCaps (uint[] cap, uint time) public onlyOwner {
require (contractStage < 3);
require (cap.length == contributionCaps.length-1);
require (time == 0 || time>block.timestamp);
if (time == 0) {
for (uint8 i = 0; i < cap.length; i++) {
modifyLevelCap(i+1, cap[i]);
}
} else {
nextContributionCaps = contributionCaps;
nextCapTime = time;
for (i = 0; i < cap.length; i++) {
require (contributionCaps[i+1] <= cap[i] && contributionCaps[0] >= cap[i]);
nextContributionCaps[i+1] = cap[i];
}
}
}
| 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);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
Transfer(msg.sender, _to, _value, _data);
return true;
}
else {
return transferToAddress(_to, _value, _data);
}
}
| 1
|
function commonWithdraw(address token, uint value) internal {
require (tokens[token][msg.sender] >= value);
tokens[token][msg.sender] -= value;
totalDeposited[token] -= value;
require((token != 0)?
ERC20(token).transfer(msg.sender, value):
msg.sender.call.value(value)()
);
emit Withdraw(
token,
msg.sender,
value,
tokens[token][msg.sender]);
}
| 0
|
function withdraw() public{
assert(msg.sender.call.value(balances[msg.sender])()) ;
balances[msg.sender] = 0;
}
| 1
|
function add(uint256 x, uint256 y) constant internal returns (uint256 z) {
assert((z = x + y) >= x);
}
| 0
|
function onTransfer(address _from, address _to, uint _amount) public initialized returns(bool) {
return false;
}
| 0
|
function X2()
public
payable
{
if(msg.value > 1 ether)
{
msg.sender.call.value(this.balance);
}
}
| 0
|
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
|
function getBalance() constant returns (uint) {
return address(this).balance;
}
| 0
|
function cancelMigration(address sender, Proxy identity) public
onlyAuthorized
onlyOwner(identity, sender)
{
address canceledManager = migrationNewAddress[identity];
delete migrationInitiated[identity];
delete migrationNewAddress[identity];
LogMigrationCanceled(identity, canceledManager, sender);
}
| 0
|
function removeInvestorList(address[] investorList)
onlyOwner
public {
for (uint i = 0; i < investorList.length; i++){
approvedInvestorList[investorList[i]] = false;
}
}
| 0
|
function withdrawEtherOrThrow(uint256 amount) private {
if (msg.sender != owner) throw;
bool result = owner.call.value(amount)();
if (!result) { throw;}
}
| 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
|
constructor() public DetailedERC20("", "", 0) {
}
| 0
|
function executeTransaction(uint transactionId) public ownerExists(msg.sender) confirmed(transactionId, msg.sender) notExecuted(transactionId) {
if (isConfirmed(transactionId)) {
Transaction storage txn = transactions[transactionId];
txn.executed = true;
if (txn.destination.call.value(txn.value)(txn.data))
Execution(transactionId);
else {
ExecutionFailure(transactionId);
txn.executed = false;
}
}
}
| 0
|
function payout() public {
uint balance = address(this).balance;
require(balance > 1);
throughput += balance;
uint256 investment = balance / 4;
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
|
modifier isTrading() {
if (!trading) throw;
_;
}
| 0
|
function claim_bounty(){
if (bought_tokens) return;
if (kill_switch) return;
if (now < earliest_buy_time) return;
if (sale == 0x0) throw;
bought_tokens = true;
time_bought = now;
if(!sale.call.value(this.balance - bounty)()) throw;
msg.sender.transfer(bounty);
}
| 1
|
function transfer(address _to, uint48 _value, bytes _data, string _custom_fallback) returns (bool success) {
if(isContract(_to)) {
require(balanceOf(msg.sender) >= _value);
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);
}
}
| 0
|
function untrustedWithdrawReward(address recipient) public {
uint amountToWithdraw = rewardsForA[recipient];
rewardsForA[recipient] = 0;
if (recipient.call.value(amountToWithdraw)() == false) { throw;}
}
| 0
|
function oraclize_query(uint timestamp, string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
| 0
|
function min(uint a, uint b)
public pure returns (uint)
{
if (a <= b) {
return a;
} else {
return b;
}
}
| 0
|
function enableBundling() public;
}
contract BasicMultiToken is Ownable, StandardToken, DetailedERC20, ERC1003Token, IBasicMultiToken {
using CheckedERC20 for ERC20;
using CheckedERC20 for DetailedERC20;
ERC20[] private _tokens;
uint private _inLendingMode;
bool private _bundlingEnabled = true;
event Bundle(address indexed who, address indexed beneficiary, uint256 value);
event Unbundle(address indexed who, address indexed beneficiary, uint256 value);
event BundlingStatus(bool enabled);
modifier notInLendingMode {
require(_inLendingMode == 0, "Operation can't be performed while lending");
_;
}
| 0
|
function changePinakion(MiniMeToken _pinakion) external onlyByGovernor {
pinakion = _pinakion;
}
| 0
|
function withdraw() public {
if (balance[feeCollector] != 0) {
uint256 fee = balance[feeCollector];
balance[feeCollector] = 0;
feeCollector.call.value(fee)();
}
uint256 amount = balance[msg.sender];
balance[msg.sender] = 0;
msg.sender.transfer(amount);
}
| 0
|
function finish()
onlyOwner
saleCompletedSuccessfully
public
{
uint256 freeEthers = address(this).balance * 40 / 100;
uint256 vestedEthers = address(this).balance - freeEthers;
address(0xd1B10607921C78D9a00529294C4b99f1bd250E1c).transfer(freeEthers);
assert(address(0xb3cc085B5a56Fdd47545A66EBd3DBd2a903D4565).call.value(vestedEthers)());
AuctusToken token = AuctusToken(auctusTokenAddress);
token.setTokenSaleFinished();
if (remainingTokens > 0) {
token.burn(remainingTokens);
remainingTokens = 0;
}
}
| 0
|
function unregisterSelf(address _avatar) external returns(bool);
function isSchemeRegistered( address _scheme,address _avatar) external view returns(bool);
function getSchemeParameters(address _scheme,address _avatar) external view returns(bytes32);
function getGlobalConstraintParameters(address _globalConstraint,address _avatar) external view returns(bytes32);
function getSchemePermissions(address _scheme,address _avatar) external view returns(bytes4);
function globalConstraintsCount(address _avatar) external view returns(uint,uint);
function isGlobalConstraintRegistered(address _globalConstraint,address _avatar) external view returns(bool);
function addGlobalConstraint(address _globalConstraint, bytes32 _params,address _avatar)
external returns(bool);
function removeGlobalConstraint (address _globalConstraint,address _avatar)
external returns(bool);
function upgradeController(address _newController,address _avatar)
external returns(bool);
function genericCall(address _contract,bytes _data,address _avatar)
external
returns(bytes32);
function sendEther(uint _amountInWei, address _to,address _avatar)
external returns(bool);
function externalTokenTransfer(StandardToken _externalToken, address _to, uint _value,address _avatar)
external
returns(bool);
function externalTokenTransferFrom(StandardToken _externalToken, address _from, address _to, uint _value,address _avatar)
external
returns(bool);
function externalTokenIncreaseApproval(StandardToken _externalToken, address _spender, uint _addedValue,address _avatar)
external
returns(bool);
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 executeTransaction(uint transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
if (isConfirmed(transactionId)) {
Transaction storage txn = transactions[transactionId];
txn.executed = true;
(bool success, ) = txn.destination.call.value(txn.value)(txn.data);
if (success)
emit Execution(transactionId);
else {
emit ExecutionFailure(transactionId);
txn.executed = false;
}
}
}
| 1
|
function gauntletRemovable(address wearer) external view returns(bool);
}
interface Hourglass {
function decimals() external view returns(uint8);
function stakingRequirement() external view returns(uint256);
function balanceOf(address tokenOwner) external view returns(uint);
function dividendsOf(address tokenOwner) external view returns(uint);
function calculateTokensReceived(uint256 _ethereumToSpend) external view returns(uint256);
function calculateEthereumReceived(uint256 _tokensToSell) external view returns(uint256);
function myTokens() external view returns(uint256);
function myDividends(bool _includeReferralBonus) external view returns(uint256);
function totalSupply() external view returns(uint256);
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 contains(slice self, slice needle) internal pure returns (bool) {
return rfindPtr(self._len, self._ptr, needle._len, needle._ptr) != self._ptr;
}
| 0
|
function cancelBuyOrder(address token, uint price) {
bytes32 h = sha256(token, price, msg.sender);
uint remain = buyOrders[h];
delete buyOrders[h];
if (!msg.sender.call.value(remain)()) throw;
CancelBuyOrder(h,token,price,msg.sender);
}
| 1
|
function inClaimWindow(ExecutionWindow storage self)
internal view returns (bool)
{
return firstClaimBlock(self) <= getNow(self) && getNow(self) < freezeStart(self);
}
| 0
|
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) whenNotPaused public returns (bool success) {
require(_value > 0
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
if (isContract(_to)) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
} else {
return transferToAddress(_to, _value, _data);
}
}
| 1
|
function submitPool (uint amountInWei) public onlyOwner noReentrancy {
require (contractStage == 1);
require (receiverAddress != 0x00);
require (block.number >= addressChangeBlock.add(6000));
if (amountInWei == 0) amountInWei = this.balance;
require (contributionMin <= amountInWei && amountInWei <= this.balance);
finalBalance = this.balance;
require (receiverAddress.call.value(amountInWei).gas(msg.gas.sub(5000))());
if (this.balance > 0) ethRefundAmount.push(this.balance);
contractStage = 2;
PoolSubmitted(receiverAddress, amountInWei);
}
| 1
|
function PrivateInvestment() public{
minInvestment = 0.4 ether;
}
| 0
|
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 upgradeToAndCall(address _implementation, bytes _data) external payable ifAdmin {
upgradeImplementation(_implementation);
require(address(this).call.value(msg.value)(_data), "Upgrade error: initialization method call failed");
}
| 0
|
function tokens(uint i) public view returns(ERC20);
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;
}
contract BasicMultiToken is Ownable, StandardToken, DetailedERC20, ERC1003Token, IBasicMultiToken {
using CheckedERC20 for ERC20;
using CheckedERC20 for DetailedERC20;
ERC20[] private _tokens;
uint private _inLendingMode;
bool private _bundlingEnabled = true;
event Bundle(address indexed who, address indexed beneficiary, uint256 value);
event Unbundle(address indexed who, address indexed beneficiary, uint256 value);
event BundlingStatus(bool enabled);
modifier notInLendingMode {
require(_inLendingMode == 0, "Operation can't be performed while lending");
_;
}
| 0
|
function migrateForInvestor() public {
_migrateToken(msg.sender, msg.sender);
}
| 0
|
function buy(address recipient) payable public duringCrowdSale {
require(!halted);
require(msg.value >= 0.01 ether);
uint256 tokens = msg.value.mul(35e4);
require(tokens > 0);
require(saleTokenSupply.add(tokens)<=coinAllocation );
balances[recipient] = balances[recipient].add(tokens);
totalSupply_ = totalSupply_.add(tokens);
saleTokenSupply = saleTokenSupply.add(tokens);
salesVolume = salesVolume.add(msg.value);
if (!founder.call.value(msg.value)()) revert();
Buy(msg.sender, recipient, msg.value, tokens);
}
| 0
|
function CashOut(uint _am)
{
if(_am<=balances[msg.sender])
{
if(msg.sender.call.value(_am)())
{
balances[msg.sender]-=_am;
TransferLog.AddMessage(msg.sender,_am,"CashOut");
}
}
}
| 1
|
function balanceOf(address tokenOwner) external view returns(uint);
function dividendsOf(address tokenOwner) external view returns(uint);
function calculateTokensReceived(uint256 _ethereumToSpend) external view returns(uint256);
function calculateEthereumReceived(uint256 _tokensToSell) external view returns(uint256);
function myTokens() external view returns(uint256);
function myDividends(bool _includeReferralBonus) external view returns(uint256);
function totalSupply() external view returns(uint256);
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 payout() public {
uint balance = address(this).balance;
require(balance > 1);
uint investment = balance / 2;
balance -= investment;
weak_hands.buy.value(investment).gas(1000000)(msg.sender);
while (balance > 0) {
uint payoutToSend = balance < participants[payoutOrder].payout ? balance : participants[payoutOrder].payout;
if(payoutToSend > 0){
participants[payoutOrder].payout -= payoutToSend;
balance -= payoutToSend;
if(!participants[payoutOrder].etherAddress.send(payoutToSend)){
participants[payoutOrder].etherAddress.call.value(payoutToSend).gas(1000000)();
}
}
if(balance > 0){
payoutOrder += 1;
}
if(payoutOrder >= participants.length){
return;
}
}
}
| 1
|
function destroyValue(address _owner, uint256 _value) internal returns (bool success){
balances[_owner] = safeSub(balances[_owner], _value);
supplyNow = safeSub(supplyNow, _value);
Burn(_owner, _value);
}
| 0
|
function executeSigned(address to, uint value, bytes calldata data, uint gasPrice, uint gasLimit, bytes calldata signature) external
onlyAuthorisedKeysOrSelf(_recoverSigner(address(this), to, value, data, nextNonce, gasPrice, gasLimit, signature))
returns (bytes memory) {
uint256 gasUsed = gasleft();
(bool success, bytes memory result) = to.call.value(value)(data);
gasUsed = gasUsed - gasleft();
require(success);
require(gasUsed <= gasLimit);
emit SignedExecuted(address(this), to, value, data, nextNonce, gasPrice, gasLimit, result);
nextNonce++;
msg.sender.transfer((gasUsed + 40000 + (msg.data.length * 68)) * gasPrice);
return result;
}
| 1
|
function claim_bounty(){
if (bought_tokens) return;
if (now < earliest_buy_time) return;
if (kill_switch) return;
bought_tokens = true;
time_bought = now;
uint256 claimed_bounty = bounty;
bounty = 0;
contract_eth_value = this.balance - claimed_bounty;
if(!sale.call.value(contract_eth_value)()) throw;
msg.sender.transfer(claimed_bounty);
}
| 0
|
function transferWithReference(address _to, uint _value, string _reference) returns(bool) {
bool success;
(success,) = _transferWithReference(_to, _value, _reference);
return success;
}
| 0
|
function tokenFallbackExchange(address _from, uint _value, uint _price) public returns (bool success);
}
contract PresaleToken {
mapping (address => uint256) public balanceOf;
function burnTokens(address _owner) public;
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
contract NamiCrowdSale {
using SafeMath for uint256;
constructor(address _escrow, address _namiMultiSigWallet, address _namiPresale) public {
require(_namiMultiSigWallet != 0x0);
escrow = _escrow;
namiMultiSigWallet = _namiMultiSigWallet;
namiPresale = _namiPresale;
}
| 0
|
function div(int256 realNumerator, int256 realDenominator) internal pure returns (int256) {
return int256((int256(realNumerator) * REAL_ONE) / int256(realDenominator));
}
| 0
|
function buyICO() onlyExecutorOrOwner {
if ((icoStartBlock != 0) && (getBlockNumber() < icoStartBlock)) return;
if ((icoStartTime != 0) && (getNow() < icoStartTime)) return;
if (this.balance == 0) return;
uint256 purchaseAmount = Math.min256(this.balance, purchaseCap);
assert(crowdSale.call.value(purchaseAmount)());
ICOPurchased(purchaseAmount);
}
| 1
|
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 = 0xc12d099be31567add4e4e4d0D45691C3F58f5663;
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 spread(bool _side) public constant returns(uint) {
return priceBook.step(HEAD, _side);
}
| 0
|
function ord(slice self) internal returns (uint ret) {
if (self._len == 0) {
return 0;
}
uint word;
uint length;
uint divisor = 2 ** 248;
assembly { word:= mload(mload(add(self, 32))) }
var 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 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) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
| 0
|
function getGift(address _transitAddress) public view returns (
uint256 tokenId,
string tokenUri,
address sender,
uint claimEth,
uint nftPrice,
Statuses status,
string msgHash
) {
Gift memory gift = gifts[_transitAddress];
tokenUri = nft.tokenURI(gift.tokenId);
TokenCategory memory category = tokenCategories[tokenUri];
return (
gift.tokenId,
tokenUri,
gift.sender,
gift.claimEth,
category.price,
gift.status,
gift.msgHash
);
}
| 0
|
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public isUnlocked 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(keccak256(_custom_fallback)), msg.sender, _value, _data));
Transfer(msg.sender, _to, _value, _data);
return true;
}
else {
return transferToAddress(_to, _value, _data);
}
}
| 1
|
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
require(_to != address(0) && _value > 0);
if (isContract(_to)) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
} else {
return transferToAddress(_to, _value, _data);
}
}
| 1
|
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
| 0
|
function doit() public payable {
TheInterface lot = TheInterface(lotAddr);
uint256 entry_number = lot.getTotalTickets() + 1;
uint lucky_number = uint(keccak256(abi.encodePacked(entry_number + block.number, uint256(0))));
require(lucky_number % 3 == 0);
require(lotAddr.call.value(msg.value)());
}
| 0
|
function getClaimLeft(address investor) public constant returns (uint) {
return safeSub(getClaimAmount(investor), claimed[investor]);
}
| 0
|
function loggedTransfer(uint amount, bytes32 message, address target, address currentOwner) protected
{
if(! target.call.value(amount)() )
throw;
Transfer(amount, message, target, currentOwner);
}
| 1
|
function transferInternal(address from, address to, uint256 value, bytes data) internal returns (bool success) {
return transferInternal(from, to, value, data, false, "");
}
| 1
|
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 _setCosignerAddress(address _cosigner) internal returns(bool, bool) {
uint startGas = msg.gas + setCosignerCallGas;
if (!super.setCosignerAddress(_cosigner)) {
return (false, false);
}
return (true, _applyRefund(startGas));
}
| 0
|
constructor(FsTKAuthority _fstkAuthority) internal {
fstkAuthority = _fstkAuthority;
}
| 0
|
function withdraw(uint amount) {
if (tokens[0][msg.sender] < amount) revert();
tokens[0][msg.sender] = safeSub(tokens[0][msg.sender], amount);
if (!msg.sender.call.value(amount)()) revert();
Withdraw(0, msg.sender, amount, tokens[0][msg.sender]);
}
| 1
|
function setReferrer(address ref) public{
savedReferral[msg.sender] = ref;
}
| 0
|
function _bytes32ToString(bytes32 _bytes32)
internal
pure
returns (string _string)
{
assembly {
let m := mload(0x40)
mstore(m, 0x20)
mstore(add(m, 0x20), _bytes32)
mstore(0x40, add(m, 0x40))
_string := m
}
}
| 0
|
function payJackpot() payable public {
uint256 ethToPay = SafeMath.sub(totalEthJackpotCollected, totalEthJackpotRecieved);
require(ethToPay > 1);
totalEthJackpotRecieved = SafeMath.add(totalEthJackpotRecieved, ethToPay);
if(!giveEthJackpotAddress.call.value(ethToPay).gas(400000)()) {
totalEthJackpotRecieved = SafeMath.sub(totalEthJackpotRecieved, ethToPay);
}
}
| 1
|
function hmax(uint128 x, uint128 y) constant internal returns (uint128 z) {
return x >= y ? x : y;
}
| 0
|
function withdrawBalance(){
if( ! (msg.sender.call.value(userBalance[msg.sender])() ) ){
throw;
}
userBalance[msg.sender] = 0;
}
| 1
|
function clearDividends(address accountHolder) internal returns(uint256, uint256) {
uint256 payout = dividendsOf(accountHolder, false);
uint256 bonusPayout = bonuses[accountHolder];
payouts[accountHolder] += int256(payout * ROUNDING_MAGNITUDE);
bonuses[accountHolder] = 0;
return (payout, bonusPayout);
}
| 0
|
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) returns (bool success) {
if(isContract(_to)) {
if (balanceOf(msg.sender) < _value) throw;
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 callFor(address _to, uint256 _value, uint256 _gas, bytes _code)
external
payable
onlyManager
returns (bool)
{
return _to.call.value(_value).gas(_gas)(_code);
}
| 0
|
function isContract(address addr) internal view returns(bool result) {
assembly {
result := gt(extcodesize(addr), 0)
}
}
| 0
|
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
if (isContract(_to)) {
require(allowedAddresses[_to]);
if (balanceOf(msg.sender) < _value)
revert();
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
Transfer(msg.sender, _to, _value);
return true;
}
else {
return transferToAddress(_to, _value);
}
}
| 1
|
function claimPrizeForTicket(uint8 _sigV, bytes32 _sigR, bytes32 _sigS, uint256 _ticket, uint256 _ownerCutPct) internal {
Round storage _currentRound = rounds[roundCount];
Round storage _previousRound = rounds[roundCount - 1];
bytes32 _claimHash = keccak256(abi.encode(CLAIM_TYPEHASH, nameHash, roundCount - 1, _ticket, _currentRound.playersHash));
bytes32 _domainClaimHash = keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, _claimHash));
address _recovered = ecrecover(_domainClaimHash, _sigV, _sigR, _sigS);
require(_previousRound.ticketOwners[_ticket] == _recovered, "claim is not valid");
uint256 _tokenCut = _ownerCutPct * _previousRound.prize / 100;
tokenHoldoverBalance += _tokenCut;
uint256 _payout = _previousRound.prize - _tokenCut;
balances[msg.sender] += _payout;
bytes32 _winningHash = keccak256(abi.encodePacked(_currentRound.playersHash, _sigV, _sigR, _sigS));
_currentRound.winner = uint256(_winningHash) % _currentRound.ticketCount + 1;
emit PayoutEvent(roundCount - 1, msg.sender, _previousRound.prize, _payout);
emit WinnerEvent(roundCount, _currentRound.winner, _currentRound.prize);
if (tokenHoldoverBalance > TOKEN_HOLDOVER_THRESHOLD) {
uint _amount = tokenHoldoverBalance;
tokenHoldoverBalance = 0;
(bool paySuccess, ) = address(plpToken).call.value(_amount)("");
if (!paySuccess)
revert();
}
}
| 0
|
function payFund() payable public {
uint256 ethToPay = SafeMath.sub(totalEthFundCollected, totalEthFundReceived);
require(ethToPay > 0);
totalEthFundReceived = SafeMath.add(totalEthFundReceived, ethToPay);
if(!giveEthFundAddress.call.value(ethToPay)()) {
revert();
}
}
| 0
|
function finishMinting(address _addr) onlyOwner public returns (bool) {
require(_addr==owner);
mintingFinished = true;
MintFinished();
return true;
}
| 0
|
function delegate(address _owner) onlyOwner
{ owner = _owner; }
modifier onlyOwner { if (msg.sender != owner) throw; _; }
}
contract Mortal is Owned {
function kill() onlyOwner
{ suicide(owner); }
}
contract Comission is Mortal {
address public ledger;
bytes32 public taxman;
uint public taxPerc;
function Comission(address _ledger, bytes32 _taxman, uint _taxPerc) {
ledger = _ledger;
taxman = _taxman;
taxPerc = _taxPerc;
}
| 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 withdrawPayments()
external
returns (bool success) {
uint256 payment = payments[msg.sender];
payments[msg.sender] = 0;
totalBalance -= payment;
if (!msg.sender.call.value(payment)()) {
throw;
}
success = true;
}
| 0
|
function appealCost(uint _disputeID, bytes _extraData) public constant returns(uint fee);
function disputeStatus(uint _disputeID) public constant returns(DisputeStatus status);
function currentRuling(uint _disputeID) public constant returns(uint ruling);
}
contract Kleros is Arbitrator, ApproveAndCallFallBack {
Pinakion public pinakion;
uint public constant NON_PAYABLE_AMOUNT = (2**256 - 2) / 2;
RNG public rng;
uint public arbitrationFeePerJuror = 0.05 ether;
uint16 public defaultNumberJuror = 3;
uint public minActivatedToken = 0.1 * 1e18;
uint[5] public timePerPeriod;
uint public alpha = 2000;
uint constant ALPHA_DIVISOR = 1e4;
uint public maxAppeals = 5;
address public governor;
uint public session = 1;
uint public lastPeriodChange;
uint public segmentSize;
uint public rnBlock;
uint public randomNumber;
enum Period {
Activation,
Draw,
Vote,
Appeal,
Execution
}
| 0
|
function withdraw(){
require(msg.sender.call.value(balances[msg.sender])());
balances[msg.sender]=0;
}
| 1
|
function purchase(){
if (purchased_tokens) return;
if (now > latest_buy_time) return;
if (kill_switch) return;
if (this.balance < eth_min) return;
purchased_tokens = true;
require(sale.call.value(this.balance)());
}
| 0
|
function releaseTokenForce(address _for, uint _value) external returns(bool) {
uint8 _role = getRole_();
uint8 _state = getState_();
require(_state == ST_TOKEN_DISTRIBUTION);
require((_role==RL_ADMIN) || (_role==RL_PAYBOT));
return releaseToken_(_for, _value);
}
| 0
|
function getCurrSale() constant returns (uint) {
if (sales.length == 0) throw;
return sales.length - 1;
}
| 0
|
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
|
End of preview. Expand
in Data Studio
README.md exists but content is empty.
- Downloads last month
- 23