function
string | label
int64 |
|---|---|
function add_referral(address referral, string promo, uint256 amount) external returns(address partner, uint256 p_partner, uint256 p_referral){
p_partner = 0;
p_referral = 0;
partner = address(0x0);
if (msg.sender == contractPreICO || msg.sender == contractICO){
if(partnersPromo[promo] != address(0x0) && partnersPromo[promo] != referral){
partner = partnersPromo[promo];
referrals[referral] += amount;
amount_referral_invest += amount;
partnersInfo[partnersPromo[promo]].balance += amount;
history[partnersPromo[promo]].push(itemHistory(now, referral, amount));
p_partner = (amount*uint256(calc_partnerPercent(amount)))/10000;
p_referral = (amount*ref_percent)/10000;
}
}
}
| 1
|
function div(uint a, uint b) internal pure returns (uint c) {
require(b > 0);
c = a / b;
}
| 0
|
function pressButton() public onlyWhenStarted payable {
require(msg.value == 10000000000000000 && block.number <= targetBlock);
lastPresser = msg.sender;
targetBlock = targetBlock + 240;
pressCount++;
Pressed(msg.sender, now);
}
| 1
|
function isOwner(address _node, address _owner) constant returns(bool) {
return hasRole(_node, OWNER, _owner);
}
| 0
|
function refund()
public
{
}
| 0
|
function GiveRocketInternal(uint16 stock_id, address target, bool buying, address referrer) internal
{
RocketTypes.StockRocket storage stock_rocket = m_InitialRockets[stock_id];
require(stock_rocket.m_IsValid);
if (buying)
{
require(msg.value == stock_rocket.m_Cost);
}
GlobalTypes.Global memory global = GlobalTypes.DeserializeGlobal(m_Database.Load(NullAddress, GlobalCategory, 0));
uint256 profit_funds = uint256(m_Database.Load(NullAddress, ProfitFundsCategory, 0));
global.m_LastRocketId++;
uint32 next_rocket_id = global.m_LastRocketId;
uint256 inventory_count = GetInventoryCount(target);
inventory_count++;
RocketTypes.Rocket memory rocket;
rocket.m_Version = 1;
rocket.m_StockId = stock_id;
rocket.m_IsForSale = 0;
bytes32 rand = sha256(block.timestamp, block.coinbase, global.m_LastRocketId);
rocket.m_TopSpeed = uint32(Lerp(stock_rocket.m_MinTopSpeed, stock_rocket.m_MaxTopSpeed, rand[0]));
rocket.m_Thrust = uint32(Lerp(stock_rocket.m_MinThrust, stock_rocket.m_MaxThrust, rand[1]));
rocket.m_Weight = uint32(Lerp(stock_rocket.m_MinWeight, stock_rocket.m_MaxWeight, rand[2]));
rocket.m_FuelCapacity = uint32(Lerp(stock_rocket.m_MinFuelCapacity, stock_rocket.m_MaxFuelCapacity, rand[3]));
rocket.m_MaxDistance = uint64(stock_rocket.m_Distance);
OwnershipTypes.Ownership memory ownership;
ownership.m_Owner = target;
ownership.m_OwnerInventoryIndex = uint32(inventory_count) - 1;
profit_funds += msg.value;
m_Database.Store(target, InventoryCategory, inventory_count, bytes32(next_rocket_id));
m_Database.Store(target, InventoryCategory, 0, bytes32(inventory_count));
m_Database.Store(NullAddress, RocketCategory, next_rocket_id, RocketTypes.SerializeRocket(rocket));
m_Database.Store(NullAddress, OwnershipCategory, next_rocket_id, OwnershipTypes.SerializeOwnership(ownership));
m_Database.Store(NullAddress, GlobalCategory, 0, GlobalTypes.SerializeGlobal(global));
if (buying)
{
m_Database.Store(NullAddress, ProfitFundsCategory, 0, bytes32(profit_funds));
m_Database.transfer(msg.value);
}
BuyStockRocketEvent(target, stock_id, next_rocket_id, referrer);
}
| 1
|
function burn(uint burnAmount) {
address burner = msg.sender;
balances[burner] = balances[burner].sub(burnAmount);
totalSupply = totalSupply.sub(burnAmount);
Burned(burner, burnAmount);
Transfer(burner, BURN_ADDRESS, burnAmount);
}
| 0
|
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 StandardToken is Token {
function transfer(address _to, uint256 _value) returns (bool success) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else {
return false;
}
}
| 0
|
function increaseApproval (address _spender, uint _addedValue)
public returns (bool success)
{
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
| 0
|
function getCurrLocking()
public
view
returns (uint256)
{
uint256 diff = (now - lockupDate) / 2592000;
uint256 partition = 30;
if (diff >= partition)
return 0;
else
return initLockupAmt.mul(partition-diff).div(partition);
}
| 0
|
function _currentDay() internal view returns(uint256) {
return now.sub(startDate).div(ONE_DAY);
}
| 1
|
function activateSaleContract(address saleContractAddress) public onlyOwner {
require(saleContractAddress != address(0));
require(!saleContractActivated);
saleContract = saleContractAddress;
saleContractActivated = true;
_mint(saleContract, _tokensForSale);
_tokensForSale = 0;
emit SaleContractActivation(saleContract, _tokensForSale);
}
| 0
|
function addMinter(address who) returns (bool) {
if (now >= _END_MINTING) throw;
if (!minters[msg.sender]) return false;
minters[who] = true;
MinterAdded(who);
return true;
}
| 0
|
function allowance(address owner, address spender) public constant 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 LockableToken is ERC20 {
function addToTimeLockedList(address addr) external returns (bool);
}
contract VinToken is Contactable {
using SafeMath for uint;
string constant public name = "VIN";
string constant public symbol = "VIN";
uint constant public decimals = 18;
uint constant public totalSupply = (10 ** 9) * (10 ** decimals);
uint constant public lockPeriod1 = 2 years;
uint constant public lockPeriod2 = 24 weeks;
uint constant public lockPeriodForBuyers = 12 weeks;
mapping (address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
bool public isActivated = false;
mapping (address => bool) public whitelistedBeforeActivation;
mapping (address => bool) public isPresaleBuyer;
address public saleAddress;
address public founder1Address;
address public founder2Address;
uint public icoEndTime;
uint public icoStartTime;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint value);
function VinToken(
address _founder1Address,
address _founder2Address,
uint _icoStartTime,
uint _icoEndTime
) public
{
require(_founder1Address != 0x0);
require(_founder2Address != 0x0);
require(_icoEndTime > _icoStartTime);
founder1Address = _founder1Address;
founder2Address = _founder2Address;
icoStartTime = _icoStartTime;
icoEndTime = _icoEndTime;
balances[owner] = totalSupply;
whitelistedBeforeActivation[owner] = true;
}
| 0
|
function buy() payable public {
uint amount = msg.value / buyPrice;
_transfer(this, msg.sender, amount);
}
| 0
|
function transferFrom(address _from, address _to, uint _value) public returns (bool)
{
require(isTransferable() == true);
require(balances[_from] >= _value);
require(approvals[_from][msg.sender] >= _value);
approvals[_from][msg.sender] = approvals[_from][msg.sender].sub(_value);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(_from, _to, _value);
return true;
}
| 0
|
function upgrade(uint256 _value) public {
UpgradeState state = getUpgradeState();
require((state == UpgradeState.ReadyToUpgrade) || (state == UpgradeState.Upgrading));
require(_value > 0);
require(balances[msg.sender] >= _value);
uint256 upgradedAmount = totalUpgraded.add(_value);
uint256 senderBalance = balances[msg.sender];
uint256 newSenderBalance = senderBalance.sub(_value);
uint256 newTotalSupply = totalSupply.sub(_value);
balances[msg.sender] = newSenderBalance;
totalSupply = newTotalSupply;
NewUpgradedAmount(totalUpgraded, newTotalSupply, msg.sender);
totalUpgraded = upgradedAmount;
upgradeAgent.upgradeFrom(msg.sender, _value);
Upgrade(msg.sender, upgradeAgent, _value);
}
| 0
|
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
| 0
|
function allowance(address _owner, address _spender) constant returns (uint256 remaining){
return approved[_owner][_spender];
}
| 0
|
function withdrawTokens() external onlyOwner {
uint256 value = balances[this];
balances[owner] = (balances[owner]).add(value);
balances[this] = 0;
emit Transfer(this, owner, value);
}
| 0
|
function approve(address spender, uint256 value) 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) 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 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);
}
pragma solidity ^0.5.0;
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
| 0
|
function increaseApproval(address _spender, uint256 _addedValue) public erc20Allowed returns (bool) {
allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
| 0
|
function halt() external onlyOwner {
halted = true;
Halted(true);
}
| 0
|
function suspend() public onlyOwner isActive {
state = State.Suspended;
emit ICOSuspended();
}
| 0
|
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
|
constructor(uint256 _startTime, address _wallet, address _tokenAddress) public
{
require(_startTime >=now);
require(_wallet != 0x0);
startTime = _startTime;
endTime = startTime + totalDurationInDays;
require(endTime >= startTime);
owner = _wallet;
maxTokensToSale = uint(15000000000).mul( 10 ** uint256(18));
token = TokenInterface(_tokenAddress);
}
| 0
|
modifier notBeforeTime(uint256 targetTime){
assert(now>targetTime);
_;
}
| 1
|
function plus(uint a, uint b) returns (uint) {
uint c = a + b;
assert(c>=a);
return c;
}
| 0
|
function _attack(uint _heroId, uint _genes, uint _heroStrength, uint _heroCurrentHealth) internal {
Monster storage monster = heroIdToMonster[_heroId];
uint8 currentLevel = monster.level;
uint heroPower;
(heroPower,,,,) = edCoreContract.getHeroPower(_genes, dungeonDifficulty);
if (now > monster.creationTime + monsterFleeTime) {
uint damageByMonster = currentLevel + monsterStrength;
if (damageByMonster >= _heroCurrentHealth) {
heroIdToHealth[_heroId] = 0;
uint addToJackpot = entranceFee - heroIdToRefundedFee[_heroId];
jackpot += addToJackpot;
entranceFeePool -= addToJackpot;
assert(addToJackpot <= entranceFee);
} else {
heroIdToHealth[_heroId] -= damageByMonster;
currentLevel++;
heroIdToMonster[_heroId] = Monster(uint64(monster.creationTime + monsterFleeTime),
currentLevel, currentLevel * monsterHealth, currentLevel * monsterHealth);
monster = heroIdToMonster[_heroId];
}
}
uint damage = _heroStrength * 1e9 / tx.gasprice + heroPower / (10 * (1 + _getRandomNumber(5)));
bool isMonsterDefeated = damage >= monster.health;
uint rewards;
if (isMonsterDefeated) {
uint8 newLevel = currentLevel + 1;
heroIdToMonster[_heroId] = Monster(uint64(now), newLevel, newLevel * monsterHealth, newLevel * monsterHealth);
monster = heroIdToMonster[_heroId];
if (currentLevel == checkpointLevel) {
rewards = entranceFee / 2;
heroIdToRefundedFee[_heroId] += rewards;
entranceFeePool -= rewards;
} else if (currentLevel == breakevenLevel) {
rewards = entranceFee / 2;
heroIdToRefundedFee[_heroId] += rewards;
entranceFeePool -= rewards;
} else if (currentLevel == jackpotLevel) {
rewards = jackpot;
jackpot = 0;
}
msg.sender.transfer(rewards);
} else {
monster.health -= uint8(damage);
}
LogAttack(now, msg.sender, _heroId, currentLevel, damage, isMonsterDefeated, rewards);
}
| 0
|
function has(Role storage role, address addr)
view
internal
returns (bool)
{
return role.bearer[addr];
}
| 0
|
function addSuperAdmin(address _admin) public onlyOwner validateAddress(_admin){
require(!superAdmins[_admin]);
superAdmins[_admin] = true;
emit AddSuperAdmin(_admin);
}
| 0
|
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
FrozenFunds(target, freeze);
}
| 0
|
function set_centralAccount(address central_Acccount) external onlyOwner
{
central_account = central_Acccount;
}
| 0
|
function balanceOf(address _owner) public view returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) 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);
}
contract StandardToken is ERC20 {
using SafeMath for uint;
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) allowed;
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
| 0
|
function withdrawCommisionToAddress(address _to, uint256 _amount) external onlyOwner {
require(_amount <= availableForWithdrawal);
availableForWithdrawal = availableForWithdrawal.sub(_amount);
_to.transfer(_amount);
}
| 0
|
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
emit FrozenFunds(target, freeze);
}
| 0
|
function transferToAddress(address _to, uint256 _value, bytes _data) internal {
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
emit Transfer(msg.sender, _to, _value, _data);
}
| 0
|
function setUpgradeMaster(address master) public {
if (master == 0x0) throw;
if (msg.sender != upgradeMaster) throw;
upgradeMaster = master;
NewUpgradeMaster(upgradeMaster);
}
| 0
|
function allowance(address from, address to) constant returns (uint256 res) {
return DCAssetBackend(backendContract).allowance(from, to);
}
| 0
|
function transfer(address _to, uint256 _amount)public returns (bool success) {
require(!lockstatus, "Token is locked now");
require( _to != 0x0, "Receiver can not be 0x0");
require(balances[msg.sender] >= _amount, "Balance does not have enough tokens");
require(!locked[msg.sender], "Sender address is locked");
balances[msg.sender] = (balances[msg.sender]).sub(_amount);
balances[_to] = (balances[_to]).add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
| 0
|
constructor () public {
highScore = 0;
currentWinner = msg.sender;
lastTimestamp = now;
}
| 0
|
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 DIGI(){
totalSupply=980000000000;
owner = msg.sender;
balances[msg.sender] = (980000000000);
twoWeeksBonusTime=now + 2 * 1 weeks;
thirdWeekBonusTime=twoWeeksBonusTime+1 * 1 weeks;
fourthWeekBonusTime=thirdWeekBonusTime+1 * 1 weeks;
deadLine=fourthWeekBonusTime+1 *1 weeks;
etherRaised=0;
}
| 0
|
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract TokenERC20 {
string public name;
string public symbol;
uint8 public decimals = 18;
uint256 initialSupply=5000000000;
uint256 MAX_CAP = 5000000000;
uint256 public totalSupply;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
function TokenERC20() public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = "Zmbc";
symbol = "ZMB";
}
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function transfer(address _to, uint256 _value) public returns (bool success){
_transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]);
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
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;
}
}
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value);
require(_value <= allowance[_from][msg.sender]);
balanceOf[_from] -= _value;
allowance[_from][msg.sender] -= _value;
totalSupply -= _value;
Burn(_from, _value);
return true;
}
}
| 0
|
function ProofOfExistence(){
manager = msg.sender;
created = "cryptonomica.net";
}
| 1
|
function AlfaToken(address _owner) UpgradeableToken(_owner) {
name = "AlfaToken";
symbol = "ALFA";
totalSupply = 100000000000000000;
decimals = 9;
balances[_owner] = totalSupply;
}
| 0
|
function balanceOf(address _owner) public view returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
}
contract DLSDLockBounty3 {
ERC20BasicInterface constant TOKEN = ERC20BasicInterface(0x8458d484572cEB89ce70EEBBe17Dc84707b241eD);
address constant OWNER = 0x603F65F7Fc4f650c2F025800F882CFb62BF23580;
address constant DESTINATION = 0x3135081dE9aEf677b3d7445e6C44Bb385cBD3E6a;
uint constant UNLOCK_DATE = 1548547199;
function unlock() public returns(bool) {
require(now > UNLOCK_DATE, 'Tokens are still locked');
return TOKEN.transfer(DESTINATION, TOKEN.balanceOf(address(this)));
}
| 0
|
function _advisorsToRelease(address who) internal view returns(uint256) {
uint256 advisorsStage = now.sub(_startTime).div(91 days);
if (advisorsStage > 4) advisorsStage = 4;
uint256 advisorsTokens = advisors[who].mul(advisorsStage).div(4).sub(advisorsReleased[who]);
return advisorsTokens;
}
| 0
|
function ParetoTeamLockup()public {
token = ERC20Basic(0xea5f88E54d982Cbb0c441cde4E79bC305e5b43Bc);
beneficiary = 0x00431934746a504D3C40C20Bc8aF1607EbA9ab4f;
releaseTime = now + 300 days;
}
| 0
|
function submit(bytes32 Bets, bytes32 secretKey_P, bytes32 secretKey_D_hash) payable public {
require(TicketPool[secretKey_D_hash].Time == 0);
require(msg.value >= LimitBottom && msg.value <= LimitTop);
uint bet_total_amount = 0;
for (uint i = 0; i < 29; i++) {
if(Bets[i] == 0x00) continue;
uint bet_amount_ = uint(Bets[i]).mul(10000000000000000);
bet_total_amount = bet_total_amount.add(bet_amount_);
}
if(bet_total_amount == msg.value){
SubmitTicket(secretKey_D_hash, msg.value, Bets, secretKey_P, msg.sender);
TicketPool[secretKey_D_hash] = Game(Bets,secretKey_P,false,false,0,block.timestamp,msg.sender);
}else{
revert();
}
}
| 0
|
function mintToken(address to, uint amount) external returns (bool success);
function balanceOf(address _owner) public view returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
| 0
|
modifier BurnAll()
{
require(now > endIco && balances[owner] > 0);
_;
}
| 1
|
function carnitaAsada(address _manager, address _bitso) public{
addressManager= _manager;
bitsoAddress= _bitso;
lastCarnita=0;
priceCarnita= 0.015 ether;
currentPeople= 8;
toPaycarnita=0.012 ether;
carnita memory temp;
temp.maxPeople=currentPeople;
temp.active=true;
temp.raised=0;
temp.min=priceCarnita;
carnitas.push(temp);
}
| 0
|
function sellTokens() public payable whenSaleIsOpen whenWhitelisted(msg.sender) whenNotPaused {
require(msg.value > minimumInvestment);
uint256 _bonus = bonus(msg.sender);
uint256 _discount = discount();
uint256 tokensAmount = (msg.value).mul(exchangeRate).mul(_bonus.add(100)).div((100 - _discount));
token.transferFromIco(msg.sender, tokensAmount);
tokensSold = tokensSold.add(tokensAmount);
addInvestment(msg.sender, msg.value);
}
| 0
|
function burn() public;
}
contract MonedaICO {
using SafeMath for uint256;
struct DateRate {
uint256 date;
uint256 rate;
}
| 0
|
function initialize() private {
lockList[0xDfa1ebaA05b68B82475Aa737d923eCF3AA8535c5] = 200 * 10 ** 18;
lockList[0x876282c8809c300fB1ab10b451fb21F1600c27F0] = 19574 * 10 ** 18;
lockList[0xa5bC6Eca62ec7bd910753d01e2dD310D465E7a22] = 197903 * 10 ** 18;
lockList[0x71A07b9f65A9008b867584c267D545aFF5c8c68f] = 1014 * 10 ** 18;
lockList[0x0531c9018a7ff16a9c16817ea6bc544d20abf94b] = 11838 * 10 ** 18;
lockList[0x2Ba00DC6Ca55CF9632978D3c38495a8ae52FbeD1] = 2146 * 10 ** 18;
lockList[0xae0b391429b0e2169abe4f030ea3700922e2696b] = 1816 * 10 ** 18;
lockList[0x3d703c1ada6f12b19DF5BC3c3CDd94F6bE16fc0a] = 4470 * 10 ** 18;
lockList[0x819953b03815F529e879AEF3344746942BBBe0cE] = 13087 * 10 ** 18;
lockList[0x290BA7bA59d6915eC8E7300581B9fD35c09D9808] = 15434 * 10 ** 18;
lockList[0x3af35E26a83c053bC5958160788Fc8a5783FAEaf] = 4521 * 10 ** 18;
lockList[0x3ca492b82978A9FB293410b254B49b24F0E43124] = 6404 * 10 ** 18;
lockList[0x59e5def48b51b1d3619dea0908b51cafa36bc32c] = 10344 * 10 ** 18;
lockList[0x56453D2139F9Fdd6e1Ec40d5370BA03dD4822537] = 4876 * 10 ** 18;
lockList[0xEC68B77c7231f7C8A0aF27251c5a8F05819D99A3] = 11632 * 10 ** 18;
lockList[0x12A3f50dDA438854491ae7CEe713D21254Bf4831] = 418 * 10 ** 18;
lockList[0x811Ff6C39f75dD3FAAeCb35C0bEcBa09AaE5ea50] = 24534 * 10 ** 18;
lockList[0x1105A96F7023AA1320b381Bb96ac7528B6De08A5] = 1059 * 10 ** 18;
lockList[0x7Da0eCc11BF1baB6f80c91525F00E8CF12a0Ce80] = 38089 * 10 ** 18;
lockList[0xf0c6Be88F289Fc1fC3e4BB25BA6C32D120556612] = 1759 * 10 ** 18;
lockList[0xD7dD9514Ac84c537526d7fBa9DB39b301369419b] = 5770 * 10 ** 18;
lockList[0xe995b1c4f73212ab9122e13d40f8227824a7d134] = 1802 * 10 ** 18;
lockList[0xd2309C4ae9Cf8E7F8680c3B87320a2b6Be702435] = 5428 * 10 ** 18;
lockList[0x7f2876eaD16E6fee63CF20412e18F4F1B1bF7e7e] = 6723 * 10 ** 18;
lockList[0x739411622fB2d07B3d54905846E3367653F4578e] = 709 * 10 ** 18;
lockList[0xe50E01F2b901AD6eAA6bcF2182e47e5EF91f4f1c] = 22722 * 10 ** 18;
lockList[0x048CCb21e664CFD700c4D5492feaed8e86895c62] = 753 * 10 ** 18;
lockList[0xDbc6E2fa275bF5d7762eEa2401ddC93a324feb17] = 16838 * 10 ** 18;
lockList[0x83f4f537b01e368e4dce5520c5E869271e3FA90f] = 77 * 10 ** 18;
lockList[0x61CFB88085f848f5685c937E7cb7A18d76802709] = 1448 * 10 ** 18;
lockList[0x028f9c71fE9cb17fBd32D72159604Fa0b64579A0] = 8532 * 10 ** 18;
lockList[0xe4Dc73D6cb05370e9C539aDB7DBf4F330A3Cc663] = 451 * 10 ** 18;
lockList[0xF37425eD1E3Eb4a01649fE136D858456d5e37020] = 93068 * 10 ** 18;
lockList[0x7d465899B2909d95a1293F4301DB5fC55f5B5008] = 784 * 10 ** 18;
lockList[0xe1ac511d43b238EAffdEd35e1F1060a20e7dE87C] = 22607.8125 * 10 ** 18;
lockList[0xDdd540e1F4fDb157164597621B236D2650428d3c] = 760 * 10 ** 18;
lockList[0x02ff817036529c72572eCfE4e48d532daC9AF777] = 19475.7 * 10 ** 18;
lockList[0x9B51Ee9F220590448bB11BcdEd2091d185257e1c] = 1289 * 10 ** 18;
lockList[0xEbD6b840d186808AadEfa8d6B0879FFEc965CC3b] = 6360.8 * 10 ** 18;
lockList[0xe9687b4633660BF831A7cEdCFe6b2f8Ad695C060] = 2750.7 * 10 ** 18;
lockList[0x96E3544A58297bB7C0eBB484280000220d64b483] = 2984 * 10 ** 18;
lockList[0xA9dDedfF71811EF9C7Ff6d5C6A800C4AB0B829A6] = 12350 * 10 ** 18;
lockList[0x6aa92ffEAD98370d8E86FAD42A4e300F614C154c] = 55074 * 10 ** 18;
lockList[0x7E4F8be3EcA8c31AAe3a955bb43Afc0c8Ab5bfaC] = 579 * 10 ** 18;
lockList[0x0067478F0aC9DF5fd513C7c5e10C3734cc95a2Bf] = 6161.5 * 10 ** 18;
lockList[0x27d2B31ded839ad94a3f637bA56A70Cd9Ae2B282] = 1085 * 10 ** 18;
lockList[0x335E44383F620D3e7647C4B2d97c6d6589979fEe] = 13264 * 10 ** 18;
lockList[0xD29E97b3940Cb2b2f241FEc7192bf25db34CE4FB] = 5891 * 10 ** 18;
lockList[0xf7026196DEacF2584636933C4918395D6E7f072B] = 1728 * 10 ** 18;
lockList[0xAf02B81eAafC2103662F3Abaf63Fc1cc3a39F8F3] = 15324 * 10 ** 18;
lockList[0xCe5dc41E2bDB3343df281faf6043e9C83e42946F] = 2048 * 10 ** 18;
lockList[0x2e161fab552e23849b219c37B237cA3e46FFE190] = 10664 * 10 ** 18;
lockList[0x948882468fecb578955575a65331abefc2820445] = 1356 * 10 ** 18;
lockList[0x2eDeB8a0aa363f11dDCBCdaD7170b2dd6888b8B7] = 1095 * 10 ** 18;
lockList[0x8B4A431805DDE778EEC6BE62F15FCAAB49180349] = 589 * 10 ** 18;
lockList[0x0F507a26F1f66761630b814974cA22f0aeEB025b] = 6623 * 10 ** 18;
lockList[0xD8467a842D4974f8460D35c0D68d27f46212FC42] = 11781 * 10 ** 18;
lockList[0x2f4b7eAA5348aB80CBF0845316fD2f5EdC8CcBB7] = 22015 * 10 ** 18;
lockList[0x7029B37167d15051f3E82467Bf8E3Be2a9f5eB66] = 7671 * 10 ** 18;
lockList[0x426de357613E1A096285DC7A9b1E4D960532dc77] = 1191 * 10 ** 18;
lockList[0xFd39138e6b4df493c22f3D45Cf675d37a53E8e59] = 3100 * 10 ** 18;
lockList[0xe0b8a2499804B466b210d1350412DD65a6DA7644] = 23195 * 10 ** 18;
lockList[0xa5440b5b3786a6a551aa52464088380a4c94cc5c] = 16281 * 10 ** 18;
lockList[0x398626e5b5D43F12C2E1f752521C31cEA6F67Edd] = 10608 * 10 ** 18;
lockList[0x33f8255f707cbb9b81561271058e264870F2932E] = 8650 * 10 ** 18;
lockList[0x52f2a2CA11562bd804E21Ae8CE24FAc1592F8d5B] = 7012 * 10 ** 18;
lockList[0x2c87a13b8f4ac9ccfc84d0cf192b7b250449f814] = 3728 * 10 ** 18;
lockList[0x5df29645580d23c7ee79387e55ae14250c5a2ef2] = 8520 * 10 ** 18;
lockList[0xc916e3de378d12e15ca68c5740e78cad6d319620] = 600 * 10 ** 18;
lockList[0x9667cb2f8cd6858d97cfb78a751ae93869498b90] = 1037 * 10 ** 18;
lockList[0xe09eC6ed709050171a6b640decC8a02e2F6E4CA4] = 1488 * 10 ** 18;
lockList[0xD4F4bEfeadbE319428F95c4496668d5499f6B3A6] = 3350 * 10 ** 18;
lockList[0x5a55368b29c238574A41d4d9513be9b5F6cE261f] = 12153 * 10 ** 18;
lockList[0x7BC569164Af97a4122d6c889d944ce222ef4318D] = 4326 * 10 ** 18;
lockList[0x684292690C546EAA7c6A37b6923d8C3d823d7ec4] = 494 * 10 ** 18;
lockList[0x9523fb6dbfcb91627714cfd41ed27d0dbf9d0288] = 8085 * 10 ** 18;
lockList[0xA5C9387746D9dad02AA8D9d8bBC85f1Cc60251DD] = 7499 * 10 ** 18;
lockList[0x3425f8f253C30905A4126f76c88358e9433BD23B] = 16984 * 10 ** 18;
lockList[0x39eA9690d8986b99047d7980e22eE7BBd20bBb36] = 6205 * 10 ** 18;
lockList[0x0316DdD222513626f6F07c0Ea9Aa76d119dbA597] = 3538 * 10 ** 18;
lockList[0x0d7ba208cfbdb009164fb5e60a528c62d80c3d2e] = 119905 * 10 ** 18;
lockList[0x6b7bF976b100df64bFC5ba541d26C1fE81C6BB1a] = 6571 * 10 ** 18;
lockList[0xF58928F2d1c07D4f37B7f35c36A573825104117A] = 42424 * 10 ** 18;
lockList[0x4B4064395Fc0B6E35CD7CC79FB324CF9115Dbd7D] = 12564 * 10 ** 18;
lockList[0x07e91aa302cb997d1524f58c0c67818bc7e9d85a] = 200 * 10 ** 18;
lockList[0x30e5E26E2b562946faf38aad8510BF4065fD351f] = 1394 * 10 ** 18;
lockList[0xfbb010c3b9216c1f5ac95587fbcefe6ec2476d14] = 47216 * 10 ** 18;
lockList[0xD79067c91e542725a2CBDafe02C9200aF34A75C5] = 2248 * 10 ** 18;
lockList[0xc491e8aac8ad3b78bc031eb0544a3feda753ed71] = 3195 * 10 ** 18;
lockList[0x4bD5258e6c4f200c8739c0de25C1BaaF4f0dd0A9] = 8238 * 10 ** 18;
lockList[0xe0f11d27a4e0d2c176562cab178898b253c2519e] = 1293 * 10 ** 18;
lockList[0x1599C57a7C89fb0B57De341245CB30b5a362bcb9] = 19581 * 10 ** 18;
lockList[0xc561DDad555F2D4590c6C234aa8eaD077557E861] = 11484 * 10 ** 18;
lockList[0xFD3A02E8AE8615614d4D29bf0132f4F5Cd0C92b9] = 20438 * 10 ** 18;
lockList[0x633b71915eAD4Ee98cBA4E605d1B93bB48f87dE9] = 275 * 10 ** 18;
lockList[0x9BAf29D4D23756Dd93Cb090D656CeA490D28A410] = 3140 * 10 ** 18;
lockList[0xc17e4c0cABe3915E52a750acC8847F77b98C6CAF] = 5281 * 10 ** 18;
lockList[0xc79eae229e131ca04722e9b4e77f75190cfe6eb8] = 3657 * 10 ** 18;
lockList[0x9954e6f38F248d3Bd213a55cDe2f53b3459680dD] = 406 * 10 ** 18;
lockList[0x6390A8807fa00551cBFdBf91ce2c06af2fFC0cCA] = 225 * 10 ** 18;
lockList[0xf430eE763C83bbAd5b072EaE9435EE228A63A888] = 16249 * 10 ** 18;
lockList[0xA7135f955BE175910E3e08048527b7ea387a881E] = 3738 * 10 ** 18;
lockList[0x68638F00c7A24dC8c1968345de50d69BA74FFa21] = 1803 * 10 ** 18;
lockList[0x713D2599e96Ae8Ec037A0E903B4A801Dec416aC0] = 9160 * 10 ** 18;
lockList[0x2fED4396Ee204a448201fAB980f1C90018e22801] = 302122 * 10 ** 18;
lockList[0x3cC8291F32a07aC9D0D9887eEc7331bD273c613B] = 1142882 * 10 ** 18;
lockList[0xef6607FafE4406dD1698865aC89BcBc22323e853] = 139708 * 10 ** 18;
lockList[0x1b15FD6FeaecC11B44D689b7B1C2471207a26a23] = 116678 * 10 ** 18;
lockList[0xe813fe32aBd2f47c5010426d259e2372e526021C] = 103784 * 10 ** 18;
lockList[0x253f9FAb9dCB4a64ceF5b3320eB9F28163924DF9] = 71770 * 10 ** 18;
lockList[0x3aa9230bF5deD1c72aa4083B6137ADC7955B5a1a] = 114020 * 10 ** 18;
lockList[0xe37079253aDa30eeF49f65EFd48608A4C15F614D] = 503303 * 10 ** 18;
lockList[0x89Ad15DfCDe37dCF1C7C8582d8ff7F195796EB7B] = 164803 * 10 ** 18;
lockList[0xD063C6f99F221Df40D1F15A1d5D6a477573f8092] = 31460 * 10 ** 18;
lockList[0x8Ef20D2388606Fd4E6ef0f0f070a63c5c655626c] = 681715 * 10 ** 18;
lockList[0x632A8a687C5c99556117650641B3ACB299ba070f] = 458888 * 10 ** 18;
lockList[0x8901A17d3964214D501F9C8B015854d037d90fEf] = 831815 * 10 ** 18;
lockList[0xDF5662248182270da3b7582d303CFb2d5E62ec23] = 1257794 * 10 ** 18;
lockList[0x1f5a6da1dfd6645eb4f3afc0d4e457aac95c8776] = 1014032 * 10 ** 18;
lockList[0xb1FA3A4c4CEEc881Ec3B4f50afa4d40a20353385] = 339020 * 10 ** 18;
lockList[0x7F3D90153259c49887d55E906af3336c38F814A9] = 421571 * 10 ** 18;
lockList[0x9c6fc8Eb31B67Cc9452c96B77DdCb5EF504CDa81] = 119204 * 10 ** 18;
lockList[0xD9c1F9347785dc2E79477E20E7d5e5b7866deF35] = 178954 * 10 ** 18;
lockList[0xa4FEf4Cc6f63E5Ea0A2F3044EA84b9a1EACeAE5e] = 139148 * 10 ** 18;
lockList[0x3Ae9e2E7fEA9031eE85facbBc26794b079b3dCd9] = 1940127 * 10 ** 18;
lockList[0x901AD29A0e95647525137E2af782C517375D37C4] = 4750115 * 10 ** 18;
lockList[0xbff165E4549bfcea5F150FC5ee04cC8dA4dCAe5d] = 59902 * 10 ** 18;
lockList[0x09c09b03563B6Be9104Da38890468C0D9A98C691] = 2729048 * 10 ** 18;
lockList[0x400D5Fd9A30C3f524931F82C687cacB6C4054F41] = 610952 * 10 ** 18;
lockList[0x054C0a11804Ad1116290CF14EE23Ad59F3d0925e] = 376660 * 10 ** 18;
lockList[0xB80ab7AAb74731243fE13d5c6Eb87223CfaDA59b] = 73479 * 10 ** 18;
lockList[0xb1DbcBd1705938546e1eBa520332B4c164878965] = 68520 * 10 ** 18;
lockList[0x4e961A68d3dafff6D4d863d21fba6Fff82b25d5c] = 10000 * 10 ** 18;
lockList[0x097515d2570baBbDa32e5caF23a765e574cDc6B1] = 50683 * 10 ** 18;
lockList[0xb2aCA30Ae71d146aad0422a141e3eF0B9313A4bc] = 25158 * 10 ** 18;
lockList[0x8Ab96a4778BB5b7E6839059D2988e846A749E9ED] = 67043 * 10 ** 18;
lockList[0x7e5177Bd22D9e64AfEBD4F06DdD4C6F6bFccc548] = 113495 * 10 ** 18;
lockList[0xd3A8bBBc7eeAF8422C791A3d046Fa773E972bAe2] = 184614 * 10 ** 18;
lockList[0x66F9A4b3C09dA25cF14a063647882c31880bcd17] = 37509 * 10 ** 18;
lockList[0x3409780afa44ede06111b927e25c1fa7ef72cda5] = 185956 * 10 ** 18;
lockList[0x1F105e0A5126a1282929ff5E4FB1819F2D48a785] = 221487 * 10 ** 18;
lockList[0x5F86Ff75c7745d40d81F155c9B2D49794F8Dd85E] = 476976 * 10 ** 18;
lockList[0xAB107D9932f4338538c72fEc7fEd65a7F87Ed24C] = 1863872 * 10 ** 18;
lockList[0xB3D3403BB64258CFA18C49D28c0E9719eF0A0004] = 192751 * 10 ** 18;
lockList[0xb1da36EfcBf2ee81178A113c631932AEc9c9ADE9] = 34386 * 10 ** 18;
lockList[0x8894EdE64044F73d293bD43eaeBf1D6Dbc55B361] = 2368356 * 10 ** 18;
lockList[0xF7F62c2B263E6C7319322f2A4a76d989404835d6] = 100515 * 10 ** 18;
lockList[0x5814639DA554762e40745b9F0e2C5d0Ba593E532] = 413704 * 10 ** 18;
lockList[0xc02918Eb9563dBa6322673C2f18096Dceb5BE71d] = 101500 * 10 ** 18;
lockList[0x61dBB6fA0d7A85a73Fb3AA4896079eE4011229e5] = 164921 * 10 ** 18;
lockList[0x30E442ADD9826B52F344D7FAfB8960Df9dbb8f30] = 280178 * 10 ** 18;
lockList[0xE8B0A0BEc7b2B772858414527C022bfb259FAC71] = 1559993 * 10 ** 18;
lockList[0x9f8B4fd6B3BbACCa93b79C37Ce1F330a5A81cbB7] = 766709 * 10 ** 18;
lockList[0x5a98B695Fe35F628DFaEBbBB5493Dc8488FA3275] = 283605 * 10 ** 18;
lockList[0x23b6E3369bD27C3C4Be5d925c6fa1FCea52283e2] = 143304 * 10 ** 18;
lockList[0xE8c215194222708C831362D5e181b2Af99c6c384] = 144635 * 10 ** 18;
lockList[0xfC0aE173522D24326CFfA9D0D0C058565Fd39d2B] = 84228 * 10 ** 18;
lockList[0x5e08EA6DDD4BF0969B33CAD27D89Fb586F0fC2f1] = 34749 * 10 ** 18;
lockList[0xE7De0652d437b627AcC466002d1bC8D44bdb156E] = 17809 * 10 ** 18;
lockList[0xEa4CedE1d23c616404Ac2dcDB3A3C5EaA24Ce38d] = 13263 * 10 ** 18;
lockList[0x7d97568b1329013A026ED561A0FA542030f7b44B] = 107752 * 10 ** 18;
lockList[0x0c52d845AB2cB7e4bec52DF6F521603683FA8780] = 36368 * 10 ** 18;
lockList[0x58d66AC8820fa6f7c18594766519c490d33C6E96] = 292311 * 10 ** 18;
lockList[0x1554972baa4b0f26bafbfac8872fc461683a64aa] = 74097 * 10 ** 18;
lockList[0xcCD4513E24C87439173f747625FDBF906AE5428A] = 33718 * 10 ** 18;
lockList[0xB81f587dEB7Dc1eb1e7372B1BD0E75DeE5804313] = 34711 * 10 ** 18;
lockList[0xad4e8ae487bf8b6005aa7cb8f3f573752db1ced0] = 62781 * 10 ** 18;
lockList[0x9e25ade8a3a4f2f1a9e902a3eaa62baee0000c16] = 1042612 * 10 ** 18;
lockList[0xeb019f923bb1Dab5Fd309E342b52950E6A3a5bb5] = 210671 * 10 ** 18;
lockList[0xf145c1E0dEcE26b8DD0eDbd0D7A1f4a16dBFE238] = 414327 * 10 ** 18;
lockList[0xf1cfa922da06079ce6ed6c5b6922df0d4b82c76f] = 135962 * 10 ** 18;
lockList[0x0Fc746A1800BDb4F6308B544e07B46eF4615776E] = 12948 * 10 ** 18;
lockList[0x448bc2419Fef08eF72a49B125EA8f2312a0Db64C] = 11331 * 10 ** 18;
lockList[0x6766B4BebcEfa05db1041b80f9C67a00aAe60d2a] = 44260 * 10 ** 18;
lockList[0xfd1b9d97772661f56cb630262311f345e24078ee] = 116657 * 10 ** 18;
lockList[0x5149F1A30Bab45e436550De2Aed5C63101CC3c61] = 161098 * 10 ** 18;
lockList[0xAeA06A4bFc2c60b2CEb3457c56eEb602C72B6C74] = 13499 * 10 ** 18;
lockList[0xB24969E6CEAE48EfccAb7dB5E56169574A3a13A8] = 62028 * 10 ** 18;
lockList[0x6FaE413d14cD734d6816d4407b1e4aB931D3F918] = 100378 * 10 ** 18;
lockList[0xb6224a0f0ab25312d100a1a8c498f7fb4c86da17] = 484510 * 10 ** 18;
lockList[0xE3C398F56733eF23a06D96f37EaE555eE6596A85] = 381015 * 10 ** 18;
lockList[0x3eB5594E1CE158799849cfC7A7861164107F2006] = 445141 * 10 ** 18;
lockList[0x15ac93dE94657882c8EB6204213D9B521dEBaBfB] = 213617 * 10 ** 18;
lockList[0x1988267Ce9B413EE6706A21417481Ed11a3Ca152] = 595134 * 10 ** 18;
lockList[0x50e10b4444F2eC1a14Deea02138A338896c2325E] = 321502 * 10 ** 18;
lockList[0x5934028055dd8bff18e75283af5a8800469c7eda] = 788752 * 10 ** 18;
lockList[0xff54d0987cba3c07dc2e65f8ba62a963439e257f] = 239170 * 10 ** 18;
lockList[0x71396C01ba9AA053a51cfadC7d0D09d97aF96189] = 2250076 * 10 ** 18;
lockList[0x795129211Eb76D8440E01Ed2374417f054dB65f2] = 2355693 * 10 ** 18;
lockList[0xac0c89c654d837100db2c3dc5923e308c745ac0e] = 34000 * 10 ** 18;
lockList[0x941D03Ae7242cF1929888FdE6160771ff27f3D8c] = 1308777 * 10 ** 18;
lockList[0xd9A2649ea71A38065B2DB6e670272Bed0bb68fB7] = 1570922 * 10 ** 18;
lockList[0x7303bDf8d7c7642F5297A0a97320ee440E55D028] = 1846600 * 10 ** 18;
lockList[0x333a0401Aa60D81Ba38e9E9Bd43FD0f8253A83eB] = 1503988 * 10 ** 18;
lockList[0x5AC44139a4E395b8d1461b251597F86F997A407B] = 1467330 * 10 ** 18;
lockList[0xbB07b26d8c7d9894FAF45139B3286784780EC94F] = 1650000 * 10 ** 18;
lockList[0xc4Ad40d8FCCDcd555B7026CAc1CC6513993a2A03] = 845391 * 10 ** 18;
lockList[0x92Dab5d9af2fC53863affd8b9212Fae404A8B625] = 48000 * 10 ** 18;
}
| 0
|
function adminshipLevel(address _newAdmin, uint8 _level) public onlyAdmin(2) {
require(_newAdmin != address(0), "Address cannot be zero");
level[_newAdmin] = _level;
emit AdminshipUpdated(_newAdmin, _level);
}
| 0
|
function transfer(address _to, uint _amountInWei) external onlyOwner {
require(address(this).balance > _amountInWei);
_to.transfer(_amountInWei);
}
| 0
|
function transfer(address to, uint256 value) public returns (bool)
{
return _fullTransfer(msg.sender, to, value);
}
| 0
|
function add_referral(address referral, string promo, uint256 amount) external returns(address partner, uint256 p_partner, uint256 p_referral){
p_partner = 0;
p_referral = 0;
partner = address(0x0);
if (msg.sender == contractPreICO || msg.sender == contractICO){
if(partnersPromo[promo] != address(0x0) && partnersPromo[promo] != referral){
partner = partnersPromo[promo];
referrals[referral] += amount;
amount_referral_invest += amount;
partnersInfo[partner].balance += amount;
history[partner].push(itemHistory(now, referral, amount));
p_partner = (amount*uint256(calc_partnerPercent(amount)))/10000;
p_referral = (amount*ref_percent)/10000;
}
}
}
| 1
|
constructor(IERC20 _token) public {
require(address(_token) != address(0x0), "Matic token address is not valid");
maticToken = _token;
uint256 SCALING_FACTOR = 10 ** 18;
uint256 day = 1 minutes;
day = day.div(15);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 0, 3230085552 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 30 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 61 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 91 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 122 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 153 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 183 * day, 1088418885 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 214 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 244 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 275 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 306 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 335 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 366 * day, 1218304816 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 396 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 427 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 457 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 488 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 519 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 549 * day, 1218304816 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 580 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 610 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 641 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 672 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 700 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 731 * day, 1084971483 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 761 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 792 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 822 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 853 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 884 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 914 * day, 618304816 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 945 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 975 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 1096 * day, 593304816 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 1279 * day, 273304816 * SCALING_FACTOR);
}
| 0
|
function hodl(address _beneficiary, uint256 _id, uint256 _value, uint256 _months) external {
require(_beneficiary != address(0));
require(_id > 0);
address _creator = msg.sender;
Item storage item = items[_creator][_id];
require(item.id != _id);
items[_creator][_id] = Item(_id, _creator, _beneficiary, false);
purpose.safeTransferFrom(_creator, this, _value);
hodler.hodl(_id, _value, _months);
uint256 balance = dubi.balanceOf(this);
dubi.safeTransfer(_beneficiary, balance);
}
| 0
|
function updateTokensPerEthOnce(uint _newValue) public onlyOwner canBeCalledOnce("updateTokensPerEth") {
defaultTokensPerWei = _newValue;
recalcBonuses();
}
| 0
|
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnerUpdate(owner, newOwner);
owner = newOwner;
newOwner = 0x0;
}
| 0
|
function transferFrom(address _from, address _to, uint256 totalTokensToTransfer)whenNotPaused returns (bool success) {
require(_from!=0x0);
require(_to!=0x0);
require(totalTokensToTransfer>0);
if (balances[_from] >= totalTokensToTransfer&&allowance(_from,_to)>=totalTokensToTransfer) {
balances[_to] += totalTokensToTransfer;
balances[_from] -= totalTokensToTransfer;
allowed[_from][msg.sender] -= totalTokensToTransfer;
Transfer(_from, _to, totalTokensToTransfer);
return true;
} else { return false; }
}
| 0
|
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
| 0
|
function getOrdersInfo(LibOrder.Order[] memory orders)
public
view
returns (LibOrder.OrderInfo[] memory)
{
uint256 ordersLength = orders.length;
LibOrder.OrderInfo[] memory ordersInfo = new LibOrder.OrderInfo[](ordersLength);
for (uint256 i = 0; i != ordersLength; i++) {
ordersInfo[i] = getOrderInfo(orders[i]);
}
return ordersInfo;
}
| 0
|
function unlock() external {
if(now < unlockDate) throw;
uint256 entitled = allocations[msg.sender];
allocations[msg.sender] = 0;
if(!StandardToken(INDI).transfer(msg.sender, entitled * exponent)) throw;
}
| 1
|
function enter_next_race(uint block_finish_last, uint8 class, uint8 variant, bool repellent) external payable{
cleanup(block_finish_last);
if(races[race_number].block_finish != 0 || race_number == 0){
declare_race(class,variant,repellent);
}else{
enter_race(class,variant,repellent);
}
}
| 0
|
constructor() public {
lock = now;
emit SetLock(0, now);
}
| 0
|
function trade(bytes _left, uint8 leftV, bytes32 leftR, bytes32 leftS, bytes _right, uint8 rightV, bytes32 rightR, bytes32 rightS) external {
checkRole(msg.sender, ROLE_TRADE);
Order memory left;
Order memory right;
left.maker = _left.sliceAddress(0);
left.baseToken = _left.sliceAddress(20);
left.quoteToken = _left.sliceAddress(40);
left.feeToken = _left.sliceAddress(60);
left.amount = uint256(_left.slice32(80));
left.priceNumerator = uint256(_left.slice32(112));
left.priceDenominator = uint256(_left.slice32(144));
left.feeNumerator = uint256(_left.slice32(176));
left.feeDenominator = uint256(_left.slice32(208));
left.expiresAt = uint256(_left.slice32(240));
left.nonce = uint256(_left.slice32(272));
if (_left.slice2(304) == 0) {
left.orderType = OrderType.Sell;
} else {
left.orderType = OrderType.Buy;
}
right.maker = _right.sliceAddress(0);
right.baseToken = _right.sliceAddress(20);
right.quoteToken = _right.sliceAddress(40);
right.feeToken = _right.sliceAddress(60);
right.amount = uint256(_right.slice32(80));
right.priceNumerator = uint256(_right.slice32(112));
right.priceDenominator = uint256(_right.slice32(144));
right.feeNumerator = uint256(_right.slice32(176));
right.feeDenominator = uint256(_right.slice32(208));
right.expiresAt = uint256(_right.slice32(240));
right.nonce = uint256(_right.slice32(272));
if (_right.slice2(304) == 0) {
right.orderType = OrderType.Sell;
} else {
right.orderType = OrderType.Buy;
}
bytes32 leftHash = getOrderHash(left);
bytes32 rightHash = getOrderHash(right);
address leftSigner = ecrecover(keccak256("\x19Ethereum Signed Message:\n32", leftHash), leftV, leftR, leftS);
address rightSigner = ecrecover(keccak256("\x19Ethereum Signed Message:\n32", rightHash), rightV, rightR, rightS);
require(leftSigner == left.maker);
require(rightSigner == right.maker);
tradeInternal(left, leftHash, right, rightHash);
}
| 0
|
function finalize() onlyOwner public {
require(!isFinalized);
require(hasEnded());
super.finalization();
isFinalized = true;
}
| 0
|
function allowance(address tokenOwner, address spender) external constant returns (uint remaining);
function transfer(address to, uint tokens) external returns (bool success);
function approve(address spender, uint tokens) external returns (bool success);
function transferFrom(address from, address to, uint tokens) external returns (bool success);
function burn(uint256 _value) external;
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
event Burn(address indexed burner, uint256 value);
}
contract KRCICOContract is Ownable{
using SafeMath for uint256;
TokenInterface public token;
uint256 public startTime;
uint256 public endTime;
uint256 public ratePerWei;
uint256 public weiRaised;
uint256 public TOKENS_SOLD;
uint256 maxTokensToSale;
uint256 bonusInPhase1;
uint256 bonusInPhase2;
uint256 bonusInPhase3;
uint256 minimumContribution;
uint256 maximumContribution;
bool isCrowdsalePaused = false;
uint256 totalDurationInDays = 45 days;
uint256 LongTermFoundationBudgetAccumulated;
uint256 LegalContingencyFundsAccumulated;
uint256 MarketingAndCommunityOutreachAccumulated;
uint256 CashReserveFundAccumulated;
uint256 OperationalExpensesAccumulated;
uint256 SoftwareProductDevelopmentAccumulated;
uint256 FoundersTeamAndAdvisorsAccumulated;
uint256 LongTermFoundationBudgetPercentage;
uint256 LegalContingencyFundsPercentage;
uint256 MarketingAndCommunityOutreachPercentage;
uint256 CashReserveFundPercentage;
uint256 OperationalExpensesPercentage;
uint256 SoftwareProductDevelopmentPercentage;
uint256 FoundersTeamAndAdvisorsPercentage;
struct Whitelist {
string Email;
}
| 0
|
function getDay() constant returns (uint256) {
return SafeMath.sub(block.timestamp, initialTimestamp) / 1 days;
}
| 1
|
function issueTokens (uint256 n, uint256 price, uint deadline) noEther onlyChallengeOwner {
if (now < tokenIssueDeadline) throw;
if (deadline < now) throw;
if (n == 0) throw;
tokenPrice = price * 1000000000000;
tokenIssueDeadline = deadline;
tokensToIssue = n;
tokensIssued = 0;
notifyTokenIssued(n, price, deadline);
}
| 0
|
function finalize() public {
require(!isFinalized);
require(hasClosed() || capReached());
finalization();
emit Finalized();
isFinalized = true;
}
| 0
|
function setActive(bool _active) external onlyRegistryOwner() {
active = _active;
emit SetActive(active);
}
| 0
|
constructor()
ERC20Burnable() ERC20Pausable() ERC20() Ownable() ERC20Detailed("Pokersoon JQK Token", "JQK", 18)
public {
_mint(msg.sender, 100000000000000000000000000);
nextminttime = now + 14 * 365 days;
}
| 0
|
constructor(IERC20 _token) public {
require(address(_token) != address(0x0), "Matic token address is not valid");
maticToken = _token;
uint256 SCALING_FACTOR = 10 ** 18;
uint256 day = 1 minutes;
day = day.div(15);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 0, 3230085552 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 30 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 61 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 91 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 122 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 153 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 183 * day, 1088418885 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 214 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 244 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 275 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 306 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 335 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 366 * day, 1218304816 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 396 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 427 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 457 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 488 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 519 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 549 * day, 1218304816 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 580 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 610 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 641 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 672 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 700 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 731 * day, 1084971483 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 761 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 792 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 822 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 853 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 884 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 914 * day, 618304816 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 945 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 975 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 1096 * day, 593304816 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 1279 * day, 273304816 * SCALING_FACTOR);
}
| 0
|
function finishMinting() external onlyMinter returns (bool) {
mintingFinished = true;
MintingFinished();
return true;
}
| 0
|
function tokensVestedPerDay(uint256 _grantId) public view returns(uint256) {
Grant storage tokenGrant = tokenGrants[_grantId];
return tokenGrant.amount.div(uint256(tokenGrant.vestingDuration));
}
| 0
|
function updateMinCapEthOnce(uint _newValue) public onlyOwner canBeCalledOnce("updateMinCapEth") {
minCapWei = _newValue * 1e18;
}
| 0
|
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
| 0
|
function myPercentageUpper() external view returns (uint256) {
return _transferIns[msg.sender].percentageUpper;
}
| 0
|
constructor(IERC20 _token) public {
require(address(_token) != address(0x0), "Matic token address is not valid");
maticToken = _token;
uint256 SCALING_FACTOR = 10 ** 18;
uint256 day = 1 minutes;
day = day.div(15);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 0, 3230085552 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 30 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 61 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 91 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 122 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 153 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 183 * day, 1088418885 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 214 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 244 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 275 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 306 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 335 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 366 * day, 1218304816 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 396 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 427 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 457 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 488 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 519 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 549 * day, 1218304816 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 580 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 610 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 641 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 672 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 700 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 731 * day, 1084971483 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 761 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 792 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 822 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 853 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 884 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 914 * day, 618304816 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 945 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 975 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 1096 * day, 593304816 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 1279 * day, 273304816 * SCALING_FACTOR);
}
| 0
|
function transfer(address _to, uint256 _tokenId) public onlyOwnerOf(_tokenId) {
clearApprovalAndTransfer(msg.sender, _to, _tokenId);
}
| 0
|
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,
AlreadyExecuted,
InsufficientApprovedTokens,
InsufficientApprovedTokensForFees,
InsufficientTokens,
InsufficientTokensForFees,
OverflowError
}
| 0
|
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 transferFrom(address _caller, address _from, address _to, uint256 _amount) onlyAsset returns (bool success) {
assert(allowTransactions);
assert(!frozenAccount[_caller]);
assert(!frozenAccount[_from]);
assert(balanceOf[_from] >= _amount);
assert(balanceOf[_to] + _amount >= balanceOf[_to]);
assert(_amount <= allowance[_from][_caller]);
balanceOf[_from] -= _amount;
uint256 fee = feeFor(_from, _to, _amount);
balanceOf[_to] += _amount - fee;
treasuryBalance += fee;
allowance[_from][_caller] -= _amount;
activateAccount(_from);
activateAccount(_to);
activateAccount(_caller);
Transfer(_from, _to, _amount);
return true;
}
| 0
|
function burnToken(uint _value) onlyOwner public
{
uint tokens = _value * E18;
require(balances[msg.sender] >= tokens);
balances[msg.sender] = balances[msg.sender].sub(tokens);
burnTokenSupply = burnTokenSupply.add(tokens);
totalTokenSupply = totalTokenSupply.sub(tokens);
emit Burn(msg.sender, tokens);
}
| 0
|
function approve(address _spender, uint256 _value) public
returns (bool success)
{
allowance[msg.sender][_spender] = _value;
return true;
}
| 0
|
function delAcceptedToken(address _token) onlyAdmin external {
require(acceptedTokens[_token]);
acceptedTokens[_token] = false;
emit DelAcceptedToken(_token);
}
| 0
|
function beneficiary() public view returns(address) {
return _beneficiary;
}
| 0
|
function upgradeMe(address newSC) external {
require(upgrades[msg.sender] == address(0));
upgrades[msg.sender] = newSC;
}
| 0
|
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 withdrawEther() external onlyOwner() {
msg.sender.transfer(address(this).balance);
}
| 0
|
function claimExtra(ERC20 token) external onlyRole(ROLE_CLAIM) {
uint256 totalBalance = token.balanceOf(this);
token.transfer(feeAccount, totalBalance.sub(tokensTotal[token]));
}
| 0
|
function WithdrawTokens(uint _amount) {
require(msg.sender == beneficiary || msg.sender == alfatokenteam);
token.transfer(beneficiary, _amount);
}
| 0
|
function whitelist(address _participant, uint256 _weiAmount) onlyOwner public {
require(_participant != 0x0);
whitelisted[_participant] = _weiAmount;
Whitelisted(_participant, _weiAmount);
}
| 0
|
End of preview. Expand
in Data Studio
README.md exists but content is empty.
- Downloads last month
- 9