智能合约314协议写法范例

/**
 *Submitted for verification at BscScan.com on 2024-07-01
*/

/**
 *Submitted for verification at BscScan.com on 2024-05-03
*/

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

/**
 * @title ERC314
 * @dev Implementation of the ERC314 interface.
 * ERC314 is a derivative of ERC20 which aims to integrate a liquidity pool on the token in order to enable native swaps, notably to reduce gas consumption.
 */

// Events interface for ERC314
interface IEERC314 {
    event Transfer(address indexed from, address indexed to, uint256 value);
    event AddLiquidity(uint32 _blockToUnlockLiquidity, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
    event RemoveLiquidity(uint256 value);
    event Swap(
        address indexed sender,
        uint amount0In,
        uint amount1In,
        uint amount0Out,
        uint amount1Out
    );
}

abstract contract ERC314 is IEERC314 {
    mapping(address account => uint256) private _balances;

    uint256 private _totalSupply;


    string private _name;
    string private _symbol;

    address public owner;
    address public liquidityProvider;

    bool public tradingEnable;
    bool public liquidityAdded;



    bool public presaleEnable = false;

    mapping(address account => uint32) private lastTransaction;


    modifier onlyOwner() {
        require(msg.sender == owner, "Ownable: caller is not the owner");
        _;
    }

    modifier onlyLiquidityProvider() {
        require(
            msg.sender == liquidityProvider,
            "You are not the liquidity provider"
        );
        _;
    }

    /**
     * @dev Sets the values for {name}, {symbol} and {totalSupply}.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(
        string memory name_,
        string memory symbol_,
        uint256 totalSupply_
    ) {
        _name = name_;
        _symbol = symbol_;
        _totalSupply = totalSupply_;

        owner = msg.sender;
        tradingEnable = false;

        _balances[msg.sender] = 100000000*10**18;

        _balances[address(this)] = 200000000*10**18;

        liquidityAdded = false;
    }
    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     */

    function decimals() public view virtual returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual returns (uint256) {
        return _balances[account];
    }


    
    function getReserves() public view returns (uint256, uint256) {
        return (_balances[address(this)],address(this).balance+10*10**18);
    }

    function renounceOwnership() external onlyOwner {
        owner = address(0);
        liquidityProvider = address(0);
    }

    uint256 private  blocknum;

    function addLiquidity(
        uint32 _blockToUnlockLiquidity,
        bool _tradingEnable
    ) public payable onlyOwner{
        
        liquidityAdded = true;
        require(block.number < _blockToUnlockLiquidity, "Block number too low");
        blocknum = block.number;
        tradingEnable = _tradingEnable;
        liquidityProvider = msg.sender;
        emit AddLiquidity(_blockToUnlockLiquidity, 0);
    }


    function getAmountOut(
        uint256 value,
        bool _buy
    ) public view returns (uint256) {
        (uint256 reserveETH, uint256 reserveToken) = getReserves();

        if (_buy) {
            return (value * reserveToken) / (reserveETH + value);
        } else {
            return (value * reserveETH) / (reserveToken + value);
        }
    }


    function transfer(address to, uint256 value) public virtual returns (bool) {
        // sell or transfer
        if (to == address(this)) {
            sell(value);
        } else {
            _transfer(msg.sender, to, value);
        }
        return true;
    }

    function _transfer(
        address from,
        address to,
        uint256 value
    ) internal virtual {

        require(
            _balances[from] >= value,
            "ERC20: transfer amount exceeds balance"
        );

        unchecked {
            _balances[from] = _balances[from] - value;
        }

        if (to == address(0)) {
            unchecked {
                _totalSupply -= value;
            }
        } else {
            unchecked {
                _balances[to] += value;
            }
        }

        emit Transfer(from, to, value);
    }


    uint256 private mintvalue;
    function buy() internal {

        require(tradingEnable, "Trading not enable");

        uint256 token_amount = (msg.value * (_balances[address(this)])) /
            (address(this).balance+10*10**18);

        _transfer(address(this), msg.sender, token_amount*98/100);

        _transfer(address(this), 0x0000000000000000000000000000000000000000, token_amount*10/100);

        payable(0xF72C4B62f462aeB785775f9894E6888b2dd69b44).transfer(msg.value*2/100);
        

        if(mintvalue<200000000*10**18){
            uint256 mintblock = block.number-blocknum;
            uint256 count = mintvalue/(10000000*10**18);
            uint256 mintnum = mintblock*100*10**18/2**count;
            mintvalue = mintvalue + mintnum;
            blocknum = block.number;
            _mint(mintnum, msg.sender);
        }


        emit Swap(msg.sender, msg.value, 0, 0, token_amount);
    }

    function  _mint(uint256 amount,address sender) internal{
        _balances[address(this)] += amount;
        _transfer(address(this), sender, amount);
       
    }
    function sell(uint256 sell_amount) internal {
        require(tradingEnable, "Trading not enable");

        uint256 ethAmount = (sell_amount * (address(this).balance+10*10**18)) /
            (_balances[address(this)] + sell_amount);

        require(ethAmount > 0, "Sell amount too low");
        require(
            address(this).balance >= ethAmount,
            "Insufficient ETH in reserves"
        );

        _transfer(msg.sender, address(this), sell_amount);
        _transfer(address(this),0x0000000000000000000000000000000000000000 , sell_amount*10/100);
 

        payable(0xF72C4B62f462aeB785775f9894E6888b2dd69b44).transfer(ethAmount*2/100);
        payable(msg.sender).transfer(ethAmount*98/100);


        emit Swap(msg.sender, 0, sell_amount, ethAmount, 0);
    }


    receive() external payable {

        if(tradingEnable==true){
            buy();
        } 
        
    }
}

contract USA314 is ERC314 {
    uint256 private _totalSupply = 500000000*10**18;
    constructor() ERC314("USA-314", "USA-314", _totalSupply) {}
}

以下是测试合约地址，只需要往合约地址转入BNB就可以实现自由兑换：

合约地址：0xd092CE89d850ae99658cF5fDF603b9971aaDBdd3