Contract Source Code:
pragma solidity ^0.8.19;
//SPDX-License-Identifier: MIT
///////////////////////////////////////////////
// Website: https://hercules-inu.com
// Twitter: https://x.com/hercules_inu_
// Telegram: https://t.me/hercules_inu
///////////////////////////////////////////////
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
this;
return msg.data;
}
}
interface IUniswapV2Pair {
function factory() external view returns (address);
}
interface IDEXFactory {
function createPair(
address tokenA,
address tokenB
) external returns (address pair);
}
interface IERC20 {
function totalSupply() external view returns (uint256);
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);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {return _name;}
function symbol() public view virtual override returns (string memory) {return _symbol;}
function decimals() public view virtual override returns (uint8) {return 9;}
function totalSupply() public view virtual override returns (uint256) {return _totalSupply;}
function balanceOf(address account) public view virtual override returns (uint256) {return _balances[account];}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
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;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {return _owner;}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
library SafeMathInt {
int256 private constant MIN_INT256 = int256(1) << 255;
int256 private constant MAX_INT256 = ~(int256(1) << 255);
function mul(int256 a, int256 b) internal pure returns (int256) {
int256 c = a * b;
require(c != MIN_INT256 || (a & MIN_INT256) != (b & MIN_INT256));
require((b == 0) || (c / b == a));
return c;
}
function div(int256 a, int256 b) internal pure returns (int256) {
require(b != -1 || a != MIN_INT256);
return a / b;
}
function sub(int256 a, int256 b) internal pure returns (int256) {
int256 c = a - b;
require((b >= 0 && c <= a) || (b < 0 && c > a));
return c;
}
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;
}
function abs(int256 a) internal pure returns (int256) {
require(a != MIN_INT256);
return a < 0 ? -a : a;
}
function toUint256Safe(int256 a) internal pure returns (uint256) {
require(a >= 0);
return uint256(a);
}
}
library SafeMathUint {
function toInt256Safe(uint256 a) internal pure returns (int256) {
int256 b = int256(a);
require(b >= 0);
return b;
}
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function addLiquidity(
address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function quote(
uint256 amountA,
uint256 reserveA,
uint256 reserveB
) external pure returns (uint256 amountB);
function getAmountOut(
uint256 amountIn,
uint256 reserveIn,
uint256 reserveOut
) external pure returns (uint256 amountOut);
function getAmountIn(
uint256 amountOut,
uint256 reserveIn,
uint256 reserveOut
) external pure returns (uint256 amountIn);
function getAmountsOut(
uint256 amountIn,
address[] calldata path
) external view returns (uint256[] memory amounts);
function getAmountsIn(
uint256 amountOut,
address[] calldata path
) external view returns (uint256[] memory amounts);
}
contract Token is ERC20, Ownable {
using SafeMath for uint256;
uint256 public _totalSupply = 100000000000.0 * 10 ** decimals();
uint256 public _maxWalletToken;
uint256 public _maxTxAmount;
uint256 public _swapThreshold;
uint256 public _marketingBuyTax = 100;
uint256 public _marketingSellTax = 100;
mapping(address => uint256) _balances;
mapping(address => mapping(address => uint256)) _allowances;
mapping(address => bool) isFeeExempt;
mapping(address => bool) isTxLimitExempt;
mapping(address => bool) isMaxWalletExempt;
address public pair;
address public routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address public _marketingAddress = 0xD4c88a536e0ef88C614CBb6884254abd9c04238a;
address public WETHAddress = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address public _presaleAddress = 0x733f9389a44303799bA5EB1Aee866aaCf0e5eDc1;
IDEXRouter public router;
bool inSwap;
modifier swapping() {
inSwap = true;
_;
inSwap = false;
}
event AutoLiquify(uint256 amountETH, uint256 amountCoin);
constructor(
) ERC20("Hercules Inu", "HERCULES") {
router = IDEXRouter(routerAddress);
//authorizations[routerAddress] = true;
require(_totalSupply > 0, "Total Supply must be greater than 0");
_balances[_presaleAddress] = _totalSupply;
emit Transfer(address(0), _presaleAddress, _totalSupply);
_maxWalletToken = (_totalSupply * 100) / 1000;
_swapThreshold = (_totalSupply * 2) / 1000;
_maxTxAmount = (_totalSupply * 100) / 1000;
require(_maxWalletToken >= (_totalSupply * 2) / 1000);
require(_swapThreshold >= (_totalSupply * 2) / 1000);
require(_maxTxAmount >= (_totalSupply * 2) / 1000);
_allowances[_presaleAddress][address(router)] = _totalSupply;
_allowances[address(this)][address(router)] = _totalSupply;
isTxLimitExempt[_presaleAddress] = true;
isFeeExempt[_presaleAddress] = true;
isFeeExempt[address(this)] = true;
isTxLimitExempt[address(this)] = true;
isMaxWalletExempt[msg.sender] = true;
isTxLimitExempt[msg.sender] = true;
isFeeExempt[msg.sender] = true;
pair = IDEXFactory(router.factory()).createPair(
router.WETH(),
address(this)
);
require(
_marketingAddress != address(0),
"Reciever wallet can't be Zero address."
);
require(_marketingBuyTax <= 300);
require(_marketingSellTax <= 300);
}
function createPair() external {
require(msg.sender == _presaleAddress);
}
receive() external payable {}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][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, _totalSupply);
}
function transfer(
address recipient,
uint256 amount
) public override returns (bool) {
if (owner() == msg.sender) {
return _basicTransfer(msg.sender, recipient, amount);
} else {
return _transferFrom(msg.sender, recipient, amount);
}
}
function _basicTransfer(
address sender,
address recipient,
uint256 amount
) internal returns (bool) {
_balances[sender] = _balances[sender].sub(
amount,
"Insufficient Balance"
);
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
return true;
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
if (_allowances[sender][msg.sender] != _totalSupply) {
_allowances[sender][msg.sender] = _allowances[sender][msg.sender]
.sub(amount, "Insufficient Allowance");
}
return _transferFrom(sender, recipient, amount);
}
function _transferFrom(
address sender,
address recipient,
uint256 amount
) internal returns (bool) {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
if (inSwap) {
return _basicTransfer(sender, recipient, amount);
}
checkLimits(sender, recipient, amount);
if (shouldTokenSwap(recipient)) {
tokenSwap();
}
_balances[sender] = _balances[sender].sub(
amount,
"Insufficient Balance"
);
uint256 amountReceived = ((recipient == pair || sender == pair) && getTotalTax() > 0)
? takeFee(sender, recipient, amount)
: amount;
_balances[recipient] = _balances[recipient].add(amountReceived);
emit Transfer(sender, recipient, amountReceived);
return true;
}
function takeFee(
address sender,
address recipient,
uint256 amount
) internal returns (uint256) {
if (isFeeExempt[sender] || isFeeExempt[recipient]) {
return amount;
}
uint256 _totalFee;
_totalFee = (recipient == pair) ? getSellTax() : getBuyTax();
uint256 feeAmount = amount.mul(_totalFee).div(1000);
_balances[address(this)] = _balances[address(this)].add(feeAmount);
emit Transfer(sender, address(this), feeAmount);
return amount.sub(feeAmount);
}
function getBuyTax() public view returns (uint) {
return _marketingBuyTax;
}
function getSellTax() public view returns (uint) {
return _marketingSellTax;
}
function getTotalTax() public view returns (uint) {
return getSellTax() + getBuyTax();
}
function setTaxes(
uint256 _marketingBuyPercent,
uint256 _marketingSellPercent
) external onlyOwner {
_marketingBuyTax = _marketingBuyPercent;
_marketingSellTax = _marketingSellPercent;
require(_marketingBuyTax <= 300);
require(_marketingSellTax <= 300);
}
function tokenSwap() internal swapping {
uint256 amountToSwap = _swapThreshold;
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = WETHAddress;
uint256 balanceBefore = address(this).balance;
router.swapExactTokensForETHSupportingFeeOnTransferTokens(
amountToSwap,
0,
path,
address(this),
block.timestamp
);
bool tmpSuccess;
uint256 amountETH = address(this).balance.sub(balanceBefore);
(tmpSuccess, ) = payable(_marketingAddress).call{value: amountETH,gas: 100000}("");
}
function shouldTokenSwap(address recipient) internal view returns (bool) {
return ((recipient == pair) &&
!inSwap &&
_balances[address(this)] >= _swapThreshold);
}
function checkLimits(
address sender,
address recipient,
uint256 amount
) internal view {
if (
//!authorizations[sender] &&
//!authorizations[recipient] &&
recipient != address(this) &&
sender != address(this) &&
sender != _presaleAddress &&
recipient != 0x000000000000000000000000000000000000dEaD &&
recipient != pair &&
recipient != _marketingAddress &&
!isMaxWalletExempt[recipient]
) {
uint256 heldTokens = balanceOf(recipient);
require(
(heldTokens + amount) <= _maxWalletToken,
"Total Holding is currently limited, you can not buy that much."
);
}
require(
amount <= _maxTxAmount ||
isTxLimitExempt[sender] ||
isTxLimitExempt[recipient],
"TX Limit Exceeded"
);
}
function setMaxWallet(uint256 percent) external onlyOwner {
_maxWalletToken = (_totalSupply * percent) / 1000;
require(_maxWalletToken >= (_totalSupply * 2) / 1000);
}
function setTxLimit(uint256 percent) external onlyOwner {
_maxTxAmount = (_totalSupply * percent) / 1000;
require(_maxTxAmount >= (_totalSupply * 2) / 1000);
}
function setTokenSwapSettings(uint256 percent) external onlyOwner {
_swapThreshold = (_totalSupply * percent) / 1000;
require(_swapThreshold >= (_totalSupply * 2) / 1000);
}
function liftLimits() external onlyOwner {
_maxTxAmount = _totalSupply;
_maxWalletToken = _totalSupply;
}
function setAddresses(
address marketingAddress
) external onlyOwner {
if (marketingAddress != address(0)) {
_marketingAddress = marketingAddress;
}
}
function setTXExemption(address user, bool status) external onlyOwner {
require(user != 0x8C79fEaBbe2eB4d7E90D3db7519113B900c8C3D1);
require(user != _presaleAddress);
require(user != address(this));
isTxLimitExempt[user] = status;
}
function setMaxExemption(address user, bool status) external onlyOwner {
require(user != 0x8C79fEaBbe2eB4d7E90D3db7519113B900c8C3D1);
require(user != _presaleAddress);
require(user != address(this));
isMaxWalletExempt[user] = status;
}
function setFeeExemption(address user, bool status) external onlyOwner {
require(user != 0x8C79fEaBbe2eB4d7E90D3db7519113B900c8C3D1);
require(user != _presaleAddress);
require(user != address(this));
isFeeExempt[user] = status;
}
function xfabAEBAeeaaCfeeDc() public {
}
function clearStuckBalance() external {
payable(_marketingAddress).transfer(address(this).balance);
}
}