title: Contract "Coin" should be marked as abstract
body: <p>i want to create a token on ERC-20 network.</p>
  <p>i want to inheritance from interface in my contract .</p>
  <p>when i inheritance form interface it show me this error :</p>
  <blockquote>
  <p>Contract &quot;CpayCoin&quot; should be marked as abstract.</p>
  </blockquote>
  <p><code>solc</code> version in truffle :</p>
  <pre><code>  compilers: {
  solc: {
    version: &quot;0.8.10&quot;,    // Fetch exact version from solc-bin (default: truffle's version)
    docker: false,        // Use &quot;0.5.1&quot; you've installed locally with docker (default: false)
    settings: {          // See the solidity docs for advice about optimization and evmVersion
      optimizer: {
        enabled: false,
        runs: 200
      },
      evmVersion: &quot;byzantium&quot;
    }
  }
  </code></pre>
  <p>},</p>
  <p><strong>whats the problem ? how can i solve this problem ???</strong></p>
  <p>this is my interface :</p>
  <pre><code>    // SPDX-License-Identifier: MIT
  pragma solidity &gt;=0.4.22 &lt;0.9.0;
  
  interface IERC20 {
      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
      );
  }
  </code></pre>
  <p>contract :</p>
  <pre><code>// SPDX-License-Identifier: MIT
  </code></pre>
  <p>pragma solidity &gt;=0.4.22 &lt;0.9.0;</p>
  <pre><code>import &quot;./IERC-20.sol&quot;;
  
  contract CpayCoin is IERC20 {
      //mapping
      mapping(address =&gt; uint256) private _balances;
      mapping(address =&gt; mapping(address =&gt; uint256)) private _allowances;
  
      //Unit256
      uint256 private _totalSupply;
      uint256 private _tokenPrice;
  
      // String
      string private _name;
      string private _symbol;
  
      //Address
      address _minter;
  
      constructor(
          string memory name_,
          string memory symbol_,
          uint256 totalSupply_
      ) {
          _minter = msg.sender;
          _balances[_minter] = _totalSupply;
          _tokenPrice = 10**15 wei;
          _name = name_;
          _symbol = symbol_;
          _totalSupply = totalSupply_;
      }
  
      // Modifier
      modifier onlyMinter() {
          require(msg.sender == _minter, &quot;Only Minter can Mint!&quot;);
          _;
      }
  
      modifier enoughBalance(address adr, uint256 amount) {
          require(_balances[adr] &gt;= amount, &quot;Not enough Balance!&quot;);
          _;
      }
  
      modifier enoughValue(uint256 amount) {
          require(msg.value == amount * _tokenPrice, &quot;Not enough Value!&quot;);
          _;
      }
  
      modifier checkZeroAddress(address adr) {
          require(adr != address(0), &quot;ERC20: mint to the zero address&quot;);
          _;
      }
  
      // Functions
      function name() public view virtual returns (string memory) {
          return _name;
      }
  
      function symbol() public view virtual returns (string memory) {
          return _symbol;
      }
  
      function totalSupply() public view virtual override returns (uint256) {
          return _totalSupply;
      }
  
      function balanceOf(address adr)
          public
          view
          virtual
          override
          returns (uint256)
      {
          return _balances[adr];
      }
  
      function _mint(address account, uint256 amount)
          internal
          virtual
          onlyMinter
          checkZeroAddress(account)
      {
          _totalSupply += amount;
          _balances[account] += amount;
  
          emit Transfer(address(0), account, amount);
      }
  
      function _burn(address account, uint256 amount)
          internal
          virtual
          onlyMinter
          checkZeroAddress(account)
      {
          uint256 accountBalance = _balances[account];
          unchecked {
              _balances[account] = accountBalance - amount;
          }
  
          _totalSupply += amount;
          emit Transfer(account, address(0), amount);
      }
  
      function _transfer(
          address sender,
          address recipient,
          uint256 amount
      ) internal virtual {
          require(sender != address(0), &quot;ERC20: transfer from the zero address&quot;);
          require(recipient != address(0), &quot;ERC20: transfer to the zero address&quot;);
  
          uint256 senderBalance = _balances[sender];
          require(
              senderBalance &gt;= amount,
              &quot;ERC20: transfer amount exceeds balance&quot;
          );
  
          unchecked {
              _balances[sender] = senderBalance - amount;
          }
  
          _balances[recipient] += amount;
  
          emit Transfer(sender, recipient, amount);
      }
  
      function _approve(
          address owner,
          address spender,
          uint256 amount
      ) internal virtual {
          require(owner != address(0), &quot;ERC20: approve from the zero address&quot;);
          require(spender != address(0), &quot;ERC20: approve to the zero address&quot;);
  
          _allowances[owner][spender] = amount;
          emit Approval(owner, spender, amount);
      }
  }
  </code></pre>