ERC20 Auto LP tax token using openzeppelin contracts-upgradeable

Smart Contracts
, , ,
1

Hello,

I am creating a ERC20 upgradeable smart contract that has the specificity of getting different fees in ETH when buy or sold. But no fees when transferred.
e.g. the fees are:

  • 1% goes to owner
  • 1% goes to dev
  • 1% goes to auto LP (this is the most tricky one to achieve)

Looking up online at some example smart contracts I saw that none of them directly uses openzeppelin libraries but instead defines elementary functions themselves.

Such as:

interface IERC20 {
    
    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);
}

Or also:

   /*

    STANDARD ERC20 COMPLIANCE FUNCTIONS

    */

    function name() public view returns (string memory) {
        return _name;
    }

    function symbol() public view returns (string memory) {
        return _symbol;
    }

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

    function totalSupply() public view override returns (uint256) {
        return _tTotal;
    }

    function balanceOf(address account) public view override returns (uint256) {
        return _tOwned[account];
    }

    function transfer(address recipient, uint256 amount) public override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    function allowance(address owner, address spender) public view override returns (uint256) {
        return _allowances[owner][spender];
    }

    function approve(address spender, uint256 amount) public override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
        return true;
    }
     
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
        return true;
    }

    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
        return true;
    }

You can find the full contract here https://github.com/techaddict0x/token/blob/main/fee%20no%20rewards.txt

Why is it so? Wouldn't overriding functions be enough to keep the whole smart contract simpler and safer relating on openzeppelin import?
It is even achievable using openzeppelin import?

2

It looks like a flattened contract, which is essentially the replacing of every import statement with the entire source code imported by that statement.

This is typically done after deploying the contract, in order to verify its source code on Etherscan (so that they can display it on their website).

To strictly answer your question:

Yes, relying on openzeppelin code is generally simpler AND safer, since this code has been thoroughly reviewed by a large community, as well as by paid auditors.

1 Like