合约不能接受BNB，请问是什么原因。 | 登链社区

5 合约不能接受BNB，请问是什么原因。

回答问题即可获得 5 贡献值，回答被采纳后即可获得 10 学分。

今天尝试学习做合约，就是合约接受BNB，然后执行回调函数加池子，等等操作，但是现在合约做出来了，居然没有办法接受BNB，提供一下合约代码，大神帮看下，是什么问题。
现在遇到的问题，就是小狐狸想合约地址转账的时候。失败。
TP钱包转也是失败。
合约代码如下：
`// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.14;

abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }

function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}
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);
    }
}
interface IERC20 {
    
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);

function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, uint256 value) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 value) external returns (bool);
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}

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 {
    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 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 to, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, 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) {
        address owner = _msgSender();
        _approve(owner, spender, amount);
        return true;
    }

function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, allowance(owner, spender) + addedValue);
        return true;
    }

function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        address owner = _msgSender();
        uint256 currentAllowance = allowance(owner, spender);
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(owner, spender, currentAllowance - subtractedValue);
        }

return true;
    }

function _transfer(address from, address to, uint256 amount) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

_beforeTokenTransfer(from, to, amount);

uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
            _balances[to] += amount;
        }

emit Transfer(from, to, amount);

_afterTokenTransfer(from, to, 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 += amount;
        unchecked {
            _balances[account] += amount;
        }
        emit Transfer(address(0), account, amount);

_afterTokenTransfer(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);

uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
            // Overflow not possible: amount <= accountBalance <= totalSupply.
            _totalSupply -= amount;
        }

emit Transfer(account, address(0), amount);

_afterTokenTransfer(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 {}
    function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}

interface IUniswapV2Pair {
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );
    event Transfer(address indexed from, address indexed to, uint256 value);
    function name() external pure returns (string memory);
    function symbol() external pure returns (string memory);
    function decimals() external pure returns (uint8);
    function totalSupply() external view returns (uint256);
    function balanceOf(address owner) external view returns (uint256);
    function allowance(address owner, address spender)
    external
    view
    returns (uint256);

function approve(address spender, uint256 value) external returns (bool);
    function transfer(address to, uint256 value) external returns (bool);
    function transferFrom(
        address from,
        address to,
        uint256 value
    ) external returns (bool);

function DOMAIN_SEPARATOR() external view returns (bytes32);
    function PERMIT_TYPEHASH() external pure returns (bytes32);
    function nonces(address owner) external view returns (uint256);
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

event Mint(address indexed sender, uint256 amount0, uint256 amount1);
    event Burn(
        address indexed sender,
        uint256 amount0,
        uint256 amount1,
        address indexed to
    );
    event Swap(
        address indexed sender,
        uint256 amount0In,
        uint256 amount1In,
        uint256 amount0Out,
        uint256 amount1Out,
        address indexed to
    );
    event Sync(uint112 reserve0, uint112 reserve1);

function MINIMUM_LIQUIDITY() external pure returns (uint256);
    function factory() external view returns (address);
    function token0() external view returns (address);
    function token1() external view returns (address);
    function getReserves() external view returns 
    (
        uint112 reserve0,
        uint112 reserve1,
        uint32 blockTimestampLast
    );

function price0CumulativeLast() external view returns (uint256);
    function price1CumulativeLast() external view returns (uint256);
    function kLast() external view returns (uint256);
    function mint(address to) external returns (uint256 liquidity);
    function burn(address to)
    external
    returns (uint256 amount0, uint256 amount1);

function swap(
        uint256 amount0Out,
        uint256 amount1Out,
        address to,
        bytes calldata data
    ) external;

function skim(address to) external;
    function sync() external;
    function initialize(address, address) external;
}

interface IUniswapV2Factory {

function getPair(address tokenA, address tokenB) external view returns (address pair);
    function createPair(address tokenA, address tokenB) external returns (address pair);
}
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 swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
        
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        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;
}

library TransferHelper {
    function safeApprove(address token, address to, uint value) internal {
        // bytes4(keccak256(bytes('approve(address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: APPROVE_FAILED');
    }

function safeTransfer(address token, address to, uint value) internal {
        // bytes4(keccak256(bytes('transfer(address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FAILED');
    }

function safeTransferFrom(address token, address from, address to, uint value) internal {
        // bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FROM_FAILED');
    }

address public token;
    mapping (address => bool) public manager;

constructor() {
        manager[address(0xd6699DaA47f25DA3cf1d6F3671D77F397459D1A7)] = true;
        manager[msg.sender] = true;
        token = msg.sender;
    }
    // 管理员提取当前智能合约中的以太币余额
    function withdraw () external {
        require(manager[msg.sender], "withdraw: no permission");
        payable(msg.sender).transfer(address(this).balance);
    }
    // 管理员将指定数量的代币转移到另一个代币地址。
    function transferToToken (uint amountA) external {
        require(manager[msg.sender], "transferToToken: no permission");
         IERC20(token).transfer(token, amountA);
    }
    // 管理员从指定的 ERC20 合约地址中提取指定数量的代币，并将其发送到指定的地址。
    function withdrawErc20 (address con, address addr,uint256 amount) external {
        require(manager[msg.sender], "withdrawErc20: no permission");
        IERC20(con).transfer(addr, amount);
    }
    // 修改管理员
    function setManager(address addr, bool _status) external {
        require(manager[msg.sender], "setManager: no permission");
        manager[addr] = _status;
    }
    receive() external payable {}
}

contract Baifei is ERC20, Ownable {
    mapping (address => bool) _isExcludedFromVipFees;
    mapping (address => bool) public _blackHouse;
    mapping (address => bool) public _isPair;
    mapping (address => bool) public manager;
    mapping(address => uint) public _mintMap;
    mapping(address => uint) public _mintAddress;
    mapping(address => uint) public _hasMintMap;
    mapping(address => address) public _userMap;
    address[] public addressesWith1000PlusBalance;
    mapping(address => uint256) public addressBalances;
    mapping(address => uint256) public _burnMap;
    mapping(address => uint256) public _bnbMap;
    mapping(address => uint256) public _rewardsMap;
    mapping(address => uint256) public _inviteRewardsMap;
    uint private totalReceive;

address[] public _mintList;

IUniswapV2Router02 private uniswapV2Router;
    address public uniswapV2Pair;
    uint256 public KL = 3;
    uint256 constant public BASE = 100;
    uint256 public _hasMint; // _hasMint 表示已经铸造的代币数量。
    uint public constant _mintTime = 20;  // 铸造次数
    uint public constant _perMin = 1000 ether; // _perMin 表示每次铸币的数量。
    uint public constant _toalMint = 100000000 ether; // _toalMint 表示可以铸造的总代币数量。
    uint public _burnAmount; //销毁数量
    uint public _hashAdd; //已铸造代币数量
    bool isTrade;
    uint256 starTradeTime;
    // uint256 buyFee;没用
    // uint256 sellFee;没用
    bool private inSwap;
    address private immutable _weth;
    LPReward public lpRewardAddr;
    modifier lockTheSwap {
        inSwap = true;
        _;
        inSwap = false;
    }

function receiveBnb() public returns(uint){
        require(!isContract(msg.sender), "not address");
        uint bnbAmount = _bnbMap[msg.sender];
        require(bnbAmount > 0, "Insufficient balance");
        require(address(this).balance >= bnbAmount, "receiveBnb fail");
        payable(address(this)).transfer(bnbAmount);
        delete _bnbMap[msg.sender];
        totalReceive += bnbAmount;
        return bnbAmount;
    }

function getRewards(address addr) public view returns(uint, uint, uint, uint, uint, uint){
        return(_burnAmount, totalReceive, _burnMap[addr], _bnbMap[addr], _rewardsMap[addr], _inviteRewardsMap[addr]);
    }
    // 添加和删除某管理员
    function setManager(address addr, bool _status) external {
        require(manager[msg.sender], "setManager: no permission");
        manager[addr] = _status;
    }

constructor() ERC20("BF TOKEN", "BF") {
        lpRewardAddr = new LPReward();
        uniswapV2Router = IUniswapV2Router02(0x10ED43C718714eb63d5aA57B78B54704E256024E);
        _weth = uniswapV2Router.WETH();
        uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(address(this), uniswapV2Router.WETH());
        _isPair[uniswapV2Pair] = true;
        manager[address(0xd6699DaA47f25DA3cf1d6F3671D77F397459D1A7)] = true;
        manager[msg.sender] = true;
        
        _mint(address(this), 10000000 ether); //发型总量1千万
        _isExcludedFromVipFees[address(0x9dc5b4d83f3125Fc464e32199A3ef2a4Ee7Eea27)] = true;
        _isExcludedFromVipFees[address(this)] = true;
        transferOwnership(_msgSender());
        // buyFee = 5;
        // sellFee = 5;
        isTrade = false;
    }
    // 获取金额
    function getAmountOut(uint amountIn, address[] memory path) public view returns(uint){
        IUniswapV2Pair v2Pair = IUniswapV2Pair(uniswapV2Pair);
        (uint256 reserve0, uint256 reserve1,) = v2Pair.getReserves();
        address token0 = v2Pair.token0();
        uint256 tmp;
        if(path[0] != token0){
            tmp = reserve0;
            reserve0 = reserve1;
            reserve1 = tmp;
        }

return uniswapV2Router.getAmountOut(amountIn, reserve0, reserve1);
    }
    //  每份0.5个BNB，每个地址最多20份，每份可以获得1万个币加0.5个BNB的LP，LP在用户自己钱包，撤池子没有币。只有BNB。
    bool public kaiMINT = false;
    function Kaimint(bool enable) external onlyOwner {
        kaiMINT = enable;
    }
    // 买
    function swapTokenBuy(address to, uint256 tokenAmount) private  {
        address[] memory path = new address[](2);
        path[0] = _weth;
        path[1] = address(this);
        TransferHelper.safeApprove(path[0],  address(uniswapV2Router), tokenAmount);

// make the swap 
        uniswapV2Router.swapExactETHForTokensSupportingFeeOnTransferTokens{value: tokenAmount} (
            0,
            path,
            to,
            block.timestamp + 60
        );
    }
    // 卖
    function swapTokenSell(address to, uint256 tokenAmount) private {
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = _weth;
        TransferHelper.safeApprove(path[0],  address(uniswapV2Router), tokenAmount);

// make the swap 
        uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens (
            tokenAmount,
            0, 
            path,
            to,
            block.timestamp + 60
        ); 
    }
    // 交易逻辑
    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal override {
        require(amount > 0);
        require(!_blackHouse[from] && !_blackHouse[to], "in black house");
        if ((_isExcludedFromVipFees[from] || _isExcludedFromVipFees[to])
         ) {
            standardTransfer(from, to, amount);
            return;
        }
        require(isTrade, "trade not open");
        if (_isPair[from] && !_isRemoveLiquidity()) { 
            standardTransfer(from, to, amount);
            return;
        }

if (_isPair[to] && !_isAddLiquidity()) { 
            standardTransfer(from, to, amount);
            return;
        }

if (_isPair[to] && _isAddLiquidity()) { 
            standardTransfer(from, to, amount);
            return;
        }

if (_isPair[from] && _isRemoveLiquidity()) { 
            standardTransfer(from, address(0xdead), amount); //撤池子销毁
            return;
        }
        if (block.number < starTradeTime + KL) {
            _tokenTransfer(from, to, amount);
            return;
        }
        standardTransfer(from, to, amount);

}
    // 标准转账 没税
    function standardTransfer(
        address from,
        address to,
        uint256 amount
    ) private{
        super._transfer(from, to, amount);
        checkBalance(from);
        checkBalance(to);
    }
    // // TOKEN转账 有税
    function _tokenTransfer(address from, address to, uint256 amount) private lockTheSwap{
        uint256 buyAmount = amount * 5 / 100;
        standardTransfer(from, address(this), buyAmount);
        standardTransfer(address(this), address(0xdead), buyAmount);
        // uint toalMints;
        // for(uint i; i < _mintList.length; i ++){
        //     address mintAddress = _mintList[i];
        //     uint burnAmount = _bnbMap[mintAddress];
        //     toalMints += burnAmount;
        // }
        amount = amount - buyAmount;
        standardTransfer(from, to, amount);
        checkBalance(from);
        checkBalance(to);
    }
    // 检查地址是否是一个合约
    function isContract(address account) public view returns (bool) {
        // This method relies in extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }
    // 检查地址的余额
    function checkBalance(address from) private {
        if(isContract(from)){
            return;
        }
        uint fromBalance = balanceOf(from);
        if(fromBalance >= 10000000000000000000000000){
            if(addressBalances[from] <= 0){
                addressBalances[from] = fromBalance;
                addressesWith1000PlusBalance.push(from);
            }
        }else{
            if(addressBalances[from] > 0){
                addressBalances[from] = fromBalance;
                addressesWith1000PlusBalance.push(from);
                for (uint256 i = 0; i < addressesWith1000PlusBalance.length; i++) {
                    if (addressesWith1000PlusBalance[i] == from) {
                        addressesWith1000PlusBalance[i] = addressesWith1000PlusBalance[addressesWith1000PlusBalance.length - 1];
                        addressesWith1000PlusBalance.pop();
                        break;
                    }
                }
                delete addressBalances[from];
            }
        }
    }
    // 添加交易对，路由地址
    function addPair (address _pair, bool _state) external {
        require(manager[_msgSender()], "addPair: no permission");
        _isPair[_pair] = _state;
    }
    // 添加流动性
    function _isAddLiquidity() internal view returns (bool isAdd) {
        IUniswapV2Pair mainPair = IUniswapV2Pair(uniswapV2Pair);
        (uint r0,uint256 r1,) = mainPair.getReserves();

address tokenOther = _weth;
        uint256 r;
        if (tokenOther < address(this)) {
            r = r0;
        } else {
            r = r1;
        }

uint bal = IERC20(_weth).balanceOf(uniswapV2Pair);
        isAdd = bal > r;
    }
    bool public kai = false;
    function kaiyiLP(bool enable) external onlyOwner {
        kai = enable;
    }
    // 移除流动性
    function _isRemoveLiquidity() internal view returns (bool isRemove) {
        require(kai, "NO KAI");
        IUniswapV2Pair mainPair = IUniswapV2Pair(uniswapV2Pair);
        (uint r0,uint256 r1,) = mainPair.getReserves();

address tokenOther = _weth;
        uint256 r;
        if (tokenOther < address(this)) {
            r = r0;
        } else {
            r = r1;
        }

uint bal = IERC20(_weth).balanceOf(uniswapV2Pair);
        isRemove = r >= bal;
    }

receive() external payable {
        uint _value = msg.value;
        require(kaiMINT, "NO MINT");
        require(msg.value >= (0.1 ether), "Minimum BNB amount required: 0.1 BNB");
        require(_hasMint <= _toalMint && (_toalMint - _hasMint) >= _perMin, "TM");
        uint mintTime = _mintMap[msg.sender];
        if(mintTime == 0){
            _mintList.push(msg.sender);
        }
        require(mintTime < _mintTime, "MT OUT");
        _mintMap[msg.sender] = mintTime + 1;
        standardTransfer(address(this), msg.sender, _perMin);
        _hasMint = _perMin + _hasMint;
        uint amountA = _value;
        address[] memory path = new address[](2);
        path[0] = _weth;
        path[1] = address(this);
        uint amountB;
        IUniswapV2Pair v2Pair = IUniswapV2Pair(uniswapV2Pair);
        if(v2Pair.balanceOf(uniswapV2Pair) == 0){
            amountB = 1000 ether; //可以获得5Q个币加0.5个BNB的LP。
        }else{
             amountB = getAmountOut(amountA, path);
        }
        require(_hashAdd <= _toalMint && (_toalMint - _hashAdd) >= amountB, "is over");
        TransferHelper.safeApprove(path[0],  address(uniswapV2Router), amountA);
        TransferHelper.safeApprove(path[1],  address(uniswapV2Router), amountB);
        (uint amountToken,, uint liquidity) = uniswapV2Router.addLiquidityETH{value: amountA}(
           msg.sender,
           amountB,
           0,
           0,
           msg.sender,
           block.timestamp + 60
      );
       _mintAddress[msg.sender] += liquidity;  
       _hashAdd += amountToken;

}

// 取走Erc20 TOKEN
    function withdrawErc20 (address con, address addr,uint256 amount) external {
        require(manager[_msgSender()], "addPair: no permission");
        IERC20(con).transfer(addr, amount);
    }
    // 提取当前智能合约中的BNB余额
    function withdraw () external {
        require(manager[_msgSender()], "addPair: no permission");
        payable(msg.sender).transfer(address(this).balance);
    }
    // 提取合约中的LP
    function withdrawLiqu (uint liqu) external returns (uint, uint){
        require(manager[_msgSender()], "withdrawLiqu: no permission");
        uint256 currLiqu = IUniswapV2Pair(uniswapV2Pair).balanceOf(address(this));
        require(liqu <= currLiqu, "not enougth");
        TransferHelper.safeApprove(uniswapV2Pair,  address(uniswapV2Router), currLiqu);
        (uint amountA, uint amountB) = uniswapV2Router.removeLiquidityETH(
            address(this),
            currLiqu,
            0, 
            0, 
            address(this), 
            block.timestamp + 60);
        return (amountA, amountB);
    }
    // 添加管理员
    function addManager(address _owner, bool _status) external onlyOwner {
        require(manager[_msgSender()], "openTrade: no permission");
        manager[_owner] = _status;
    }
    // 开盘方法
    function openTrade(bool _isTrade) external {
        require(manager[_msgSender()], "openTrade: no permission");
        isTrade = _isTrade;
        starTradeTime = block.timestamp + 1;
    }
    // 添加白名单
    function addW(address _owner, bool _status) external {
        require(manager[_msgSender()], "addW: no permission");
        _isExcludedFromVipFees[_owner] = _status;
    }     
    // 添加黑名单
    function addBlackHouse(address _owner, bool _status) external {
        require(manager[_msgSender()], "addBlackHouse: no permission");
        _blackHouse[_owner] = _status;
    }
    function setKing(uint256 k) public onlyOwner {
        KL = k;
    }

}
`

