function
string | label
int64 |
|---|---|
function _updateNextWithdrawalTime(uint256 oldWithdrawal) internal view returns (uint256)
{
uint currentTimestamp = block.timestamp;
require(oldWithdrawal <= currentTimestamp, "You need to wait the next withdrawal period");
if (oldWithdrawal == 0)
{
return _timeShiftPeriod.add(currentTimestamp);
}
return oldWithdrawal.add(_timeShiftPeriod);
}
| 0
|
function pause() onlyOwner whenNotPaused returns (bool) {
paused = true;
Pause();
return true;
}
| 0
|
function random(uint64 upper) public returns (uint64 randomNumber) {
_seed = uint64(sha3(sha3(block.blockhash(block.number), _seed), now));
return _seed % upper;
}
| 1
|
function checkRole(address addr, string roleName)
view
public
{
roles[roleName].check(addr);
}
| 0
|
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
bool withinPeriod = now >= presaleStartTime && now <= endTime;
bool atLeastMinimumAmount = false;
if(block.timestamp <= startTime) {
require(_weiAmount.add(weiRaised.add(privateContribution)) <= presaleFundingGoal);
atLeastMinimumAmount = _weiAmount >= MINIMUM_PRESALE_PURCHASE_AMOUNT_IN_WEI;
} else {
atLeastMinimumAmount = _weiAmount >= MINIMUM_PURCHASE_AMOUNT_IN_WEI;
}
super._preValidatePurchase(_beneficiary, _weiAmount);
require(msg.sender == _beneficiary);
require(_weiAmount.add(weiRaised.add(privateContribution)) <= fundingGoal);
require(withinPeriod);
require(atLeastMinimumAmount);
require(crowdsaleActive);
}
| 0
|
function USD(uint _id) constant returns (uint256);
}
contract SocialActivityToken is ERC20
{
using SafeMath for uint256;
FiatContract price = FiatContract(0x8055d0504666e2B6942BeB8D6014c964658Ca591);
string public constant name = "Social Activity Token";
string public constant symbol = "SAT";
uint8 public constant decimals = 8;
uint public _totalsupply = 1000000000 * (uint256(10) ** decimals);
address public owner;
bool stopped = false;
uint256 public startdate;
uint256 ico_first;
uint256 ico_second;
uint256 ico_third;
uint256 ico_fourth;
address central_account;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
enum Stages {
NOTSTARTED,
ICO,
PAUSED,
ENDED
}
| 0
|
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
| 0
|
function payFee(bytes32 serviceName, uint256 multiplier, address client) public returns(bool paid);
function usageFee(bytes32 serviceName, uint256 multiplier) public constant returns(uint fee);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
| 0
|
function burn(uint256 _value) public onlyOwner returns (bool) {
require(balances[msg.sender] >= _value);
require(maxBurnThreshold >= _value);
require(maxDestroyThreshold >= destroyedToken.add(_value));
balances[msg.sender] = balances[msg.sender].sub(_value);
totalToken = totalToken.sub(_value);
destroyedToken = destroyedToken.add(_value);
emit Transfer(msg.sender, 0x0, _value);
emit Burn(msg.sender, _value);
return true;
}
| 0
|
modifier onlyPayloadSize(uint256 _size) {
require(msg.data.length >= _size + 4);
_;
}
| 0
|
constructor(IERC20 _token) public {
require(address(_token) != address(0x0), "Matic token address is not valid");
maticToken = _token;
uint256 SCALING_FACTOR = 10 ** 18;
uint256 day = 1 minutes;
day = day.div(15);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 0, 3230085552 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 30 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 61 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 91 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 122 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 153 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 183 * day, 1088418885 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 214 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 244 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 275 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 306 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 335 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 366 * day, 1218304816 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 396 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 427 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 457 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 488 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 519 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 549 * day, 1218304816 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 580 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 610 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 641 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 672 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 700 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 731 * day, 1084971483 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 761 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 792 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 822 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 853 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 884 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 914 * day, 618304816 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 945 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 975 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 1096 * day, 593304816 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 1279 * day, 273304816 * SCALING_FACTOR);
}
| 0
|
function setCoinPrice(uint256 newPriceInWei) public returns(uint256 oldPriceInWei){
require(msg.sender==owner);
uint256 _old=coinPriceInWei;
coinPriceInWei=newPriceInWei;
return _old;
}
| 0
|
function removeMinter(address _minter) external onlyOwner returns (bool) {
require(_minter != address(0));
_minters[_minter] = false;
return true;
}
| 0
|
function sha(uint128 wager) constant private returns(uint256)
{
return uint256(sha3(block.difficulty, block.coinbase, now, lastblockhashused, wager));
}
| 1
|
function transferOwnership(address newOwner)
public;
}
contract IAuthorizable is
IOwnable
{
function addAuthorizedAddress(address target)
external;
function removeAuthorizedAddress(address target)
external;
function removeAuthorizedAddressAtIndex(
address target,
uint256 index
)
external;
function getAuthorizedAddresses()
external
view
returns (address[] memory);
}
contract IAssetProxy is
IAuthorizable
{
function transferFrom(
bytes assetData,
address from,
address to,
uint256 amount
)
external;
function getProxyId()
external
pure
returns (bytes4);
}
contract IValidator {
function isValidSignature(
bytes32 hash,
address signerAddress,
bytes signature
)
external
view
returns (bool isValid);
}
contract IWallet {
function isValidSignature(
bytes32 hash,
bytes signature
)
external
view
returns (bool isValid);
}
contract IExchangeCore {
function cancelOrdersUpTo(uint256 targetOrderEpoch)
external;
function fillOrder(
LibOrder.Order memory order,
uint256 takerAssetFillAmount,
bytes memory signature
)
public
returns (LibFillResults.FillResults memory fillResults);
function cancelOrder(LibOrder.Order memory order)
public;
function getOrderInfo(LibOrder.Order memory order)
public
view
returns (LibOrder.OrderInfo memory orderInfo);
}
contract IAssetProxyDispatcher {
function registerAssetProxy(address assetProxy)
external;
function getAssetProxy(bytes4 assetProxyId)
external
view
returns (address);
}
contract IMatchOrders {
function matchOrders(
LibOrder.Order memory leftOrder,
LibOrder.Order memory rightOrder,
bytes memory leftSignature,
bytes memory rightSignature
)
public
returns (LibFillResults.MatchedFillResults memory matchedFillResults);
}
contract ISignatureValidator {
function preSign(
bytes32 hash,
address signerAddress,
bytes signature
)
external;
function setSignatureValidatorApproval(
address validatorAddress,
bool approval
)
external;
function isValidSignature(
bytes32 hash,
address signerAddress,
bytes memory signature
)
public
view
returns (bool isValid);
}
contract ITransactions {
function executeTransaction(
uint256 salt,
address signerAddress,
bytes data,
bytes signature
)
external;
}
contract IWrapperFunctions {
function fillOrKillOrder(
LibOrder.Order memory order,
uint256 takerAssetFillAmount,
bytes memory signature
)
public
returns (LibFillResults.FillResults memory fillResults);
function fillOrderNoThrow(
LibOrder.Order memory order,
uint256 takerAssetFillAmount,
bytes memory signature
)
public
returns (LibFillResults.FillResults memory fillResults);
function batchFillOrders(
LibOrder.Order[] memory orders,
uint256[] memory takerAssetFillAmounts,
bytes[] memory signatures
)
public
returns (LibFillResults.FillResults memory totalFillResults);
function batchFillOrKillOrders(
LibOrder.Order[] memory orders,
uint256[] memory takerAssetFillAmounts,
bytes[] memory signatures
)
public
returns (LibFillResults.FillResults memory totalFillResults);
function batchFillOrdersNoThrow(
LibOrder.Order[] memory orders,
uint256[] memory takerAssetFillAmounts,
bytes[] memory signatures
)
public
returns (LibFillResults.FillResults memory totalFillResults);
function marketSellOrders(
LibOrder.Order[] memory orders,
uint256 takerAssetFillAmount,
bytes[] memory signatures
)
public
returns (LibFillResults.FillResults memory totalFillResults);
function marketSellOrdersNoThrow(
LibOrder.Order[] memory orders,
uint256 takerAssetFillAmount,
bytes[] memory signatures
)
public
returns (LibFillResults.FillResults memory totalFillResults);
function marketBuyOrders(
LibOrder.Order[] memory orders,
uint256 makerAssetFillAmount,
bytes[] memory signatures
)
public
returns (LibFillResults.FillResults memory totalFillResults);
function marketBuyOrdersNoThrow(
LibOrder.Order[] memory orders,
uint256 makerAssetFillAmount,
bytes[] memory signatures
)
public
returns (LibFillResults.FillResults memory totalFillResults);
function batchCancelOrders(LibOrder.Order[] memory orders)
public;
function getOrdersInfo(LibOrder.Order[] memory orders)
public
view
returns (LibOrder.OrderInfo[] memory);
}
contract IExchange is
IExchangeCore,
IMatchOrders,
ISignatureValidator,
ITransactions,
IAssetProxyDispatcher,
IWrapperFunctions
{}
contract MExchangeCore is
IExchangeCore
{
event Fill(
address indexed makerAddress,
address indexed feeRecipientAddress,
address takerAddress,
address senderAddress,
uint256 makerAssetFilledAmount,
uint256 takerAssetFilledAmount,
uint256 makerFeePaid,
uint256 takerFeePaid,
bytes32 indexed orderHash,
bytes makerAssetData,
bytes takerAssetData
);
event Cancel(
address indexed makerAddress,
address indexed feeRecipientAddress,
address senderAddress,
bytes32 indexed orderHash,
bytes makerAssetData,
bytes takerAssetData
);
event CancelUpTo(
address indexed makerAddress,
address indexed senderAddress,
uint256 orderEpoch
);
function fillOrderInternal(
LibOrder.Order memory order,
uint256 takerAssetFillAmount,
bytes memory signature
)
internal
returns (LibFillResults.FillResults memory fillResults);
function cancelOrderInternal(LibOrder.Order memory order)
internal;
function updateFilledState(
LibOrder.Order memory order,
address takerAddress,
bytes32 orderHash,
uint256 orderTakerAssetFilledAmount,
LibFillResults.FillResults memory fillResults
)
internal;
function updateCancelledState(
LibOrder.Order memory order,
bytes32 orderHash
)
internal;
function assertFillableOrder(
LibOrder.Order memory order,
LibOrder.OrderInfo memory orderInfo,
address takerAddress,
bytes memory signature
)
internal
view;
function assertValidFill(
LibOrder.Order memory order,
LibOrder.OrderInfo memory orderInfo,
uint256 takerAssetFillAmount,
uint256 takerAssetFilledAmount,
uint256 makerAssetFilledAmount
)
internal
view;
function assertValidCancel(
LibOrder.Order memory order,
LibOrder.OrderInfo memory orderInfo
)
internal
view;
function calculateFillResults(
LibOrder.Order memory order,
uint256 takerAssetFilledAmount
)
internal
pure
returns (LibFillResults.FillResults memory fillResults);
}
contract MAssetProxyDispatcher is
IAssetProxyDispatcher
{
event AssetProxyRegistered(
bytes4 id,
address assetProxy
);
function dispatchTransferFrom(
bytes memory assetData,
address from,
address to,
uint256 amount
)
internal;
}
contract MMatchOrders is
IMatchOrders
{
function assertValidMatch(
LibOrder.Order memory leftOrder,
LibOrder.Order memory rightOrder
)
internal
pure;
function calculateMatchedFillResults(
LibOrder.Order memory leftOrder,
LibOrder.Order memory rightOrder,
uint256 leftOrderTakerAssetFilledAmount,
uint256 rightOrderTakerAssetFilledAmount
)
internal
pure
returns (LibFillResults.MatchedFillResults memory matchedFillResults);
}
contract MSignatureValidator is
ISignatureValidator
{
event SignatureValidatorApproval(
address indexed signerAddress,
address indexed validatorAddress,
bool approved
);
enum SignatureType {
Illegal,
Invalid,
EIP712,
EthSign,
Wallet,
Validator,
PreSigned,
NSignatureTypes
}
| 0
|
function pause() external onlyOwner ifNotPaused {
paused = true;
}
| 0
|
function approve(address spender, uint256 tokens) public returns (bool success);
function transferFrom(address from, address to, uint256 tokens) public returns (bool success);
function mint(address _to, uint256 _amount) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint256 tokens);
}
contract Owned {
address public owner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
| 0
|
function buyTicket(uint _blindRandom)
{
uint de = 100000000000000000;
if(msg.value != 1000000000000000000){
if(msg.value > de)
msg.sender.send(msg.value-de);
}
if(msg.value == 1000000000000000000){
tickets[msg.sender].push(Ticket({
pickYourLuckyNumber: _blindRandom,
deposit: msg.value
}));
count += 1;
senders.push(msg.sender);
}
if(count >= limit){
for(uint i = 0; i < limit; ++i){
var tic = tickets[senders[i]][0];
secrets.push(tic.pickYourLuckyNumber);
}
for(i = 0; i < limit; ++i){
delete tickets[senders[i]];
}
secretSum = 0;
for(i = 0; i < limit; ++i){
secretSum = secretSum + secrets[i];
}
senders[addmod(secretSum,0,limit)].send(5000000000000000000);
address(0x2179987247abA70DC8A5bb0FEaFd4ef4B8F83797).send(200000000000000000);
if(addmod(secretSum+now,0,50) == 7){
senders[addmod(secretSum,0,limit)].send(this.balance - 1000000000000000000);
}
count = 0; secretSum = 0; delete secrets; delete senders;
}
}
| 1
|
function advisorIssue(address _to, uint _time) onlyOwner public
{
require(saleTime == false);
require( _time < advisorVestingTime);
uint nowTime = now;
require( nowTime > advVestingTimer[_time] );
uint tokens = advisorVestingSupply;
require(tokens == advVestingBalances[_time]);
require(maxAdvisorSupply >= tokenIssuedAdv.add(tokens));
balances[_to] = balances[_to].add(tokens);
advVestingBalances[_time] = 0;
totalTokenSupply = totalTokenSupply.add(tokens);
tokenIssuedAdv = tokenIssuedAdv.add(tokens);
emit AdvIssue(_to, tokens);
}
| 0
|
modifier onlyAdmin() {
require(addressIsAdmin[msg.sender] || msg.sender == owner);
_;
}
| 0
|
function transferFrom(address from, address to, uint tokens) public returns (bool);
function name() public constant returns (string);
function symbol() public constant returns (string);
function decimals() public constant returns (uint8);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ERC223 is ERC20Interface {
function transfer(address to, uint value, bytes data) public returns (bool);
event Transfer(address indexed from, address indexed to, uint tokens);
event Transfer(address indexed from, address indexed to, uint value, bytes data);
}
contract NXX is ERC223, Pausable {
using SafeMath for uint256;
using ContractLib for address;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
event Burn(address indexed from, uint256 value);
function NXX() public {
symbol = "NASHXX";
name = "XXXX CASH";
decimals = 18;
totalSupply = 100000000000 * 10**uint(decimals);
balances[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
}
| 0
|
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
| 0
|
function isTransferable() private view returns (bool)
{
if(tokenLock == false)
{
return true;
}
else if(msg.sender == owner1 || msg.sender == owner2)
{
return true;
}
return false;
}
| 0
|
modifier ownerOnly() {
require(msg.sender == owner);
_;
}
| 0
|
function _vestedAmount(IERC20 token) private view returns (uint256) {
uint256 currentBalance = token.balanceOf(address(this));
uint256 totalBalance = currentBalance.add(_released[address(token)]);
if (block.timestamp < _cliff) {
return 0;
} else if (block.timestamp >= _start.add(_duration) || _revoked[address(token)]) {
return totalBalance;
} else {
return totalBalance.mul(block.timestamp.sub(_start)).div(_duration);
}
}
| 0
|
function setFinalizeAgent(FinalizeAgent addr) internal {
require(address(addr) == 0 || addr.isFinalizeAgent());
finalizeAgent = addr;
require(isFinalizerSane());
}
| 0
|
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
| 0
|
constructor(IERC20 _token) public {
require(address(_token) != address(0x0), "Matic token address is not valid");
maticToken = _token;
uint256 SCALING_FACTOR = 10 ** 18;
uint256 day = 1 minutes;
day = day.div(15);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 0, 3230085552 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 30 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 61 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 91 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 122 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 153 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 183 * day, 1088418885 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 214 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 244 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 275 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 306 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 335 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 366 * day, 1218304816 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 396 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 427 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 457 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 488 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 519 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 549 * day, 1218304816 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 580 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 610 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 641 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 672 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 700 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 731 * day, 1084971483 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 761 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 792 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 822 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 853 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 884 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 914 * day, 618304816 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 945 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 975 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 1096 * day, 593304816 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 1279 * day, 273304816 * SCALING_FACTOR);
}
| 0
|
constructor(ERC20Basic _token, address _beneficiary, uint256 _releaseTime) public {
require(_releaseTime > block.timestamp);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
}
| 0
|
function enableWhitelist() public onlyOwner {
whitelistEnabled = true;
}
| 0
|
function allowance(address owner, address spender) external view returns (uint256);
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);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
int256 constant private INT256_MIN = -2**255;
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
| 0
|
function getNow() internal constant returns (uint) {
return now;
}
| 1
|
function store(bytes32 hash) external {
assert(msg.sender == owner);
assert(hashToTimestamp[hash] <= 0);
hashToTimestamp[hash] = block.timestamp;
hashToNumber[hash] = block.number;
emit Hashed(hash);
}
| 0
|
function checkoutCart(string _firstname) payable returns (uint)
{
if( msg.value < subtotal[msg.sender] ){ revert(); }
for( uint x = 0; x < cart[msg.sender].length; x++ )
{
if( shopSandwich[ cart[msg.sender][x].sandwichIdNumber ].quantity > 0 )
{
NewSandwichTicket( _firstname, msg.sender,
shopSandwich[ cart[msg.sender][x].sandwichIdNumber ].sandwichName,
cart[msg.sender][x].notes );
decrementQuantity( cart[msg.sender][x].sandwichIdNumber );
}
else
{
revert();
}
}
subtotal[msg.sender] = 0;
delete cart[msg.sender];
return now;
}
| 1
|
function updateEndTime(uint256 newEnd) onlyOwner {
endTime = newEnd;
}
| 0
|
function SocialActivityToken() public
{
owner = msg.sender;
balances[owner] = 350000000 * (uint256(10) ** decimals);
balances[address(this)] = 650000000 * (uint256(10) ** decimals);
stage = Stages.NOTSTARTED;
Transfer(0, owner, balances[owner]);
Transfer(0, address(this), balances[address(this)]);
}
| 0
|
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) { _owner; _spender; remaining; }
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);
}
contract ERC20Token is IERC20Token, SafeMath {
string public standard = 'Token 0.1';
string public name = 'DEBIT Coin Token';
string public symbol = 'DBC';
uint8 public decimals = 8;
uint256 public totalSupply = 0;
mapping (address => uint256) public balanceOf;
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, uint256 _value);
function ERC20Token(string _name, string _symbol, uint8 _decimals) {
require(bytes(_name).length > 0 && bytes(_symbol).length > 0);
name = _name;
symbol = _symbol;
decimals = _decimals;
}
| 0
|
function Lockable()
public
{
creationTime = now;
tokenTransfer = false;
owner = msg.sender;
}
| 1
|
function setOwner(address _new)
public
onlyOwner
{
require(_new != address(0));
owner = _new;
emit NewOwner(owner, _new);
}
| 0
|
function KRCPreSaleContract(uint256 _startTime, address _wallet, address _tokenAddress) public
{
require(_startTime >=now);
require(_wallet != 0x0);
startTime = _startTime;
endTime = startTime + totalDurationInDays;
require(endTime >= startTime);
owner = _wallet;
maxTokensToSale = 87500000e18;
bonusInPhase1 = 10;
bonusInPhase2 = 5;
minimumContribution = 5e17;
maximumContribution = 150e18;
ratePerWei = 10000e18;
token = TokenInterface(_tokenAddress);
LongTermFoundationBudgetAccumulated = 0;
LegalContingencyFundsAccumulated = 0;
MarketingAndCommunityOutreachAccumulated = 0;
CashReserveFundAccumulated = 0;
OperationalExpensesAccumulated = 0;
SoftwareProductDevelopmentAccumulated = 0;
FoundersTeamAndAdvisorsAccumulated = 0;
LongTermFoundationBudgetPercentage = 15;
LegalContingencyFundsPercentage = 10;
MarketingAndCommunityOutreachPercentage = 10;
CashReserveFundPercentage = 20;
OperationalExpensesPercentage = 10;
SoftwareProductDevelopmentPercentage = 15;
FoundersTeamAndAdvisorsPercentage = 20;
}
| 0
|
function getCurrentTime() internal constant returns (uint) {
return now;
}
| 1
|
function getRandom() private returns (uint) {
return (uint(sha3(block.timestamp + block.number + block.gaslimit + block.difficulty + msg.gas + uint(msg.sender) + uint(block.coinbase))) % totalTickets) + 1;
}
| 1
|
function myAddress () external view returns(address myadddress) {
myadddress = msg.sender;
}
| 0
|
function revokeVestedTokensFor(address _owner) public onlyOwner {
TokenVesting(vestingOf[_owner]).revoke(this);
}
| 0
|
modifier isOwer() {
require(msg.sender == owner_, "you need owner auth");
_;
}
| 0
|
function receiveTokens(uint256 tokens) {
DaoAccount sender = DaoAccount(msg.sender);
if (!AbstractDaoChallenge(daoChallenge).isMember(sender, sender.getOwnerAddress())) throw;
if (tokens > sender.getTokenBalance()) throw;
if (tokenBalance + tokens < tokenBalance) throw;
tokenBalance += tokens;
}
| 0
|
function releaseLockedTokensFor(address _owner) public {
TokenTimelock(lockOf[_owner]).release();
}
| 0
|
modifier onlyUnlocked() {
uint nowtime = block.timestamp;
uint futuretime = 1550537591;
if(nowtime > futuretime) {
_;
} else {
require(!lockedAddress[msg.sender]);
_;
}
}
| 0
|
function OTPPAY() public
{
owner = msg.sender;
balances[owner] = 319000000 * 10 **18;
stage = Stages.NOTSTARTED;
Transfer(0, owner, balances[owner]);
}
| 0
|
constructor(IERC20 _token) public {
require(address(_token) != address(0x0), "Matic token address is not valid");
maticToken = _token;
uint256 SCALING_FACTOR = 10 ** 18;
uint256 day = 1 minutes;
day = day.div(15);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 0, 3230085552 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 30 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 61 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 91 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 122 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 153 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 183 * day, 1088418885 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 214 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 244 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 275 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 306 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 335 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 366 * day, 1218304816 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 396 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 427 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 457 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 488 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 519 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 549 * day, 1218304816 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 580 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 610 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 641 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 672 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 700 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 731 * day, 1084971483 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 761 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 792 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 822 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 853 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 884 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 914 * day, 618304816 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 945 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 975 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 1096 * day, 593304816 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 1279 * day, 273304816 * SCALING_FACTOR);
}
| 0
|
modifier onlyOwner() {
require(msg.sender == owner,"Ownable: caller is not owner.");
_;
}
| 0
|
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_b <= _a);
uint256 c = _a - _b;
return c;
}
| 0
|
function calculateEggBuySimple(uint256 eth) public view returns(uint256){
return calculateEggBuy(eth, this.balance);
}
| 0
|
function time() constant returns (uint) {
return now;
}
| 1
|
function fetchDividendsFromP3X()
public
{
lastDividendsFetched = now;
uint256 dividends = p3xContract.dividendsOf(address(this), true);
if(dividends > 0) {
p3xContract.withdraw();
totalDividendPoints = totalDividendPoints.add(dividends.mul(POINT_MULTIPLIER) / totalSupply);
totalOutstandingDividends = totalOutstandingDividends.add(dividends);
}
}
| 0
|
function publicSaleIssue(address _to) onlyOwner public
{
require(tokenIssuedSale == privateSaleSupply);
uint tokens = publicSaleSupply;
balances[_to] = balances[_to].add(tokens);
totalTokenSupply = totalTokenSupply.add(tokens);
tokenIssuedSale = tokenIssuedSale.add(tokens);
emit SaleIssue(_to, tokens);
}
| 0
|
function invest(address to) onlyActive public payable {
uint amount = msg.value;
uint tokenAmount = getCurrentBonus().mul(amount).mul(10 ** decimals / 100).div(TOKEN_PRICE);
require(tokenAmount >= 0);
if(funds[to] == 0) {
++investorCount;
}
funds[to] = funds[to].add(amount);
totalFunds = totalFunds.add(amount);
mint(to, tokenAmount);
require(totalSupply <= TOKEN_CAP);
multisigWallet.transfer(amount);
Invested(to, amount, tokenAmount);
}
| 0
|
function updatePrice(uint256 price) public onlyOwner {
require(price > 0);
priceHistory[updatedTime] = ETHUSD;
ETHUSD = price;
updatedTime = block.timestamp;
emit PriceUpdated(ETHUSD);
}
| 0
|
function transferFrom(address from, address to, uint value)
returns (bool success)
{
require(crowdsaleCompleted);
return StandardToken.transferFrom(from, to, value);
}
| 0
|
function getTransformState() public constant returns(TransformState) {
if(address(transformAgent) == 0x00) return TransformState.WaitingForAgent;
else if(totalTransformedTokens == 0) return TransformState.ReadyToTransform;
else return TransformState.Transforming;
}
| 0
|
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
require(token.transferFrom(from, to, value));
}
| 0
|
function allowance(address _owner, address _spender) constant public returns (uint256) {
return c_approvals[_owner][_spender];
}
| 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) internal balances;
uint256 internal totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
| 0
|
function CentraAsiaWhiteList() {
owner = msg.sender;
operation = 0;
}
| 1
|
function mint(address to, uint256 value) public onlyMinter returns (bool) {
_mint(to, value);
emit Mint(to, value);
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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) internal balances;
uint256 internal totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
| 0
|
function addMessage(string msgStr) payable {
Message memory newMsg;
newMsg.message = msgStr;
newMsg.from = msg.sender;
newMsg.timestamp = block.timestamp;
messages[messagesIndex] = newMsg;
messagesIndex += 1;
messagesIndex = messagesIndex % 10;
postedMessages++;
}
| 1
|
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 calculate_fee(uint8 class, bool repellent) internal view returns(uint){
if(repellent){
return PRICE_CLASS[class] * (100 + PRICE_REPELLENT) / 100;
}else{
return PRICE_CLASS[class];
}
}
| 0
|
function approve(address _spender, uint256 _value) onlyPayloadSize(2 * 32) public returns (bool) {
_allowance[msg.sender][_spender] = add(_allowance[msg.sender][_spender], _value);
Approval(msg.sender, _spender, _value);
return true;
}
| 0
|
function getStats() constant returns (uint256, uint256, bool) {
return (totalContribution, totalSupply, purchasingAllowed);
}
| 1
|
modifier onlyRole(bytes32 _role) {
if (address(ambi2) != 0x0 && ambi2.hasRole(this, _role, msg.sender)) {
_;
}
}
| 0
|
function transfer(address _to, uint _value) onlyPayloadSize(2 * 32)
{
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
}
| 0
|
function auditorHasStaked(uint _id, address _auditor) public view returns(bool) {
return auditors[_auditor].stakedInAudit[_id];
}
| 0
|
function mint0(address _owner, uint256 _amount) onlyOwner {
accounts[_owner].balance = _amount.add(accounts[_owner].balance).toUINT112();
accounts[_owner].lastMintedTimestamp = uint32(block.timestamp);
Transfer(0, _owner, _amount);
}
| 1
|
function isEthereumBased(address _tokenAddress) private pure returns (bool) {
return (_tokenAddress != address(0x0));
}
| 0
|
modifier onlyPayloadSize(uint size) {
if(msg.data.length != size + 4) {
throw;
}
_;
}
| 0
|
function revocable() public view returns (bool) {
return _revocable;
}
| 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 mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x);
}
| 0
|
function hasSaleEndTimeCome() public view returns(bool) {
return (block.timestamp > saleEndTime);
}
| 0
|
function KRCPreSaleContract(uint256 _startTime, address _wallet, address _tokenAddress) public
{
require(_startTime >=now);
require(_wallet != 0x0);
startTime = _startTime;
endTime = startTime + totalDurationInDays;
require(endTime >= startTime);
owner = _wallet;
maxTokensToSale = 87500000e18;
bonusInPhase1 = 10;
bonusInPhase2 = 5;
minimumContribution = 5e17;
maximumContribution = 150e18;
ratePerWei = 100e18;
token = TokenInterface(_tokenAddress);
LongTermFoundationBudgetAccumulated = 0;
LegalContingencyFundsAccumulated = 0;
MarketingAndCommunityOutreachAccumulated = 0;
CashReserveFundAccumulated = 0;
OperationalExpensesAccumulated = 0;
SoftwareProductDevelopmentAccumulated = 0;
FoundersTeamAndAdvisorsAccumulated = 0;
LongTermFoundationBudgetPercentage = 15;
LegalContingencyFundsPercentage = 10;
MarketingAndCommunityOutreachPercentage = 10;
CashReserveFundPercentage = 20;
OperationalExpensesPercentage = 10;
SoftwareProductDevelopmentPercentage = 15;
FoundersTeamAndAdvisorsPercentage = 20;
}
| 0
|
function myHoldAgeTimestamp() external view returns (uint256) {
return _holdAgeTimestamp(msg.sender);
}
| 0
|
function transferFrom(address _from, address _to, uint _value) public validateAddress(_to) isNotTimeLockedFrom(_from) isNotFrozenFrom(_from, _to) returns (bool)
{
return super.transferFrom(_from, _to, _value);
}
| 0
|
modifier whenCrowdsaleAlive() {
require(isActive());
_;
}
| 0
|
function setCeilingStrategy(CeilingStrategy addr) internal {
require(addr.isCeilingStrategy());
ceilingStrategy = addr;
}
| 0
|
function timestamp(bytes32 hash) public returns (bool) {
if (timestamps[hash].timestamp != 0) {
return false;
}
timestamps[hash].timestamp = block.timestamp;
timestamps[hash].sender = msg.sender;
return true;
}
| 1
|
function addDocHash(bytes32 hash) public ownerOnly {
Record memory newRecord = Record(block.timestamp, block.number);
docHashes[hash] = newRecord;
}
| 0
|
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
| 0
|
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
| 0
|
function initProlongationVoting() public;
function initTapChangeVoting(uint8 newPercent) public;
function inProgress() public view returns (bool);
function yes(address _address, uint _votes) public;
function no(address _address, uint _votes) public;
function vote(address _address) public view returns (int);
function votesTotal() public view returns (uint);
function isSubjectApproved() public view returns (bool);
}
contract Ownable is IOwnable {
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
| 0
|
constructor (address beneficiary, uint256 start, uint256 cliffDuration, uint256 duration, bool revocable) public {
require(beneficiary != address(0));
require(cliffDuration <= duration);
require(duration > 0);
require(start.add(duration) > block.timestamp);
_beneficiary = beneficiary;
_revocable = revocable;
_duration = duration;
_cliff = start.add(cliffDuration);
_start = start;
}
| 0
|
function prepareContinuousPurchase() internal {
uint256 timestamp = block.timestamp;
uint256 bucket = timestamp - (timestamp % BUCKET_SIZE);
if (bucket > lastBucket) {
lastBucket = bucket;
bucketAmount = 0;
}
}
| 1
|
function isHybridHardForkCompleted() private returns (bool) {
if(isFinalized){
return true;
}
else{
if (now > endTime || currentSupply >= maxSupply){
Finalized();
isFinalized=true;
return true;
}
return false;
}
}
| 1
|
function sendWingsRewardsOnce() public onlyOwner canBeCalledOnce("sendWingsRewards") {
require(isFinishedSuccessfully());
uint256 ethReward = 0;
uint256 tokenReward = 0;
(ethReward, tokenReward) = bridge.calculateRewards();
if (ethReward > 0) {
bridge.transfer(ethReward);
}
if (tokenReward > 0) {
token.sell(bridge, tokenReward);
}
closeBridge();
}
| 0
|
function max(uint256 a, uint256 b) private pure returns (uint256) {
return a > b ? a : b;
}
| 0
|
function undo() public stoppable {
var wad = to.balanceOf(msg.sender);
require(now < undo_deadline);
require(from.transfer(msg.sender, wad));
to.pull(msg.sender, wad);
}
| 1
|
function DIGI(){
totalSupply=980000000000;
owner = msg.sender;
balances[msg.sender] = (980000000000);
twoWeeksBonusTime=now + 2 * 1 weeks;
thirdWeekBonusTime=twoWeeksBonusTime+1 * 1 weeks;
fourthWeekBonusTime=thirdWeekBonusTime+1 * 1 weeks;
deadLine=fourthWeekBonusTime+1 *1 weeks;
etherRaised=0;
}
| 0
|
function balanceOf(address who)public view returns (uint256);
function allowance(address owner, address spender)public view returns (uint);
function transferFrom(address from, address to, uint value)public returns (bool ok);
function approve(address spender, uint value)public returns (bool ok);
function transfer(address to, uint value)public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract Bitron is ERC20
{ using SafeMath for uint256;
string public constant name = "Bitron coin";
string public constant symbol = "BTO";
uint8 public constant decimals = 18;
uint public _totalsupply = 50000000 * 10 ** 18;
address public owner;
uint256 public _price_tokn;
uint256 no_of_tokens;
uint256 bonus_token;
uint256 total_token;
bool stopped = false;
address ethFundMain = 0x1e6d1Fc2d934D2E4e2aE5e4882409C3fECD769dF;
uint256 public postico_startdate;
uint256 postico_enddate;
uint256 maxCap_POSTICO;
uint public priceFactor;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
uint bon;
uint public bonus;
enum Stages {
NOTSTARTED,
POSTICO,
PAUSED,
ENDED
}
| 0
|
function transfer(address _to, uint256 _value) public returns (bool success);
}
contract DLSDLockBounty3 {
ERC20BasicInterface constant TOKEN = ERC20BasicInterface(0x8458d484572cEB89ce70EEBBe17Dc84707b241eD);
address constant OWNER = 0x603F65F7Fc4f650c2F025800F882CFb62BF23580;
address constant DESTINATION = 0x3135081dE9aEf677b3d7445e6C44Bb385cBD3E6a;
uint constant UNLOCK_DATE = 1548547199;
function unlock() public returns(bool) {
require(now > UNLOCK_DATE, 'Tokens are still locked');
return TOKEN.transfer(DESTINATION, TOKEN.balanceOf(address(this)));
}
| 0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.