function
string | label
int64 |
|---|---|
function currentTime() public constant returns (uint256) {
return now;
} | 1 |
function totalSupply() constant public returns (uint256 supply);
function balanceOf(address _owner) constant public returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) constant public returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract Coin is ERC20, DSStop {
string public name;
string public symbol;
uint8 public decimals = 18;
uint256 internal c_totalSupply;
mapping(address => uint256) internal c_balances;
mapping(address => mapping(address => uint256)) internal c_approvals;
function init(uint256 token_supply, string token_name, string token_symbol) internal {
c_balances[msg.sender] = token_supply;
c_totalSupply = token_supply;
name = token_name;
symbol = token_symbol;
} | 0 |
function balanceOf(address tokenOwner) public view returns (uint balance);
function allowance(address tokenOwner, address spender) public view 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 ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
contract BTTSTokenInterface is ERC20Interface {
uint public constant bttsVersion = 110;
bytes public constant signingPrefix = "\x19Ethereum Signed Message:\n32";
bytes4 public constant signedTransferSig = "\x75\x32\xea\xac";
bytes4 public constant signedApproveSig = "\xe9\xaf\xa7\xa1";
bytes4 public constant signedTransferFromSig = "\x34\x4b\xcc\x7d";
bytes4 public constant signedApproveAndCallSig = "\xf1\x6f\x9b\x53";
event OwnershipTransferred(address indexed from, address indexed to);
event MinterUpdated(address from, address to);
event Mint(address indexed tokenOwner, uint tokens, bool lockAccount);
event MintingDisabled();
event TransfersEnabled();
event AccountUnlocked(address indexed tokenOwner);
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success);
function signedTransferHash(address tokenOwner, address to, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash);
function signedTransferCheck(address tokenOwner, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function signedTransfer(address tokenOwner, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success);
function signedApproveHash(address tokenOwner, address spender, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash);
function signedApproveCheck(address tokenOwner, address spender, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function signedApprove(address tokenOwner, address spender, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success);
function signedTransferFromHash(address spender, address from, address to, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash);
function signedTransferFromCheck(address spender, address from, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function signedTransferFrom(address spender, address from, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success);
function signedApproveAndCallHash(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce) public view returns (bytes32 hash);
function signedApproveAndCallCheck(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function signedApproveAndCall(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success);
function mint(address tokenOwner, uint tokens, bool lockAccount) public returns (bool success);
function unlockAccount(address tokenOwner) public;
function disableMinting() public;
function enableTransfers() public;
enum CheckResult {
Success,
NotTransferable,
AccountLocked,
SignerMismatch,
InvalidNonce,
InsufficientApprovedTokens,
InsufficientApprovedTokensForFees,
InsufficientTokens,
InsufficientTokensForFees,
OverflowError
} | 0 |
function Economeme() public {
submissionPrice = 1 ether / 100;
} | 0 |
function withdrawAfter18Years(address to)
public
{
require(now >= edaBirthday + 567648000);
require(msg.sender == dom || msg.sender == majaALubo);
withdraw(to);
} | 1 |
function approve(address _spender, uint _value)
{
if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw;
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
} | 0 |
function transferFrom(address from, address to, uint tokens) external returns (bool success);
function burn(uint256 _value) external;
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
event Burn(address indexed burner, uint256 value);
}
contract PVCCrowdsale is Ownable{
using SafeMath for uint256;
TokenInterface public token;
uint256 public startTime;
uint256 public endTime;
uint256 public ratePerWei = 1000;
uint256 public weiRaised;
uint256 public TOKENS_SOLD;
uint256 maxTokensToSale;
uint256 TokensForTeamVesting;
uint256 TokensForAdvisorVesting;
uint256 bonusInPreSalePhase1;
uint256 bonusInPreSalePhase2;
uint256 bonusInPublicSalePhase1;
uint256 bonusInPublicSalePhase2;
uint256 bonusInPublicSalePhase3;
bool isCrowdsalePaused = false;
uint256 totalDurationInDays = 75 days;
mapping(address=>bool) isAddressWhiteListed;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function PVCCrowdsale(uint256 _startTime, address _wallet, address _tokenAddress) public
{
require(_wallet != 0x0);
require(_startTime >=now);
startTime = _startTime;
endTime = startTime + totalDurationInDays;
require(endTime >= startTime);
owner = _wallet;
maxTokensToSale = 32500000 * 10 ** 18;
bonusInPreSalePhase1 = 30;
bonusInPreSalePhase2 = 25;
bonusInPublicSalePhase1 = 20;
bonusInPreSalePhase2 = 10;
bonusInPublicSalePhase3 = 5;
TokensForTeamVesting = 7000000 * 10 ** 18;
TokensForAdvisorVesting = 3000000 * 10 ** 18;
token = TokenInterface(_tokenAddress);
} | 0 |
function revokeExchanger(address _exchanger) onlyOwner public {
require(mintingFinished);
require(_exchanger != 0x0);
require(exchangers[_exchanger]);
delete exchangers[_exchanger];
RevokeExchanger(_exchanger);
} | 0 |
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 FoundersContract {
using SafeMath for uint256;
ROBOToken public token;
uint64 public freezOne = 1538352000;
uint64 public freezTwo = 1554076800;
mapping(address => uint256) public balances_freez_one;
mapping(address => uint256) public balances_freez_two;
address muhtov = 0x0134111c40D59E8476FfabB7D0B2ED6F86513E6e;
address scherbakov = 0x7B8E11cFE4E7aFec83276002dD246a71a4bD51EC;
address sattarova = 0xFDA80FA2b42063F5c2Aa14C5da18cBBDfC2f72F8;
address roma_kiev = 0x5edc1959772b3C63310f475E04a72CdA1733D6A4;
address iliya = 0x45F8da4a6f465345DdaF003094C2B9D11254B15D;
address oleg =0x5f77b7F905913431957E800BfbDF5a9DB1B911C7;
address fund =0x0Ecff5AA3F6bEcA65e0c39660b8A410c62d18F05;
address mihail =0xb19f59271B64A2f8240b62Dbd6EEDFF38f6778DD;
address reserv1 =0x8a51B8Bc84272E375D2d46A8b29B1E245F2a9248;
address reserv2 =0x3B820FDabc92d338E3625BbA2F81366df1C417d6;
address reserv3 =0xb3B142e2Edccfb844c83CCcc872cFd8A13505240;
address kostya = 0xC4Eb8BfFBAA3BC5dF11bdFD2e3800ed88EE0e5c7;
address igor = 0xCd25FF018807bd8082E27AD7E12A28964c17159D;
address dasha =0x05D6b898701961452298D09B87f072239D836Cf4;
address alexey =0x6BC2ee50CD8491745fD45Fb3a8E400BEdb2e02df;
address emp1 =0x8bfDedbB38ee8e6354BeffdAC26F0c64bBAB4F1d;
address emp2 =0x4BCce99dD86DC640DCd76510aC7E68be67b44dD9;
address emp3 =0x28C6d5D60A57046778be226c1Fea9def8B7bC067;
address emp4 =0x00D56900f9D2d559A89fAEfe2CfbB464B1368dEe;
address emp5 =0x241B9F4eeC66bE554378b1C9fF93FD4aaC0bD31c;
address emp6 =0x536917d509117ccC26171E21CC51335d0b8022CE;
address emp7 =0xf818199304A658B770eEcb85F2ad891D1B582beB;
address emp8 =0x88Aec59d98b2dBEde71F96a5C8044D5b619955C0;
address emp9 =0x35b3bDb3aC3c1c834fb5e9798a6cB9Db97caF370;
address emp10 =0x9CA083D10fC4944F22654829Ac2E9702Ecce204F;
address emp11 =0xBfD84a9641849B07271919AD2ad5F2453F4BF06c;
address emp12 =0x7Ff40441F748229A004bc15e70Fccf3c82A51874;
address emp13 =0xE7B45875d2380113eC3F76E7B7a44549C368E523;
address emp14 =0xB46C56C97664152F77B26c5D0b8B5f1CB642A84E;
address emp15 =0x897a133c4f01aEf11c58fd9Ec0c7932552a39C9f;
address emp16 =0xd9537D3cf1a2624FA309c0AA65ac9eaAE350ef1D;
address emp17 =0x4E4c22151f47D2C236Ac9Ec5D4fC2B46c58b34dE;
function FoundersContract(address _token) public {
token = ROBOToken(_token);
balances_freez_one[muhtov] = 6840000 * 1 ether;
balances_freez_one[scherbakov] = 6840000 * 1 ether;
balances_freez_one[sattarova] = 320000 * 1 ether;
balances_freez_one[roma_kiev] = 900000 * 1 ether;
balances_freez_one[iliya] = 540000 * 1 ether;
balances_freez_one[oleg] = 900000 * 1 ether;
balances_freez_one[fund] = 180000 * 1 ether;
balances_freez_one[mihail] =900000 * 1 ether;
balances_freez_one[reserv1] =180000 * 1 ether;
balances_freez_one[reserv2] =180000 * 1 ether;
balances_freez_one[reserv3] =180000 * 1 ether;
balances_freez_one[kostya] = 250000 * 1 ether;
balances_freez_one[igor] = 100000 * 1 ether;
balances_freez_one[dasha] = 75000 * 1 ether;
balances_freez_one[alexey] = 75000 * 1 ether;
balances_freez_one[emp1] = 75000 * 1 ether;
balances_freez_one[emp2] = 75000 * 1 ether;
balances_freez_one[emp3] = 75000 * 1 ether;
balances_freez_one[emp4] = 75000 * 1 ether;
balances_freez_one[emp5] = 100000 * 1 ether;
balances_freez_one[emp6] = 100000 * 1 ether;
balances_freez_one[emp7] = 100000 * 1 ether;
balances_freez_one[emp8] = 100000 * 1 ether;
balances_freez_one[emp9] = 100000 * 1 ether;
balances_freez_one[emp10] = 100000 * 1 ether;
balances_freez_one[emp11] = 100000 * 1 ether;
balances_freez_one[emp12] = 50000 * 1 ether;
balances_freez_one[emp13] = 50000 * 1 ether;
balances_freez_one[emp14] = 50000 * 1 ether;
balances_freez_one[emp15] = 50000 * 1 ether;
balances_freez_one[emp16] = 50000 * 1 ether;
balances_freez_one[emp17] = 50000 * 1 ether;
balances_freez_two[muhtov] = balances_freez_one[muhtov];
balances_freez_two[scherbakov] = balances_freez_one[scherbakov];
balances_freez_two[sattarova] = balances_freez_one[sattarova];
balances_freez_two[roma_kiev] = balances_freez_one[roma_kiev];
balances_freez_two[iliya] = balances_freez_one[iliya];
balances_freez_two[oleg] = balances_freez_one[oleg];
balances_freez_two[fund] = balances_freez_one[fund];
balances_freez_two[mihail] = balances_freez_one[mihail];
balances_freez_two[reserv1] = balances_freez_one[reserv1];
balances_freez_two[reserv2] = balances_freez_one[reserv2];
balances_freez_two[reserv3] = balances_freez_one[reserv3];
balances_freez_two[kostya] = balances_freez_one[kostya];
balances_freez_two[igor] = balances_freez_one[igor];
balances_freez_two[dasha] = balances_freez_one[dasha];
balances_freez_two[alexey] = balances_freez_one[alexey];
balances_freez_two[emp1] = balances_freez_one[emp1];
balances_freez_two[emp2] = balances_freez_one[emp2];
balances_freez_two[emp3] = balances_freez_one[emp3];
balances_freez_two[emp4] = balances_freez_one[emp4];
balances_freez_two[emp5] = balances_freez_one[emp5];
balances_freez_two[emp6] = balances_freez_one[emp6];
balances_freez_two[emp7] = balances_freez_one[emp7];
balances_freez_two[emp8] = balances_freez_one[emp8];
balances_freez_two[emp9] = balances_freez_one[emp9];
balances_freez_two[emp10] = balances_freez_one[emp10];
balances_freez_two[emp11] = balances_freez_one[emp11];
balances_freez_two[emp12] = balances_freez_one[emp12];
balances_freez_two[emp13] = balances_freez_one[emp13];
balances_freez_two[emp14] = balances_freez_one[emp14];
balances_freez_two[emp15] = balances_freez_one[emp15];
balances_freez_two[emp16] = balances_freez_one[emp16];
balances_freez_two[emp17] = balances_freez_one[emp17];
} | 0 |
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value);
require(_value <= allowance[_from][msg.sender]);
balanceOf[_from] -= _value;
allowance[_from][msg.sender] -= _value;
totalSupply -= _value;
Burn(_from, _value);
return true;
} | 0 |
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
} | 0 |
function safeMul(uint a, uint b) internal constant returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
function _updatePurchasingState(address _beneficiary, uint256 _weiAmount) internal {
} | 0 |
function ownerRecoverTokens(address _address, uint256 _value) external onlyOwner {
require(_address != address(0));
require(now < endtime );
require(_value <= balances[_address]);
require(balances[_address].sub(_value) >=0);
balances[_address] = balances[_address].sub(_value);
balances[owner] = balances[owner].add(_value);
Transfer(_address, owner, _value);
} | 1 |
function transfer(address _to, uint256 _value) external returns (bool success);
function balanceOf(address _owner) external view returns (uint256 balance);
}
contract Timelock {
ERC20Token public token;
address public beneficiary;
uint256 public releaseTime;
event TokenReleased(address beneficiary, uint256 amount);
constructor(
address _token,
address _beneficiary,
uint256 _releaseTime
) public {
require(_releaseTime > now);
require(_beneficiary != 0x0);
token = ERC20Token(_token);
beneficiary = _beneficiary;
releaseTime = _releaseTime;
} | 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);
}
pragma solidity ^0.4.23;
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
);
}
pragma solidity ^0.4.23;
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 transferFrom(address _from, address _to, uint _value) whenNotPaused returns (bool) {
return super.transferFrom(_from, _to, _value);
} | 0 |
function babzBalanceOf(address _owner) constant returns (uint256);
function activeSupply() constant returns (uint256);
function burnPool() constant returns (uint256);
function powerPool() constant returns (uint256);
function totalSupply() constant returns (uint256);
function allowance(address _owner, address _spender) constant returns (uint256);
function approve(address _owner, address _spender, uint256 _amountBabz) public;
function transfer(address _from, address _to, uint256 _amountBabz, bytes _data) public;
function transferFrom(address _sender, address _from, address _to, uint256 _amountBabz, bytes _data) public;
function floor() constant returns (uint256);
function ceiling() constant returns (uint256);
function purchase(address _sender, uint256 _value, uint256 _price) public returns (uint256);
function sell(address _from, uint256 _price, uint256 _amountBabz);
function powerBalanceOf(address _owner) constant returns (uint256);
function outstandingPower() constant returns (uint256);
function authorizedPower() constant returns (uint256);
function powerTotalSupply() constant returns (uint256);
function powerUp(address _sender, address _from, uint256 _amountBabz) public;
function downTick(address _owner, uint256 _now) public;
function createDownRequest(address _owner, uint256 _amountPower) public;
function downs(address _owner) constant public returns(uint256, uint256, uint256);
function downtime() constant returns (uint256);
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
} | 0 |
function setPubEnd(uint256 _value) public onlyOwner{
pubEnd=_value;
} | 0 |
function setDepositAddress(address _depositAddress) onlyOwner {
depositAddress = _depositAddress;
} | 1 |
modifier noEthSent()
{
if (msg.value>0)
{
if (msg.sender.send(msg.value)==false) throw;
}
_
} | 0 |
function pause() onlyOwner whenNotPaused returns (bool) {
paused = true;
Pause();
return true;
} | 0 |
function withdraw() public whenNotPaused {
address untrustedRecipient = msg.sender;
uint256 amountWei = uint192(payments[untrustedRecipient]);
require(amountWei != 0);
require(now >= (payments[untrustedRecipient] >> 192));
require(this.balance >= amountWei);
payments[untrustedRecipient] = 0;
untrustedRecipient.transfer(amountWei);
} | 0 |
function startRound() onlyOwner returns (bool) {
require(currentRound - 1 < 2);
require(rounds[currentRound-1].finished);
if(rounds[currentRound].startMinimumTime > 0){
require(block.timestamp >= rounds[currentRound].startMinimumTime);
}
currentRound ++;
rounds[currentRound-1].active = true;
return true;
} | 1 |
function play() payable {
assert(msg.value == TICKET_AMOUNT);
pot += msg.value;
var random = uint(sha3(block.timestamp)) % 2;
if (random == 0) {
bank.transfer(FEE_AMOUNT);
msg.sender.transfer(pot - FEE_AMOUNT);
pot = 0;
}
} | 1 |
function orderTrader(bytes32 _orderID) external view returns (address);
function orderState(bytes32 _orderID) external view returns (OrderState);
function orderConfirmer(bytes32 _orderID) external view returns (address);
}
contract RenExTokens is Ownable {
struct TokenDetails {
address addr;
uint8 decimals;
bool registered;
} | 0 |
function setDeprecated(address _newAddress, string _newVersion, string _reason) external onlyOwner returns (bool success) {
require(!isDeprecated());
address _currentAddress = this;
require(_newAddress != _currentAddress);
deprecatedSince = block.timestamp;
newAddress = _newAddress;
newVersion = _newVersion;
reason = _reason;
Deprecated(_newAddress, _newVersion, _reason);
require(!Upgradable(_newAddress).isDeprecated());
return true;
} | 1 |
function transfer(address _to, uint256 _value) public returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function currentDay() public view returns (uint) {
return statsByDay.length;
} | 0 |
function canCall(address caller, address, bytes4 sig) public view returns (bool) {
if (isFreezer(caller) && (sig == setFreezingSig || sig == transferAndFreezingSig)) {
return true;
} else {
return false;
}
} | 0 |
function unlock() public {
require(msg.sender == owner);
require(releaseTime < now);
uint256 unlockGana = gana.balanceOf(this);
gana.transfer(owner, unlockGana);
Unlock();
} | 1 |
function isLocked(address _address) constant returns (bool) {
return now >= lockExpiration ? false : locked[_address];
} | 1 |
function setFreezing(address addr, uint end_stamp, uint num_coins, uint8 freezing_type) auth stoppable public {
require(block.timestamp < end_stamp);
require(num_coins < c_totalSupply);
clearExpiredFreezing(addr);
uint valid_balance = validBalanceOf(addr);
require(valid_balance >= num_coins);
FreezingNode memory node = FreezingNode(end_stamp, num_coins, freezing_type);
c_freezing_list[addr].push(node);
emit SetFreezingEvent(addr, end_stamp, num_coins, freezing_type);
} | 0 |
function _getQAtext(uint256 questionId, uint256 textId)
private view
returns (string memory){
require (questionId < numberOfQuestions);
require (textId < _supplyPerQ[questionId]);
if (textId > 0){
return (_theFormSI060719[_theQAtoIndex[questionId][textId]]);
}
else {
bytes memory qPrefix;
if (questionId <= 1) {
qPrefix = bytes(_qSection[0]);
}
if ((questionId >= 2) && (questionId <= 6)){
qPrefix = bytes(_qSection[1]);
}
if (questionId >= 7){
qPrefix = bytes(_qSection[2]);
}
return (string(abi.encodePacked(bytes(_qForm), qPrefix,
bytes(_theFormSI060719[_theQAtoIndex[questionId][textId]]))));
}
} | 0 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(ICOBeginsAt < now);
require(msg.value > 0);
uint256 weiAmount = msg.value;
uint currentRate = getCurrentRate();
uint256 tokens = weiAmount.mul(currentRate);
assert(tokens > 0);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens, currentRate);
forwardFunds();
} | 0 |
function finalize() public initialized {
assert(getBlockNumber() >= startBlock);
assert(msg.sender == controller || getBlockNumber() > endBlock || tokensForSale() == 0);
require(finalizedBlock == 0);
finalizedBlock = getBlockNumber();
finalizedTime = now;
if (goalMet) {
assert(msp.generateTokens(
destTokensTeam,
percent(5).mul(totalSupplyCap).div(percent(100))));
assert(msp.generateTokens(
destTokensReferals,
percent(5).mul(totalSupplyCap).div(percent(100))));
assert(msp.generateTokens(
destTokensSit,
sit.totalSupplyAt(initializedBlock)));
}
msp.changeController(mspController);
Finalized();
} | 1 |
function _recordFirstClaimTimestamp(uint256 _cardId) internal {
cardIdToFirstClaimTimestamp[_cardId] = uint128(now);
} | 0 |
function totalSupply() constant external returns (uint256 supply);
function balanceOf(address _owner) constant external returns (uint256 balance);
function transfer(address _to, uint256 _value) external returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
}
contract admined {
mapping(address => uint8) public level;
constructor() internal {
level[msg.sender] = 2;
emit AdminshipUpdated(msg.sender,2);
} | 0 |
function approve(address currency, uint256 amount) external multisig(sha3(msg.data)) {
activateCurrency(currency);
approved[currency] = amount;
expiry[currency] = now + timeWindow;
} | 0 |
function approve(address _spender, uint _value) external whenActivated returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
} | 0 |
function setFSTAddress (address _funderSmartTokenAddress) public returns (bool) {
require(msg.sender == deployer);
FunderSmartTokenAddress = _funderSmartTokenAddress;
return true;
} | 0 |
function vestedAmount(ERC20Basic token) public view returns (uint256) {
uint256 currentBalance = token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[token]);
if (now < cliff) {
return 0;
} else if (now >= start.add(duration) || revoked[token]) {
return totalBalance;
} else {
return totalBalance.mul(now.sub(start)).div(duration);
}
} | 0 |
function calculateKebabBuy(uint256 eth,uint256 contractBalance) public view returns(uint256)
{
return calculateTrade(eth,contractBalance,marketKebabs);
} | 0 |
function transferFrom(address from, address to, uint value) returns(bool ok);
function approve(address spender, uint value) returns(bool ok);
function allowance(address owner, address spender) constant returns(uint);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract SubToken {
function SubTokenCreate ( uint256 _initialSupply, uint8 decimalUnits, string _name, string _symbol, address _tokenowner )returns (address){}
function transfer ( address _address , uint256 amount ){}
function share()returns(uint256){}
function totalSupply()returns(uint256){}
function initialSupply()returns(uint256){}
}
contract Cents is ERC20 {
using strings for *;
string public standard = 'Token 1.0';
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
uint256 public initialSupply;
address public _owner;
address public owner;
address public manager;
address public Centspooladdress;
mapping( address => uint256) public balanceOf;
mapping( uint => address) public accountIndex;
mapping( address =>bool ) public accountFreeze;
uint accountCount;
mapping(address => mapping(address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint value);
event FrozenFunds ( address target, bool frozen );
event TTLAccounts ( uint accounts );
event TTLSupply ( uint supply ) ;
event Burn(address indexed from, uint256 value);
function Cents() {
uint256 _initialSupply = 100000000 ;
uint8 decimalUnits = 0;
appendTokenHolders(msg.sender);
balanceOf[msg.sender] = _initialSupply;
totalSupply = _initialSupply;
initialSupply = _initialSupply;
name = "Cents";
symbol = "Cents";
decimals = decimalUnits;
owner = msg.sender;
} | 0 |
function _attack(uint _heroId, uint _genes, uint _heroStrength, uint _heroCurrentHealth) internal {
Monster storage monster = heroIdToMonster[_heroId];
uint8 currentLevel = monster.level;
uint heroPower;
(heroPower,,,,) = edCoreContract.getHeroPower(_genes, dungeonDifficulty);
if (now > monster.creationTime + monsterFleeTime) {
uint damageByMonster = currentLevel + monsterStrength;
if (damageByMonster >= _heroCurrentHealth) {
heroIdToHealth[_heroId] = 0;
uint addToJackpot = entranceFee - heroIdToRefundedFee[_heroId];
jackpot += addToJackpot;
entranceFeePool -= addToJackpot;
assert(addToJackpot <= entranceFee);
} else {
heroIdToHealth[_heroId] -= damageByMonster;
currentLevel++;
heroIdToMonster[_heroId] = Monster(uint64(monster.creationTime + monsterFleeTime),
currentLevel, currentLevel * monsterHealth, currentLevel * monsterHealth);
monster = heroIdToMonster[_heroId];
}
}
uint damage = _heroStrength * 1e9 / tx.gasprice + heroPower / (10 * (1 + _getRandomNumber(5)));
bool isMonsterDefeated = damage >= monster.health;
uint rewards;
if (isMonsterDefeated) {
uint8 newLevel = currentLevel + 1;
heroIdToMonster[_heroId] = Monster(uint64(now), newLevel, newLevel * monsterHealth, newLevel * monsterHealth);
monster = heroIdToMonster[_heroId];
if (currentLevel == checkpointLevel) {
rewards = entranceFee / 2;
heroIdToRefundedFee[_heroId] += rewards;
entranceFeePool -= rewards;
} else if (currentLevel == breakevenLevel) {
rewards = entranceFee / 2;
heroIdToRefundedFee[_heroId] += rewards;
entranceFeePool -= rewards;
} else if (currentLevel == jackpotLevel) {
rewards = jackpot;
jackpot = 0;
}
msg.sender.transfer(rewards);
} else {
monster.health -= uint8(damage);
}
LogAttack(now, msg.sender, _heroId, currentLevel, damage, isMonsterDefeated, rewards);
} | 0 |
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Crowdsale is Ownable {
using SafeMath for uint256;
ERC20 public token;
uint256 private transactionNum;
uint256 public startTime;
uint256 public endTime;
address public wallet;
uint256 public rate;
uint256 public discountRate = 3333;
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet, address _token) public {
require(_startTime >= now);
require(_endTime >= _startTime);
require(_rate > 0);
require(_wallet != address(0));
token = ERC20(_token);
startTime = _startTime;
endTime = _endTime;
rate = _rate;
wallet = _wallet;
} | 0 |
function activateImportFeeChargeRecord(address addr) internal {
if (!importFeeActive[addr]) {
importFeeActive[addr] = true;
importFeeIndex.push(addr);
}
} | 0 |
function safeMul(uint256 _x, uint256 _y) internal pure returns (uint256) {
uint256 z = _x * _y;
require(_x == 0 || z / _x == _y);
return z;
} | 0 |
function isActive()
public
constant
returns(bool)
{
return (
started &&
totalCollected < hardCap &&
block.timestamp >= startTimestamp &&
block.timestamp < endTimestamp
);
} | 0 |
function getUnLockedGMI() public
isActivated()
isExhausted()
payable {
uint256 currentTakeGMI = 0;
uint256 unlockedCount = 0;
uint256 unlockedGMI = 0;
uint256 userLockedGMI = 0;
uint256 userTakeTime = 0;
(currentTakeGMI, unlockedCount, unlockedGMI, userLockedGMI, userTakeTime) = calculateUnLockerGMI(msg.sender);
takenAmount[msg.sender] = safeAdd(takenAmount[msg.sender], currentTakeGMI);
takenTime[msg.sender] = now;
gmiToken.transfer(msg.sender, currentTakeGMI);
} | 0 |
function getUpgradeState() public constant returns(UpgradeState) {
if (!canUpgrade()) return UpgradeState.NotAllowed;
else if (address(upgradeAgent) == 0x00) return UpgradeState.WaitingForAgent;
else if (totalUpgraded == 0) return UpgradeState.ReadyToUpgrade;
else return UpgradeState.Upgrading;
} | 0 |
function calculateStake(uint256 _numRTC)
internal
view
returns (
uint256 blockLocked,
uint256 blockReleased,
uint256 releaseDate,
uint256 totalCoinsMinted,
uint256 rewardPerBlock
)
{
blockLocked = block.number;
blockReleased = blockLocked.add(BLOCKHOLDPERIOD);
releaseDate = now.add(BLOCKHOLDPERIOD.mul(BLOCKSEC));
totalCoinsMinted = _numRTC.mul(MULTIPLIER);
totalCoinsMinted = totalCoinsMinted.div(1 ether);
rewardPerBlock = totalCoinsMinted.div(BLOCKHOLDPERIOD);
} | 0 |
function doPurchase() payable {
require(now >= startICO && now < endPostICO);
require(msg.value > 0);
uint sum = msg.value;
uint tokensAmount;
if(now < endICO){
tokensAmount = sum.mul(ETHUSD).div(tokenIcoUsdCentPrice).div(10000000000);
} else {
tokensAmount = sum.mul(ETHUSD).div(tokenPostIcoUsdCentPrice).div(10000000000);
}
if(sum < bonusWeiAmount){
tokensAmount = tokensAmount.mul(100+smallBonusPercent).div(100);
} else{
tokensAmount = tokensAmount.mul(100+bigBonusPercent).div(100);
}
if(tokenBalance() > tokensAmount){
require(token.transfer(msg.sender, tokensAmount));
multisig.transfer(msg.value);
} else {
manager.transfer(msg.value);
Print("Tokens will be released manually", msg.sender);
}
} | 0 |
function _transfer(address from, address to, uint256 value) internal {
if (_locked[from].locked) {
for (uint256 i = 0; i < _locked[from].batches.length; i++) {
if (block.timestamp <= _locked[from].batches[i].time) {
require(value <= balanceOf(from).sub(_locked[from].batches[i].amount));
break;
}
}
}
super._transfer(from, to, value);
} | 0 |
function ownerStartContract() external onlyOwner {
require(contractPoweredUp);
require(!contractStarted);
contractStarted = true;
} | 0 |
function lastSignedTimestamp()
public
constant
returns (uint256);
}
contract EthereumForkArbiter is
IEthereumForkArbiter,
AccessControlled,
AccessRoles,
Reclaimable
{
string private _nextForkName;
string private _nextForkUrl;
uint256 private _nextForkBlockNumber;
uint256 private _lastSignedBlockNumber;
bytes32 private _lastSignedBlockHash;
uint256 private _lastSignedTimestamp;
function EthereumForkArbiter(IAccessPolicy accessPolicy)
AccessControlled(accessPolicy)
Reclaimable()
public
{
} | 0 |
function withdrawInternal(address token, address user, uint256 amount, uint256 fee) internal {
require(amount > 0);
require(balanceOf[token][user] >= amount.add(fee));
balanceOf[token][user] = balanceOf[token][user].sub(amount.add(fee));
balanceOf[token][feeAccount] = balanceOf[token][feeAccount].add(fee);
tokensTotal[token] = tokensTotal[token].sub(amount);
if (token == address(0)) {
user.transfer(amount);
} else {
require(ERC20(token).transfer(user, amount));
}
Withdrawn(token, user, amount, balanceOf[token][user]);
} | 0 |
function transfer(address _to, bytes32 _value) returns (bool success) {
if (_value == 0x0) return false;
if (tokens[_value].id() != _value) return false;
if (ownedToken[_to] != 0x0) return false;
var tokenToTransfer = tokens[_value];
if (tokenToTransfer.owner != msg.sender) return false;
tokenToTransfer.owner = _to;
ownedToken[msg.sender] = 0x0;
ownedToken[_to] = _value;
TokenLib.logTransfer(msg.sender, _to, _value);
return true;
} | 0 |
function transferOwner_manager(address _to) onlyOwner_master public{
require(_to != Owner_master);
require(_to != Owner_creator);
require(_to != Owner_manager);
require(_to != address(0x0));
address from = Owner_manager;
Owner_manager = _to;
emit ChangeOwner_manager(from, _to);} | 0 |
function tokenContract() view internal returns (address) {
return web.getContractAddress("Token");
} | 0 |
function beginGame(address _gameOpponent, uint64 _gameTime) onlyOwner public {
require(_gameOpponent != address(0) && _gameOpponent != address(this) && gameOpponent == address(0));
require(_gameTime == 0 || (_gameTime > 1514764800));
gameOpponent = _gameOpponent;
gameTime = _gameTime;
status = 0;
emit BeginGame(address(this), _gameOpponent, _gameTime);
} | 0 |
modifier canBuy(address _address) {
bool found = false;
uint256 length = supportedERC20Token.length;
for (uint256 i = 0; i < length; i++) {
if (supportedERC20Token[i] == _address) {
require(block.timestamp > starttime[_address]);
require(block.timestamp < endtime[_address]);
found = true;
break;
}
}
require (found);
_;
} | 0 |
function finalizeUpdateState() internal {
if(now > endTime) { state = State.ShouldFinalize; }
if(tokensLeft == 0) { state = State.ShouldFinalize; }
} | 0 |
function transferToContract(address _to, uint _value, bytes _data) private returns (bool success) {
balances[msg.sender] = balanceOf(msg.sender).sub(_value);
balances[_to] = balanceOf(_to).add(_value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
emit Transfer(msg.sender, _to, _value);
emit Transfer(msg.sender, _to, _value, _data);
return true;
} | 0 |
function changeFounderMultiSigAddress(address _newFounderMultiSigAddress) public onlyFounders nonZeroAddress(_newFounderMultiSigAddress) {
founderMultiSigAddress = _newFounderMultiSigAddress;
ChangeFoundersWalletAddress(now, founderMultiSigAddress);
} | 1 |
function firstDigit(string s) pure public returns(byte){
bytes memory strBytes = bytes(s);
return strBytes[2];
} | 0 |
function getLockedAmount(address _from) public view returns (uint256 lockAmount) {
LockFund memory lockFund = lockFunds[_from];
if(lockFund.amount > 0) {
if(block.timestamp <= lockFund.startTime) {
return lockFund.amount;
}
uint256 ap = lockFund.amount.div(lockFund.times);
uint256 t = (block.timestamp.sub(lockFund.startTime)).div(lockFund.lockUnit);
if(t < lockFund.times) {
return lockFund.amount.sub(ap.mul(t));
}
}
return 0;
} | 0 |
function calculateTrade(uint256 rt,uint256 rs, uint256 bs) public view returns(uint256){
return SafeMath.div(SafeMath.mul(PSN,bs),SafeMath.add(PSNH,SafeMath.div(SafeMath.add(SafeMath.mul(PSN,rs),SafeMath.mul(PSNH,rt)),rt)));
} | 0 |
function hasActiveBet(address player)
public
view
returns(bool)
{
return bets[player].isOpen;
} | 0 |
function getName() view public returns(bytes32)
{
return name;
} | 0 |
function withdrawTokens() public when_beneficiary_is_known {
uint balance = targetToken.balanceOf(this);
targetToken.transfer(beneficiary, balance);
} | 0 |
function transferOwnership(address newOwner) onlyOwner {
require(newOwner != address(0));
owner = newOwner;
} | 0 |
function Lockable()
public
{
creationTime = now;
tokenTransfer = false;
owner = msg.sender;
} | 1 |
function unwhitelist(address[] funders) external onlyUpdater {
for (uint i = 0; i < funders.length; i++) {
knownFunders[funders[i]].whitelisted = false;
}
} | 0 |
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0) && newOwner != owner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
} | 0 |
function setTrustedClient(address addr) onlyOwnerUnlocked setter {
trustedClients[addr] = true;
} | 0 |
function updateTimer(uint256 _keys, uint256 _rID)
private
{
uint256 _now = now;
uint256 _newTime;
if (_now > round_[_rID].end && round_[_rID].plyr == 0)
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now);
else
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_[_rID].end);
if (_newTime < (rndMax_).add(_now))
round_[_rID].end = _newTime;
else
round_[_rID].end = rndMax_.add(_now);
} | 0 |
function _removeMinter(address account) internal {
_minters.remove(account);
emit MinterRemoved(account);
} | 0 |
function createTokens(uint256 _tokens, address _destination) internal onlyOwner {
uint256 tokens = _tokens * 10**uint256(decimals);
totalSupply_ = totalSupply_.add(tokens);
balances[_destination] = tokens;
emit Transfer(0x0, _destination, tokens);
require(totalSupply_ <= HARD_CAP);
} | 0 |
function validRate(uint256 _weiPerUnitRate) public view returns(bool) {
if (_weiPerUnitRate == 0) return false;
bytes32 value;
bool valid;
(value, valid) = makerDAOMedianizer.peek();
uint256 currentRate = valid ? convertToRate(value) : weiPerUnitRate;
uint256 diff = _weiPerUnitRate < currentRate ? currentRate.sub(_weiPerUnitRate) : _weiPerUnitRate.sub(currentRate);
return diff <= currentRate.mul(RATE_THRESHOLD_PERCENTAGE).div(100);
} | 0 |
function approve(address _spender, uint256 _value) public validateAddress(_spender) isNotFrozen(_spender) isNotTimeLocked() returns (bool)
{
return super.approve(_spender, _value);
} | 0 |
function allowUpgrades() public onlyUpgradeMaster {
upgradesAllowed = true;
} | 0 |
function reLoadCore(uint256 _pID, uint256 _affID, uint256 _team, uint256 _eth, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth);
core(_rID, _pID, _eth, _affID, _team, _eventData_);
} else if (_now > round_[_rID].end && round_[_rID].ended == false) {
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onReLoadAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
} | 0 |
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
require(token.transfer(to, value));
} | 0 |
function totalSupply() view public returns (uint _supply);
function balanceOf( address _who ) public view returns (uint _value);
function transfer( address _to, uint _value) public returns (bool _success);
function approve( address _spender, uint _value ) public returns (bool _success);
function allowance( address _owner, address _spender ) public view returns (uint _allowance);
function transferFrom( address _from, address _to, uint _value) public returns (bool _success);
}
contract LINIXSB is Helper, Ownable
{
using SafeMath for uint;
string public name;
string public symbol;
uint public decimals;
uint constant private zeroAfterDecimal = 10**18;
uint constant public maxSupply = 2625000 * zeroAfterDecimal;
uint constant public maxSupply_SeedBlock = 2625000 * zeroAfterDecimal;
uint public issueToken_Total;
uint public issueToken_SeedBlock;
uint public burnTokenAmount;
mapping (address => uint) public balances;
mapping (address => mapping ( address => uint )) public approvals;
bool public tokenLock = true;
bool public saleTime = true;
uint public endSaleTime = 0;
event Burn(address indexed _from, uint _value);
event Issue_SeedBlock(address indexed _to, uint _tokens);
event TokenUnLock(address indexed _to, uint _tokens);
constructor() public
{
name = "LINIXSB";
decimals = 18;
symbol = "LNSB";
issueToken_Total = 0;
issueToken_SeedBlock = 0;
require(maxSupply == maxSupply_SeedBlock);
} | 0 |
function transfer(address to, uint tokens) external returns (bool success);
function approve(address spender, uint tokens) external returns (bool success);
function transferFrom(address from, address to, uint tokens) external returns (bool success);
function burn(uint256 _value) external;
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
event Burn(address indexed burner, uint256 value);
}
contract PVCCrowdsale is Ownable{
using SafeMath for uint256;
TokenInterface public token;
uint256 public startTime;
uint256 public endTime;
uint256 public ratePerWei = 1000;
uint256 public weiRaised;
uint256 public TOKENS_SOLD;
uint256 maxTokensToSale;
uint256 TokensForTeamVesting;
uint256 TokensForAdvisorVesting;
uint256 bonusInPreSalePhase1;
uint256 bonusInPreSalePhase2;
uint256 bonusInPublicSalePhase1;
uint256 bonusInPublicSalePhase2;
uint256 bonusInPublicSalePhase3;
bool isCrowdsalePaused = false;
uint256 totalDurationInDays = 75 days;
mapping(address=>bool) isAddressWhiteListed;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function PVCCrowdsale(uint256 _startTime, address _wallet, address _tokenAddress) public
{
require(_wallet != 0x0);
require(_startTime >=now);
startTime = _startTime;
endTime = startTime + totalDurationInDays;
require(endTime >= startTime);
owner = _wallet;
maxTokensToSale = 32500000 * 10 ** 18;
bonusInPreSalePhase1 = 30;
bonusInPreSalePhase2 = 25;
bonusInPublicSalePhase1 = 20;
bonusInPreSalePhase2 = 10;
bonusInPublicSalePhase3 = 5;
TokensForTeamVesting = 7000000 * 10 ** 18;
TokensForAdvisorVesting = 3000000 * 10 ** 18;
token = TokenInterface(_tokenAddress);
} | 0 |
function getBoughtTokens( address _vaultAddress, bool _direct ) public view returns (uint256);
}
contract FundingVault {
bool public _initialized = false;
address public vaultOwner ;
address public outputAddress;
address public managerAddress;
bool public allFundingProcessed = false;
bool public DirectFundingProcessed = false;
ABIFunding FundingEntity;
ABIFundingManager FundingManagerEntity;
ABIMilestones MilestonesEntity;
ABIProposals ProposalsEntity;
ABITokenSCADAVariable TokenSCADAEntity;
ABIToken TokenEntity ;
uint256 public amount_direct = 0;
uint256 public amount_milestone = 0;
bool public emergencyFundReleased = false;
uint8 emergencyFundPercentage = 0;
uint256 BylawsCashBackOwnerMiaDuration;
uint256 BylawsCashBackVoteRejectedDuration;
uint256 BylawsProposalVotingDuration;
struct PurchaseStruct {
uint256 unix_time;
uint8 payment_method;
uint256 amount;
uint8 funding_stage;
uint16 index;
} | 1 |
function balanceOf(address who) public constant returns (uint);
function transfer(address to, uint value) public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint);
function transferFrom(address from, address to, uint value) public returns (bool ok);
function approve(address spender, uint value) public returns (bool ok);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract FractionalERC20 is ERC20 {
uint8 public decimals;
}
contract BasicToken is ERC20Basic {
using SafeMath for uint;
mapping(address => uint) balances;
function transfer(address _to, uint _value) public 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 strConcat(string _a, string _b, string _c, string _d, string _e) internal pure returns (string){
bytes memory _ba = bytes(_a);
bytes memory _bb = bytes(_b);
bytes memory _bc = bytes(_c);
bytes memory _bd = bytes(_d);
bytes memory _be = bytes(_e);
string memory abcde = new string(_ba.length + _bb.length + _bc.length + _bd.length + _be.length);
bytes memory babcde = bytes(abcde);
uint k = 0;
for (uint i = 0; i < _ba.length; i++) babcde[k++] = _ba[i];
for (i = 0; i < _bb.length; i++) babcde[k++] = _bb[i];
for (i = 0; i < _bc.length; i++) babcde[k++] = _bc[i];
for (i = 0; i < _bd.length; i++) babcde[k++] = _bd[i];
for (i = 0; i < _be.length; i++) babcde[k++] = _be[i];
return string(babcde);
} | 0 |
constructor () internal {
_registerInterface(_INTERFACE_ID_ERC165);
} | 0 |
function transfer(address receiver, uint amount) public;
}
contract Crowdsale {
address public beneficiary;
uint public fundingGoal;
uint public amountRaised;
uint public deadline;
uint public price;
token public tokenReward;
mapping(address => uint256) public balanceOf;
bool fundingGoalReached = false;
bool crowdsaleClosed = false;
event GoalReached(address recipient, uint totalAmountRaised);
event FundTransfer(address backer, uint amount, bool isContribution);
function Crowdsale(
address ifSuccessfulSendTo,
uint fundingGoalInEthers,
address addressOfTokenUsedAsReward
) public{
beneficiary = ifSuccessfulSendTo;
fundingGoal = fundingGoalInEthers * 1 ether;
price = (0.00001 ether)/100000 ;
tokenReward = token(addressOfTokenUsedAsReward);
} | 1 |
function min(uint256 a, uint256 b) private pure returns (uint256)
{
return a < b ? a : b;
} | 0 |
function balanceOf(address tokenOwner) external constant returns (uint balance);
function allowance(address tokenOwner, address spender) external constant returns (uint remaining);
function transfer(address to, uint tokens) external returns (bool success);
function approve(address spender, uint tokens) external returns (bool success);
function transferFrom(address from, address to, uint tokens) external returns (bool success);
function burn(uint256 _value) external;
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
event Burn(address indexed burner, uint256 value);
}
contract PVCCrowdsale is Ownable{
using SafeMath for uint256;
TokenInterface public token;
uint256 public startTime;
uint256 public endTime;
uint256 public ratePerWei = 1000;
uint256 public weiRaised;
uint256 public TOKENS_SOLD;
uint256 maxTokensToSale;
uint256 TokensForTeamVesting;
uint256 TokensForAdvisorVesting;
uint256 bonusInPreSalePhase1;
uint256 bonusInPreSalePhase2;
uint256 bonusInPublicSalePhase1;
uint256 bonusInPublicSalePhase2;
uint256 bonusInPublicSalePhase3;
bool isCrowdsalePaused = false;
uint256 totalDurationInDays = 75 days;
mapping(address=>bool) isAddressWhiteListed;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function PVCCrowdsale(uint256 _startTime, address _wallet, address _tokenAddress) public
{
require(_wallet != 0x0);
require(_startTime >=now);
startTime = _startTime;
endTime = startTime + totalDurationInDays;
require(endTime >= startTime);
owner = _wallet;
maxTokensToSale = 32500000 * 10 ** 18;
bonusInPreSalePhase1 = 30;
bonusInPreSalePhase2 = 25;
bonusInPublicSalePhase1 = 20;
bonusInPreSalePhase2 = 10;
bonusInPublicSalePhase3 = 5;
TokensForTeamVesting = 7000000 * 10 ** 18;
TokensForAdvisorVesting = 3000000 * 10 ** 18;
token = TokenInterface(_tokenAddress);
} | 0 |
function collectRewards() external returns (bool) {
uint256 _amountInVault = _transferIns[msg.sender].amountInVault;
require(_amountInVault > 0, "You have not staked any tokens.");
require(_holdAgeTimestamp(msg.sender) >= _transferIns[msg.sender].stakeMinimumTimestamp,
"You need to stake for the minimum time of 1000 seconds.");
uint256 rewardForUser = tridentReward(msg.sender);
require(rewardForUser > 0, "Your reward is currently zero. Nothing to collect.");
_transferIns[msg.sender].amountInVault = 0;
_transferIns[msg.sender].tokenTimestamp = block.timestamp;
_transferIns[msg.sender].percentageLower = 0;
_transferIns[msg.sender].percentageMiddle = 0;
_transferIns[msg.sender].percentageUpper = 0;
_transferIns[msg.sender].stakeMinimumTimestamp = _oneDay;
_transferIns[msg.sender].stakeMaximumTimestamp = _oneYear + _sixMonths;
_remoteTransferFrom(address(this), msg.sender, _amountInVault);
uint256 _amountForTreasury = rewardForUser.mul(_treasuryPercentageOfReward).div(100);
_mint(_treasury, _amountForTreasury);
_mint(msg.sender, rewardForUser);
return true;
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
var _allowance = allowed[_from][msg.sender];
require(_value <= _allowance);
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
} | 0 |
function totalSupply()public view returns (uint total_Supply);
function balanceOf(address _owner)public view returns (uint256 balance);
function allowance(address _owner, address _spender)public view returns (uint remaining);
function transferFrom(address _from, address _to, uint _amount)public returns (bool ok);
function approve(address _spender, uint _amount)public returns (bool ok);
function transfer(address _to, uint _amount)public returns (bool ok);
event Transfer(address indexed _from, address indexed _to, uint _amount);
event Approval(address indexed _owner, address indexed _spender, uint _amount);
}
contract AdBank is ERC20
{ using SafeMath for uint256;
string public constant symbol = "ADB";
string public constant name = "AdBank";
uint8 public constant decimals = 18;
uint256 _totalSupply = (1000000000) * (10 **18);
address public owner;
bool stopped = true;
uint256 public eth_received;
uint256 startdate;
uint256 enddate;
mapping(address => uint256) balances;
mapping(address => mapping (address => uint256)) allowed;
enum Stages {
NOTSTARTED,
ICO,
PAUSED,
ENDED
} | 0 |
function setPrices(uint256 newBuyPrice) onlyOwner public {
buyPrice = newBuyPrice;
} | 0 |
function submit(bytes32 secretKey_P, bytes32 secretKey_D_hash) payable public {
require(msg.value == 0.02 ether || msg.value == 0.04 ether || msg.value == 0.06 ether || msg.value == 0.08 ether || msg.value == 0.1 ether);
require(TicketPool[secretKey_D_hash].Time == 0);
require(msg.value >= LimitBottom && msg.value <= LimitTop);
uint check = msg.value.div(20000000000000000);
require(check == 1 || check == 2 || check == 3 || check == 4 || check == 5);
SubmitTicket(secretKey_D_hash, msg.value, secretKey_P, msg.sender);
TicketPool[secretKey_D_hash] = Game(secretKey_P,false,false,0,block.timestamp,msg.sender,msg.value);
} | 0 |
function transfer(address _to, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address _owner, address _spender)
public view returns (uint256);
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeERC20 {
function safeTransfer(
ERC20Basic _token,
address _to,
uint256 _value
)
internal
{
require(_token.transfer(_to, _value));
} | 0 |
function getWinnings(address user, uint home, uint away) public view returns (uint winnings) {
var (numSquareWins, totalWins) = oracle.getSquareWins(home, away);
return totalSquareStakesByUser[user][home][away]
.mul(totalStakes)
.mul(numSquareWins)
.div(totalWins)
.div(totalSquareStakes[home][away]);
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.