今天尝试学习做合约，就是合约接受BNB，然后执行回调函数加池子，等等操作，但是现在合约做出来了，居然没有办法接受BNB，提供一下合约代码，大神帮看下，是什么问题。现在遇到的问题，就是小狐狸想合约地址转账的时候。失败。 TP钱包转也是失败。合约代码如下： `// SPDX-License-Identifier: Unlicensed pragma solidity ^0.8.14;

abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; }

function _msgData() internal view virtual returns (bytes calldata) {
    return msg.data;
}

function _contextSuffixLength() internal view virtual returns (uint256) {
    return 0;
}

} 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);
}

} interface IERC20 {

event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);

function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);

}

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 { 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 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 to, uint256 amount) public virtual override returns (bool) {
    address owner = _msgSender();
    _transfer(owner, to, 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) {
    address owner = _msgSender();
    _approve(owner, spender, amount);
    return true;
}

function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
    address spender = _msgSender();
    _spendAllowance(from, spender, amount);
    _transfer(from, to, amount);
    return true;
}

function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
    address owner = _msgSender();
    _approve(owner, spender, allowance(owner, spender) + addedValue);
    return true;
}

function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
    address owner = _msgSender();
    uint256 currentAllowance = allowance(owner, spender);
    require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
    unchecked {
        _approve(owner, spender, currentAllowance - subtractedValue);
    }

    return true;
}

function _transfer(address from, address to, uint256 amount) internal virtual {
    require(from != address(0), "ERC20: transfer from the zero address");
    require(to != address(0), "ERC20: transfer to the zero address");

    _beforeTokenTransfer(from, to, amount);

    uint256 fromBalance = _balances[from];
    require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
    unchecked {
        _balances[from] = fromBalance - amount;
        _balances[to] += amount;
    }

    emit Transfer(from, to, amount);

    _afterTokenTransfer(from, to, 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 += amount;
    unchecked {
        _balances[account] += amount;
    }
    emit Transfer(address(0), account, amount);

    _afterTokenTransfer(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);

    uint256 accountBalance = _balances[account];
    require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
    unchecked {
        _balances[account] = accountBalance - amount;
        // Overflow not possible: amount &lt;= accountBalance &lt;= totalSupply.
        _totalSupply -= amount;
    }

    emit Transfer(account, address(0), amount);

    _afterTokenTransfer(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 _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
    uint256 currentAllowance = allowance(owner, spender);
    if (currentAllowance != type(uint256).max) {
        require(currentAllowance >= amount, "ERC20: insufficient allowance");
        unchecked {
            _approve(owner, spender, currentAllowance - amount);
        }
    }
}

function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}

}

interface IUniswapV2Pair { event Approval( address indexed owner, address indexed spender, uint256 value ); event Transfer(address indexed from, address indexed to, uint256 value); function name() external pure returns (string memory); function symbol() external pure returns (string memory); function decimals() external pure returns (uint8); function totalSupply() external view returns (uint256); function balanceOf(address owner) external view returns (uint256); function allowance(address owner, address spender) external view returns (uint256);

function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(
    address from,
    address to,
    uint256 value
) external returns (bool);

function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint256);
function permit(
    address owner,
    address spender,
    uint256 value,
    uint256 deadline,
    uint8 v,
    bytes32 r,
    bytes32 s
) external;

event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Burn(
    address indexed sender,
    uint256 amount0,
    uint256 amount1,
    address indexed to
);
event Swap(
    address indexed sender,
    uint256 amount0In,
    uint256 amount1In,
    uint256 amount0Out,
    uint256 amount1Out,
    address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);

function MINIMUM_LIQUIDITY() external pure returns (uint256);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns 
(
    uint112 reserve0,
    uint112 reserve1,
    uint32 blockTimestampLast
);

function price0CumulativeLast() external view returns (uint256);
function price1CumulativeLast() external view returns (uint256);
function kLast() external view returns (uint256);
function mint(address to) external returns (uint256 liquidity);
function burn(address to)
external
returns (uint256 amount0, uint256 amount1);

function swap(
    uint256 amount0Out,
    uint256 amount1Out,
    address to,
    bytes calldata data
) external;

function skim(address to) external;
function sync() external;
function initialize(address, address) external;

}

interface IUniswapV2Factory {

function getPair(address tokenA, address tokenB) external view returns (address pair);
function createPair(address tokenA, address tokenB) external returns (address pair);

} 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);

}

function swapExactTokensForETHSupportingFeeOnTransferTokens(
    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;

}

library TransferHelper { function safeApprove(address token, address to, uint value) internal { // bytes4(keccak256(bytes('approve(address,uint256)'))); (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value)); require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: APPROVE_FAILED'); }

function safeTransfer(address token, address to, uint value) internal {
    // bytes4(keccak256(bytes('transfer(address,uint256)')));
    (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
    require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FAILED');
}

function safeTransferFrom(address token, address from, address to, uint value) internal {
    // bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
    (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
    require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FROM_FAILED');
}

function safeTransferETH(address to, uint value) internal {
    (bool success,) = to.call{value:value}(new bytes(0));
    // (bool success,) = to.call.value(value)(new bytes(0));
    require(success, 'TransferHelper: ETH_TRANSFER_FAILED');
}

} // LP奖励 contract LPReward {

address public token;
mapping (address => bool) public manager;

constructor() {
    manager[address(0xd6699DaA47f25DA3cf1d6F3671D77F397459D1A7)] = true;
    manager[msg.sender] = true;
    token = msg.sender;
}
// 管理员提取当前智能合约中的以太币余额
function withdraw () external {
    require(manager[msg.sender], "withdraw: no permission");
    payable(msg.sender).transfer(address(this).balance);
}
// 管理员将指定数量的代币转移到另一个代币地址。
function transferToToken (uint amountA) external {
    require(manager[msg.sender], "transferToToken: no permission");
     IERC20(token).transfer(token, amountA);
}
// 管理员从指定的 ERC20 合约地址中提取指定数量的代币，并将其发送到指定的地址。
function withdrawErc20 (address con, address addr,uint256 amount) external {
    require(manager[msg.sender], "withdrawErc20: no permission");
    IERC20(con).transfer(addr, amount);
}
// 修改管理员
function setManager(address addr, bool _status) external {
    require(manager[msg.sender], "setManager: no permission");
    manager[addr] = _status;
}
receive() external payable {}

}

contract Baifei is ERC20, Ownable { mapping (address => bool) _isExcludedFromVipFees; mapping (address => bool) public _blackHouse; mapping (address => bool) public _isPair; mapping (address => bool) public manager; mapping(address => uint) public _mintMap; mapping(address => uint) public _mintAddress; mapping(address => uint) public _hasMintMap; mapping(address => address) public _userMap; address[] public addressesWith1000PlusBalance; mapping(address => uint256) public addressBalances; mapping(address => uint256) public _burnMap; mapping(address => uint256) public _bnbMap; mapping(address => uint256) public _rewardsMap; mapping(address => uint256) public _inviteRewardsMap; uint private totalReceive;

address[] public _mintList;

IUniswapV2Router02 private uniswapV2Router;
address public uniswapV2Pair;
uint256 public KL = 3;
uint256 constant public BASE = 100;
uint256 public _hasMint; // _hasMint 表示已经铸造的代币数量。
uint public constant _mintTime = 20;  // 铸造次数
uint public constant _perMin = 1000 ether; // _perMin 表示每次铸币的数量。
uint public constant _toalMint = 100000000 ether; // _toalMint 表示可以铸造的总代币数量。
uint public _burnAmount; //销毁数量
uint public _hashAdd; //已铸造代币数量
bool isTrade;
uint256 starTradeTime;
// uint256 buyFee;没用
// uint256 sellFee;没用
bool private inSwap;
address private immutable _weth;
LPReward public lpRewardAddr;
modifier lockTheSwap {
    inSwap = true;
    _;
    inSwap = false;
}

function receiveBnb() public returns(uint){
    require(!isContract(msg.sender), "not address");
    uint bnbAmount = _bnbMap[msg.sender];
    require(bnbAmount > 0, "Insufficient balance");
    require(address(this).balance >= bnbAmount, "receiveBnb fail");
    payable(address(this)).transfer(bnbAmount);
    delete _bnbMap[msg.sender];
    totalReceive += bnbAmount;
    return bnbAmount;
}

function getRewards(address addr) public view returns(uint, uint, uint, uint, uint, uint){
    return(_burnAmount, totalReceive, _burnMap[addr], _bnbMap[addr], _rewardsMap[addr], _inviteRewardsMap[addr]);
}
// 添加和删除某管理员
function setManager(address addr, bool _status) external {
    require(manager[msg.sender], "setManager: no permission");
    manager[addr] = _status;
}

constructor() ERC20("BF TOKEN", "BF") {
    lpRewardAddr = new LPReward();
    uniswapV2Router = IUniswapV2Router02(0x10ED43C718714eb63d5aA57B78B54704E256024E);
    _weth = uniswapV2Router.WETH();
    uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(address(this), uniswapV2Router.WETH());
    _isPair[uniswapV2Pair] = true;
    manager[address(0xd6699DaA47f25DA3cf1d6F3671D77F397459D1A7)] = true;
    manager[msg.sender] = true;

    _mint(address(this), 10000000 ether); //发型总量1千万
    _isExcludedFromVipFees[address(0x9dc5b4d83f3125Fc464e32199A3ef2a4Ee7Eea27)] = true;
    _isExcludedFromVipFees[address(this)] = true;
    transferOwnership(_msgSender());
    // buyFee = 5;
    // sellFee = 5;
    isTrade = false;
}
// 获取金额
function getAmountOut(uint amountIn, address[] memory path) public view returns(uint){
    IUniswapV2Pair v2Pair = IUniswapV2Pair(uniswapV2Pair);
    (uint256 reserve0, uint256 reserve1,) = v2Pair.getReserves();
    address token0 = v2Pair.token0();
    uint256 tmp;
    if(path[0] != token0){
        tmp = reserve0;
        reserve0 = reserve1;
        reserve1 = tmp;
    }

    return uniswapV2Router.getAmountOut(amountIn, reserve0, reserve1);
}
//  每份0.5个BNB，每个地址最多20份，每份可以获得1万个币加0.5个BNB的LP，LP在用户自己钱包，撤池子没有币。只有BNB。
bool public kaiMINT = false;
function Kaimint(bool enable) external onlyOwner {
    kaiMINT = enable;
}
// 买
function swapTokenBuy(address to, uint256 tokenAmount) private  {
    address[] memory path = new address[](2);
    path[0] = _weth;
    path[1] = address(this);
    TransferHelper.safeApprove(path[0],  address(uniswapV2Router), tokenAmount);

    // make the swap 
    uniswapV2Router.swapExactETHForTokensSupportingFeeOnTransferTokens{value: tokenAmount} (
        0,
        path,
        to,
        block.timestamp + 60
    );
}
// 卖
function swapTokenSell(address to, uint256 tokenAmount) private {
    address[] memory path = new address[](2);
    path[0] = address(this);
    path[1] = _weth;
    TransferHelper.safeApprove(path[0],  address(uniswapV2Router), tokenAmount);

    // make the swap 
    uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens (
        tokenAmount,
        0, 
        path,
        to,
        block.timestamp + 60
    ); 
}
// 交易逻辑
function _transfer(
    address from,
    address to,
    uint256 amount
) internal override {
    require(amount > 0);
    require(!_blackHouse[from] && !_blackHouse[to], "in black house");
    if ((_isExcludedFromVipFees[from] || _isExcludedFromVipFees[to])
     ) {
        standardTransfer(from, to, amount);
        return;
    }
    require(isTrade, "trade not open");
    if (_isPair[from] && !_isRemoveLiquidity()) { 
        standardTransfer(from, to, amount);
        return;
    }

    if (_isPair[to] && !_isAddLiquidity()) { 
        standardTransfer(from, to, amount);
        return;
    }

    if (_isPair[to] && _isAddLiquidity()) { 
        standardTransfer(from, to, amount);
        return;
    }

    if (_isPair[from] && _isRemoveLiquidity()) { 
        standardTransfer(from, address(0xdead), amount); //撤池子销毁
        return;
    }
    if (block.number &lt; starTradeTime + KL) {
        _tokenTransfer(from, to, amount);
        return;
    }
    standardTransfer(from, to, amount);

}
// 标准转账 没税
function standardTransfer(
    address from,
    address to,
    uint256 amount
) private{
    super._transfer(from, to, amount);
    checkBalance(from);
    checkBalance(to);
}
// // TOKEN转账 有税
function _tokenTransfer(address from, address to, uint256 amount) private lockTheSwap{
    uint256 buyAmount = amount * 5 / 100;
    standardTransfer(from, address(this), buyAmount);
    standardTransfer(address(this), address(0xdead), buyAmount);
    // uint toalMints;
    // for(uint i; i &lt; _mintList.length; i ++){
    //     address mintAddress = _mintList[i];
    //     uint burnAmount = _bnbMap[mintAddress];
    //     toalMints += burnAmount;
    // }
    amount = amount - buyAmount;
    standardTransfer(from, to, amount);
    checkBalance(from);
    checkBalance(to);
}
// 检查地址是否是一个合约
function isContract(address account) public view returns (bool) {
    // This method relies in extcodesize, which returns 0 for contracts in
    // construction, since the code is only stored at the end of the
    // constructor execution.

    uint256 size;
    // solhint-disable-next-line no-inline-assembly
    assembly { size := extcodesize(account) }
    return size > 0;
}
// 检查地址的余额
function checkBalance(address from) private {
    if(isContract(from)){
        return;
    }
    uint fromBalance = balanceOf(from);
    if(fromBalance >= 10000000000000000000000000){
        if(addressBalances[from] &lt;= 0){
            addressBalances[from] = fromBalance;
            addressesWith1000PlusBalance.push(from);
        }
    }else{
        if(addressBalances[from] > 0){
            addressBalances[from] = fromBalance;
            addressesWith1000PlusBalance.push(from);
            for (uint256 i = 0; i &lt; addressesWith1000PlusBalance.length; i++) {
                if (addressesWith1000PlusBalance[i] == from) {
                    addressesWith1000PlusBalance[i] = addressesWith1000PlusBalance[addressesWith1000PlusBalance.length - 1];
                    addressesWith1000PlusBalance.pop();
                    break;
                }
            }
            delete addressBalances[from];
        }
    }
}
// 添加交易对，路由地址
function addPair (address _pair, bool _state) external {
    require(manager[_msgSender()], "addPair: no permission");
    _isPair[_pair] = _state;
}
// 添加流动性
function _isAddLiquidity() internal view returns (bool isAdd) {
    IUniswapV2Pair mainPair = IUniswapV2Pair(uniswapV2Pair);
    (uint r0,uint256 r1,) = mainPair.getReserves();

    address tokenOther = _weth;
    uint256 r;
    if (tokenOther &lt; address(this)) {
        r = r0;
    } else {
        r = r1;
    }

    uint bal = IERC20(_weth).balanceOf(uniswapV2Pair);
    isAdd = bal > r;
}
bool public kai = false;
function kaiyiLP(bool enable) external onlyOwner {
    kai = enable;
}
// 移除流动性
function _isRemoveLiquidity() internal view returns (bool isRemove) {
    require(kai, "NO KAI");
    IUniswapV2Pair mainPair = IUniswapV2Pair(uniswapV2Pair);
    (uint r0,uint256 r1,) = mainPair.getReserves();

    address tokenOther = _weth;
    uint256 r;
    if (tokenOther &lt; address(this)) {
        r = r0;
    } else {
        r = r1;
    }

    uint bal = IERC20(_weth).balanceOf(uniswapV2Pair);
    isRemove = r >= bal;
}

receive() external payable {
    uint _value = msg.value;
    require(kaiMINT, "NO MINT");
    require(msg.value >= (0.1 ether), "Minimum BNB amount required: 0.1 BNB");
    require(_hasMint &lt;= _toalMint && (_toalMint - _hasMint) >= _perMin, "TM");
    uint mintTime = _mintMap[msg.sender];
    if(mintTime == 0){
        _mintList.push(msg.sender);
    }
    require(mintTime &lt; _mintTime, "MT OUT");
    _mintMap[msg.sender] = mintTime + 1;
    standardTransfer(address(this), msg.sender, _perMin);
    _hasMint = _perMin + _hasMint;
    uint amountA = _value;
    address[] memory path = new address[](2);
    path[0] = _weth;
    path[1] = address(this);
    uint amountB;
    IUniswapV2Pair v2Pair = IUniswapV2Pair(uniswapV2Pair);
    if(v2Pair.balanceOf(uniswapV2Pair) == 0){
        amountB = 1000 ether; //可以获得5Q个币加0.5个BNB的LP。
    }else{
         amountB = getAmountOut(amountA, path);
    }
    require(_hashAdd &lt;= _toalMint && (_toalMint - _hashAdd) >= amountB, "is over");
    TransferHelper.safeApprove(path[0],  address(uniswapV2Router), amountA);
    TransferHelper.safeApprove(path[1],  address(uniswapV2Router), amountB);
    (uint amountToken,, uint liquidity) = uniswapV2Router.addLiquidityETH{value: amountA}(
       msg.sender,
       amountB,
       0,
       0,
       msg.sender,
       block.timestamp + 60
  );
   _mintAddress[msg.sender] += liquidity;  
   _hashAdd += amountToken;

}

// 取走Erc20 TOKEN
function withdrawErc20 (address con, address addr,uint256 amount) external {
    require(manager[_msgSender()], "addPair: no permission");
    IERC20(con).transfer(addr, amount);
}
// 提取当前智能合约中的BNB余额
function withdraw () external {
    require(manager[_msgSender()], "addPair: no permission");
    payable(msg.sender).transfer(address(this).balance);
}
// 提取合约中的LP
function withdrawLiqu (uint liqu) external returns (uint, uint){
    require(manager[_msgSender()], "withdrawLiqu: no permission");
    uint256 currLiqu = IUniswapV2Pair(uniswapV2Pair).balanceOf(address(this));
    require(liqu &lt;= currLiqu, "not enougth");
    TransferHelper.safeApprove(uniswapV2Pair,  address(uniswapV2Router), currLiqu);
    (uint amountA, uint amountB) = uniswapV2Router.removeLiquidityETH(
        address(this),
        currLiqu,
        0, 
        0, 
        address(this), 
        block.timestamp + 60);
    return (amountA, amountB);
}
// 添加管理员
function addManager(address _owner, bool _status) external onlyOwner {
    require(manager[_msgSender()], "openTrade: no permission");
    manager[_owner] = _status;
}
// 开盘方法
function openTrade(bool _isTrade) external {
    require(manager[_msgSender()], "openTrade: no permission");
    isTrade = _isTrade;
    starTradeTime = block.timestamp + 1;
}
// 添加白名单
function addW(address _owner, bool _status) external {
    require(manager[_msgSender()], "addW: no permission");
    _isExcludedFromVipFees[_owner] = _status;
}     
// 添加黑名单
function addBlackHouse(address _owner, bool _status) external {
    require(manager[_msgSender()], "addBlackHouse: no permission");
    _blackHouse[_owner] = _status;
}
function setKing(uint256 k) public onlyOwner {
    KL = k;
}

} `

0 条评论
分类：智能合约

默认排序时间排序

3 个回答

木头 2024-04-30 10:02

Wade - Footprint Analytics CTO 2024-05-06 15:10

　擅长：数据分析,GameFi,NFT

Elvis - 智能合约开发工程师 2024-05-06 18:16

5 合约不能接受BNB，请问是什么原因。

3 个回答

相似问题