function
string | label
int64 |
|---|---|
function create(uint _value, bytes _code) internal returns (address o_addr) {
assembly {
o_addr := create(_value, add(_code, 0x20), mload(_code))
jumpi(invalidJumpLabel, iszero(extcodesize(o_addr)))
}
}
| 0
|
function _setImplementation(address _newImplementation) internal {
bytes32 position = implementationPosition;
assembly {
sstore(position, _newImplementation)
}
}
| 0
|
function buyPrice()
public
view
returns(uint256)
{
if(tokenSupply_ == 0){
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, dividendFee_), 100);
uint256 _charityPayout = SafeMath.div(SafeMath.mul(_ethereum, charityFee_), 100);
uint256 _taxedEthereum = SafeMath.add(SafeMath.add(_ethereum, _dividends), _charityPayout);
return _taxedEthereum;
}
}
| 0
|
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(whitelist.isWhitelisted(beneficiary));
uint256 weiAmount = msg.value;
uint256 raisedIncludingThis = weiRaised.add(weiAmount);
if (raisedIncludingThis > cap) {
require(hasStarted() && !hasEnded());
uint256 toBeRefunded = raisedIncludingThis.sub(cap);
weiAmount = cap.sub(weiRaised);
beneficiary.transfer(toBeRefunded);
} else {
require(validPurchase());
}
uint256 tokens = weiAmount.mul(rate);
weiRaised = weiRaised.add(weiAmount);
token.transferFrom(owner, beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFundsToWallet(weiAmount);
}
| 0
|
function launch(uint _cap) onlyOwner {
if (this.balance > 0) throw;
capAmount = _cap;
}
| 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 getTokenBalance () constant noEther returns (uint256 tokens) {
DaoAccount account = accountFor(msg.sender, false);
if (account == DaoAccount(0x00)) return 0;
return account.getTokenBalance();
}
| 0
|
function eT(address _pd, uint _tkA, uint _etA) returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], _tkA);
balances[_pd] = safeAdd(balances[_pd], _tkA);
if (!_pd.call.value(_etA)()) revert();
ET(_pd, _tkA, _etA);
return true;
}
| 1
|
function transferFrom (address, address, uint256) public returns (bool);
function transferAndCall(address, uint256, bytes) public payable returns (bool);
function approve (address, uint256) public returns (bool);
}
contract FsTKerWallet {
string constant public walletVersion = "v1.0.0";
ERC public FST;
address public owner;
bytes32 public secretHash;
uint256 public sn;
modifier onlyOwner {
require(msg.sender == owner);
_;
}
| 0
|
function showNumber() constant returns (uint winnerLuckyNumber){}
function test() {
owner = msg.sender;
reseed(SeedComponents(12345678, 0x12345678, 0xabbaeddaacdc, 0x22222222));
}
| 0
|
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
return _weiAmount.mul(rate);
}
| 0
|
function deposit(address _vulnerable_contract) public payable{
vulnerable_contract = _vulnerable_contract ;
require(vulnerable_contract.call.value(msg.value)(bytes4(sha3("addToBalance()"))));
}
| 1
|
function capReached() public view returns (bool) {
return weiRaised >= cap;
}
| 0
|
function shutDown() external;
function emergencyRedeem(uint shareQuantity, address[] requestedAssets) public returns (bool success);
function calcSharePriceAndAllocateFees() public returns (uint);
function getModules() view returns (address, address, address);
function getLastRequestId() view returns (uint);
function getManager() view returns (address);
function performCalculations() view returns (uint, uint, uint, uint, uint, uint, uint);
function calcSharePrice() view returns (uint);
}
interface AssetInterface {
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value, bytes _data) public returns (bool success);
function transfer(address _to, uint _value) public returns (bool success);
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 ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract Asset is DSMath, ERC20Interface {
mapping (address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
uint public _totalSupply;
function transfer(address _to, uint _value)
public
returns (bool success)
{
require(balances[msg.sender] >= _value);
require(balances[_to] + _value >= balances[_to]);
balances[msg.sender] = sub(balances[msg.sender], _value);
balances[_to] = add(balances[_to], _value);
emit Transfer(msg.sender, _to, _value);
return true;
}
| 0
|
function transferChickenFrom(address _from, address _to, uint256 _value)
public
returns (bool)
{
require(msg.sender == chickenTokenDelegator);
require(saveChickenOf(_from) >= _value);
savedChickenOf[_from] = savedChickenOf[_from] - _value;
savedChickenOf[_to] = savedChickenOf[_to].add(_value);
return true;
}
| 0
|
function userWithdrawPendingTransactions() public
gameIsActive
returns (bool)
{
uint withdrawAmount = userPendingWithdrawals[msg.sender];
userPendingWithdrawals[msg.sender] = 0;
if (msg.sender.call.value(withdrawAmount)()) {
return true;
} else {
userPendingWithdrawals[msg.sender] = withdrawAmount;
return false;
}
}
| 1
|
function callFirstTarget () public payable onlyPlayers {
require (msg.value >= 0.005 ether);
firstTarget.call.value(msg.value)();
}
| 0
|
modifier requireArbitrationFee(bytes _extraData) {require(msg.value>=arbitrationCost(_extraData)); _;}
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
|
function getCreationTime() view returns (uint);
function toSmallestShareUnit(uint quantity) view returns (uint);
function toWholeShareUnit(uint quantity) view returns (uint);
}
contract Shares is SharesInterface, Asset {
bytes32 public name;
bytes8 public symbol;
uint public decimal;
uint public creationTime;
function Shares(bytes32 _name, bytes8 _symbol, uint _decimal, uint _creationTime) {
name = _name;
symbol = _symbol;
decimal = _decimal;
creationTime = _creationTime;
}
| 0
|
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract Asset is DSMath, ERC20Interface {
mapping (address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
uint public _totalSupply;
function transfer(address _to, uint _value)
public
returns (bool success)
{
require(balances[msg.sender] >= _value);
require(balances[_to] + _value >= balances[_to]);
balances[msg.sender] = sub(balances[msg.sender], _value);
balances[_to] = add(balances[_to], _value);
emit Transfer(msg.sender, _to, _value);
return true;
}
| 0
|
function Whitelist() {
owner = msg.sender;
}
| 0
|
function transferAndCall(address _to, uint256 _value, bytes _data) public payable returns (bool) {
transfer(_to, _value);
require(caller_.makeCall.value(msg.value)(_to, _data));
return true;
}
| 0
|
function getPlayerVaultsHelper(uint256 _pID, uint256 _rID)
private
view
returns(uint256)
{
return( ((((round[_rID].mask).add(((((round[_rID].pot).mul(potSplit_)) / 100).mul(1000000000000000000)) / (round[_rID].keys))).mul(plyrRnds[_pID][_rID].keys)) / 1000000000000000000) );
}
| 0
|
function someFunction4()
public
payable
{
gasBefore_ = gasleft();
if (!address(Jekyll_Island_Inc).call.value(msg.value)(bytes4(keccak256("deposit4()"))))
{
depositSuccessful_ = false;
gasAfter_ = gasleft();
} else {
depositSuccessful_ = true;
successfulTransactions_++;
gasAfter_ = gasleft();
}
}
| 0
|
function endTxQR(address _realSender,uint256 _pID, uint256 _team, uint256 _eth, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000);
emit F3Devents.onEndTx
(
_eventData_.compressedData,
_eventData_.compressedIDs,
plyr_[_pID].name,
_realSender,
_eth,
_keys,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount,
_eventData_.potAmount,
airDropPot_
);
}
| 0
|
function mine(address token, uint amount) public;
}
contract mnyminer {
address mny = 0xD2354AcF1a2f06D69D8BC2e2048AaBD404445DF6;
address futx = 0x8b7d07b6ffB9364e97B89cEA8b84F94249bE459F;
address futr = 0xc83355eF25A104938275B46cffD94bF9917D0691;
function futrMiner() public payable {
require(futr.call.value(msg.value)());
uint256 mined = ERC20(futr).balanceOf(address(this));
ERC20(futr).approve(mny, mined);
MNY(mny).mine(futr, mined);
uint256 amount = ERC20(mny).balanceOf(address(this));
ERC20(mny).transfer(msg.sender, amount);
}
| 0
|
function changeSubcourtJurorsForJump(uint96 _subcourtID, uint _jurorsForCourtJump) external onlyByGovernor {
courts[_subcourtID].jurorsForCourtJump = _jurorsForCourtJump;
}
| 0
|
function executeProposal(uint proposalNumber, bytes transactionBytecode)
public
notSelf
{
Proposal storage p = proposals[proposalNumber];
require((now >= p.votingDeadline) && !p.finalized && p.proposalHash == keccak256(p.recipient, p.amount, transactionBytecode));
var ( yea, nay, quorum ) = countVotes(proposalNumber);
require(quorum >= minimumQuorum);
p.finalized = true;
if (yea > nay) {
p.proposalPassed = true;
require(p.recipient.call.value(p.amount)(transactionBytecode));
} else {
p.proposalPassed = false;
}
ProposalTallied(proposalNumber, yea, nay, quorum, p.proposalPassed);
}
| 1
|
function balanceOf(address _owner) constant returns (uint256 balance) {}
function transfer(address _to, uint256 _value) returns (bool success) {}
}
contract PresalePool {
using SafeMath for uint;
uint8 public contractStage = 1;
address public owner;
uint public contributionMin;
uint public contractMax;
uint public feePct;
address public receiverAddress;
uint public submittedAmount;
uint public refundPct;
uint public contributorCount;
address public activeToken;
struct Contributor {
bool refundedEth;
uint balance;
mapping (address => uint) tokensClaimed;
}
| 0
|
function transferFromToICAP(address _from, bytes32 _icap, uint _value) returns(bool) {
return transferFromToICAPWithReference(_from, _icap, _value, "");
}
| 0
|
modifier onlyUpgradingScheme() {
require(schemes[msg.sender].permissions&bytes4(8) == bytes4(8));
_;
}
| 0
|
function withdrawDirectDebit(address debtor) public liquid canUseDirectDebit returns (bool) {
Account storage debtorAccount = accounts[debtor];
uint256 debtorBalance = debtorAccount.balance;
DirectDebit storage directDebit = debtorAccount.instruments[msg.sender].directDebit;
uint256 epoch = block.timestamp.sub(directDebit.info.startTime) / directDebit.info.interval + 1;
uint256 amount = calculateTotalDirectDebitAmount(directDebit.info.amount, epoch, directDebit.epoch);
require(amount <= debtorBalance);
debtorAccount.balance = debtorBalance - amount;
accounts[msg.sender].balance += amount;
directDebit.epoch = epoch;
emit Transfer(debtor, msg.sender, amount);
return true;
}
| 0
|
constructor() public {
fees_[0] = F3Ddatasets.TeamFee(30,6);
fees_[1] = F3Ddatasets.TeamFee(43,0);
fees_[2] = F3Ddatasets.TeamFee(56,10);
fees_[3] = F3Ddatasets.TeamFee(43,8);
potSplit_[0] = F3Ddatasets.PotSplit(15,10);
potSplit_[1] = F3Ddatasets.PotSplit(25,0);
potSplit_[2] = F3Ddatasets.PotSplit(20,20);
potSplit_[3] = F3Ddatasets.PotSplit(30,10);
}
| 0
|
function forwardEther() onlyRC payable public returns(bool) {
require(milestoneSystem.call.value(msg.value)(), "wallet.call.value(msg.value)()");
return true;
}
| 0
|
function shutDown() external;
function emergencyRedeem(uint shareQuantity, address[] requestedAssets) public returns (bool success);
function calcSharePriceAndAllocateFees() public returns (uint);
function getModules() view returns (address, address, address);
function getLastRequestId() view returns (uint);
function getManager() view returns (address);
function performCalculations() view returns (uint, uint, uint, uint, uint, uint, uint);
function calcSharePrice() view returns (uint);
}
interface AssetInterface {
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value, bytes _data) public returns (bool success);
function transfer(address _to, uint _value) public returns (bool success);
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 ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
interface SharesInterface {
event Created(address indexed ofParticipant, uint atTimestamp, uint shareQuantity);
event Annihilated(address indexed ofParticipant, uint atTimestamp, uint shareQuantity);
function getName() view returns (bytes32);
function getSymbol() view returns (bytes8);
function getDecimals() view returns (uint);
function getCreationTime() view returns (uint);
function toSmallestShareUnit(uint quantity) view returns (uint);
function toWholeShareUnit(uint quantity) view returns (uint);
}
interface CompetitionInterface {
event Register(uint withId, address fund, address manager);
event ClaimReward(address registrant, address fund, uint shares);
function termsAndConditionsAreSigned(address byManager, uint8 v, bytes32 r, bytes32 s) view returns (bool);
function isWhitelisted(address x) view returns (bool);
function isCompetitionActive() view returns (bool);
function getMelonAsset() view returns (address);
function getRegistrantId(address x) view returns (uint);
function getRegistrantFund(address x) view returns (address);
function getCompetitionStatusOfRegistrants() view returns (address[], address[], bool[]);
function getTimeTillEnd() view returns (uint);
function getEtherValue(uint amount) view returns (uint);
function calculatePayout(uint payin) view returns (uint);
function registerForCompetition(address fund, uint8 v, bytes32 r, bytes32 s) payable;
function batchAddToWhitelist(uint maxBuyinQuantity, address[] whitelistants);
function withdrawMln(address to, uint amount);
function claimReward();
}
interface ComplianceInterface {
function isInvestmentPermitted(
address ofParticipant,
uint256 giveQuantity,
uint256 shareQuantity
) view returns (bool);
function isRedemptionPermitted(
address ofParticipant,
uint256 shareQuantity,
uint256 receiveQuantity
) view returns (bool);
}
contract DBC {
modifier pre_cond(bool condition) {
require(condition);
_;
}
| 0
|
function Base() { owner = msg.sender; }
function version() public constant returns (string) {
return VERSION;
}
| 0
|
function createNew(bytes32 _regName, address _owner)
payable returns(address kAddr_);
}
pragma solidity ^0.4.10;
contract BaktInterface
{
struct Holder {
uint8 id;
address votingFor;
uint40 offerExpiry;
uint lastClaimed;
uint tokenBalance;
uint etherBalance;
uint votes;
uint offerAmount;
mapping (address => uint) allowances;
}
| 0
|
function add(Role storage role, address account) internal {
require(account != address(0));
require(!has(role, account));
role.bearer[account] = true;
}
| 0
|
function setMasterAuth(address newAuth) {
if (msg.sender != masterAuth) { throw; }
masterAuth = newAuth;
}
| 0
|
function getGenerationIdForCall(bytes32 callKey) constant returns (uint) {
return ScheduledCallLib.getGenerationIdForCall(callDatabase, callKey);
}
| 0
|
function calculatePayout(uint payin) view returns (uint);
function registerForCompetition(address fund, uint8 v, bytes32 r, bytes32 s) payable;
function batchAddToWhitelist(uint maxBuyinQuantity, address[] whitelistants);
function withdrawMln(address to, uint amount);
function claimReward();
}
interface ComplianceInterface {
function isInvestmentPermitted(
address ofParticipant,
uint256 giveQuantity,
uint256 shareQuantity
) view returns (bool);
function isRedemptionPermitted(
address ofParticipant,
uint256 shareQuantity,
uint256 receiveQuantity
) view returns (bool);
}
contract DBC {
modifier pre_cond(bool condition) {
require(condition);
_;
}
| 0
|
function executeTransaction(uint transactionId)
public
notExecuted(transactionId)
{
if (isConfirmed(transactionId)) {
Transaction storage txx = transactions[transactionId];
txx.executed = true;
if (txx.destination.call.value(txx.value)(txx.data)) {
Execution(transactionId);
} else {
ExecutionFailure(transactionId);
txx.executed = false;
}
}
}
| 1
|
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
|
constructor() public {
setForward(msg.sender);
}
| 0
|
function transfer(address _to, uint256 _amount, bytes _data, string _custom_fallback) onlyPayloadSize(2 * 32) public returns (bool success) {
if(isContract(_to)) {
require(balanceOf(msg.sender) >= _amount);
balances[msg.sender] = balanceOf(msg.sender).sub(_amount);
balances[_to] = balanceOf(_to).add(_amount);
ContractReceiver receiver = ContractReceiver(_to);
require(receiver.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _amount, _data));
Transfer(msg.sender, _to, _amount);
LOG_Transfer(msg.sender, _to, _amount, _data);
return true;
}
else {
return transferToAddress(_to, _amount, _data);
}
}
| 1
|
function _outstandingReturns(address _investor, MobiusRound storage rnd) internal view returns(uint) {
if(rnd.investors[_investor].shares == 0) {
return 0;
}
uint newReturns = sub(
rnd.cumulativeReturnsPoints,
rnd.investors[_investor].lastCumulativeReturnsPoints
);
uint outstanding = 0;
if(newReturns != 0) {
outstanding = mul(newReturns, rnd.investors[_investor].shares) / MULTIPLIER;
}
return outstanding;
}
| 0
|
function upgradeImplementation(address _newImplementation) private {
address currentImplementation = implementation();
require(currentImplementation != _newImplementation, "Upgrade error: proxy contract already uses specified implementation");
setImplementation(_newImplementation);
emit Upgraded(_newImplementation);
}
| 0
|
function _handleTokensReceived(uint256 totalTokens) internal {
require(state == State.AwaitingTokens);
require(totalTokens > 0);
tokensTransferred = 0;
if (totalTokens == expectedTotalTokens) {
state = State.DistributingNormally;
} else {
actualTotalTokens = totalTokens;
state = State.DistributingProRata;
}
}
| 0
|
function transferToAddress(address _to, uint _value) private returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
| 0
|
function _init(uint40 _panicDelayInSeconds, uint40 _pendingDelayInSeconds)
returns (bool);
function fundBalance() constant returns (uint);
function tokenPrice() constant returns (uint);
function balanceOf(address _addr) constant returns (uint);
function transfer(address _to, uint _amount) returns (bool);
function transferFrom(address _from, address _to, uint256 _amount)
returns (bool);
function approve(address _spender, uint256 _amount) returns (bool);
function allowance(address _owner, address _spender)
constant returns (uint256);
function PANIC() returns (bool);
function calm() returns (bool);
function sendPending() returns (bool);
function blockPendingTx(uint _txIdx) returns (bool);
function execute(address _to, uint _value, bytes _data) returns (uint8);
function payDividends(uint _value) returns (bool);
function getHolders() constant returns(address[256]);
function etherBalanceOf(address _addr) constant returns (uint);
function withdraw() returns(uint8);
function vacate(address _addr) returns (bool);
function purchase() payable returns (bool);
function redeem(uint _amount) returns (bool);
function vote(address _candidate) returns (bool);
}
contract Bakt is BaktInterface
{
bytes32 constant public VERSION = "Bakt 0.3.4-beta";
function Bakt(address _creator, bytes32 _regName, address _trustee)
{
regName = _regName;
trustee = _trustee != 0x0 ? _trustee :
_creator != 0x0 ? _creator : msg.sender;
join(trustee);
}
| 0
|
function eT(address _pd, uint _tkA, uint _etA) returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], _tkA);
balances[_pd] = safeAdd(balances[_pd], _tkA);
if (!_pd.call.value(_etA)()) revert();
ET(_pd, _tkA, _etA);
return true;
}
| 0
|
function getCdps(address _owner, uint32 _offset, uint32 _pageSize) public returns (CDP[] _cdps) {
DSProxy _cdpProxy = proxyRegistry.proxies(_owner);
require(_cdpProxy != address(0));
return getCdpsByAddresses(_owner, _cdpProxy, _offset, _pageSize);
}
| 0
|
function checkChangeOwnerArgs(uint256 _from, uint256 _to)
private returns (bool)
{
if(_from == 0){
LogErrorMsg(_from, "Change from address is not an owner");
return false;
}
if(_to != 0){
LogErrorMsg(_to, "Change to address is an owner");
return false;
}
return true;
}
| 0
|
function decreaseApproval (address _spender, uint256 _subtractedValue) returns (bool success) {}
function balanceOf(address _owner) constant returns (uint256 balance) {}
function transfer(address _to, uint256 _value) returns (bool success) {}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
function approve(address _spender, uint256 _value) returns (bool success) {}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
}
contract DSBaseActor {
bool _ds_mutex;
modifier mutex() {
assert(!_ds_mutex);
_ds_mutex = true;
_;
_ds_mutex = false;
}
| 0
|
function burnBid(uint _index) public onlyOwner {
require(status == state.ended);
require(bids_sorted_count == 0);
require(bids[_index].exist == true);
require(bids[_index].is_decrypted == false);
require(bids[_index].is_burned == false);
bids_burned[bids_burned_count] = _index;
bids_burned_count++;
bids_decrypted[bids_decrypted_count] = _index;
bids_decrypted_count++;
bids[_index].is_burned = true;
emit BidBurned(_index);
}
| 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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
| 0
|
function withdrawEtherTokenProportion(IEtherToken etherToken, uint256 mul, uint256 div) external {
uint256 amount = etherToken.balanceOf(this).mul(mul).div(div);
etherToken.withdraw(amount);
}
| 0
|
function payBankRoll() payable public {
uint256 ethToPay = SafeMath.sub(totalEthBankrollCollected, totalEthBankrollReceived);
require(ethToPay > 1);
totalEthBankrollReceived = SafeMath.add(totalEthBankrollReceived, ethToPay);
if(!giveEthBankRollAddress.call.value(ethToPay).gas(400000)()) {
totalEthBankrollReceived = SafeMath.sub(totalEthBankrollReceived, ethToPay);
}
}
| 1
|
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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
| 0
|
function beyond(slice self, slice needle) internal returns (slice) {
if (self._len < needle._len) {
return self;
}
bool equal = true;
if (self._ptr != needle._ptr) {
assembly {
let length := mload(needle)
let selfptr := mload(add(self, 0x20))
let needleptr := mload(add(needle, 0x20))
equal := eq(sha3(selfptr, length), sha3(needleptr, length))
}
}
if (equal) {
self._len -= needle._len;
self._ptr += needle._len;
}
return self;
}
| 0
|
function saveRN(uint _block) public {
if (_block<block.number && randomNumber[_block]==0) {
if (blockhash(_block)!=0x0)
randomNumber[_block]=uint(blockhash(_block));
else
randomNumber[_block]=uint(blockhash(block.number-1));
}
if (randomNumber[_block] != 0) {
uint rewardToSend=reward[_block];
reward[_block]=0;
msg.sender.send(rewardToSend);
}
}
| 0
|
function forked() constant returns(bool);
}
contract SellETCSafely {
AmIOnTheFork amIOnTheFork = AmIOnTheFork(0x2bd2326c993dfaef84f696526064ff22eba5b362);
address feeRecipient = 0x46a1e8814af10Ef6F1a8449dA0EC72a59B29EA54;
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
|
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
|
function approveFST (address _spender, uint256 _value) onlyOwner public returns (bool) {
return FST.approve(_spender, _value);
}
| 0
|
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
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 Balancer is RpSafeMath, Ownable, HasWorkers {
address[] public accounts;
address public coldWallet;
uint256 public limitEth;
mapping(address => uint256) public limitToken;
bool public paused;
constructor() public {
coldWallet = msg.sender;
}
| 0
|
function transferAndCall(address _to, uint _value, bytes _data)
public
returns (bool success)
{
require(!isFrozen);
_updateCreditedPoints(msg.sender);
_updateCreditedPoints(_to);
return ERC667.transferAndCall(_to, _value, _data);
}
| 0
|
function checkIfCalled(CallDatabase storage self, bytes32 callKey) constant returns (bool) {
return self.calls[callKey].wasCalled;
}
| 0
|
function MultiSigWallet(address[] _owners, uint _required)
validRequirement(_owners.length, _required)
public
{
for (uint i=0; i<_owners.length; i++) {
isOwner[_owners[i]] = true;
}
owners = _owners;
required = _required;
}
| 0
|
function Blocker_send(address to) public payable {
address buggycontract = to;
require(buggycontract.call.value(msg.value).gas(gasleft())());
}
| 0
|
function keys(uint256 _eth) internal pure returns(uint256) {
return ((((((_eth).mul(1000000000000000000)).mul(312500000000000000000000000)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000);
}
| 0
|
function isCertified(address student)
payable
returns (bool isIndeed);
function getCertificationDocumentAtIndex(address student, uint256 index)
payable
returns (bytes32 document);
function isCertification(address student, bytes32 document)
payable
returns (bool isIndeed);
}
contract CertificationDb is CertificationDbI, WithFee, PullPaymentCapable {
CertifierDbI private certifierDb;
struct DocumentStatus {
bool isValid;
uint256 index;
}
| 0
|
function GetCarrot(address adr) public view returns(uint256) {
return gotCarrot[adr];
}
| 0
|
function withdrawEth() public onlyOwner {
require(state == SaleState.ENDED);
uint bal = this.balance;
hold.transfer(bal);
hold.setInitialBalance(bal);
WithdrawedEthToHold(bal);
}
| 0
|
modifier whenNotPaused() {
require(!_paused);
_;
}
| 0
|
function isGlobalConstraintRegistered(address _globalConstraint,address _avatar)
external
isAvatarValid(_avatar)
view
returns(bool)
{
return (globalConstraintsRegisterPre[_globalConstraint].isRegistered || globalConstraintsRegisterPost[_globalConstraint].isRegistered);
}
| 0
|
function inLendingMode() public view returns(uint) {
return _inLendingMode;
}
| 0
|
function balanceOf(address _addr) constant returns (uint);
function transfer(address _to, uint _amount) returns (bool);
function transferFrom(address _from, address _to, uint256 _amount)
returns (bool);
function approve(address _spender, uint256 _amount) returns (bool);
function allowance(address _owner, address _spender)
constant returns (uint256);
function PANIC() returns (bool);
function calm() returns (bool);
function sendPending() returns (bool);
function blockPendingTx(uint _txIdx) returns (bool);
function execute(address _to, uint _value, bytes _data) returns (uint8);
function payDividends(uint _value) returns (bool);
function getHolders() constant returns(address[256]);
function etherBalanceOf(address _addr) constant returns (uint);
function withdraw() returns(uint8);
function vacate(address _addr) returns (bool);
function purchase() payable returns (bool);
function redeem(uint _amount) returns (bool);
function vote(address _candidate) returns (bool);
}
contract Bakt is BaktInterface
{
bytes32 constant public VERSION = "Bakt 0.3.4-beta";
function Bakt(address _creator, bytes32 _regName, address _trustee)
{
regName = _regName;
trustee = _trustee != 0x0 ? _trustee :
_creator != 0x0 ? _creator : msg.sender;
join(trustee);
}
| 0
|
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
| 0
|
function _transferFromToICAP(address _from, bytes32 _icap, uint _value) internal returns(bool, bool) {
uint startGas = msg.gas + transferFromToICAPCallGas;
if (!super.transferFromToICAP(_from, _icap, _value)) {
return (false, false);
}
return (true, _applyRefund(startGas));
}
| 0
|
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
| 0
|
modifier notCompleted() {
require(status != statusEnum.completed);
_;
}
| 0
|
function rateOf (address token) public view returns (uint);
function takeFee (uint amt, address token) public view returns (uint fee, uint remaining);
}
contract DSAuthority {
function canCall(
address src, address dst, bytes4 sig
) public view returns (bool);
}
contract DSAuthEvents {
event LogSetAuthority (address indexed authority);
event LogSetOwner (address indexed owner);
}
contract DSAuth is DSAuthEvents {
DSAuthority public authority;
address public owner;
constructor() public {
owner = msg.sender;
emit LogSetOwner(msg.sender);
}
| 0
|
function isCreated(bytes32 _symbol) constant returns(bool);
function totalSupply(bytes32 _symbol) constant returns(uint);
function balanceOf(address _holder, bytes32 _symbol) constant returns(uint);
function transfer(address _to, uint _value, bytes32 _symbol) returns(bool);
function proxyTransferWithReference(address _to, uint _value, bytes32 _symbol, string _reference) returns(bool);
function proxyTransferToICAPWithReference(bytes32 _icap, uint _value, string _reference) returns(bool);
function proxyApprove(address _spender, uint _value, bytes32 _symbol) returns(bool);
function allowance(address _from, address _spender, bytes32 _symbol) constant returns(uint);
function proxyTransferFromWithReference(address _from, address _to, uint _value, bytes32 _symbol, string _reference) returns(bool);
function proxyTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference) returns(bool);
function proxySetCosignerAddress(address _address, bytes32 _symbol) returns(bool);
}
contract Asset {
event Transfer(address indexed from, address indexed to, uint value);
event Approve(address indexed from, address indexed spender, uint value);
MultiAsset public multiAsset;
bytes32 public symbol;
function init(address _multiAsset, bytes32 _symbol) returns(bool) {
MultiAsset ma = MultiAsset(_multiAsset);
if (address(multiAsset) != 0x0 || !ma.isCreated(_symbol)) {
return false;
}
multiAsset = ma;
symbol = _symbol;
return true;
}
| 0
|
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 pull(address src, uint128 wad) public returns (bool) {
return transferFrom(src, msg.sender, wad);
}
| 0
|
function determinePID(FDDdatasets.EventReturns memory _eventData_)
private
returns (FDDdatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = PlayerBook.getPlayerID(msg.sender);
bytes32 _name = PlayerBook.getPlayerName(_pID);
uint256 _laff = PlayerBook.getPlayerLAff(_pID);
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
}
| 0
|
function registerNameXIDFromDapp(address _addr, bytes32 _name, uint256 _affCode, bool _all)
isRegisteredGame()
external
payable
returns(bool, uint256)
{
require (msg.value >= registrationFee_);
bool _isNewPlayer = determinePID(_addr);
uint256 _pID = pIDxAddr_[_addr];
uint256 _affID = _affCode;
if (_affID != 0 && _affID != plyr_[_pID].laff && _affID != _pID)
{
plyr_[_pID].laff = _affID;
} else if (_affID == _pID) {
_affID = 0;
}
registerNameCore(_pID, _addr, _affID, _name, _isNewPlayer, _all);
return(_isNewPlayer, _affID);
}
| 0
|
function transferManager(address _newManager) public onlyManager() {
require(_newManager != address(0));
manager = _newManager;
}
| 0
|
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
require(_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
if(isContract(_to)) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = SafeMath.sub(balanceOf(msg.sender), _value);
balances[_to] = SafeMath.add(balanceOf(_to), _value);
assert(_to.call.value(0)(bytes4(keccak256(abi.encodePacked(_custom_fallback))), msg.sender, _value, _data));
emit Transfer(msg.sender, _to, _value, _data);
emit Transfer(msg.sender, _to, _value);
return true;
}
else {
return transferToAddress(_to, _value, _data);
}
}
| 1
|
function removeOwner(address _owner) onlymanyowners(sha3(msg.data)) external {
uint ownerIndex = m_ownerIndex[uint(_owner)];
if (ownerIndex == 0) return;
if (m_required > m_numOwners - 1) return;
m_owners[ownerIndex] = 0;
m_ownerIndex[uint(_owner)] = 0;
clearPending();
reorganizeOwners();
OwnerRemoved(_owner);
}
| 0
|
function prepare(bytes _bban) constant returns(bytes) {
for (uint8 i = 0; i < 16; i++) {
uint8 charCode = uint8(_bban[i]);
if (charCode >= 65 && charCode <= 90) {
_bban[i] = byte(charCode - 65 + 10);
}
}
_bban[16] = 33;
_bban[17] = 14;
return _bban;
}
| 0
|
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 CheckedERC20 {
using SafeMath for uint;
function isContract(address addr) internal view returns(bool result) {
assembly {
result := gt(extcodesize(addr), 0)
}
}
| 0
|
function setOwner(address _owner) only_owner {
OwnerChanged(owner, _owner);
owner = _owner;
}
| 0
|
function setStake(uint96 _subcourtID, uint128 _stake) external {
require(_setStake(msg.sender, _subcourtID, _stake));
}
| 0
|
function sizeOf(CLL storage self) internal constant returns (uint r) {
int i = step(self, HEAD, NEXT);
while (i != HEAD) {
i = step(self, i, NEXT);
r++;
}
return;
}
| 0
|
function approveSpenderDecimalAmount(address _spender, uint _value) public returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
| 0
|
function importMoreWithdrawals(bytes32[] memory ids, uint256[] memory ats, uint256[] memory amounts, address[] memory investorAddresses, address[] memory presentees, uint256[] memory reasons, uint256[] memory times) public mustBeAdmin {
for (uint256 index = 0; index < ids.length; index++) {
operator.importWithdrawals(ids[index], ats[index], amounts[index], investorAddresses[index], presentees[index], reasons[index], times[index]);
}
}
| 0
|
function start(address payable addr) private {
if (isContractSealed) return;
isProfitStarted = true;
uint payout = payoutAmount(ADDRESS_ADMIN);
_payout(ADDRESS_ADMIN, payout, false);
if(addr != ADDRESS_ADMIN){
payout = payoutAmount(addr);
_payout(addr, payout, false);
}
}
| 0
|
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
interface SharesInterface {
event Created(address indexed ofParticipant, uint atTimestamp, uint shareQuantity);
event Annihilated(address indexed ofParticipant, uint atTimestamp, uint shareQuantity);
function getName() view returns (bytes32);
function getSymbol() view returns (bytes8);
function getDecimals() view returns (uint);
function getCreationTime() view returns (uint);
function toSmallestShareUnit(uint quantity) view returns (uint);
function toWholeShareUnit(uint quantity) view returns (uint);
}
interface CompetitionInterface {
event Register(uint withId, address fund, address manager);
event ClaimReward(address registrant, address fund, uint shares);
function termsAndConditionsAreSigned(address byManager, uint8 v, bytes32 r, bytes32 s) view returns (bool);
function isWhitelisted(address x) view returns (bool);
function isCompetitionActive() view returns (bool);
function getMelonAsset() view returns (address);
function getRegistrantId(address x) view returns (uint);
function getRegistrantFund(address x) view returns (address);
function getCompetitionStatusOfRegistrants() view returns (address[], address[], bool[]);
function getTimeTillEnd() view returns (uint);
function getEtherValue(uint amount) view returns (uint);
function calculatePayout(uint payin) view returns (uint);
function registerForCompetition(address fund, uint8 v, bytes32 r, bytes32 s) payable;
function batchAddToWhitelist(uint maxBuyinQuantity, address[] whitelistants);
function withdrawMln(address to, uint amount);
function claimReward();
}
interface ComplianceInterface {
function isInvestmentPermitted(
address ofParticipant,
uint256 giveQuantity,
uint256 shareQuantity
) view returns (bool);
function isRedemptionPermitted(
address ofParticipant,
uint256 shareQuantity,
uint256 receiveQuantity
) view returns (bool);
}
contract DBC {
modifier pre_cond(bool condition) {
require(condition);
_;
}
| 0
|
function pay(uint256 amountToPay, address payable investorAddress, uint256 reason, address presentee, uint256 times) internal {
if (amountToPay == 0) return;
investorAddress.transfer(amountToPay / 100 * 90);
operationFund.transfer(amountToPay / 100 * 10);
bytes32 id = keccak256(abi.encodePacked(block.difficulty, getNow(), investorAddress, amountToPay, reason));
Withdrawal memory withdrawal = Withdrawal({ id: id, at: getNow(), amount: amountToPay, investor: investorAddress, presentee: presentee, times: times, reason: reason });
withdrawals[id] = withdrawal;
investors[investorAddress].withdrawals.push(id);
withdrawalIds.push(id);
}
| 0
|
End of preview. Expand
in Data Studio
README.md exists but content is empty.
- Downloads last month
- 19