Contract Source Code:
File 1 of 1 : BETA
pragma solidity 0.4.25;
/** ONUP TOKEN AFFILIATE PROJECT THE SECOND EDITION
CREATED 2018-11-01 BY DAO DRIVER ETHEREUM
ALL PROJECT DETAILS AT https://onup.online **/
library SafeMath{
function mul(uint256 a, uint256 b)internal pure returns(uint256){if(a==0){return 0;}uint256 c=a*b;assert(c/a==b);return c;}
function div(uint256 a, uint256 b)internal pure returns(uint256){uint256 c=a/b;return c;}
function sub(uint256 a, uint256 b)internal pure returns(uint256){assert(b<=a);return a-b;}
function add(uint256 a, uint256 b)internal pure returns(uint256){uint256 c=a+b;assert(c>=a);return c;}
}
contract ERC20{
uint256 internal Bank=0;string public constant name="OnUp TOKEN";string public constant symbol="OnUp";
uint8 public constant decimals=6;uint256 public price=700000000;uint256 public totalSupply;
event Approval(address indexed owner,address indexed spender,uint value);
event Transfer(address indexed from,address indexed to,uint value);
mapping(address=>mapping(address=>uint256))public allowance;mapping(address=>uint256)public balanceOf;
function balanceOf(address who)public constant returns(uint){return balanceOf[who];}
function approve(address _spender,uint _value)public{allowance[msg.sender][_spender]=_value; emit Approval(msg.sender,_spender,_value);}
function allowance(address _owner,address _spender) public constant returns (uint remaining){return allowance[_owner][_spender];}
}
contract BETA is ERC20{
using SafeMath for uint256;
modifier onlyPayloadSize(uint size){require(msg.data.length >= size + 4); _;}
address ref1=0x0000000000000000000000000000000000000000;
address ref2=0x0000000000000000000000000000000000000000;
address ref3=0x0000000000000000000000000000000000000000;
address ref4=0x0000000000000000000000000000000000000000;
address ref5=0x0000000000000000000000000000000000000000;
address public owner;
address internal constant insdr=0xaB85Cb1087ce716E11dC37c69EaaBc09d674575d;// FEEDER
address internal constant advrt=0x28fF20D2d413A346F123198385CCf16E15295351;// ADVERTISE
address internal constant spcnv=0x516e0deBB3dB8C2c087786CcF7653fa0991784b3;// AIRDROPS
mapping (address=>address) public referrerOf;
mapping (address=>uint256) public prevOf;
mapping (address=>uint256) public summOf;
constructor()payable public{owner=msg.sender;prevOf[advrt]=6;prevOf[owner]=6;}
function()payable public{
require(isContract(msg.sender)==false);
require(msg.value>=10000000000000000);
require(msg.value<=30000000000000000000);
if(msg.sender!=insdr){
ref1=0x0000000000000000000000000000000000000000;
ref2=0x0000000000000000000000000000000000000000;
ref3=0x0000000000000000000000000000000000000000;
ref4=0x0000000000000000000000000000000000000000;
ref5=0x0000000000000000000000000000000000000000;
if(msg.sender!= advrt && msg.sender!=owner){CheckPrivilege();}else{mintTokens();}
}else{Bank+=(msg.value.div(100)).mul(90);price=Bank.div(totalSupply);}
}
function CheckPrivilege()internal{
if(msg.value>=25000000000000000000 && prevOf[msg.sender]<6){prevOf[msg.sender]=6;}
if(msg.value>=20000000000000000000 && prevOf[msg.sender]<5){prevOf[msg.sender]=5;}
if(msg.value>=15000000000000000000 && prevOf[msg.sender]<4){prevOf[msg.sender]=4;}
if(msg.value>=10000000000000000000 && prevOf[msg.sender]<3){prevOf[msg.sender]=3;}
if(msg.value>= 5000000000000000000 && prevOf[msg.sender]<2){prevOf[msg.sender]=2;}
if(msg.value>= 100000000000000000 && prevOf[msg.sender]<1){prevOf[msg.sender]=1;}
if(summOf[msg.sender]>=250000000000000000000 && prevOf[msg.sender]<6){prevOf[msg.sender]=6;}
if(summOf[msg.sender]>=200000000000000000000 && prevOf[msg.sender]<5){prevOf[msg.sender]=5;}
if(summOf[msg.sender]>=150000000000000000000 && prevOf[msg.sender]<4){prevOf[msg.sender]=4;}
if(summOf[msg.sender]>=100000000000000000000 && prevOf[msg.sender]<3){prevOf[msg.sender]=3;}
if(summOf[msg.sender]>= 50000000000000000000 && prevOf[msg.sender]<2){prevOf[msg.sender]=2;}
ref1=referrerOf[msg.sender];if(ref1==0x0000000000000000000000000000000000000000){
ref1=bytesToAddress(msg.data);require(isContract(ref1)==false);require(balanceOf[ref1]>0);require(ref1!=spcnv);
require(ref1!=insdr);referrerOf[msg.sender]=ref1;}
mintTokens();
}
function mintTokens()internal{
uint256 tokens=msg.value.div((price*100).div(70));
require(tokens>0);require(balanceOf[msg.sender]+tokens>balanceOf[msg.sender]);
uint256 perc=msg.value.div(100);uint256 sif=perc.mul(10);
uint256 percair=0;uint256 bonus1=0;uint256 bonus2=0;uint256 bonus3=0;
uint256 bonus4=0;uint256 bonus5=0;uint256 minus=10;uint256 airdrop=0;
if(msg.sender!=advrt && msg.sender!=owner && msg.sender!=spcnv){
if(ref1!=0x0000000000000000000000000000000000000000){summOf[ref1]+=msg.value;
if(summOf[ref1]>=250000000000000000000 && prevOf[ref1]<6){prevOf[ref1]=6;}
if(summOf[ref1]>=200000000000000000000 && prevOf[ref1]<5){prevOf[ref1]=5;}
if(summOf[ref1]>=150000000000000000000 && prevOf[ref1]<4){prevOf[ref1]=4;}
if(summOf[ref1]>=100000000000000000000 && prevOf[ref1]<3){prevOf[ref1]=3;}
if(summOf[ref1]>= 50000000000000000000 && prevOf[ref1]<2){prevOf[ref1]=2;}
if(referrerOf[ref1]!=0x0000000000000000000000000000000000000000){ref2=referrerOf[ref1];}
if(referrerOf[ref2]!=0x0000000000000000000000000000000000000000){ref3=referrerOf[ref2];}
if(referrerOf[ref3]!=0x0000000000000000000000000000000000000000){ref4=referrerOf[ref3];}
if(referrerOf[ref4]!=0x0000000000000000000000000000000000000000){ref5=referrerOf[ref4];}
if(prevOf[ref1]>1){sif-=perc;bonus1=perc.mul(2);minus-=2;}
else if(prevOf[ref1]>0){bonus1=perc;minus-=1;}}
if(ref2!=0x0000000000000000000000000000000000000000){if(prevOf[ref2]>2){sif-=perc.mul(2);bonus2=perc.mul(2);minus-=2;}
else if(prevOf[ref2]>0){sif-=perc;bonus2=perc;minus-=1;}}
if(ref3!=0x0000000000000000000000000000000000000000){if(prevOf[ref3]>3){sif-=perc.mul(2);bonus3=perc.mul(2);minus-=2;}
else if(prevOf[ref3]>0){sif-=perc;bonus3=perc;minus-=1;}}
if(ref4!=0x0000000000000000000000000000000000000000){if(prevOf[ref4]>4){sif-=perc.mul(2);bonus4=perc.mul(2);minus-=2;}
else if(prevOf[ref4]>0){sif-=perc;bonus4=perc;minus-=1;}}
if(ref5!=0x0000000000000000000000000000000000000000){if(prevOf[ref5]>5){sif-=perc.mul(2);bonus5=perc.mul(2);minus-=2;}
else if(prevOf[ref5]>0){sif-=perc;bonus5=perc;minus-=1;}}}
if(sif>0){
airdrop=sif.div((price*100).div(70));
require(airdrop>0);percair=sif.div(100);
balanceOf[spcnv]+=airdrop;
emit Transfer(this,spcnv,airdrop);
}
Bank+=(perc + percair).mul(85-minus);
totalSupply+=(tokens+airdrop);
price=Bank.div(totalSupply);
balanceOf[msg.sender]+=tokens;
emit Transfer(this,msg.sender,tokens);
tokens=0;airdrop=0;
owner.transfer(perc.mul(5));
advrt.transfer(perc.mul(5));
if(bonus1>0){ref1.transfer(bonus1);}
if(bonus2>0){ref2.transfer(bonus2);}
if(bonus3>0){ref3.transfer(bonus3);}
if(bonus4>0){ref4.transfer(bonus4);}
if(bonus5>0){ref5.transfer(bonus5);}
}
function transfer(address _to,uint _value)
public onlyPayloadSize(2*32)returns(bool success){
require(balanceOf[msg.sender]>=_value);
if(_to!=address(this)){
if(msg.sender==spcnv){require(_value<20000001);}
require(balanceOf[_to]+_value>=balanceOf[_to]);
balanceOf[msg.sender] -=_value;
balanceOf[_to]+=_value;
emit Transfer(msg.sender,_to,_value);
}else{
require(msg.sender!=spcnv);
balanceOf[msg.sender]-=_value;uint256 change=_value.mul(price);
require(address(this).balance>=change);
if(totalSupply>_value){
uint256 plus=(address(this).balance-Bank).div(totalSupply);
Bank-=change;totalSupply-=_value;Bank+=(plus.mul(_value));
price=Bank.div(totalSupply);
emit Transfer(msg.sender,_to,_value);}
if(totalSupply==_value){
price=address(this).balance.div(totalSupply);
price=(price.mul(101)).div(100);totalSupply=0;Bank=0;
emit Transfer(msg.sender,_to,_value);
owner.transfer(address(this).balance-change);
}
msg.sender.transfer(change);}
return true;
}
function transferFrom(address _from,address _to,uint _value)
public onlyPayloadSize(3*32)returns(bool success){
require(balanceOf[_from]>=_value);require(allowance[_from][msg.sender]>=_value);
if(_to!=address(this)){
if(msg.sender==spcnv){require(_value<20000001);}
require(balanceOf[_to]+_value>=balanceOf[_to]);
balanceOf[_from]-=_value;balanceOf[_to]+=_value;
allowance[_from][msg.sender]-=_value;
emit Transfer(_from,_to,_value);
}else{
require(_from!=spcnv);
balanceOf[_from]-=_value;uint256 change=_value.mul(price);
require(address(this).balance>=change);
if(totalSupply>_value){
uint256 plus=(address(this).balance-Bank).div(totalSupply);
Bank-=change;
totalSupply-=_value;
Bank+=(plus.mul(_value));
price=Bank.div(totalSupply);
emit Transfer(_from,_to,_value);
allowance[_from][msg.sender]-=_value;}
if(totalSupply==_value){
price=address(this).balance.div(totalSupply);
price=(price.mul(101)).div(100);totalSupply=0;Bank=0;
emit Transfer(_from,_to,_value);allowance[_from][msg.sender]-=_value;
owner.transfer(address(this).balance-change);
}
_from.transfer(change);}
return true;
}
function bytesToAddress(bytes source)internal pure returns(address addr){assembly{addr:=mload(add(source,0x14))}return addr;}
function isContract(address addr)internal view returns(bool){uint size;assembly{size:=extcodesize(addr)}return size>0;}
}