function
string | label
int64 |
|---|---|
function refundTokens(address _buyer, uint256 tokens) external onlyCrowdsale whenNotPaused {
require(_buyer != address(0));
require(tokens > 0);
require(balances[_buyer] >= tokens);
balances[_buyer] = balances[_buyer].sub(tokens);
RefundedTokens(_buyer, tokens);
}
| 0
|
function transferWithReference(address _to, uint _value, string _reference) returns(bool);
function totalSupply() constant returns(uint);
function approve(address _spender, uint _value) returns(bool);
}
contract VestingInterface {
function createVesting(address _receiver, AssetProxyInterface _AssetProxy, uint _amount, uint _parts, uint _paymentInterval, uint _schedule) returns(bool);
function sendVesting(uint _id) returns(bool);
function getReceiverVesting(address _receiver, address _ERC20) constant returns(uint);
}
contract CryptykVestingManager is Ambi2EnabledFull {
AssetProxyInterface public assetProxy;
VestingInterface public vesting;
uint public paymentInterval;
uint public schedule;
uint public presaleDeadline;
function setVesting(VestingInterface _vesting) onlyRole('admin') returns(bool) {
require(address(vesting) == 0x0);
vesting = _vesting;
return true;
}
| 0
|
function claimOwnerSupply() onlyOwner {
if (now < ownerTokensFreeDay) throw;
if (remainingOwner == 0) throw;
if (!remaindersSet) throw;
balanceOf[owner] = safeAdd(balanceOf[owner], remainingOwner);
remainingOwner = 0;
}
| 1
|
function sub(uint a, uint b) internal pure returns (uint c) {
require(b <= a);
c = a - b;
}
| 0
|
function allowance( address _owner, address _spender ) public view returns (uint _allowance);
function transferFrom( address _from, address _to, uint _value) public returns (bool _success);
}
contract LINIXToken is ERC20Interface, OwnerHelper
{
using SafeMath for uint;
string public name;
uint public decimals;
string public symbol;
uint constant private E18 = 1000000000000000000;
uint constant private month = 2592000;
uint constant public maxTotalSupply = 2473750000 * E18;
uint constant public maxTeamSupply = 247375000 * E18;
uint constant public maxRnDSupply = 247375000 * E18;
uint constant public maxEcoSupply = 371062500 * E18;
uint constant public maxMktSupply = 197900000 * E18;
uint constant public maxReserveSupply = 296850000 * E18;
uint constant public maxAdvisorSupply = 123687500 * E18;
uint constant public maxSaleSupply = 989500000 * E18;
uint constant public publicSaleSupply = 100000000 * E18;
uint constant public privateSaleSupply = 889500000 * E18;
uint constant public rndVestingSupply = 9895000 * E18;
uint constant public rndVestingTime = 25;
uint constant public teamVestingSupply = 247375000 * E18;
uint constant public teamVestingLockDate = 24 * month;
uint constant public advisorVestingSupply = 30921875 * E18;
uint constant public advisorVestingLockDate = 3 * month;
uint constant public advisorVestingTime = 4;
uint public totalTokenSupply;
uint public tokenIssuedTeam;
uint public tokenIssuedRnD;
uint public tokenIssuedEco;
uint public tokenIssuedMkt;
uint public tokenIssuedRsv;
uint public tokenIssuedAdv;
uint public tokenIssuedSale;
uint public burnTokenSupply;
mapping (address => uint) public balances;
mapping (address => mapping ( address => uint )) public approvals;
uint public teamVestingTime;
mapping (uint => uint) public rndVestingTimer;
mapping (uint => uint) public rndVestingBalances;
mapping (uint => uint) public advVestingTimer;
mapping (uint => uint) public advVestingBalances;
bool public tokenLock = true;
bool public saleTime = true;
uint public endSaleTime = 0;
event TeamIssue(address indexed _to, uint _tokens);
event RnDIssue(address indexed _to, uint _tokens);
event EcoIssue(address indexed _to, uint _tokens);
event MktIssue(address indexed _to, uint _tokens);
event RsvIssue(address indexed _to, uint _tokens);
event AdvIssue(address indexed _to, uint _tokens);
event SaleIssue(address indexed _to, uint _tokens);
event Burn(address indexed _from, uint _tokens);
event TokenUnlock(address indexed _to, uint _tokens);
event EndSale(uint _date);
constructor() public
{
name = "LINIX Token";
decimals = 18;
symbol = "LNX";
totalTokenSupply = 0;
tokenIssuedTeam = 0;
tokenIssuedRnD = 0;
tokenIssuedEco = 0;
tokenIssuedMkt = 0;
tokenIssuedRsv = 0;
tokenIssuedAdv = 0;
tokenIssuedSale = 0;
burnTokenSupply = 0;
require(maxTeamSupply == teamVestingSupply);
require(maxRnDSupply == rndVestingSupply.mul(rndVestingTime));
require(maxAdvisorSupply == advisorVestingSupply.mul(advisorVestingTime));
require(maxSaleSupply == publicSaleSupply + privateSaleSupply);
require(maxTotalSupply == maxTeamSupply + maxRnDSupply + maxEcoSupply + maxMktSupply + maxReserveSupply + maxAdvisorSupply + maxSaleSupply);
}
| 0
|
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract DetailedERC20 is ERC20 {
string public name;
string public symbol;
uint8 public decimals;
function DetailedERC20(string _name, string _symbol, uint8 _decimals) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
}
| 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 setPaycarnita(uint256 _newPaycarnita) onlyManager public{
toPaycarnita=_newPaycarnita;
}
| 0
|
function declare_finish(uint block_finish) external {
require(races[race_number].block_start != 0,"unstarted");
require(block_finish < block.number, "undetermined");
require(block.number <= races[race_number].block_start + 255,"void");
if( races[race_number].block_finish != 0 ){
uint balance = bank[msg.sender];
require(balance > 0, "finished");
bank[msg.sender] = 0;
msg.sender.transfer( balance );
emit CashOut( msg.sender );
return;
}
do_declare_finish(block_finish);
uint balance = bank[msg.sender];
bank[msg.sender] = 0;
msg.sender.transfer( balance );
}
| 0
|
function getNumberOfAnswers(uint256 questionId)
public view
returns (uint256){
require (questionId < numberOfQuestions);
return (_supplyPerQ[questionId] - 1);
}
| 0
|
function DividendManager(address token_address, address auth_address) public {
token = SingleTokenCoin(token_address);
set_new_admin(auth_address);
dividends_share = 50;
reinvestment_share = 50;
}
| 1
|
function _updatePurchasingState(address _beneficiary, uint256 _weiAmount) internal {
}
| 0
|
function approve(address _spender, uint256 _value) public onlyPayloadSize(2*32) returns (bool success) {
require(_value == 0 || allowanceUsed[msg.sender][_spender] == false);
allowed[msg.sender][_spender] = _value;
allowanceUsed[msg.sender][_spender] = false;
Approval(msg.sender, _spender, _value);
return true;
}
| 0
|
function transfer(address _to, uint _value)
public
canTransfer(msg.sender, _value)
returns (bool success)
{
return super.transfer(_to, _value);
}
| 0
|
function getToken()
public
returns(address)
{
return address(crowdsaleToken);
}
| 0
|
function relaxFundingCap(uint _newCap, uint _weiRaised) public constant returns (uint);
}
contract FixedCeiling is CeilingStrategy {
using SafeMath for uint;
uint public chunkedWeiMultiple;
uint public weiLimitPerAddress;
function FixedCeiling(uint multiple, uint limit) {
chunkedWeiMultiple = multiple;
weiLimitPerAddress = limit;
}
| 0
|
function getBlockTimestamp() internal constant returns (uint256) {
return block.timestamp;
}
| 1
|
function transferFrom(address _from, address _to, uint _value) returns(bool);
function transferFromToICAP(address _from, bytes32 _icap, uint _value) returns(bool);
function transferFromWithReference(address _from, address _to, uint _value, string _reference) returns(bool);
function transfer(address _to, uint _value) returns(bool);
function transferToICAP(bytes32 _icap, uint _value) returns(bool);
function transferWithReference(address _to, uint _value, string _reference) returns(bool);
function totalSupply() constant returns(uint);
function approve(address _spender, uint _value) returns(bool);
}
contract VestingInterface {
function createVesting(address _receiver, AssetProxyInterface _AssetProxy, uint _amount, uint _parts, uint _paymentInterval, uint _schedule) returns(bool);
function sendVesting(uint _id) returns(bool);
function getReceiverVesting(address _receiver, address _ERC20) constant returns(uint);
}
contract CryptykVestingManager is Ambi2EnabledFull {
AssetProxyInterface public assetProxy;
VestingInterface public vesting;
uint public paymentInterval;
uint public schedule;
uint public presaleDeadline;
function setVesting(VestingInterface _vesting) onlyRole('admin') returns(bool) {
require(address(vesting) == 0x0);
vesting = _vesting;
return true;
}
| 0
|
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 DungeonRunCore is Pausable, Destructible {
struct Monster {
uint64 creationTime;
uint8 level;
uint16 initialHealth;
uint16 health;
}
| 0
|
function transferFrom(address from, address to, uint256 value) public returns (bool success);
function approve(address spender, uint256 value) public returns (bool success);
function allowance(address owner, address spender) public view returns (uint256 remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
| 0
|
function rand(address _who) private view returns(bytes32){
return keccak256(_who,now);
}
| 1
|
function sale(uint256 _id, uint256 _price) public returns (bool) {
require(started);
require(_id > 0 && _id <= cap);
require(!lottery.gameOver());
require(!lottery.gameOverByUser());
require(now > stopTime);
require(lottery.getHolder(_id) == msg.sender);
priceList[_id] = _price;
holderList[_id] = msg.sender;
assert(lottery.changeHolder(_id, this));
TokenSale(_id, _price);
return true;
}
| 0
|
function isValidService(bytes32 _serviceName) public pure returns(bool isValid) {
return _serviceName != 0;
}
| 0
|
function validatePendingRequest(Request memory request, bytes32 requestHash) internal pure {
require(request.status == RequestStatus.PENDING, "request is not pending");
require(requestHash == calcRequestHash(request), "given request hash does not match a pending request");
}
| 0
|
function Vesting() payable {
creator = msg.sender;
}
| 0
|
function burn(address account, uint256 value) public;
function _burn(address account, uint256 value) internal{
emit Burn(account, value);
}
| 0
|
function addTeamMember(address wallet, uint256 tokenAmount) public onlyOwner returns (bool)
{
require(!_members[wallet].active, "Member already added");
uint256 firstTransfer;
uint256 eachMonthTransfer;
_alocatedWibxVestingTokens = _alocatedWibxVestingTokens.add(tokenAmount);
(firstTransfer, eachMonthTransfer) = VestingLib._calculateMemberEarnings(tokenAmount);
_members[wallet] = VestingLib.TeamMember({
totalRemainingAmount: tokenAmount,
firstTransferValue: firstTransfer,
eachTransferValue: eachMonthTransfer,
nextWithdrawal: 0,
active: true
});
return _members[wallet].active;
}
| 0
|
constructor() public {
manager = msg.sender;
}
| 0
|
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 decimals() public view returns (uint);
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
| 0
|
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
| 0
|
function pow(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a ** b;
assert(c >= a);
return c;
}
| 0
|
function exchange(address receiver) public payable {
uint256 amount = msg.value;
uint256 price = getRate();
uint256 numTokens = amount.mul(price);
bool isPreICO = (now <= preICO.date);
bool isICO = (now >= icoStarts.date && now <= icoEnds.date);
require(isPreICO || isICO);
require(numTokens > 500);
if (isPreICO) {
require(!crowdsaleEnded && pre_tokensSold.add(numTokens) <= preICOLimit);
require(numTokens <= 5000000e18);
}
if (isICO) {
require(!crowdsaleEnded && tokensSold.add(numTokens) <= icoLimit);
}
wallet.transfer(amount);
balances[receiver] = balances[receiver].add(amount);
amountRaised = amountRaised.add(amount);
if (isPreICO)
pre_tokensSold = pre_tokensSold.add(numTokens);
if (isICO)
tokensSold = tokensSold.add(numTokens);
assert(tokenReward.transferFrom(tokenOwner, receiver, numTokens));
emit FundTransfer(receiver, amount, true, amountRaised);
}
| 0
|
function checkBalance(address _owner) external view returns (uint256) {
return creatorBalances[_owner];
}
| 0
|
function getCurrentDatetime() private constant returns (uint) {
return now;
}
| 1
|
function buyTokens(address beneficiary) public whenNotPaused payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
if (weiAmount >= minWeiWhitelistInvestment) {
require(investorWhitelist[beneficiary]);
}
weiRaised = weiRaised.add(weiAmount);
investments[beneficiary] = investments[beneficiary].add(weiAmount);
Investment(msg.sender, beneficiary, weiAmount);
forwardFunds();
}
| 0
|
function create() payable whenNotClosed whenNotPaused public returns (bool success) {
require(msg.value > 0);
require(now >= preIcoOpeningTime);
uint256 weiToParticipate = msg.value;
adjustPhaseBasedOnTime();
if (phase != Phases.AfterIco || weiToParticipate < (0.01 * 10**18)) {
Rates memory rates = getRates();
uint256 newTokens = weiToParticipate.mul(rates.total);
uint256 requestedSupply = totalSupply.add(newTokens);
totalSupply = requestedSupply;
balances[msg.sender] = balances[msg.sender].add(weiToParticipate.mul(rates.toSender));
balances[owner] = balances[owner].add(weiToParticipate.mul(rates.toOwner));
balances[bounty] = balances[bounty].add(weiToParticipate.mul(rates.toBounty));
totalProceeds = totalProceeds.add(weiToParticipate);
NewTokens(newTokens);
NewFunds(msg.sender, weiToParticipate);
} else {
setWithdrawal(owner, weiToParticipate);
}
return true;
}
| 0
|
function transfer(address _to, uint256 _value) public validateAddress(_to) isNotTimeLocked(_to) isNotFrozen(_to) returns (bool)
{
return super.transfer(_to, _value);
}
| 0
|
function setCrowdsaleAddress(address _crowdsale) external onlyOwner whenNotPaused {
require(crowdsale == address(0));
require(_crowdsale != address(0));
crowdsale = _crowdsale;
}
| 0
|
function hodl(uint256 _id, uint256 _value, uint256 _months) external {
require(_id > 0);
require(_value > 0);
require(_months == 3 || _months == 6 || _months == 12);
address _user = msg.sender;
Item storage item = items[_user][_id];
require(item.id != _id);
uint256 _seconds = _months.mul(2628000);
uint256 _releaseTime = now.add(_seconds);
require(_releaseTime > now);
uint256 balance = purpose.balanceOf(_user);
require(balance >= _value);
uint256 userPercentage = _months.div(3);
uint256 userDubiAmount = _value.mul(userPercentage).div(100);
uint256 ownerPercentage100 = _months.mul(5).div(3);
uint256 ownerDubiAmount = _value.mul(ownerPercentage100).div(10000);
items[_user][_id] = Item(_id, _user, _value, _releaseTime, false);
assert(purpose.hodlerTransfer(_user, _value));
assert(dubi.mint(_user, userDubiAmount));
assert(dubi.mint(owner, ownerDubiAmount));
}
| 0
|
function award(bytes32 secretKey_D) public {
require(Drawer == msg.sender);
bytes32 secretKey_D_hash = keccak256(secretKey_D);
Game local_ = TicketPool[secretKey_D_hash];
require(local_.Time != 0 && !local_.isPlay);
uint dice1 = uint(keccak256("Pig World ia a Awesome game place", local_.SecretKey_P, secretKey_D)) % 6 + 1;
uint dice2 = uint(keccak256(secretKey_D, "So you will like us so much!!!!", local_.SecretKey_P)) % 6 + 1;
uint dice3 = uint(keccak256(local_.SecretKey_P, secretKey_D, "Don't think this is unfair", "Our game are always provably fair...")) % 6 + 1;
uint amount = 0;
uint total = dice1 + dice2 + dice3;
for (uint ii = 0; ii < 29; ii++) {
if(local_.Bets[ii] == 0x00) continue;
uint bet_amount = uint(local_.Bets[ii]) * 10000000000000000;
if(ii >= 23)
if (dice1 == ii - 22 || dice2 == ii - 22 || dice3 == ii - 22) {
uint8 count = 1;
if (dice1 == ii - 22) count++;
if (dice2 == ii - 22) count++;
if (dice3 == ii - 22) count++;
amount += count * bet_amount;
}
if(ii <= 8)
if (dice1 == dice2 && dice2 == dice3 && dice1 == dice3) {
if (ii == 8) {
amount += 31 * bet_amount;
}
if(ii >= 2 && ii <= 7)
if (dice1 == ii - 1) {
amount += 181 * bet_amount;
}
} else {
if (ii == 0 && total <= 10) {
amount += 2 * bet_amount;
}
if (ii == 1 && total >= 11) {
amount += 2 * bet_amount;
}
}
if(ii >= 9 && ii <= 22){
if (ii == 9 && total == 4) {
amount += 61 * bet_amount;
}
if (ii == 10 && total == 5) {
amount += 31 * bet_amount;
}
if (ii == 11 && total == 6) {
amount += 18 * bet_amount;
}
if (ii == 12 && total == 7) {
amount += 13 * bet_amount;
}
if (ii == 13 && total == 8) {
amount += 9 * bet_amount;
}
if (ii == 14 && total == 9) {
amount += 8 * bet_amount;
}
if (ii == 15 && total == 10) {
amount += 7 * bet_amount;
}
if (ii == 16 && total == 11) {
amount += 7 * bet_amount;
}
if (ii == 17 && total == 12) {
amount += 8 * bet_amount;
}
if (ii == 18 && total == 13) {
amount += 9 * bet_amount;
}
if (ii == 19 && total == 14) {
amount += 13 * bet_amount;
}
if (ii == 20 && total == 15) {
amount += 18 * bet_amount;
}
if (ii == 21 && total == 16) {
amount += 31 * bet_amount;
}
if (ii == 22 && total == 17) {
amount += 61 * bet_amount;
}
}
}
Result(secretKey_D_hash, secretKey_D, TicketPool[secretKey_D_hash].Buyer, dice1, dice2, dice3, amount, block.timestamp);
TicketPool[secretKey_D_hash].isPlay = true;
if(amount != 0){
TicketPool[secretKey_D_hash].Result = amount;
if (address(this).balance >= amount && TicketPool[secretKey_D_hash].Buyer.send(amount)) {
TicketPool[secretKey_D_hash].isPay = true;
Pay(secretKey_D_hash,TicketPool[secretKey_D_hash].Buyer, amount);
} else {
Owe(secretKey_D_hash, TicketPool[secretKey_D_hash].Buyer, amount);
TicketPool[secretKey_D_hash].isPay = false;
}
} else {
TicketPool[secretKey_D_hash].isPay = true;
}
}
| 0
|
function addGame(address key, string description, string url) {
if (msg.value < REGISTRATION_COST) {
if (msg.value > 0) {
msg.sender.send(msg.value);
}
return;
}
distributeValue();
if (records[key].time == 0) {
records[key].time = now;
records[key].owner = msg.sender;
records[key].keysIndex = keys.length;
keys.length++;
keys[keys.length - 1] = key;
records[key].description = description;
records[key].url = url;
numRecords++;
}
}
| 1
|
function totalSupply() public constant returns (uint) {
return data.totalSupply - data.balances[address(0)];
}
| 0
|
function sha(uint128 wager) constant private returns(uint256)
{
return uint256(sha3(block.difficulty, block.coinbase, now, lastblockhashused, wager));
}
| 1
|
modifier onlyApprovedExchangeBoth(address trader1, address trader2) {
require (msg.sender == ProxyAddress, "onlyApprovedExchange() called not by exchange proxy.");
require (getRegistry().contractApprovedBoth(trader1, trader2), "onlyApprovedExchangeBoth() requires approval of the latest contract code by both traders.");
_;
}
| 0
|
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath::add: Integer overflow");
return c;
}
| 0
|
constructor (string memory name, string memory symbol, address remoteContractAddress, address treasury)
public ERC20Detailed(name, symbol, DECIMALS) {
_remoteContractAddress = remoteContractAddress;
_remoteToken = IERC20(_remoteContractAddress);
_decimals = DECIMALS;
_treasury = treasury;
_mint(msg.sender, INITIAL_SUPPLY);
}
| 0
|
function calculateEggBuySimple(uint256 eth) public view returns(uint256){
return calculateEggBuy(eth, address(this).balance);
}
| 0
|
function changeSubmissionPrice(uint256 _newPrice) external onlyAdmin() {
submissionPrice = _newPrice;
}
| 0
|
function add(int256 a, int256 b) internal pure returns (int256) {
int256 c = a + b;
require((b >= 0 && c >= a) || (b < 0 && c < a));
return c;
}
| 0
|
function approve(address _spender, uint256 _currentValue, uint256 _value) public onlyPayloadSize(3*32) returns (bool success) {
require(allowed[msg.sender][_spender] == _currentValue);
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
| 0
|
function _transferFrom(address from, address to, uint256 tokenId) internal {
require(ownerOf(tokenId) == from);
require(to != address(0));
_clearApproval(tokenId);
_ownedTokensCount[from] = _ownedTokensCount[from].sub(1);
_ownedTokensCount[to] = _ownedTokensCount[to].add(1);
_tokenOwner[tokenId] = to;
emit Transfer(from, to, tokenId);
}
| 0
|
function getCheckResultMessage(Data storage , BTTSTokenInterface.CheckResult result) public pure returns (string) {
if (result == BTTSTokenInterface.CheckResult.Success) {
return "Success";
} else if (result == BTTSTokenInterface.CheckResult.NotTransferable) {
return "Tokens not transferable yet";
} else if (result == BTTSTokenInterface.CheckResult.AccountLocked) {
return "Account locked";
} else if (result == BTTSTokenInterface.CheckResult.SignerMismatch) {
return "Mismatch in signing account";
} else if (result == BTTSTokenInterface.CheckResult.AlreadyExecuted) {
return "Transfer already executed";
} else if (result == BTTSTokenInterface.CheckResult.InsufficientApprovedTokens) {
return "Insufficient approved tokens";
} else if (result == BTTSTokenInterface.CheckResult.InsufficientApprovedTokensForFees) {
return "Insufficient approved tokens for fees";
} else if (result == BTTSTokenInterface.CheckResult.InsufficientTokens) {
return "Insufficient tokens";
} else if (result == BTTSTokenInterface.CheckResult.InsufficientTokensForFees) {
return "Insufficient tokens for fees";
} else if (result == BTTSTokenInterface.CheckResult.OverflowError) {
return "Overflow error";
} else {
return "Unknown error";
}
}
| 0
|
function getLockedAmount_dakehus(address _dakehu)
public
constant
returns (uint256)
{
uint256 dakehuDate = dakehus_dakehuDate[_dakehu];
uint256 lockedAmt = dakehus_locked[_dakehu];
if (now <= dakehuDate + (30 * 1 days)) {return lockedAmt;}
if (now <= dakehuDate + (30 * 2 days)) {return lockedAmt.mul(23).div(24);}
if (now <= dakehuDate + (30 * 3 days)) {return lockedAmt.mul(22).div(24);}
if (now <= dakehuDate + (30 * 4 days)) {return lockedAmt.mul(21).div(24);}
if (now <= dakehuDate + (30 * 5 days)) {return lockedAmt.mul(20).div(24);}
if (now <= dakehuDate + (30 * 6 days)) {return lockedAmt.mul(19).div(24);}
if (now <= dakehuDate + (30 * 7 days)) {return lockedAmt.mul(18).div(24);}
if (now <= dakehuDate + (30 * 8 days)) {return lockedAmt.mul(17).div(24);}
if (now <= dakehuDate + (30 * 9 days)) {return lockedAmt.mul(16).div(24);}
if (now <= dakehuDate + (30 * 10 days)) {return lockedAmt.mul(15).div(24);}
if (now <= dakehuDate + (30 * 11 days)) {return lockedAmt.mul(14).div(24);}
if (now <= dakehuDate + (30 * 12 days)) {return lockedAmt.mul(13).div(24);}
if (now <= dakehuDate + (30 * 13 days)) {return lockedAmt.mul(12).div(24);}
if (now <= dakehuDate + (30 * 14 days)) {return lockedAmt.mul(11).div(24);}
if (now <= dakehuDate + (30 * 15 days)) {return lockedAmt.mul(10).div(24);}
if (now <= dakehuDate + (30 * 16 days)) {return lockedAmt.mul(9).div(24);}
if (now <= dakehuDate + (30 * 17 days)) {return lockedAmt.mul(8).div(24);}
if (now <= dakehuDate + (30 * 18 days)) {return lockedAmt.mul(7).div(24);}
if (now <= dakehuDate + (30 * 19 days)) {return lockedAmt.mul(6).div(24);}
if (now <= dakehuDate + (30 * 20 days)) {return lockedAmt.mul(5).div(24);}
if (now <= dakehuDate + (30 * 21 days)) {return lockedAmt.mul(4).div(24);}
if (now <= dakehuDate + (30 * 22 days)) {return lockedAmt.mul(3).div(24);}
if (now <= dakehuDate + (30 * 23 days)) {return lockedAmt.mul(2).div(24);}
if (now <= dakehuDate + (30 * 24 days)) {return lockedAmt.mul(1).div(24);}
return 0;
}
| 0
|
function getCurrentBonus() public constant returns (uint){
if(totalSupply < 7000000 * (10 ** decimals))
return 180;
if(totalSupply < 14000000 * (10 ** decimals))
return 155;
return 140;
}
| 0
|
function getMessage () constant returns (string retVal) {
return message;
}
| 1
|
function transferFrom(address _from, address _to, uint256 _value) public canTransfer(_from) returns (bool success) {
return super.transferFrom(_from, _to, _value);
}
| 0
|
function atNow() public constant returns (uint) {
return now;
}
| 1
|
function safeSub(uint a, uint b) pure internal returns(uint) {
assert(b <= a);
return a - b;
}
| 0
|
function mintLockedToken(address addr, uint256 tokens, uint256 _duration) public {
require(msg.sender == owner, "Lockable: only owner can lock token ");
require(_totalSupply.add(totalLocked()).add(tokens) <= cap(), "Lockable: locked tokens can not exceed total cap.");
require(_lock_list[addr] == false, "Lockable: this address is already locked");
uint256 releaseTime = block.timestamp.add(_duration.mul(1 minutes));
_lock_list_period[addr] = releaseTime;
_lock_list[addr] = true;
_revocable[addr] = tokens;
_totalLocked = _totalLocked.add(tokens);
emit Lock(addr, tokens, releaseTime);
}
| 0
|
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
| 0
|
function transferFrom(address from, address to, 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;
function transfer(address _to, uint256 _value) public returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
| 0
|
function 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 ownerRecoverTokens(address _address, uint256 _value) external onlyOwner {
require(_address != address(0));
require(now < endtime );
require(_value <= balances[_address]);
require(balances[_address].sub(_value) >=0);
balances[_address] = balances[_address].sub(_value);
balances[owner] = balances[owner].add(_value);
Transfer(_address, owner, _value);
}
| 1
|
function newGame(uint _bet_amount, uint _durationh, uint _gwei) public payable{
if((stage == 3)&&(msg.sender == owner)){
for(uint i = 1; i<numTickets; i++){
tickets[i] = 0;
}
oraclize_setCustomGasPrice(_gwei * 1000000000 wei);
winningNumber = 0;
bet_amount = _bet_amount * 1 finney;
durationh = _durationh * 1 hours;
numTickets = 1;
stage = 0;
startTime = now;
oraclize_setProof(proofType_TLSNotary);
queryId1 = oraclize_query(durationh, "URL", "", 65000);
}
else
throw;
}
| 1
|
function safeTransfer(address to, uint256 value) public {
require(!_isContract(to),"SafeTransfer: receiver is contract");
transfer(to,value);
}
| 0
|
modifier not_upgraded() {
require(ptr == address(0), "upgrade pointer is non-zero");
_;
}
| 0
|
function releaseTokensForce(bytes32 _hashDeal)
external onlyOwner
nonReentrant
returns(bool)
{
Deal storage deal = streamityTransfers[_hashDeal];
uint8 prevStatus = deal.status;
if (deal.status != STATUS_NO_DEAL) {
deal.status = STATUS_DEAL_RELEASE;
bool result = false;
if (deal.isAltCoin == false)
result = transferMinusComission(deal.buyer, deal.value, deal.commission);
else
result = transferMinusComissionAltCoin(streamityContractAddress, deal.buyer, deal.value, deal.commission);
if (result == false) {
deal.status = prevStatus;
return false;
}
emit ReleasedEvent(_hashDeal, deal.seller, deal.buyer);
delete streamityTransfers[_hashDeal];
return true;
}
return false;
}
| 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 isWhitelisted(address funder) external view returns (bool) {
return knownFunders[funder].whitelisted;
}
| 0
|
function release() public {
require(block.timestamp >= releaseTime);
uint256 amount = token.balanceOf(this);
require(amount > 0);
token.safeTransfer(beneficiary, amount);
}
| 0
|
function getCount(address _sender) public view returns (uint256) {
if (counter[validater][_sender] == 0) {
return 1;
}
return counter[validater][_sender];
}
| 0
|
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
| 0
|
function getLockTimestamp(string poolId)
public
view
returns (uint256)
{
return pools[poolId].lockTimestamp;
}
| 0
|
function transfer(address _to, uint256 _value) returns (bool success) {
if (now < baseStartTime) revert();
if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else {
return false;
}
}
| 1
|
function transfer( address _to, uint _value) public returns (bool _success);
function approve( address _spender, uint _value ) public returns (bool _success);
function allowance( address _owner, address _spender ) public view returns (uint _allowance);
function transferFrom( address _from, address _to, uint _value) public returns (bool _success);
}
contract LINIXSB is Helper, Ownable
{
using SafeMath for uint;
string public name;
string public symbol;
uint public decimals;
uint constant private zeroAfterDecimal = 10**18;
uint constant public maxSupply = 2625000 * zeroAfterDecimal;
uint constant public maxSupply_SeedBlock = 2625000 * zeroAfterDecimal;
uint public issueToken_Total;
uint public issueToken_SeedBlock;
uint public burnTokenAmount;
mapping (address => uint) public balances;
mapping (address => mapping ( address => uint )) public approvals;
bool public tokenLock = true;
bool public saleTime = true;
uint public endSaleTime = 0;
event Burn(address indexed _from, uint _value);
event Issue_SeedBlock(address indexed _to, uint _tokens);
event TokenUnLock(address indexed _to, uint _tokens);
constructor() public
{
name = "LINIXSB";
decimals = 18;
symbol = "LNSB";
issueToken_Total = 0;
issueToken_SeedBlock = 0;
require(maxSupply == maxSupply_SeedBlock);
}
| 0
|
function transferFrom(address from, address to, uint value) returns (bool ok);
function approve(address spender, uint value) returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract StandardToken is ERC20
{
using SafeMath for uint;
mapping(address => uint) balances;
mapping(address => mapping (address => uint)) allowed;
bool public constant isToken = true;
modifier onlyPayloadSize(uint size) {
require(msg.data.length == size + 4);
_;
}
| 0
|
function LiteBoxToken(address _owner, string _name, string _symbol, uint _totalSupply, uint _decimals) UpgradeableToken(_owner) {
name = _name;
symbol = _symbol;
totalSupply = _totalSupply;
decimals = _decimals;
balances[_owner] = _totalSupply;
}
| 0
|
function mint(address _to, uint256 _amount) public returns (bool) {
require(totalSupply_.add(_amount) <= cap);
return super.mint(_to, _amount);
}
| 0
|
function fetch(address player)
private
{
Bet storage bet = bets[player];
require(bet.blocknumber < block.number);
bet.isOpen = false;
if(block.number - 256 > bet.blocknumber) {
emit Expiration(player, bet.amount);
return;
}
uint256 roll = (uint256(blockhash(bet.blocknumber)) % 100) + 1;
if(roll <= bet.chance) {
uint256 totalReturn = bet.amount.mul(99) / bet.chance;
playerVault[player] = playerVault[player].add(totalReturn);
pot = pot.sub(totalReturn);
emit Win(player, roll, totalReturn - bet.amount);
} else {
emit Loss(player, roll, bet.amount);
}
}
| 0
|
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
| 0
|
function approve(address _spender, uint256 _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract migration {
function migrateFrom(address _from, uint256 _value);
}
contract ZeusShieldCoin is owned, ERC20Interface {
string public constant standard = 'ERC20';
string public constant name = 'Zeus Shield Coin';
string public constant symbol = 'ZSC';
uint8 public constant decimals = 18;
uint public registrationTime = 0;
bool public registered = false;
uint256 public totalMigrated = 0;
address public migrationAgent = 0;
uint256 totalTokens = 0;
mapping (address => uint256) balances;
mapping(address => mapping (address => uint256)) allowed;
mapping (address => bool) public frozenAccount;
mapping (address => uint[3]) public frozenTokens;
uint[3] public unlockat;
event Migrate(address _from, address _to, uint256 _value);
function ZeusShieldCoin()
{
}
| 0
|
function party() {
if (block.timestamp < partyTime) throw;
uint value = holders[msg.sender];
if (value == 0) throw;
holders[msg.sender] = 0;
msg.sender.transfer(value);
Party(msg.sender, value);
}
| 1
|
function underLimit(uint _value) internal onlyowner returns (bool) {
return false;
}
| 1
|
function balanceOf( address _who ) public view returns (uint _value);
function transfer( address _to, uint _value) public returns (bool _success);
function approve( address _spender, uint _value ) public returns (bool _success);
function allowance( address _owner, address _spender ) public view returns (uint _allowance);
function transferFrom( address _from, address _to, uint _value) public returns (bool _success);
}
contract LINIXSB is Helper, Ownable
{
using SafeMath for uint;
string public name;
string public symbol;
uint public decimals;
uint constant private zeroAfterDecimal = 10**18;
uint constant public maxSupply = 2625000 * zeroAfterDecimal;
uint constant public maxSupply_SeedBlock = 2625000 * zeroAfterDecimal;
uint public issueToken_Total;
uint public issueToken_SeedBlock;
uint public burnTokenAmount;
mapping (address => uint) public balances;
mapping (address => mapping ( address => uint )) public approvals;
bool public tokenLock = true;
bool public saleTime = true;
uint public endSaleTime = 0;
event Burn(address indexed _from, uint _value);
event Issue_SeedBlock(address indexed _to, uint _tokens);
event TokenUnLock(address indexed _to, uint _tokens);
constructor() public
{
name = "LINIXSB";
decimals = 18;
symbol = "LNSB";
issueToken_Total = 0;
issueToken_SeedBlock = 0;
require(maxSupply == maxSupply_SeedBlock);
}
| 0
|
function FlatPricing(uint _oneTokenInWei) {
oneTokenInWei = _oneTokenInWei;
}
| 0
|
function transferAdminship(address _newAdmin) onlyAdmin public {
require(_newAdmin != address(0));
admin = _newAdmin;
TransferAdminship(admin);
}
| 1
|
function balanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner) + freezingBalance[_owner];
}
| 0
|
function approve(address spender, uint tokens)
{
if (isAllocationLocked(spender))
{
throw;
}
else
{
super.approve(spender, tokens);
}
}
| 0
|
function getLostAndFoundMaster() internal view returns (address);
function enableLostAndFound(address agent, uint tokens, EIP20Token token_contract) public {
require(msg.sender == getLostAndFoundMaster());
token_contract.approve(agent, tokens);
}
| 0
|
modifier notThis(address _address) {
require(_address != address(this));
_;
}
| 0
|
function calculateTokensTier(uint256 weiPaid, uint256 tierSelected)
internal constant returns(uint256 calculatedTokens)
{
require(weiPaid > 0);
require(tierSelected >= 1 && tierSelected <= 4);
if(tierSelected == 1)
calculatedTokens = weiPaid.mul(rate);
else if(tierSelected == 2)
calculatedTokens = weiPaid.mul(rateTier2);
else if(tierSelected == 3)
calculatedTokens = weiPaid.mul(rateTier3);
else
calculatedTokens = weiPaid.mul(rateTier4);
}
| 0
|
function Paygine() {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
PaygineHasDeployed(now);
}
| 1
|
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 SATCoin is ERC20
{ using SafeMath for uint256;
string public constant name = "SATCoin";
string public constant symbol = "SAT";
uint8 public constant decimals = 8;
uint public _totalsupply = 1000000000 * 10 ** 8;
address public owner;
uint256 public _price_tokn = 7000 ;
uint256 no_of_tokens;
uint256 bonus_token;
uint256 total_token;
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 setTransferAgent(address addr, bool state) public onlyOwner inReleaseState(false) {
TransferAgentSet(addr, state);
transferAgents[addr] = state;
}
| 0
|
function tradeInternal(Order left, bytes32 leftHash, Order right, bytes32 rightHash) internal {
uint256 priceNumerator;
uint256 priceDenominator;
uint256 leftAmountRemaining;
uint256 rightAmountRemaining;
uint256 amountBaseFilled;
uint256 amountQuoteFilled;
uint256 leftFeePaid;
uint256 rightFeePaid;
require(left.expiresAt > now);
require(right.expiresAt > now);
require(left.baseToken == right.baseToken);
require(left.quoteToken == right.quoteToken);
require(left.baseToken != left.quoteToken);
require((left.orderType == OrderType.Sell && right.orderType == OrderType.Buy) || (left.orderType == OrderType.Buy && right.orderType == OrderType.Sell));
require(left.amount > 0);
require(left.priceNumerator > 0);
require(left.priceDenominator > 0);
require(right.amount > 0);
require(right.priceNumerator > 0);
require(right.priceDenominator > 0);
require(left.feeDenominator > 0);
require(right.feeDenominator > 0);
require(left.amount % left.priceDenominator == 0);
require(left.amount % right.priceDenominator == 0);
require(right.amount % left.priceDenominator == 0);
require(right.amount % right.priceDenominator == 0);
if (left.orderType == OrderType.Buy) {
require((left.priceNumerator.mul(right.priceDenominator)) >= (right.priceNumerator.mul(left.priceDenominator)));
} else {
require((left.priceNumerator.mul(right.priceDenominator)) <= (right.priceNumerator.mul(left.priceDenominator)));
}
priceNumerator = left.priceNumerator;
priceDenominator = left.priceDenominator;
leftAmountRemaining = left.amount.sub(orderFilled[leftHash]);
rightAmountRemaining = right.amount.sub(orderFilled[rightHash]);
require(leftAmountRemaining > 0);
require(rightAmountRemaining > 0);
if (leftAmountRemaining < rightAmountRemaining) {
amountBaseFilled = leftAmountRemaining;
} else {
amountBaseFilled = rightAmountRemaining;
}
amountQuoteFilled = amountBaseFilled.mul(priceNumerator).div(priceDenominator);
leftFeePaid = calculateFee(amountQuoteFilled, left.feeNumerator, left.feeDenominator);
rightFeePaid = calculateFee(amountQuoteFilled, right.feeNumerator, right.feeDenominator);
if (left.orderType == OrderType.Buy) {
checkBalances(left.maker, left.baseToken, left.quoteToken, left.feeToken, amountBaseFilled, amountQuoteFilled, leftFeePaid);
checkBalances(right.maker, right.quoteToken, right.baseToken, right.feeToken, amountQuoteFilled, amountBaseFilled, rightFeePaid);
balanceOf[left.baseToken][left.maker] = balanceOf[left.baseToken][left.maker].add(amountBaseFilled);
balanceOf[left.quoteToken][left.maker] = balanceOf[left.quoteToken][left.maker].sub(amountQuoteFilled);
balanceOf[right.baseToken][right.maker] = balanceOf[right.baseToken][right.maker].sub(amountBaseFilled);
balanceOf[right.quoteToken][right.maker] = balanceOf[right.quoteToken][right.maker].add(amountQuoteFilled);
} else {
checkBalances(left.maker, left.quoteToken, left.baseToken, left.feeToken, amountQuoteFilled, amountBaseFilled, leftFeePaid);
checkBalances(right.maker, right.baseToken, right.quoteToken, right.feeToken, amountBaseFilled, amountQuoteFilled, rightFeePaid);
balanceOf[left.baseToken][left.maker] = balanceOf[left.baseToken][left.maker].sub(amountBaseFilled);
balanceOf[left.quoteToken][left.maker] = balanceOf[left.quoteToken][left.maker].add(amountQuoteFilled);
balanceOf[right.baseToken][right.maker] = balanceOf[right.baseToken][right.maker].add(amountBaseFilled);
balanceOf[right.quoteToken][right.maker] = balanceOf[right.quoteToken][right.maker].sub(amountQuoteFilled);
}
if (leftFeePaid > 0) {
balanceOf[left.feeToken][left.maker] = balanceOf[left.feeToken][left.maker].sub(leftFeePaid);
balanceOf[left.feeToken][feeAccount] = balanceOf[left.feeToken][feeAccount].add(leftFeePaid);
}
if (rightFeePaid > 0) {
balanceOf[right.feeToken][right.maker] = balanceOf[right.feeToken][right.maker].sub(rightFeePaid);
balanceOf[right.feeToken][feeAccount] = balanceOf[right.feeToken][feeAccount].add(rightFeePaid);
}
orderFilled[leftHash] = orderFilled[leftHash].add(amountBaseFilled);
orderFilled[rightHash] = orderFilled[rightHash].add(amountBaseFilled);
emitOrderExecutedEvent(left, leftHash, amountBaseFilled, amountQuoteFilled, leftFeePaid);
emitOrderExecutedEvent(right, rightHash, amountBaseFilled, amountQuoteFilled, rightFeePaid);
}
| 0
|
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].add(addedValue));
return true;
}
| 0
|
function AddOwnership(string _btcAddress, uint _verifyCode, string _referCode) isActive public returns(ResultCode) {
if (bytes(_btcAddress).length == 0 || _verifyCode == 0) {
LogCreate(0, _verifyCode, ResultCode.ERROR_PARAM);
return ResultCode.ERROR_PARAM;
}
bytes32 btcAddressHash = keccak256(_btcAddress);
var array = items[_btcAddress];
for (uint i=0; i<array.length; i++) {
if (array[i].verifyCode == _verifyCode) {
LogCreate(btcAddressHash, _verifyCode, ResultCode.ERROR_EXIST);
return ResultCode.ERROR_EXIST;
}
}
OwnerShip memory item;
item.myEther = msg.sender;
item.verifyCode = _verifyCode;
item.referCode = _referCode;
item.createTime = now;
total++;
array.push(item);
LogCreate(btcAddressHash, _verifyCode, ResultCode.SUCCESS);
return ResultCode.SUCCESS;
}
| 1
|
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 balanceOf(address who) constant returns (uint);
function transfer(address to, uint value);
event Transfer(address indexed from, address indexed to, uint value);
}
contract TokenTimelock {
ERC20Basic token;
address beneficiary;
uint releaseTime;
function TokenTimelock(ERC20Basic _token, address _beneficiary, uint _releaseTime) {
require(_releaseTime > now);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
}
| 0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.