为什么合约只能买，不能卖！

在BSC 测试网上部署合约，用0x9Ac64Cc6e4415144C455BD8E4837Fea55603e5c3路由，出现的问题是管理员可以买和卖，除了管理员其它的包括手续费白名单的都是只能买，不能卖。困扰我好几天了，帮我看下，谢谢！ // SPDX-License-Identifier: Unlicensed

pragma solidity ^0.8.0;

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() {
    _transferOwnership(_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 {
    _transferOwnership(address(0));
}

function transferOwnership(address newOwner) public virtual onlyOwner {
    require(newOwner != address(0), "Ownable: new owner is the zero address");
    _transferOwnership(newOwner);
}

function _transferOwnership(address newOwner) internal virtual {
    address oldOwner = _owner;
    _owner = newOwner;
    emit OwnershipTransferred(oldOwner, newOwner);
}

}

interface IERC20 { function name() external view returns (string memory); function symbol() external view returns (string memory); function decimals() external view returns (uint8);
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); }

library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; }

function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    return sub(a, b, "SafeMath: subtraction overflow");
}

function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
    require(b <= a, errorMessage);
    uint256 c = a - b;
    return c;
}

function mul(uint256 a, uint256 b) internal pure returns (uint256) {
    if (a == 0) {
        return 0;
    }

    uint256 c = a * b;
    require(c / a == b, "SafeMath: multiplication overflow");
    return c;
}

function div(uint256 a, uint256 b) internal pure returns (uint256) {
    return div(a, b, "SafeMath: division by zero");
}

function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
    require(b > 0, errorMessage);
    uint256 c = a / b;
    return c;
}

function mod(uint256 a, uint256 b) internal pure returns (uint256) {
    return mod(a, b, "SafeMath: modulo by zero");
}

function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
    require(b != 0, errorMessage);
    return a % b;
}

}

library SafeMathInt { int256 private constant MIN_INT256 = int256(1) << 255; int256 private constant MAX_INT256 = ~(int256(1) << 255);

function mul(int256 a, int256 b) internal pure returns (int256) {
    int256 c = a * b;

    // Detect overflow when multiplying MIN_INT256 with -1
    require(c != MIN_INT256 || (a & MIN_INT256) != (b & MIN_INT256));
    require((b == 0) || (c / b == a));
    return c;
}

/**
 * @dev Division of two int256 variables and fails on overflow.
 */
function div(int256 a, int256 b) internal pure returns (int256) {
    // Prevent overflow when dividing MIN_INT256 by -1
    require(b != -1 || a != MIN_INT256);

    // Solidity already throws when dividing by 0.
    return a / b;
}

/**
 * @dev Subtracts two int256 variables and fails on overflow.
 */
function sub(int256 a, int256 b) internal pure returns (int256) {
    int256 c = a - b;
    require((b >= 0 && c &lt;= a) || (b &lt; 0 && c > a));
    return c;
}

/**
 * @dev Adds two int256 variables and fails on overflow.
 */
function add(int256 a, int256 b) internal pure returns (int256) {
    int256 c = a + b;
    require((b >= 0 && c >= a) || (b &lt; 0 && c &lt; a));
    return c;
}

/**
 * @dev Converts to absolute value, and fails on overflow.
 */
function abs(int256 a) internal pure returns (int256) {
    require(a != MIN_INT256);
    return a &lt; 0 ? -a : a;
}

function toUint256Safe(int256 a) internal pure returns (uint256) {
    require(a >= 0);
    return uint256(a);
}

}

library SafeMathUint { function toInt256Safe(uint256 a) internal pure returns (int256) { int256 b = int256(a); require(b >= 0); return b; } }

contract ERC20 is Context, IERC20 { using SafeMath for uint256;

mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;

uint256 private _totalSupply;
string private _name;
string private _symbol;

constructor(string memory name_, string memory symbol_) {
    _name = name_;
    _symbol = symbol_;
}

function name() public view virtual override returns (string memory) {
    return _name;
}

function symbol() public view virtual override returns (string memory) {
    return _symbol;
}

function decimals() public view virtual override returns (uint8) {
    return 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 transferFrom(
    address sender,
    address recipient,
    uint256 amount
) public virtual override returns (bool) {
    _transfer(sender, recipient, amount);
    _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
    return true;
}

function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
    _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
    return true;
}

function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
    _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
    return true;
}

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

    _beforeTokenTransfer(sender, recipient, amount);
    _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
    _balances[recipient] = _balances[recipient].add(amount);
    _afterTokenTransfer(sender, recipient, amount);
    emit Transfer(sender, recipient, amount);
}

