contract MyAdvancedToken is owned, token {

    //卖出的汇率,一个代币，可以换多少个以太币，单位是wei
    uint256 public sellPrice;

    //买入的汇率,1个以太币，可以买几个代币
    uint256 public buyPrice;
    
    //价格单位
    uint8 public priceDecimals = 3;

    //是否冻结帐户的列表
    mapping (address => bool) public frozenAccount;

    //定义一个事件，当有资产被冻结的时候，通知正在监听事件的客户端
    event FrozenFunds(address target, bool frozen);


    /*初始化合约，并且把初始的所有的令牌都给这合约的创建者
     * @param initialSupply 所有币的总数
     * @param tokenName 代币名称
     * @param tokenSymbol 代币符号
     * @param centralMinter 是否指定其他帐户为合约所有者,为0是去中心化
     */
    constructor(
      uint256 initialSupply,
      string memory tokenName,
      string memory tokenSymbol,
      address centralMinter
    ) token (initialSupply, tokenName, tokenSymbol)  {

        //设置合约的管理者
        if(centralMinter != 0x0000000000000000000000000000000000000000 ) owner = centralMinter;

        sellPrice = 1;     //设置1个单位的代币(单位是wei)，能够卖出0.001个以太币
        buyPrice = 1;      //设置1个以太币，可以买1000个代币
    }


    /**
     * 私有方法，从指定帐户转出余额
     * @param  _from address 发送代币的地址
     * @param  _to address 接受代币的地址
     * @param  _value uint256 接受代币的数量
     */
    function _transfer(address _from, address _to, uint _value) internal override{

        //避免转帐的地址是0x0
        require (_to != 0x0000000000000000000000000000000000000000);

        //检查发送者是否拥有足够余额
        require (balanceOf[_from] > _value);

        //检查是否溢出
        require (balanceOf[_to] + _value > balanceOf[_to]);

        //检查 冻结帐户
        require(!frozenAccount[_from]);
        require(!frozenAccount[_to]);



        //从发送者减掉发送额
        balanceOf[_from] -= _value;

        //给接收者加上相同的量
        balanceOf[_to] += _value;

        //通知任何监听该交易的客户端
        emit Transfer(_from, _to, _value);

    }

    /**
     * 合约拥有者，可以为指定帐户创造一些代币
     * @param  target address 帐户地址
     * @param  mintedAmount uint256 增加的金额(单位是wei)
     */
    function mintToken(address target, uint256 mintedAmount) onlyOwner public override {
        //给指定地址增加代币，同时总量也相加
        balanceOf[target] += mintedAmount;
        totalSupply += mintedAmount;
        emit Transfer(0x0000000000000000000000000000000000000000, address(this), mintedAmount);
        emit Transfer(address(this), target, mintedAmount);
    }

    /**
     * 增加冻结帐户名称
     *
     * 你可能需要监管功能以便你能控制谁可以/谁不可以使用你创建的代币合约
     *
     * @param  target address 帐户地址
     * @param  freeze bool    是否冻结
     */
    function freezeAccount(address target, bool freeze) onlyOwner public{
        frozenAccount[target] = freeze;
        emit FrozenFunds(target, freeze);
    }

    /**
     * 设置买卖价格
     *
     * 如果你想让ether(或其他代币)为你的代币进行背书,以便可以市场价自动化买卖代币,我们可以这么做。如果要使用浮动的价格，也可以在这里设置,这个函数已经实现了代币的市场化,当然比较初级
     *
     * @param newSellPrice 新的卖出价格
     * @param newBuyPrice 新的买入价格
     */
    function setPrices(uint256 newSellPrice, uint256 newBuyPrice, uint8 newPriceDecimals) onlyOwner  public{
        sellPrice = newSellPrice;
        buyPrice = newBuyPrice;
        priceDecimals = newPriceDecimals;
    }

    //注意,这些交易函数会消耗相应的以太币,目前,接受以太币的函数需要增加 payable 关键字
    /**
     * 使用以太币购买代币
    function buy() payable public {
      uint amount = msg.value / buyPrice * (10 ** uint256(priceDecimals));
      _transfer(address(this), msg.sender, amount);
    }
    function sell(uint256 amount) public {

        //检查合约的余额是否足够
        require(balanceOf[address(this)] >= amount * sellPrice / (10 ** uint256(priceDecimals)) );

        _transfer(msg.sender, address(this), amount);

        msg.sender.transfer(amount * sellPrice/(10 ** uint256(priceDecimals)) );
    }
    */
}
// 增加冻结用户、挖矿、根据指定汇率购买(售出)代币价格的功能
function mintToken(address target, uint256 mintedAmount) onlyOwner public override {
        //给指定地址增加代币，同时总量也相加
        balanceOf[target] += mintedAmount;
        totalSupply += mintedAmount;
        emit Transfer(0x0000000000000000000000000000000000000000, address(this), mintedAmount);
        emit Transfer(address(this), target, mintedAmount);
    }
/**
 * 合约拥有者，可以为指定帐户创造一些代币
 * @param  target address 帐户地址
 * @param  mintedAmount uint256 增加的金额(单位是wei)
 */