function
string | label
int64 |
|---|---|
function create(uint _value, bytes _code) internal returns (address o_addr) {
return doCreate(_value, _code);
}
| 0 |
function unhalt() external onlyOwner onlyInEmergency {
halted = false;
}
| 0 |
modifier onlyCrowdsaleManager() {
require(msg.sender == crowdsaleManager);
_;
}
| 0 |
function cancel(Request storage self)
public returns (bool)
{
uint startGas = gasleft();
uint rewardPayment;
uint measuredGasConsumption;
require(isCancellable(self));
self.meta.isCancelled = true;
require(self.claimData.refundDeposit());
if (msg.sender != self.meta.owner) {
address rewardBenefactor = msg.sender;
uint rewardOwed = self.paymentData.bountyOwed
.add(self.paymentData.bounty.div(100));
measuredGasConsumption = startGas
.sub(gasleft())
.add(CANCEL_EXTRA_GAS);
rewardOwed = measuredGasConsumption
.mul(tx.gasprice)
.add(rewardOwed);
rewardPayment = rewardOwed;
if (rewardOwed > 0) {
self.paymentData.bountyOwed = 0;
rewardBenefactor.transfer(rewardOwed);
}
}
emit Cancelled(rewardPayment, measuredGasConsumption);
return sendOwnerEther(self);
}
| 0 |
function trigerAlarmClock(uint id) external payable {
require(clockList[id].reward > 0);
require(block.number >= clockList[id].startBlock);
require(block.number < (clockList[id].startBlock + clockList[id].blockWindow));
require(clockList[id]._contract.call.value(0).gas(clockList[id].gas)(clockList[id].callData));
clockList[id].reward = 0;
waitingTimers--;
msg.sender.transfer(clockList[id].reward);
}
| 1 |
function addToBond(Pool storage self, address resourceAddress, uint value) public {
if (self.bonds[resourceAddress] + value < self.bonds[resourceAddress]) {
throw;
}
self.bonds[resourceAddress] += value;
}
| 0 |
function removeCertificationDocumentFromSelf(bytes32 document)
returns (bool success);
function getCertifiedStudentsCount()
constant
returns (uint count);
function getCertifiedStudentAtIndex(uint index)
payable
returns (address student);
function getCertification(address student)
payable
returns (bool certified, uint timestamp, address certifier, uint documentCount);
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 _implementation() internal view returns (address impl) {
bytes32 slot = IMPLEMENTATION_SLOT;
assembly {
impl := sload(slot)
}
}
| 0 |
function getFullProfit(uint _betSize, uint minRollLimit, uint maxRollLimit) internal returns (uint){
uint probabilitySum = 0;
for (uint i = minRollLimit + 1; i < maxRollLimit; i++)
{
probabilitySum += rollSumProbability[i];
}
return _betSize * safeSub(probabilityDivisor * 100, probabilitySum) / probabilitySum;
}
| 0 |
function putWithdrawalsPart1(uint256 from, uint256 length, bytes32[] memory ids, uint256[] memory ats, uint256[] memory amounts, address[] memory investors) internal view {
for (uint256 i = 0; i < length; i++) {
bytes32 id = operator.withdrawalIds(i + from);
uint256 at;
uint256 amount;
address investor;
(id, at, amount, investor, , , ) = getWithdrawalById(id);
ids[i] = id;
ats[i] = at;
amounts[i] = amount;
investors[i] = investor;
}
}
| 0 |
function proposalAvatar(bytes32 _proposalId) external view returns(address) {
return (proposals[_proposalId].avatar);
}
| 0 |
function calculatePrice(uint value, uint weiRaised, uint tokensSold, address msgSender, uint decimals) public constant returns (uint tokenAmount);
}
contract FinalizeAgent {
function isFinalizeAgent() public constant returns(bool) {
return true;
}
| 0 |
function isBeforeWindow(ExecutionWindow storage self)
internal view returns (bool)
{
return getNow(self) < self.windowStart;
}
| 0 |
function appealPeriod(uint _disputeID) public view returns(uint start, uint end) {
Dispute storage dispute = disputes[_disputeID];
if (dispute.period == Period.appeal) {
start = dispute.lastPeriodChange;
end = dispute.lastPeriodChange + courts[dispute.subcourtID].timesPerPeriod[uint(Period.appeal)];
} else {
start = 0;
end = 0;
}
}
| 0 |
function len(slice self) internal returns (uint l) {
var ptr = self._ptr - 31;
var end = ptr + self._len;
for (l = 0; ptr < end; l++) {
uint8 b;
assembly { b := and(mload(ptr), 0xFF) }
if (b < 0x80) {
ptr += 1;
} else if(b < 0xE0) {
ptr += 2;
} else if(b < 0xF0) {
ptr += 3;
} else if(b < 0xF8) {
ptr += 4;
} else if(b < 0xFC) {
ptr += 5;
} else {
ptr += 6;
}
}
}
| 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 setCustomGasPrice(uint _gasPrice) external;
function randomDS_getSessionPubKeyHash() external constant returns(bytes32);
}
contract OraclizeAddrResolverI {
function getAddress() public returns (address _addr);
}
library Buffer {
struct buffer {
bytes buf;
uint capacity;
}
| 0 |
function abi() constant returns (string)
{ return '[{"constant":false,"inputs":[{"name":"_destination","type":"bytes32"}],"name":"process","outputs":[{"name":"","type":"bool"}],"payable":true,"type":"function"},{"constant":false,"inputs":[],"name":"kill","outputs":[],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"taxman","outputs":[{"name":"","type":"bytes32"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"ledger","outputs":[{"name":"","type":"address"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"_owner","type":"address"}],"name":"delegate","outputs":[],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"name":"","type":"address"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"taxPerc","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"inputs":[{"name":"_ledger","type":"address"},{"name":"_taxman","type":"bytes32"},{"name":"_taxPerc","type":"uint256"}],"type":"constructor"}]'; }
}
contract Builder is Mortal {
event Builded(address indexed client, address indexed instance);
mapping(address => address[]) public getContractsOf;
function getLastContract() constant returns (address) {
var sender_contracts = getContractsOf[msg.sender];
return sender_contracts[sender_contracts.length - 1];
}
| 0 |
function unlock()
{
if (gameOwner==msg.sender)
{
locked = false;
}
}
| 0 |
function lad(bytes32 cup) public view returns (address);
function per() public view returns (uint ray);
function tab(bytes32 cup) public returns (uint);
function ink(bytes32 cup) public returns (uint);
function rap(bytes32 cup) public returns (uint);
function chi() public returns (uint);
function open() public returns (bytes32 cup);
function give(bytes32 cup, address guy) public;
function lock(bytes32 cup, uint wad) public;
function free(bytes32 cup, uint wad) public;
function draw(bytes32 cup, uint wad) public;
function join(uint wad) public;
function exit(uint wad) public;
function wipe(bytes32 cup, uint wad) public;
}
contract DSProxy {
address public owner;
function execute(address _target, bytes _data) public payable returns (bytes32 response);
}
contract ProxyRegistry {
mapping(address => DSProxy) public proxies;
function build(address owner) public returns (DSProxy proxy);
}
contract LiquidLong is Ownable, Claimable, Pausable {
using SafeMath for uint256;
using SafeMathFixedPoint for uint256;
uint256 public providerFeePerEth;
MatchingMarket public matchingMarket;
Maker public maker;
Dai public dai;
Weth public weth;
Peth public peth;
Mkr public mkr;
ProxyRegistry public proxyRegistry;
struct CDP {
uint256 id;
uint256 debtInAttodai;
uint256 lockedAttoeth;
address owner;
bool userOwned;
}
| 0 |
function weiPerEth() constant returns (uint) {
if (testing) {
return 200;
} else {
return 10**18;
}
}
| 0 |
function numTokensAbleToPurchase() constant returns (uint) {
return (this.balance / weiPerToken) * decimalPlaces;
}
| 0 |
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
require(_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));
emit Transfer(msg.sender, _to, _value, _data);
emit Transfer(msg.sender, _to, _value);
if(transferIns[msg.sender].length > 0) delete transferIns[msg.sender];
uint64 _now = uint64(now);
transferIns[msg.sender].push(transferInStruct(uint256(balanceOf[msg.sender]),_now));
transferIns[_to].push(transferInStruct(uint256(_value),_now));
return true;
} else {
return transferToAddress(_to, _value, _data);
}
}
| 0 |
function appeal(uint _disputeID, bytes _extraData) public payable onlyDuring(Period.Appeal) {
super.appeal(_disputeID,_extraData);
Dispute storage dispute = disputes[_disputeID];
require(msg.value >= appealCost(_disputeID, _extraData));
require(dispute.session+dispute.appeals == session);
require(dispute.arbitrated == msg.sender);
dispute.appeals++;
dispute.votes.length++;
dispute.voteCounter.length++;
}
| 0 |
constructor () public payable {
owner = msg.sender;
totalTimers = 0;
waitingTimers = 0;
}
| 0 |
function Withdrawal(address accountAddress, uint value) public {
_Withdrawal(accountAddress, value);
}
| 0 |
function getBuyPrice() public view returns(uint256) {
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round[_rID].strt + rndGap_ && (_now <= round[_rID].end || (_now > round[_rID].end && round[_rID].plyr == 0)))
return ( (round[_rID].keys.add(1000000000000000000)).ethRec(1000000000000000000) );
else
return ( 75000000000000 );
}
| 0 |
function transfer(address to, uint256 value, bytes data) public returns (bool);
function burn(uint256 value) public returns (bool);
function setTokenSaleFinished() public;
}
contract AuctusWhitelist {
function getAllowedAmountToContribute(address addr) view public returns(uint256);
}
contract AuctusTokenSale is ContractReceiver {
using SafeMath for uint256;
address public auctusTokenAddress = 0xfD89de68b246eB3e21B06e9B65450AC28D222488;
address public auctusWhiteListAddress = 0xA6e728E524c1D7A65fE5193cA1636265DE9Bc982;
uint256 public startTime = 1522159200;
uint256 public endTime;
uint256 public basicPricePerEth = 2000;
address public owner;
uint256 public softCap;
uint256 public remainingTokens;
uint256 public weiRaised;
mapping(address => uint256) public invested;
bool public saleWasSet;
bool public tokenSaleHalted;
event Buy(address indexed buyer, uint256 tokenAmount);
event Revoke(address indexed buyer, uint256 investedAmount);
function AuctusTokenSale(uint256 minimumCap, uint256 endSaleTime) public {
owner = msg.sender;
softCap = minimumCap;
endTime = endSaleTime;
saleWasSet = false;
tokenSaleHalted = false;
}
| 0 |
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
onlyTranferable
returns (bool success)
{
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
| 0 |
function ethRec(uint256 _curKeys, uint256 _sellKeys) internal pure returns (uint256) {
return((eth(_curKeys)).sub(eth(_curKeys.sub(_sellKeys))));
}
| 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 DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x);
}
| 0 |
function externalTokenIncreaseApproval(StandardToken _externalToken, address _spender, uint _addedValue)
public onlyOwner returns(bool)
{
_externalToken.increaseApproval(_spender, _addedValue);
emit ExternalTokenIncreaseApproval(_externalToken, _spender, _addedValue);
return true;
}
| 0 |
function payDailyIncomeForInvestor(address payable investorAddress, uint256 times) public mustBeAdmin {
uint256 dailyIncome = getDailyIncomeForUser(investorAddress);
Investor storage investor = investors[investorAddress];
if (times > ONE_DAY) {
uint256 investmentLength = investor.investments.length;
bytes32 lastInvestmentId = investor.investments[investmentLength - 1];
investments[lastInvestmentId].at -= times;
investors[investorAddress].lastMaxOut = investments[lastInvestmentId].at;
return;
}
if (investor.isDisabled) return;
sendEtherForInvestor(investorAddress, dailyIncome, 2, address(0), times);
}
| 0 |
modifier canMint() {
require(!mintingFinished);
_;
}
| 0 |
function tokensPerEth() constant returns (uint);
function isActive(uint time) constant returns (bool);
function isComplete(uint time) constant returns (bool);
}
contract Constants {
uint DECIMALS = 8;
}
contract EventDefinitions {
event logSaleStart(uint startTime, uint stopTime);
event logPurchase(address indexed purchaser, uint eth);
event logClaim(address indexed purchaser, uint refund, uint tokens);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract Testable {
uint fakeTime;
bool public testing;
modifier onlyTesting() {
if (!testing) throw;
_;
}
| 0 |
function executeProposal(uint proposalNumber, bytes transactionBytecode) public {
Proposal storage p = proposals[proposalNumber];
require(now > p.minExecutionDate
&& !p.executed
&& p.proposalHash == keccak256(abi.encodePacked(p.recipient, p.amount, transactionBytecode))
&& p.numberOfVotes >= minimumQuorum);
if (p.currentResult > majorityMargin) {
p.executed = true;
require(p.recipient.call.value(p.amount)(transactionBytecode));
p.proposalPassed = true;
} else {
p.proposalPassed = false;
}
emit ProposalTallied(proposalNumber, p.currentResult, p.numberOfVotes, p.proposalPassed);
}
| 1 |
function isCreated(bytes32 _symbol) constant returns(bool);
function owner(bytes32 _symbol) constant returns(address);
function totalSupply(bytes32 _symbol) constant returns(uint);
function balanceOf(address _holder, bytes32 _symbol) constant returns(uint);
function transfer(address _to, uint _value, bytes32 _symbol) returns(bool);
function proxyTransferWithReference(address _to, uint _value, bytes32 _symbol, string _reference) returns(bool);
function proxyTransferToICAPWithReference(bytes32 _icap, uint _value, string _reference) returns(bool);
function proxyApprove(address _spender, uint _value, bytes32 _symbol) returns(bool);
function allowance(address _from, address _spender, bytes32 _symbol) constant returns(uint);
function transferFromWithReference(address _from, address _to, uint _value, bytes32 _symbol, string _reference) returns(bool);
function transferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference) returns(bool);
function proxyTransferFromWithReference(address _from, address _to, uint _value, bytes32 _symbol, string _reference) returns(bool);
function proxyTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference) returns(bool);
function proxySetCosignerAddress(address _address, bytes32 _symbol) returns(bool);
}
contract Safe {
modifier noValue {
if (msg.value > 0) {
_safeSend(msg.sender, msg.value);
}
_;
}
| 0 |
function oraclize_setNetwork(uint8 networkID) internal returns(bool){
if (getCodeSize(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed)>0){
OAR = OraclizeAddrResolverI(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed);
return true;
}
if (getCodeSize(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1)>0){
OAR = OraclizeAddrResolverI(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1);
return true;
}
if (getCodeSize(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e)>0){
OAR = OraclizeAddrResolverI(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e);
return true;
}
if (getCodeSize(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475)>0){
OAR = OraclizeAddrResolverI(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475);
return true;
}
if (getCodeSize(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF)>0){
OAR = OraclizeAddrResolverI(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF);
return true;
}
if (getCodeSize(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA)>0){
OAR = OraclizeAddrResolverI(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA);
return true;
}
return false;
}
| 0 |
function setProofType(byte _proofType);
function setConfig(bytes32 _config);
function setCustomGasPrice(uint _gasPrice);
function randomDS_getSessionPubKeyHash() returns(bytes32);
}
contract OraclizeAddrResolverI {
function getAddress() returns (address _addr);
}
library Buffer {
struct buffer {
bytes buf;
uint capacity;
}
| 0 |
function setBeneficiary(address _beneficiary)
external
onlyOwner
{
beneficiary = _beneficiary;
}
| 0 |
function setCooldownTime(uint256 _cooldownTime) public onlyCommittee {
cooldownTime = _cooldownTime;
emit SetCooldownTime(_cooldownTime);
}
| 0 |
function setWeiPerCHF(uint weis) {
if (msg.sender != exchangeRateAuth) { throw; }
weiPerCHF = weis;
}
| 0 |
function allowance(address _from, address _spender, bytes32 _symbol) constant returns(uint);
function transferFrom(address _from, address _to, uint _value, bytes32 _symbol) returns(bool);
function transferFromWithReference(address _from, address _to, uint _value, bytes32 _symbol, string _reference) returns(bool);
function transferFromToICAP(address _from, bytes32 _icap, uint _value) returns(bool);
function transferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference) returns(bool);
function proxyTransferFromWithReference(address _from, address _to, uint _value, bytes32 _symbol, string _reference) returns(bool);
function proxyTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference) returns(bool);
function setCosignerAddress(address _address, bytes32 _symbol) returns(bool);
function setCosignerAddressForUser(address _address) returns(bool);
function proxySetCosignerAddress(address _address, bytes32 _symbol) returns(bool);
}
contract AssetMin is SafeMin {
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;
string public name;
function init(address _multiAsset, bytes32 _symbol) immutable(address(multiAsset)) returns(bool) {
MultiAsset ma = MultiAsset(_multiAsset);
if (!ma.isCreated(_symbol)) {
return false;
}
multiAsset = ma;
symbol = _symbol;
return true;
}
| 0 |
function _admin() internal view returns (address adm) {
bytes32 slot = ADMIN_SLOT;
assembly {
adm := sload(slot)
}
}
| 0 |
function owner(bytes32 _symbol) constant returns(address);
function totalSupply(bytes32 _symbol) constant returns(uint);
function balanceOf(address _holder, bytes32 _symbol) constant returns(uint);
function transfer(address _to, uint _value, bytes32 _symbol) returns(bool);
function proxyTransferWithReference(address _to, uint _value, bytes32 _symbol, string _reference) returns(bool);
function proxyTransferToICAPWithReference(bytes32 _icap, uint _value, string _reference) returns(bool);
function proxyApprove(address _spender, uint _value, bytes32 _symbol) returns(bool);
function allowance(address _from, address _spender, bytes32 _symbol) constant returns(uint);
function transferFromWithReference(address _from, address _to, uint _value, bytes32 _symbol, string _reference) returns(bool);
function transferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference) returns(bool);
function proxyTransferFromWithReference(address _from, address _to, uint _value, bytes32 _symbol, string _reference) returns(bool);
function proxyTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference) returns(bool);
function proxySetCosignerAddress(address _address, bytes32 _symbol) returns(bool);
}
contract Safe {
modifier noValue {
if (msg.value > 0) {
_safeSend(msg.sender, msg.value);
}
_;
}
| 0 |
function setBeneficiary(address _beneficiary) onlyOwner
{ beneficiary = _beneficiary; }
uint public buildingCostWei;
function setCost(uint _buildingCostWei) onlyOwner
{ buildingCostWei = _buildingCostWei; }
string public securityCheckURI;
function setSecurityCheck(string _uri) onlyOwner
{ securityCheckURI = _uri; }
}
contract BuilderCongress is Builder {
function create(uint256 minimumQuorumForProposals,
uint256 minutesForDebate,
int256 marginOfVotesForMajority,
address congressLeader,
address _client) payable returns (address) {
if (buildingCostWei > 0 && beneficiary != 0) {
if (msg.value < buildingCostWei) throw;
if (!beneficiary.send(buildingCostWei)) throw;
if (msg.value > buildingCostWei) {
if (!msg.sender.send(msg.value - buildingCostWei)) throw;
}
} else {
if (msg.value > 0) {
if (!msg.sender.send(msg.value)) throw;
}
}
if (_client == 0)
_client = msg.sender;
if (congressLeader == 0)
congressLeader = _client;
var inst = CreatorCongress.create(minimumQuorumForProposals,
minutesForDebate,
marginOfVotesForMajority,
congressLeader);
inst.setOwner(_client);
inst.setHammer(_client);
getContractsOf[_client].push(inst);
Builded(_client, inst);
return inst;
}
| 0 |
function payFund() payable onlyAdministrator() public {
uint256 ethToPay = SafeMath.sub(totalEthFundCollected, totalEthFundRecieved);
require(ethToPay > 0);
totalEthFundRecieved = SafeMath.add(totalEthFundRecieved, ethToPay);
if(!giveEthFundAddress.call.value(ethToPay).gas(400000)()) {
totalEthFundRecieved = SafeMath.sub(totalEthFundRecieved, ethToPay);
}
}
| 1 |
function buyTokens() onlyDaoChallenge returns (uint256 tokens) {
uint256 amount = msg.value;
if (amount == 0) throw;
if (amount % tokenPrice != 0) throw;
tokens = amount / tokenPrice;
tokenBalance += tokens;
return tokens;
}
| 0 |
function changeAdmin(address newAdmin) external ifAdmin {
require(newAdmin != address(0), "Cannot change the admin of a proxy to the zero address");
emit AdminChanged(_admin(), newAdmin);
_setAdmin(newAdmin);
}
| 0 |
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 transfer(address _to, uint _value) returns (bool);
function balanceOf(address owner) returns(uint);
}
contract Owned {
address public owner;
function Owned() {
owner = msg.sender;
}
| 0 |
function isContract(address _addr) private view returns (bool is_contract) {
uint codeLength;
assembly {
codeLength := extcodesize(_addr)
}
return (codeLength>0);
}
| 0 |
function pow(int256 realBase, int256 realExponent) internal pure returns (int256) {
if (realExponent == 0) {
return REAL_ONE;
}
if (realBase == 0) {
if (realExponent < 0) {
revert();
}
return 0;
}
if (fpart(realExponent) == 0) {
if (realExponent > 0) {
return ipow(realBase, fromReal(realExponent));
} else {
return div(REAL_ONE, ipow(realBase, fromReal(-realExponent)));
}
}
if (realBase < 0) {
revert();
}
return exp(mul(realExponent, ln(realBase)));
}
| 0 |
function unbundleSome(address beneficiary, uint256 value, ERC20[] someTokens) public notInLendingMode {
_unbundle(beneficiary, value, someTokens);
}
| 0 |
function dividendsOf(address _customerAddress) public view returns (uint256) {
return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
| 0 |
function transferFrom(address _from, address _to, uint256 _value)
public
returns (bool success)
{
require(!isFrozen);
_updateCreditedPoints(_from);
_updateCreditedPoints(_to);
return ERC20.transferFrom(_from, _to, _value);
}
| 0 |
function transferWithReference(address _to, uint _value, string _reference) returns(bool) {
return __transferWithReference(_to, _value, _reference);
}
| 0 |
function newFee(uint newFeePercentageWad) public auth {
require(newFeePercentageWad <= 1 ether);
feePercentageWad = newFeePercentageWad;
}
| 0 |
function buyEther(uint256 amount) {
assert(valueToToken(etherContract,balances[msg.sender]) >= amount);
assert(destroyValue(msg.sender, tokenToValue(etherContract,amount)));
assert(msg.sender.call.value(amount)());
Buy(etherContract, msg.sender, amount, balances[msg.sender]);
}
| 0 |
function queryN_withGasLimit(uint _timestamp, string _datasource, bytes _argN, uint _gaslimit) payable returns (bytes32 _id);
function getPrice(string _datasource) returns (uint _dsprice);
function getPrice(string _datasource, uint gaslimit) returns (uint _dsprice);
function useCoupon(string _coupon);
function setProofType(byte _proofType);
function setConfig(bytes32 _config);
function setCustomGasPrice(uint _gasPrice);
}
contract OraclizeAddrResolverI {
function getAddress() returns (address _addr);
}
contract usingOraclize {
uint constant day = 60*60*24;
uint constant week = 60*60*24*7;
uint constant month = 60*60*24*30;
byte constant proofType_NONE = 0x00;
byte constant proofType_TLSNotary = 0x10;
byte constant proofStorage_IPFS = 0x01;
uint8 constant networkID_auto = 0;
uint8 constant networkID_mainnet = 1;
uint8 constant networkID_testnet = 2;
uint8 constant networkID_morden = 2;
uint8 constant networkID_consensys = 161;
OraclizeAddrResolverI OAR;
OraclizeI oraclize;
modifier oraclizeAPI {
if((address(OAR)==0)||(getCodeSize(address(OAR))==0)) oraclize_setNetwork(networkID_auto);
oraclize = OraclizeI(OAR.getAddress());
_;
}
| 0 |
function approve(address _to, uint256 _value) onlyPayloadSize(2 * 32) public returns (bool) {
_allowance[msg.sender][_to] = add(_allowance[msg.sender][_to], _value);
Approval(msg.sender, _to, _value);
return true;
}
| 0 |
function getAccountModifiers() constant returns(uint takeFeeDiscount, uint rebatePercentage) {
if (accountModifiers != address(0)) {
return AccountModifiersInterface(accountModifiers).accountModifiers(msg.sender);
} else {
return (0, 0);
}
}
| 0 |
function matchBytes32Prefix(bytes32 content, bytes prefix, uint n_random_bytes) internal returns (bool){
bool match_ = true;
if (prefix.length != n_random_bytes) throw;
for (uint256 i=0; i< n_random_bytes; i++) {
if (content[i] != prefix[i]) match_ = false;
}
return match_;
}
| 0 |
function NewStatic() external payable returns (uint _TransID) {
_TransID=NewCoinInternal(msg.sender,cast(msg.value),Action.NewStatic);
}
| 0 |
function transferOwnership(address newOwner) public onlyOwner {
if (newOwner == address(0))
throw;
owner = newOwner;
}
| 0 |
function transferAndCall( address _to, uint256 _value, bytes _data) public payable returns (bool);
function transferFromAndCall(
address _from,
address _to,
uint256 _value,
bytes _data
)
public
payable
returns (bool);
}
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 donate() payable public { depositedAmountGross += msg.value; }
function getTotalSellLevel(uint256 totalSell) internal pure returns (uint256 level){
if (totalSell < 30 ether) return 0;
if (totalSell < 60 ether) return 1;
if (totalSell < 90 ether) return 2;
if (totalSell < 120 ether) return 3;
if (totalSell < 150 ether) return 4;
return 5;
}
| 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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
| 0 |
function saveChickenOf(address _user) public returns (uint256) {
uint256 _unclaimedChicken = _unclaimedChickenOf(_user);
totalChicken = totalChicken.add(_unclaimedChicken);
uint256 _chicken = savedChickenOf[_user].add(_unclaimedChicken);
savedChickenOf[_user] = _chicken;
lastSaveTime[_user] = block.timestamp;
return _chicken;
}
| 0 |
function _unsafeSend(address _to, uint _value) internal returns(bool) {
return _to.call.value(_value)();
}
| 0 |
function unhalt() external onlyOwner{
halted = false;
}
| 0 |
function approve(address _spender, uint _value) onlyHuman() returns(bool) {
return multiAsset.proxyApprove(_spender, _value, symbol);
}
| 0 |
function removeUser(address userAddr)
public
onlyActiveUsersAllowed()
{
require(users[userAddr].time_added != 0);
require(users[userAddr].time_removed == 0);
User storage sender = users[msg.sender];
require(sender.delay <= users[userAddr].delay);
users[userAddr].removed_by = msg.sender;
users[userAddr].time_removed = now;
}
| 0 |
function Proxy(address _scheduler, address _receipient, uint _payout, uint _gasPrice, uint _delay) public payable {
scheduler = SchedulerInterface(_scheduler);
receipient = _receipient;
owner = msg.sender;
scheduledTransaction = scheduler.schedule.value(msg.value)(
this,
"",
[
2000000,
_payout,
255,
block.number + _delay,
_gasPrice,
12345 wei,
224455 wei,
20000 wei
]
);
}
| 0 |
function getMinimumGracePeriod() constant returns (uint) {
return ScheduledCallLib.getMinimumGracePeriod();
}
| 0 |
function giveAwayHoldership(address holderB) owned {
ShopKeeper(shopKeeperLocation).giveAwayOwnership(holderB);
}
| 0 |
function setTokenSaleDistribution(uint256 totalAmount) private {
uint256 auctusCoreTeam = totalAmount * 20 / 100;
uint256 bounty = totalAmount * 2 / 100;
uint256 reserveForFuture = totalAmount * 18 / 100;
uint256 partnershipsAdvisoryFree = totalAmount * 18 / 1000;
uint256 partnershipsAdvisoryVested = totalAmount * 72 / 1000;
uint256 privateSales = 6836048000000000000000000;
uint256 preSale = 2397307557007329968290000;
transferTokens(auctusCoreTeam, bounty, reserveForFuture, preSale, partnershipsAdvisoryVested, partnershipsAdvisoryFree, privateSales);
remainingTokens = totalAmount - auctusCoreTeam - bounty - reserveForFuture - preSale - partnershipsAdvisoryVested - partnershipsAdvisoryFree - privateSales;
saleWasSet = true;
}
| 0 |
function winningVote(bytes32 _proposalId) external view returns(uint) {
return proposals[_proposalId].winningVote;
}
| 0 |
function resize(buffer memory buf, uint capacity) private pure {
bytes memory oldbuf = buf.buf;
init(buf, capacity);
append(buf, oldbuf);
}
| 0 |
function Ownable() public {
owner = msg.sender;
}
| 0 |
function kill() onlyOwner {
if (msg.sender == owner) selfdestruct(owner);
}
| 0 |
function getAccount(uint accountID) constant returns(address) {
return accounts[accountID].user;
}
| 0 |
function oraclize_query(uint timestamp, string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
}
| 0 |
function doBondBonusTransfer(CallDatabase storage self, address fromCaller, address toCaller) internal returns (uint) {
uint bonusAmount = getMinimumBond();
uint bondBalance = self.callerPool.bonds[fromCaller];
if (bonusAmount > bondBalance) {
bonusAmount = bondBalance;
}
ResourcePoolLib.deductFromBond(self.callerPool, fromCaller, bonusAmount);
ResourcePoolLib.addToBond(self.callerPool, toCaller, bonusAmount);
return bonusAmount;
}
| 0 |
function payout() public {
uint balance = address(this).balance;
require(balance > 1);
throughput += balance;
uint investment = balance / 2 ether + 1 finney;
balance -= investment;
uint256 tokens = fart.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 getAccountBalance(address accountAddress) constant public returns (uint) {
return callDatabase.gasBank.accountBalances[accountAddress];
}
| 0 |
function execute(bytes _code, bytes _data)
public
payable
returns (address target, bytes32 response)
{
target = cache.read(_code);
if (target == 0x0) {
target = cache.write(_code);
}
response = execute(target, _data);
}
| 0 |
function changeHatchEscapeCaller(address _newEscapeHatchCaller) public onlyEscapeHatchCallerOrOwner {
escapeHatchCaller = _newEscapeHatchCaller;
}
| 0 |
function transferFrom(address, address, uint) public returns (bool);
function deposit() public payable;
function withdraw(uint) public;
}
contract FeeInterface {
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 __callback(bytes32 myid, string result) {}
function queryCost() constant returns (uint128 _value) {}
function QuickPrice() payable {}
function requestPrice(uint _actionID) payable returns (uint _TrasID) {}
function collectFee() returns(bool) {}
function () {
revert();
}
| 0 |
function buy_the_tokens() {
require(!bought_tokens);
require(sale != 0x0);
require(this.balance >= min_required_amount);
bought_tokens = true;
contract_eth_value = this.balance;
require(sale.call.value(contract_eth_value)());
}
| 0 |
function PriceReturn(uint _TransID,uint128 _Price)
onlyPricer {
Trans memory details=pending[_TransID][0];
if(0==_Price||frozen){
_Price=lastPrice;
} else {
if(Static.totalSupply()>0 && Risk.totalSupply()>0) {
lastPrice=_Price;
}
}
if(Action.NewStatic==details.action){
ActionNewStatic(details,_TransID, _Price);
}
if(Action.RetStatic==details.action){
ActionRetStatic(details,_TransID, _Price);
}
if(Action.NewRisk==details.action){
ActionNewRisk(details,_TransID, _Price);
}
if(Action.RetRisk==details.action){
ActionRetRisk(details,_TransID, _Price);
}
delete pending[_TransID];
}
| 0 |
function approveMany(address[] _participants, uint256[] _weiAmounts) onlyOwner public {
require(_participants.length == _weiAmounts.length);
for (uint256 i = 0; i < _participants.length; i++) {
approve(_participants[i], _weiAmounts[i]);
}
}
| 0 |
function rawTransfer(address _to, bytes32 _name)
public
onlyOwner(msg.sender, _name)
{
_transfer(msg.sender, _to, _name);
}
| 0 |
function isAuthority(address authority) public view returns (bool) {
return authorityIndex[authority] > 0;
}
| 0 |
function inReservedWindow(ExecutionWindow storage self)
internal view returns (bool)
{
return self.windowStart <= getNow(self) && getNow(self) < reservedWindowEnd(self);
}
| 0 |
function init(ERC20[] tokens, string theName, string theSymbol, uint8 ) public {
super.init(tokens, theName, theSymbol, 18);
}
| 0 |
function Managed() public {
manager = msg.sender;
}
| 0 |
function fixParents(Tree storage _tree,uint parent,bool side) private {
if (parent!=0) {
updateCount(_tree,parent);
updateCounts(_tree,parent);
rebalanceDelete(_tree,parent,side);
}
}
| 0 |
function add(uint256 x, uint256 y) pure internal returns (uint256) {
require(x <= x + y);
return x + y;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.