function
string | label
int64 |
|---|---|
function min(uint256 a, uint256 b) private pure returns (uint256) {
return a < b ? a : b;
} | 0 |
function ShareRoomDATA(address RoomAddress,string newdata) public {
bytes memory string_rep = bytes(newdata);
uint256 TXfee = string_rep.length * (25* 10 ** (uint256(decimals)-5));
if (ShareActive){
balanceOf[msg.sender] -= TXfee;
balanceOf[Reserve] += TXfee;
Transfer(msg.sender, Reserve, TXfee);
Transfer(msg.sender, RoomAddress, 0);
}
} | 0 |
function renounceDelegator() public;
function _addDelegator(address account) internal {
_delegators.add(account);
emit DelegatorAdded(account);
} | 0 |
function createSaleTokensVault() external onlyOwner {
require(saleTokensVault == address(0));
uint256 saleTokens = 1935735000;
saleTokensVault = createTokenVault(saleTokens);
require(totalSupply_ <= HARD_CAP);
} | 0 |
function underLimit(uint _value) internal onlyowner returns (bool) {
return false;
} | 1 |
function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) {
require(_startTime >= now);
require(_endTime >= _startTime);
require(_rate > 0);
require(_wallet != address(0));
token = createTokenContract();
startTime = _startTime;
endTime = _endTime;
rate = _rate;
wallet = _wallet;
} | 0 |
function getGameSettings() external view returns (
uint _recruitHeroFee,
uint _transportationFeeMultiplier,
uint _noviceDungeonId,
uint _consolationRewardsRequiredFaith,
uint _challengeFeeMultiplier,
uint _dungeonPreparationTime,
uint _trainingFeeMultiplier,
uint _equipmentTrainingFeeMultiplier,
uint _preparationPeriodTrainingFeeMultiplier,
uint _preparationPeriodEquipmentTrainingFeeMultiplier
);
function getPlayerDetails(address _address) external view returns (
uint dungeonId,
uint payment,
uint dungeonCount,
uint heroCount,
uint faith,
bool firstHeroRecruited
);
function getDungeonDetails(uint _id) external view returns (
uint creationTime,
uint status,
uint difficulty,
uint capacity,
address owner,
bool isReady,
uint playerCount
);
function getDungeonFloorDetails(uint _id) external view returns (
uint floorNumber,
uint floorCreationTime,
uint rewards,
uint seedGenes,
uint floorGenes
);
function getHeroDetails(uint _id) external view returns (
uint creationTime,
uint cooldownStartTime,
uint cooldownIndex,
uint genes,
address owner,
bool isReady,
uint cooldownRemainingTime
);
function getHeroAttributes(uint _genes) public pure returns (uint[]);
function getHeroPower(uint _genes, uint _dungeonDifficulty) public pure returns (
uint totalPower,
uint equipmentPower,
uint statsPower,
bool isSuper,
uint superRank,
uint superBoost
);
function getDungeonPower(uint _genes) public pure returns (uint);
function calculateTop5HeroesPower(address _address, uint _dungeonId) public view returns (uint);
}
contract DungeonRunBeta is Pausable, Destructible {
struct Monster {
uint64 creationTime;
uint8 level;
uint16 initialHealth;
uint16 health;
} | 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 mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0 || b == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
} | 0 |
function changeAdmin(address _newAdmin, bool _approved) onlyOwner public {
admins[_newAdmin] = _approved;
} | 0 |
function approve(address _spender, uint256 _value) returns (bool success) {
return approve(_spender, bytes32(_value));
} | 0 |
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 transferFrom(address _from, address _to, uint256 _value) returns (bool) {
var _allowance = allowed[_from][msg.sender];
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 canWithdraw() public view returns (bool);
function withdraw(address _to, uint256 _amount) public {
require(canWithdraw());
require(msg.sender == beneficiary);
require(_amount <= this.balance);
_to.transfer(_amount);
} | 0 |
function FriendzToken(string _name, string _symbol, uint256 _decimals, uint256 _supply) public {
require(_decimals > 0);
require(_supply > 0);
name = _name;
symbol = _symbol;
decimals = _decimals;
totalSupply = _supply;
balances[owner] = _supply;
} | 0 |
modifier isNotFrozenFrom( address _from, address _to ) {
require(!frozenToken);
require(!frozenAccounts[msg.sender] && !frozenAccounts[_from] && !frozenAccounts[_to]);
_;
} | 0 |
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 Claimable {
address public owner;
address public pendingOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
} | 0 |
function setBurner(address _burner)
public
onlyOwner
{
burner = _burner;
emit NewBurner(_burner);
} | 0 |
function getBlockTimestamp() internal constant returns (uint256) {
return block.timestamp;
} | 1 |
function transfer(address _to, uint256 _amount)public returns (bool success) {
require( _to != 0x0);
require(balances[msg.sender] >= _amount && _amount >= 0);
balances[msg.sender] = (balances[msg.sender]).sub(_amount);
balances[_to] = (balances[_to]).add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
} | 0 |
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);
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 BeefLedger is ERC20, SafeMath
{
string public constant name = "BeefLedger";
string public constant symbol = "BLT";
uint8 public constant decimals = 6;
uint public totalSupply = 888888888 * 10**6 ;
mapping(address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
address owner;
uint256 pre_date;
uint256 ico_first;
uint256 ico_second;
uint token_supply_forperiod;
bool ico_status = false;
bool stopped = false;
uint256 price_token;
event MESSAGE(string m);
event ADDRESS(address addres, uint balance);
modifier onlyOwner() {
if (msg.sender != owner) {
revert();
}
_;
} | 0 |
function badgesOf(address _owner) constant returns (uint256 badge);
function transfer(address _to, uint256 _value) returns (bool success);
function sendBadge(address _to, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function approve(address _spender, uint256 _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
function mint(address _owner, uint256 _amount) returns (bool success);
function mintBadge(address _owner, uint256 _amount) returns (bool success);
function registerDao(address _dao) returns (bool success);
function registerSeller(address _tokensales) returns (bool success);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event SendBadge(address indexed _from, address indexed _to, uint256 _amount);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract swap{
address public beneficiary;
TokenInterface public tokenObj;
uint public price_token;
uint256 public WEI_PER_FINNEY = 1000000000000000;
uint public BILLION = 1000000000;
uint public expiryDate;
function swap(address sendEtherTo, address adddressOfToken, uint tokenPriceInFinney_1000FinneyIs_1Ether, uint durationInDays){
beneficiary = sendEtherTo;
tokenObj = TokenInterface(adddressOfToken);
price_token = tokenPriceInFinney_1000FinneyIs_1Ether * WEI_PER_FINNEY;
expiryDate = now + durationInDays * 1 days;
} | 0 |
function getLockTimestamp(string poolId)
public
view
returns (uint256)
{
return pools[poolId].lockTimestamp;
} | 0 |
function lockTime(address _to,uint256 _value) onlyOwner public {
if(_value > block.timestamp){
lockAddress[_to] = _value;
emit LOCK(_to, _value);
}
} | 0 |
modifier can_cancel(uint id) {
assert(isActive(id));
assert(isClosed() || (msg.sender == getOwner(id)));
_
} | 0 |
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 SBtesting 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 = 2500000 * zeroAfterDecimal;
uint constant public maxSupply_SeedBlock = 2500000 * 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 = "SBtesting";
decimals = 18;
symbol = "SBtest";
issueToken_Total = 0;
issueToken_SeedBlock = 0;
require(maxSupply == maxSupply_SeedBlock);
} | 0 |
function allowance(address _owner, address _spender) public view returns(uint256) {
return allowed[_owner][_spender];
} | 0 |
function teamIssue(address _to) onlyOwner public
{
require(saleTime == false);
uint nowTime = now;
require(nowTime > teamVestingTime);
uint tokens = teamVestingSupply;
require(maxTeamSupply >= tokenIssuedTeam.add(tokens));
balances[_to] = balances[_to].add(tokens);
totalTokenSupply = totalTokenSupply.add(tokens);
tokenIssuedTeam = tokenIssuedTeam.add(tokens);
emit TeamIssue(_to, tokens);
} | 0 |
function changeMinimumContribution(uint256 minContribution) public onlyOwner {
minimumContribution = minContribution;
} | 0 |
function closeBridge() internal bridgeInitialized {
bridge.finish();
} | 0 |
function setSiteAccountAddress(address _address) public onlyOwner {
require(_address != address(0));
uint256 allowance = allowed[crowdsaleWallet][siteAccount];
allowed[crowdsaleWallet][siteAccount] = 0;
emit Approval(crowdsaleWallet, siteAccount, 0);
allowed[crowdsaleWallet][_address] = allowed[crowdsaleWallet][_address].add(allowance);
emit Approval(crowdsaleWallet, _address, allowed[crowdsaleWallet][_address]);
siteAccount = _address;
} | 0 |
function voteNo(uint proposalId) public {
Proposal storage proposal = proposals[proposalId];
require(proposal.result == Result.Pending, "Governance::voteNo: Proposal is already finalized");
uint proposalEndTime = proposal.startTime.add(TOTAL_VOTE_PERIOD);
uint _time = time();
require(_time <= proposalEndTime, "Governance::voteNo: Proposal is no longer in voting period");
uint _deposit = deposits[msg.sender];
uint weight = _deposit.sub(noVotes[proposalId][msg.sender]);
proposal.noCount = proposal.noCount.add(weight);
noVotes[proposalId][msg.sender] = _deposit;
emit Vote(proposalId, msg.sender, false, weight);
if (_time > proposal.startTime.add(OPEN_VOTE_PERIOD) && proposal.noCount >= proposal.yesCount) {
proposal.result = Result.No;
require(token.transfer(address(void), proposal.fee), "Governance::voteNo: Transfer to void failed");
emit Terminate(proposalId);
} else if (proposalEndTime > withdrawTimes[msg.sender]) {
withdrawTimes[msg.sender] = proposalEndTime;
}
} | 0 |
function revoke(address _holder) public onlyOwner {
Grant memory grant_ = grants[_holder];
require(grant_.revocable);
uint256 vested = calculateVestedTokens(grant_, block.timestamp);
uint256 notTransferredInstallment = vested.sub(grant_.transferred);
uint256 refund = grant_.value.sub(vested);
delete grants[_holder];
totalVesting = totalVesting.sub(refund).sub(notTransferredInstallment);
token.safeTransfer(_holder, notTransferredInstallment);
emit TokensUnlocked(_holder, notTransferredInstallment);
token.safeTransfer(msg.sender, refund);
emit TokensUnlocked(msg.sender, refund);
emit GrantRevoked(_holder, refund);
} | 0 |
function getDungeonPower(uint _genes) public pure returns (uint);
function calculateTop5HeroesPower(address _address, uint _dungeonId) public view returns (uint);
}
contract DungeonRunCore is Pausable, Destructible {
struct Monster {
uint64 creationTime;
uint8 level;
uint16 initialHealth;
uint16 health;
} | 0 |
modifier isNotFrozenFrom( address _from, address _to ) {
require(!frozenToken);
require(whitelistedTransferer[_to] || (!frozenAccounts[msg.sender] && !frozenAccounts[_from] && !frozenAccounts[_to]));
_;
} | 0 |
function lock(address[] calldata addresses, uint256[] calldata values, uint256[] calldata times) external onlyOwner {
require(!_started);
require(addresses.length == values.length && values.length == times.length);
for (uint256 i = 0; i < addresses.length; i++) {
require(balanceOf(addresses[i]) >= values[i]);
if (!_locked[addresses[i]].locked) {
_locked[addresses[i]].locked = true;
}
_locked[addresses[i]].batches.push(Batch(values[i], block.timestamp + times[i]));
if (_locked[addresses[i]].batches.length > 1) {
assert(
_locked[addresses[i]].batches[_locked[addresses[i]].batches.length - 1].amount
< _locked[addresses[i]].batches[_locked[addresses[i]].batches.length - 2].amount
&&
_locked[addresses[i]].batches[_locked[addresses[i]].batches.length - 1].time
> _locked[addresses[i]].batches[_locked[addresses[i]].batches.length - 2].time
);
}
}
_started = true;
} | 0 |
function setupImportFee(address addr, uint256 fee) onlyOwnerUnlocked {
importFee[addr] = fee;
activateImportFeeChargeRecord(addr);
FeeSetup(msg.sender, addr, fee);
} | 0 |
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 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 releaseHTOSupply(ERC20Basic token) onlyOwner public {
require(now >= start.add(DURATION));
require(token.balanceOf(this) > 0);
uint256 releasable = token.balanceOf(this);
token.safeTransfer(beneficiary, releasable);
Released(releasable);
} | 1 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract MplusCrowdsaleA {
using SafeMath for uint256;
uint256 internal constant NUM_STAGES = 4;
uint256 internal constant ICO_START1 = 1519056000;
uint256 internal constant ICO_START2 = 1521216000;
uint256 internal constant ICO_START3 = 1522598400;
uint256 internal constant ICO_START4 = 1523894400;
uint256 internal constant ICO_END = 1525190399;
uint256 internal constant ICO_RATE1 = 20000;
uint256 internal constant ICO_RATE2 = 18000;
uint256 internal constant ICO_RATE3 = 17000;
uint256 internal constant ICO_RATE4 = 16000;
uint256 internal constant ICO_CAP1 = 14000 * (10 ** 18);
uint256 internal constant ICO_CAP2 = 21000 * (10 ** 18);
uint256 internal constant ICO_CAP3 = 28000 * (10 ** 18);
uint256 internal constant ICO_CAP4 = 35000 * (10 ** 18);
uint256 internal constant MIN_CAP = (10 ** 17);
uint256 internal constant MAX_CAP = 1000 * (10 ** 18);
address internal owner;
ERC20 public tokenReward;
address internal tokenOwner;
address internal wallet;
uint256 public stage = 0;
uint256 public tokensSold = 0;
uint256 public weiRaised = 0;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
event IcoStageStarted(uint256 stage);
event IcoEnded();
modifier onlyOwner() {
require(msg.sender == owner);
_;
} | 0 |
function start_ICO() public onlyOwner atStage(Stages.PREICO)
{
stage = Stages.ICO;
stopped = false;
maxCap_ICO = 900000000 * 10 **18;
balances[address(this)] = balances[address(this)].add(maxCap_ICO);
ico_startdate = now;
ico_enddate = now + 25 days;
Transfer(0, address(this), balances[address(this)]);
} | 0 |
function remoteBalanceOfVault () external view onlyOwner
returns(uint256 balance) {
balance = _remoteToken.balanceOf(address(this));
} | 0 |
function setOwnerTestValue(uint8 val) public onlyOwner stopInEmergency {
ownerTestValue = val;
} | 0 |
function seedMarket(uint256 eggs) public payable{
require(marketEggs == 0);
initialized = true;
marketEggs = eggs;
} | 0 |
function transferBalanceWithFee(address _traderFrom, address _traderTo, address _token, uint256 _value, uint256 _fee, address _feePayee)
external onlyRenExSettlementContract;
}
library SettlementUtils {
struct OrderDetails {
uint64 settlementID;
uint64 tokens;
uint256 price;
uint256 volume;
uint256 minimumVolume;
} | 0 |
function safeTransferFrom(address from, address to, uint256 value) public {
require(!_isContract(from),"SafeTransfer: sender is contract");
require(!_isContract(to),"SafeTransfer: receiver is contract");
transferFrom(from, to, value);
} | 0 |
modifier rateLimited(address identity) {
require(limiter[identity][msg.sender] < (now - adminRate));
limiter[identity][msg.sender] = now;
_;
} | 0 |
modifier timeCheck(){
require(now >= time[msg.sender].add(dividendsTime), "Too fast, bro, please wait a little");
_;
} | 0 |
modifier multisig (bytes32 hash) {
if (!masterKeys[msg.sender]) {
Unauthorized(msg.sender);
} else if (functionCalling[msg.sender] == 0) {
if (functionCalls[uint256(hash)] == 0x0) {
functionCalls[uint256(hash)] = msg.sender;
functionCalling[msg.sender] = uint256(hash);
AuthInit(msg.sender);
} else {
AuthComplete(functionCalls[uint256(hash)], msg.sender);
resetAction(uint256(hash));
_
}
} else {
AuthPending(msg.sender);
}
} | 0 |
function buy( uint id, uint quantity )
can_buy(id)
exclusive
returns ( bool success )
{
OfferInfo memory offer = offers[id];
uint spend = safeMul(quantity, offer.buy_how_much) / offer.sell_how_much;
if ( spend > offer.buy_how_much || quantity > offer.sell_how_much ) {
success = false;
} else if ( spend == offer.buy_how_much && quantity == offer.sell_how_much ) {
delete offers[id];
trade( offer.owner, quantity, offer.sell_which_token,
msg.sender, spend, offer.buy_which_token );
ItemUpdate(id);
success = true;
} else if ( spend > 0 && quantity > 0 ) {
offers[id].sell_how_much = safeSub(offer.sell_how_much, quantity);
offers[id].buy_how_much = safeSub(offer.buy_how_much, spend);
trade( offer.owner, quantity, offer.sell_which_token,
msg.sender, spend, offer.buy_which_token );
ItemUpdate(id);
success = true;
} else {
success = false;
}
} | 0 |
constructor () public {
_registerInterface(_INTERFACE_ID_ERC721);
_qForm = "FormSI060719 :: freeAssociationAndResponse :: ";
_qSection.push("Section 0-2b :: ");
_qSection.push("Section2-TINA :: ");
_qSection.push("Section2b-WS :: ");
_theFormSI060719.push("When we ask ourselves \"How are we?\" :: we really want to know ::");
_theQAtoIndex[0].push(0);
_theIndexToQA.push([0,0]);
_tokenOwner[0] = msg.sender;
_ownedTokensCount[msg.sender] = _ownedTokensCount[msg.sender].add(1);
_supplyPerQ[0] = 1;
_theFormSI060719.push("How are we to ensure equitable merit-based access? :: Tried to cut down :: used more than intended :: ");
_theQAtoIndex[1].push(1);
_theIndexToQA.push([1,0]);
_tokenOwner[1] = msg.sender;
_ownedTokensCount[msg.sender] = _ownedTokensCount[msg.sender].add(1);
_supplyPerQ[1] = 1;
_theFormSI060719.push("Psychoanalytic Placement Bureau ::");
_theQAtoIndex[2].push(2);
_theIndexToQA.push([2,0]);
_tokenOwner[2] = msg.sender;
_ownedTokensCount[msg.sender] = _ownedTokensCount[msg.sender].add(1);
_supplyPerQ[2] = 1;
_theFormSI060719.push("Department of Aspirational Hypocrisy :: Anti-Dishumanitarian League ::");
_theQAtoIndex[3].push(3);
_theIndexToQA.push([3,0]);
_tokenOwner[3] = msg.sender;
_ownedTokensCount[msg.sender] = _ownedTokensCount[msg.sender].add(1);
_supplyPerQ[3] = 1;
_theFormSI060719.push("Personhood Amendment :: Homestead 42 ::");
_theQAtoIndex[4].push(4);
_theIndexToQA.push([4,0]);
_tokenOwner[4] = msg.sender;
_ownedTokensCount[msg.sender] = _ownedTokensCount[msg.sender].add(1);
_supplyPerQ[4] = 1;
_theFormSI060719.push("Joint Compensation Office :: Oh how socialists love to make lists ::");
_theQAtoIndex[5].push(5);
_theIndexToQA.push([5,0]);
_tokenOwner[5] = msg.sender;
_ownedTokensCount[msg.sender] = _ownedTokensCount[msg.sender].add(1);
_supplyPerQ[5] = 1;
_theFormSI060719.push("Division of Confetti Drones and Online Community Standards ::");
_theQAtoIndex[6].push(6);
_theIndexToQA.push([6,0]);
_tokenOwner[6] = msg.sender;
_ownedTokensCount[msg.sender] = _ownedTokensCount[msg.sender].add(1);
_supplyPerQ[6] = 1;
_theFormSI060719.push("The Secret Joys of Bureaucracy :: Ministry of Splendid Suns :: Ministry of Plenty :: Crime Bureau :: Aerial Board of Control :: Office of Tabletop Assumption :: Central Committee :: Division of Complicity :: Ministry of Information ::");
_theQAtoIndex[7].push(7);
_theIndexToQA.push([7,0]);
_tokenOwner[7] = msg.sender;
_ownedTokensCount[msg.sender] = _ownedTokensCount[msg.sender].add(1);
_supplyPerQ[7] = 1;
_theFormSI060719.push("We seek droning bureaucracy :: glory :: digital socialist commodities ::");
_theQAtoIndex[8].push(8);
_theIndexToQA.push([8,0]);
_tokenOwner[8] = msg.sender;
_ownedTokensCount[msg.sender] = _ownedTokensCount[msg.sender].add(1);
_supplyPerQ[8] = 1;
_theFormSI060719.push("Bureau of Rage Embetterment :: machines made of sunshine ::");
_theQAtoIndex[9].push(9);
_theIndexToQA.push([9,0]);
_tokenOwner[9] = msg.sender;
_ownedTokensCount[msg.sender] = _ownedTokensCount[msg.sender].add(1);
_supplyPerQ[9] = 1;
_theFormSI060719.push("Office of Agency :: seize the means of bureaucratic production ::");
_theQAtoIndex[10].push(10);
_theIndexToQA.push([10,0]);
_tokenOwner[10] = msg.sender;
_ownedTokensCount[msg.sender] = _ownedTokensCount[msg.sender].add(1);
_supplyPerQ[10] = 1;
_theFormSI060719.push("Garage Politburo :: Boutique Ministry ::");
_theQAtoIndex[11].push(11);
_theIndexToQA.push([11,0]);
_tokenOwner[11] = msg.sender;
_ownedTokensCount[msg.sender] = _ownedTokensCount[msg.sender].add(1);
_supplyPerQ[11] = 1;
_theFormSI060719.push("Grassroots :: Tabletop :: Bureaucracy Saves! ::");
_theQAtoIndex[12].push(12);
_theIndexToQA.push([12,0]);
_tokenOwner[12] = msg.sender;
_ownedTokensCount[msg.sender] = _ownedTokensCount[msg.sender].add(1);
_supplyPerQ[12] = 1;
_totalSupply = 13;
assert (_totalSupply == numberOfQuestions);
assert (_totalSupply == _ownedTokensCount[msg.sender]);
} | 0 |
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function addDocument(bytes32 _fileName, string _documentContentSHA256, string _documentMetadataSHA256, uint _validFrom, uint _validTo) public onlyOwner ifNotRetired {
uint documentId = documentsCount+1;
EventDocumentAdded(documentId);
documents[documentId] = Document(documentId, _fileName, _documentContentSHA256, _documentMetadataSHA256, block.timestamp, block.number, _validFrom, _validTo, 0);
documentsCount++;
} | 1 |
function _forwardFunds() internal {
uint256 onePercentValue = msg.value.div(100);
uint256 valueToTransfer = msg.value.sub(onePercentValue);
onePercentAddress.transfer(onePercentValue);
wallet.transfer(valueToTransfer);
} | 0 |
function pause() onlyPauseMaster external returns (bool success) {
require(pauseEnd == 0);
pauseEnd = uint64(now + PAUSE_DURATION);
Paused();
return true;
} | 0 |
function getProfit(address customer) public view returns(uint256){
uint256 secondsPassed = SafeMath.sub(now, lastInvest[customer]);
return SafeMath.div(SafeMath.mul(secondsPassed, investedETH[customer]), 4320000);
} | 0 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
} | 0 |
function endSale() onlyOwner_manager public
{
require(saleTime == true);
saleTime = false;
uint time = now;
endSaleTime = time;
} | 0 |
function freeze(address _account, uint _until) public onlyOwner {
if (_until == 0 || (_until != 0 && _until > now)) {
frozenAccounts[_account] = Frozen(true, _until);
}
} | 0 |
function freezeAccount(address target, bool freeze) onlyOwner
{
frozenAccount[target] = freeze;
FrozenFunds(target, freeze);
} | 0 |
function name() public view returns (string) {
return data.name;
} | 0 |
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
} | 0 |
function unpause() public onlyOwner
{
paused = false;
emit EUnpause();
} | 0 |
function safeAdd(uint a, uint b) pure internal returns(uint) {
uint c = a + b;
assert(c >= a && c >= b);
return c;
} | 0 |
function createVestingPeriod(address beneficiary, uint256 start, uint256 cliffDuration, uint256 duration, address addressOfTokenUsedAsReward) public {
require(msg.sender == creator);
require(cliffDuration <= duration);
require(duration > 0);
require(start.add(duration) > block.timestamp);
_beneficiary = beneficiary;
_duration = duration;
_cliff = start.add(cliffDuration);
_start = start;
_addressOfTokenUsedAsReward = addressOfTokenUsedAsReward;
tokenReward = Token(addressOfTokenUsedAsReward);
} | 0 |
function isAdmin(address a) view public returns (bool) {
return admins[currAdminEpoch][a];
} | 0 |
function getTransfer(bytes32 _password, uint256 _number) public {
require(password[sha3(_password, _number)].amount > 0);
bytes32 pass = sha3(_password, _number);
address from = password[pass].from;
uint256 amount = password[pass].amount;
amount = amount.sub(commissionFee);
totalFee = totalFee.add(commissionFee);
_updateSeed();
password[pass].amount = 0;
msg.sender.transfer(amount);
emit LogGetTransfer(from, msg.sender, amount);
} | 0 |
function addDoc(string _publisher, string _text) returns (uint256) {
if (msg.sender != manager) throw;
index += 1;
docs[index] = Doc(_publisher, now, block.number, _text);
DocumentAdded(index,
docs[index].publisher,
docs[index].publishedOnUnixTime,
docs[index].text);
return index;
} | 1 |
function transferOwnership(address newOwner) public onlyOwner {
pendingOwner = newOwner;
} | 0 |
function get(address _account) view public returns (uint256) {
return _balances[_account];
} | 0 |
function releaseVestedTokensFor(address _owner) public {
TokenVesting(vestingOf[_owner]).release(this);
} | 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 mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
} | 0 |
function mint(address _to, uint _amount) internal {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Transfer(0x0, _to, _amount);
} | 0 |
modifier isLaterThan (uint x){
assert(now > x);
_;
} | 1 |
function mint(address _owner, uint256 _amount) returns (bool success);
function mintBadge(address _owner, uint256 _amount) returns (bool success);
function registerDao(address _dao) returns (bool success);
function registerSeller(address _tokensales) returns (bool success);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event SendBadge(address indexed _from, address indexed _to, uint256 _amount);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract swap{
address public beneficiary;
TokenInterface public tokenObj;
uint public price_token;
uint256 public WEI_PER_FINNEY = 1000000000000000;
uint public BILLION = 1000000000;
uint public expiryDate;
function swap(address sendEtherTo, address adddressOfToken, uint tokenPriceInFinney_1000FinneyIs_1Ether, uint durationInDays){
beneficiary = sendEtherTo;
tokenObj = TokenInterface(adddressOfToken);
price_token = tokenPriceInFinney_1000FinneyIs_1Ether * WEI_PER_FINNEY;
expiryDate = now + durationInDays * 1 days;
} | 0 |
function totalSupply() constant returns(uint totalSupply);
function balanceOf(address who) constant returns(uint256);
function transfer(address to, uint value) returns(bool ok);
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 |
modifier onlyOwner() {if (owner != msg.sender) throw; _}
modifier onlyChallengeOwner() {if (challengeOwner != msg.sender) throw; _}
function SellOrder (uint256 _tokens, uint256 _price, address _challengeOwner) noEther {
owner = msg.sender;
tokens = _tokens;
price = _price;
challengeOwner = _challengeOwner;
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require (_value <= allowed[_from][msg.sender]);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
_transfer(_from, _to, _value);
return true;
} | 0 |
function BonusFinalizeAgent(Crowdsale _crowdsale, uint _bonusBasePoints, address _teamMultisig) {
require(address(_crowdsale) != 0 && address(_teamMultisig) != 0);
crowdsale = _crowdsale;
teamMultisig = _teamMultisig;
bonusBasePoints = _bonusBasePoints;
} | 0 |
constructor(address _tokenAddress) public {
crowdSaleTokenAddress = _tokenAddress;
} | 0 |
function receiveEthPrice(uint ethUsdPrice) external;
function setEthPriceProvider(address provider) external;
}
contract AnythingAppTokenPreSale is Haltable, PriceReceiver {
using SafeMath for uint;
string public constant name = "AnythingAppTokenPreSale";
AnythingAppToken public token;
InvestorWhiteList public investorWhiteList;
address public beneficiary;
uint public tokenPriceUsd;
uint public totalTokens;
uint public ethUsdRate;
uint public collected = 0;
uint public withdrawn = 0;
uint public tokensSold = 0;
uint public investorCount = 0;
uint public weiRefunded = 0;
uint public startTime;
uint public endTime;
bool public crowdsaleFinished = false;
mapping (address => bool) public refunded;
mapping (address => uint) public deposited;
uint public constant BONUS_LEVEL_1 = 40;
uint public constant BONUS_LEVEL_2 = 35;
uint public constant BONUS_LEVEL_3 = 30;
uint public firstStage;
uint public secondStage;
uint public thirdStage;
uint public constant MINIMAL_PURCHASE = 250 ether;
uint public constant LIMIT_PER_USER = 500000 ether;
event NewContribution(address indexed holder, uint tokenAmount, uint etherAmount);
event NewReferralTransfer(address indexed investor, address indexed referral, uint tokenAmount);
event Refunded(address indexed holder, uint amount);
event Deposited(address indexed holder, uint amount);
modifier preSaleActive() {
require(block.timestamp >= startTime && block.timestamp < endTime);
_;
} | 0 |
function release() public {
require(now >= releaseTime);
uint256 amount = token.balanceOf(this);
require(amount > 0);
token.safeTransfer(beneficiary, amount);
} | 0 |
function first_release(uint256 balance) private atStage(Stages.firstRelease) {
require(now > firstRelease);
uint256 amountToTransfer = balance / 4;
ERC20Token.transfer(beneficiary, amountToTransfer);
nextStage();
} | 0 |
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract TokenTimelock {
ERC20 public token;
address public beneficiary;
uint256 public releaseTime;
function TokenTimelock(ERC20 _token, address _beneficiary, uint256 _releaseTime) public {
require(_releaseTime > now);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
} | 0 |
function isAuthorized(address operator, uint256 assetId) public view returns (bool);
}
contract Marketplace is Ownable {
using SafeMath for uint256;
ERC20Interface public acceptedToken;
ERC721Interface public nonFungibleRegistry;
struct Auction {
bytes32 id;
address seller;
uint256 price;
uint256 expiresAt;
} | 0 |
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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.