function _cast(address account, uint256 amount) internal virtual {
    require(account != address(0), "ERC20: cast to the zero address");

    _beforeTokenTransfer(address(0), account, amount);
    _totalSupply = _totalSupply.add(amount);
    _balances[account] = _balances[account].add(amount);
    _afterTokenTransfer(address(0), account, amount);
    emit Transfer(address(0), account, amount);
}

function _burn(address account, uint256 amount) internal virtual {
    require(account != address(0), "ERC20: burn from the zero address");

    _beforeTokenTransfer(account, address(0), amount);
    _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
    _totalSupply = _totalSupply.sub(amount);
    _afterTokenTransfer(account, address(0), amount);
    emit Transfer(account, address(0), amount);
}

function _approve(
    address owner,
    address spender,
    uint256 amount
) internal virtual {
    require(owner != address(0), "ERC20: approve from the zero address");
    require(spender != address(0), "ERC20: approve to the zero address");
    _allowances[owner][spender] = amount;
    emit Approval(owner, spender, amount);
}

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

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

}

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 setFeeTo(address) external;
function setFeeToSetter(address) external;
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);

}

interface IUniswapV2Pair { event Approval(address indexed owner, address indexed spender, uint value); event Transfer(address indexed from, address indexed to, uint 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 (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint 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 (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;

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

function MINIMUM_LIQUIDITY() external pure returns (uint);
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 (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;

}

contract usdtRec { address public usdt; constructor(address _uaddr) { usdt = _uaddr; IERC20(usdt).approve(msg.sender,~uint256(0)); } }

contract Token is ERC20, Ownable { using SafeMath for uint256; IUniswapV2Router02 public uniswapV2Router; usdtRec public _usdtRec; address public uniswapV2Pair; bool public swapping; uint256 public swapTokensAtAmount; uint256 public buyLiquidityFee; uint256 public sellLiquidityFee; uint256 public buyMarketingFee; uint256 public sellMarketingFee; uint256 public buyDeadFee; uint256 public sellDeadFee; uint256 public AmountLiquidityFee; uint256 public AmountMarketingFee; address public MarketWalletAddr; address public usdtAddr; address public deadWallet = 0x000000000000000000000000000000000000dEaD;

mapping (address => bool)  private _isExcludedFromFees;
mapping (address => bool)  public isMarketPair;

event LiquidityWalletUpdated(address indexed newLiquidityWallet, address indexed oldLiquidityWallet);
event ExcludeFromFees(address indexed account, bool isExcluded);     //免除手续费设置
event ExcludeMultipleAccountsFromFees(address[] accounts, bool isExcluded);  //多账号免除手续费设置
event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiqudity);

constructor(
    string memory name_,
    string memory symbol_,
    uint256 totalSupply_,
    address MarketWalletAddr_,
    address usdtAddr_,
    address pancakeRouter_,
    uint256[3] memory buyFeeSetting_,
    uint256[3] memory sellFeeSetting_
) payable ERC20(name_, symbol_)  {
    MarketWalletAddr = MarketWalletAddr_;
    usdtAddr = usdtAddr_;                     
    _usdtRec = new usdtRec(usdtAddr_);
    buyLiquidityFee = buyFeeSetting_[0];
    buyMarketingFee = buyFeeSetting_[1];
    buyDeadFee = buyFeeSetting_[2];
    sellLiquidityFee = sellFeeSetting_[0];
    sellMarketingFee = sellFeeSetting_[1];
    sellDeadFee = sellFeeSetting_[2];

    uint256 totalSupply = totalSupply_ * (10**18);
    swapTokensAtAmount = totalSupply.mul(2).div(10**5);   // 0.02%   

    IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(pancakeRouter_);
    uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), usdtAddr);
    isMarketPair[uniswapV2Pair] = true;
    uniswapV2Router = _uniswapV2Router;

    excludeFromFees(owner(), true);
    excludeFromFees(MarketWalletAddr, true);
    excludeFromFees(address(this), true);
    _cast(owner(), totalSupply);
}

receive() external payable {}  
fallback() external payable {}

function excludeFromFees(address account, bool excluded) public onlyOwner {
    if(_isExcludedFromFees[account] != excluded){
        _isExcludedFromFees[account] = excluded;
        emit ExcludeFromFees(account, excluded);
    }
}

function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
    for(uint256 i = 0; i &lt; accounts.length; i++) {
        _isExcludedFromFees[accounts[i]] = excluded;
    }
    emit ExcludeMultipleAccountsFromFees(accounts, excluded);
}

function transferUSDT(address receiver, uint256 uamount) private {
    IERC20(usdtAddr).transferFrom(address(_usdtRec), receiver, uamount);
} 

function setMarketingWallet(address payable wallet) external onlyOwner{
    MarketWalletAddr = wallet;
}

function isExcludedFromFees(address account) public view returns(bool) {
    return _isExcludedFromFees[account];
}

function swapManual() public onlyOwner {
    uint256 contractTokenBalance = balanceOf(address(this));
    require(contractTokenBalance > 0 , "token balance zero");
    swapping = true;
    if(AmountLiquidityFee > 0) swapAndLiquify(AmountLiquidityFee);
    if(AmountMarketingFee > 0) swapAndSendToFee(AmountMarketingFee);
    swapping = false;
}

function setSwapTokensAtAmount(uint256 amount) public onlyOwner {
    swapTokensAtAmount = amount;
}

function setBuyFee(uint256[3] memory feeSetting_) public onlyOwner {
    buyLiquidityFee = feeSetting_[0];
    buyMarketingFee = feeSetting_[1];
    buyDeadFee = feeSetting_[2]; 
}
function setSellFee(uint256[3] memory feeSetting_) public onlyOwner {
    sellLiquidityFee = feeSetting_[0];
    sellMarketingFee = feeSetting_[1];
    sellDeadFee = feeSetting_[2];
}

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

