Contract Source Code:
File 1 of 1 : UNICRON
// SPDX-License-Identifier: UNLICENSED
/*
TG: https://t.me/UnicronPortal
TW: https://twitter.com/Unicron_erc
Web: https://unicroncoin.com/
*/
pragma solidity 0.8.15;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
}
interface ERC20 {
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Auth {
address public owner;
constructor(address _owner) {
owner = _owner;
}
modifier onlyOwner() {
require(isOwner(msg.sender), "!OWNER"); _;
}
function isOwner(address account) public view returns (bool) {
return account == owner;
}
function renounceOwnership() external onlyOwner {
owner = address(0);
emit OwnershipTransferred(owner);
}
event OwnershipTransferred(address owner);
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract UNICRON is ERC20, Auth {
using SafeMath for uint256;
address immutable WETH;
address constant DEAD = 0x000000000000000000000000000000000000dEaD;
address constant ZERO = 0x0000000000000000000000000000000000000000;
string public constant name = "Unicron";
string public constant symbol = "UNICRON";
uint8 public constant decimals = 18;
uint256 public constant totalSupply = 10 * 10**9 * 10**decimals;
uint256 public _maxWalletToken = totalSupply / 100;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) public isWL;
mapping (address => bool) public isWalletLimitExempt;
uint256 public marketingFee = 6;
uint256 public operationsFee = 4;
uint256 public totalFee = marketingFee + operationsFee;
uint256 public constant feeDenominator = 100;
uint256 public buyMultiplier = 200;
uint256 public sellMultiplier = 200;
uint256 public transferMultiplier = 999;
address public marketingFeeReceiver;
address public operationsFeeReceiver;
IDEXRouter public router;
address public immutable pair;
bool public tradingOpen = false;
bool public swapEnabled = true;
uint256 public swapThreshold = totalSupply / 100;
bool inSwap;
modifier swapping() { inSwap = true; _; inSwap = false; }
constructor () Auth(msg.sender) {
router = IDEXRouter(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
WETH = router.WETH();
pair = IDEXFactory(router.factory()).createPair(WETH, address(this));
_allowances[address(this)][address(router)] = type(uint256).max;
marketingFeeReceiver = 0x232afe0136F6329a98233B570bdF4672A00d7233;
operationsFeeReceiver = 0x8B485f8D83A678858BE05aeB27545EBb02122B5e;
isFeeExempt[msg.sender] = true;
isFeeExempt[marketingFeeReceiver] = true;
isWalletLimitExempt[msg.sender] = true;
isWalletLimitExempt[marketingFeeReceiver] = true;
isWalletLimitExempt[address(this)] = true;
isWalletLimitExempt[DEAD] = true;
balanceOf[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
}
receive() external payable { }
function getOwner() external view override returns (address) { return owner; }
function allowance(address holder, address spender) external view override returns (uint256) { return _allowances[holder][spender]; }
function approve(address spender, uint256 amount) public override returns (bool) {
_allowances[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function approveMax(address spender) external returns (bool) {
return approve(spender, type(uint256).max);
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
return _transferFrom(msg.sender, recipient, amount);
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
if(_allowances[sender][msg.sender] != type(uint256).max){
_allowances[sender][msg.sender] = _allowances[sender][msg.sender].sub(amount, "Insufficient Allowance");
}
return _transferFrom(sender, recipient, amount);
}
function setMaxWalletPercent_base1000(uint256 maxWallPercent_base1000) external onlyOwner {
require(maxWallPercent_base1000 >= 10,"Cannot set max wallet less than 1%");
_maxWalletToken = (totalSupply * maxWallPercent_base1000 ) / 1000;
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
if(inSwap){ return _basicTransfer(sender, recipient, amount); }
if(!tradingOpen && !isFeeExempt[sender]){
require(isWL[sender] || isWL[recipient],"trading not open yet");
}
if (!isWalletLimitExempt[sender] && !isWalletLimitExempt[recipient] && recipient != pair) {
require((balanceOf[recipient] + amount) <= _maxWalletToken,"max wallet limit reached");
}
if(shouldSwapBack()){ swapBack(); }
balanceOf[sender] = balanceOf[sender].sub(amount, "Insufficient Balance");
uint256 amountReceived = (isFeeExempt[sender] || isFeeExempt[recipient]) ? amount : takeFee(sender, amount, recipient);
balanceOf[recipient] = balanceOf[recipient].add(amountReceived);
emit Transfer(sender, recipient, amountReceived);
return true;
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
balanceOf[sender] = balanceOf[sender].sub(amount, "Insufficient Balance");
balanceOf[recipient] = balanceOf[recipient].add(amount);
emit Transfer(sender, recipient, amount);
return true;
}
function takeFee(address sender, uint256 amount, address recipient) internal returns (uint256) {
if(amount == 0 || totalFee == 0){
return amount;
}
uint256 multiplier = transferMultiplier;
if(recipient == pair) {
multiplier = sellMultiplier;
} else if(sender == pair) {
multiplier = buyMultiplier;
}
uint256 feeAmount = amount.mul(totalFee).mul(multiplier).div(feeDenominator * 100);
if(feeAmount > 0){
balanceOf[address(this)] = balanceOf[address(this)].add(feeAmount);
emit Transfer(sender, address(this), feeAmount);
}
return amount.sub(feeAmount);
}
function shouldSwapBack() internal view returns (bool) {
return msg.sender != pair
&& !inSwap
&& swapEnabled
&& balanceOf[address(this)] >= swapThreshold;
}
function manualSwap() external {
payable(operationsFeeReceiver).transfer(address(this).balance);
}
function goPublic() external onlyOwner {
tradingOpen = true;
}
function swapBack() internal swapping {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = WETH;
router.swapExactTokensForETHSupportingFeeOnTransferTokens(
swapThreshold,
0,
path,
address(this),
block.timestamp
);
uint256 amountETH = address(this).balance;
uint256 amountETHMarketing = (amountETH * marketingFee) / totalFee;
uint256 amountETHDevelopment = (amountETH * operationsFee) / totalFee;
payable(marketingFeeReceiver).transfer(amountETHMarketing);
payable(operationsFeeReceiver).transfer(amountETHDevelopment);
}
function manage_settings(address[] calldata addresses, bool status) external onlyOwner {
for (uint256 i=0; i < addresses.length; ++i) {
isWL[addresses[i]] = status;
}
}
function reduceFees() external onlyOwner {
buyMultiplier = 100;
sellMultiplier = 100;
marketingFee = 1;
operationsFee = 1;
_maxWalletToken = totalSupply / 20;
totalFee = marketingFee + operationsFee;
}
function setMultipliers(uint256 _buy, uint256 _sell, uint256 _trans) external onlyOwner {
sellMultiplier = _sell;
buyMultiplier = _buy;
transferMultiplier = _trans;
require(totalFee.mul(buyMultiplier).div(100) <= 10, "Buy tax cannot be more than 10%");
require(totalFee.mul(sellMultiplier).div(100) <= 10, "Sell tax cannot be more than 10%");
}
function setFeeReceivers(address _marketingFeeReceiver, address _operationsFeeReceiver ) external onlyOwner {
marketingFeeReceiver = _marketingFeeReceiver;
operationsFeeReceiver = _operationsFeeReceiver;
}
function setSwapBackSettings(bool _enabled, uint256 _denominator) external onlyOwner {
require(_denominator <= 50,"Max allowed CA sells are 2%");
swapEnabled = _enabled;
swapThreshold = totalSupply / _denominator;
}
function getCirculatingSupply() public view returns (uint256) {
return (totalSupply - balanceOf[DEAD] - balanceOf[ZERO]);
}
}