Please check my first created bep20 contract

Hello :smiley:
As an amateur i’ve created a bep20 token, and i’m still learning and learning.
It enjoys me (maybe one day i’ll be like you:) ) but there are moments where i need your help (and hope to get it)
My goals for my token are those:

  1. Can Burn
  2. Can Mint
  3. Can Pausae
  • Distribute 3% to holders;
  • Distribute 2% to the project address;
  • Distribute 1% to a specific address (dev);
  • Liquiditiy 4%;
  1. Exclude owner from fee
  2. Lock time
  3. I saw some tokens that are paired to Uniswap, don’t really know what it is, but if its possible i would add the same to my token.
  4. Telling me if the token is ready and compatible to be listed on exchanges like “Poloniex or Binance”

Please find below the Solidity code that i’ve created, and need help to check if my codes are written correct (Of course some of the codes are copy paste and i don’t know if i’ve copied them correct)

Thank you in advance and hope for an answer!

pragma solidity ^0.8.2;

import "";

contract Token {
    mapping(address => uint) public balances;
    mapping(address => mapping(address => uint)) public allowance;
    uint public totalSupply = 100000000000 *10 ** 18;
    string public name = "Testtoken1";
    string public symbol = "TTN";
    uint public decimals = 18;
    event Transfer(address indexed from, address indexed to, uint value);
    event Approval(address indexed owner, address indexed spender, uint value);
    constructor () {
        balances[msg.sender] = totalSupply;
    function balanceOf(address owner) public view returns(uint) {
        return balances[owner];
    function transfer(address to, uint value) public returns(bool) {
        require(balanceOf(msg.sender) >= value, 'balances too low');
        balances[to] += value;
        balances[msg.sender] -= value;
        emit Transfer(msg.sender, to, value);
        return true;
    function transferFrom(address from, address to, uint value) public returns(bool) {
        require(balanceOf(from) >= value, 'balance too low');
        require(allowance[from][msg.sender] >= value, 'allowance too low');
        balances[to] += value;
        balances[from] -= value;
        emit Transfer(from, to, value);
        return true;
    function approve(address spender, uint value) public returns(bool) {
        allowance[msg.sender][spender] = value;
        emit Approval(msg.sender, spender, value);
        return true;

contract Ownable is Context {
  address private _owner;

  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

  constructor () internal {
   address msgSender = _msgSender();
    _owner = msgSender;
    emit OwnershipTransferred(address(0), msgSender);

  function owner() public view returns (address) {
    return _owner;

  modifier onlyOwner() {
    require(_owner == _msgSender(), "Ownable: caller is not the owner");

  function renounceOwnership() public onlyOwner {
    emit OwnershipTransferred(_owner, address(0));
    _owner = address(0);

  function transferOwnership(address newOwner) public onlyOwner {

  function _transferOwnership(address newOwner) internal {
    require(newOwner != address(0), "Ownable: new owner is the zero address");
    emit OwnershipTransferred(_owner, newOwner);
    _owner = newOwner;
  function setLiquidityFeePercent(uint256 liquidityFee) external onlyOwner() {
		liquidityFee = 4;
  function setTaxFeePercent(uint256 taxFee) external onlyOwner() {
		taxFee = 3;
  function burn(uint256 burningAmount) public onlyOwner {
		_burn(_msgSender(), burningAmount);
  function transfer(address recipient, uint256 amount) external returns (bool) {
    _transfer(_msgSender(), recipient, amount);
    return true;

   * @dev See {BEP20-allowance}.

  function approve(address spender, uint256 amount) external returns (bool) {
    _approve(_msgSender(), spender, amount);
    return true;
  function mint(uint256 amount) public onlyOwner returns (bool) {
    _mint(_msgSender(), amount);
    return true;
    function _mint(address account, uint256 amount) internal {
    require(account != address(0), "BEP20: mint to the zero address");

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

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

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

I’ve moved the post to the new category #general:review-wanted and fixed code formatting in your post. Use triple backticks as follows.

code here

Informal reviews by the community are not a substitute for a professional audit.