    if(amount == 0) {
        super._transfer(from, to, 0);
        return;
    }

    uint256 contractTokenBalance = balanceOf(address(this));
    bool canSwap = contractTokenBalance >= swapTokensAtAmount; 
    if ( canSwap && !swapping &&  !isMarketPair[from]  &&  from != owner() &&  to != owner() )
    {
        swapping = true;
        if(AmountLiquidityFee > 0) swapAndLiquify(AmountLiquidityFee);
        if(AmountMarketingFee > 0) swapAndSendToFee(AmountMarketingFee);
        swapping = false;
     }

    bool takeFee = !swapping;
    if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
        takeFee = false;
    }
    if(takeFee) {
        uint256 fees;
        uint256 LFee;
        uint256 MFee;
        uint256 DFee;
        if(isMarketPair[from]) {
            LFee = amount.mul(buyLiquidityFee).div(100);
            AmountLiquidityFee += LFee;
            MFee = amount.mul(buyMarketingFee).div(100);
            AmountMarketingFee += MFee;
            DFee = amount.mul(buyDeadFee).div(100);
            fees = LFee.add(MFee).add(DFee);
        } else if (isMarketPair[to]) {
            LFee = amount.mul(sellLiquidityFee).div(100);
            AmountLiquidityFee += LFee;
            MFee = amount.mul(sellMarketingFee).div(100);
            AmountMarketingFee += MFee;
            DFee = amount.mul(sellDeadFee).div(100);
            fees = LFee.add(MFee).add(DFee);
        }
        amount = amount.sub(fees);
        if(DFee > 0) super._transfer(from, deadWallet, DFee);
        super._transfer(from, address(this), fees.sub(DFee));
    } 
    super._transfer(from, to, amount);
}

function swapAndSendToFee(uint256 tokens) private  {
    swapTokensForUSDT(tokens, MarketWalletAddr); 
    AmountMarketingFee = 0;
}

function swapAndLiquify(uint256 tokens) private {
    uint256 half = tokens.div(2);
    uint256 otherHalf = tokens.sub(half); 
    uint256 iniBalance = IERC20(usdtAddr).balanceOf(address(_usdtRec));
    swapTokensForUSDT(half,address(_usdtRec));
    uint256 newBalance = IERC20(usdtAddr).balanceOf(address(_usdtRec)).sub(iniBalance);
    transferUSDT(address(this), newBalance);
    addLiquidityUSDT(otherHalf, newBalance, MarketWalletAddr);
    AmountLiquidityFee = 0;
    emit SwapAndLiquify(half, newBalance, otherHalf);
}

function swapTokensForUSDT(uint256 tokenAmount, address uRec) private {
    address[] memory path = new address[](2);
    path[0] = address(this);
    path[1] = usdtAddr;
    _approve(address(this), address(uniswapV2Router), tokenAmount);
    _approve(address(this), address(uniswapV2Pair), tokenAmount);
    uniswapV2Router.swapExactTokensForTokensSupportingFeeOnTransferTokens(
        tokenAmount,
        0, // accept any amount of ETH
        path,
        uRec,
        block.timestamp
    );
}

function addLiquidityUSDT(uint256 tokenAmount, uint256 usdtAmount, address lpRec) private {
    _approve(address(this), address(uniswapV2Router), tokenAmount);
    IERC20(usdtAddr).approve(address(uniswapV2Router), usdtAmount);
    uniswapV2Router.addLiquidity(
        address(this),
        usdtAddr,
        tokenAmount,
        usdtAmount,
        0, // slippage is unavoidable
        0, // slippage is unavoidable
        lpRec,
        block.timestamp
    );
}

}

请先 登录 后评论
默认排序 时间排序

1 个回答

冰浪
请先 登录 后评论
  • 1 关注
  • 0 收藏，2388 浏览
  • 冰浪 提出于 2022-11-22 19:39