Initializable ERC20 token

Question

I want to create a clone factory, that will initialize ERC20 tokens. I saw some examples for older solidity versions (0.5) and it worked there. Back then was ERC20Detailed contract that could be initialized. With solidity ^0.8.0 it doesn't work anymore or I am doing something wrong.

Here are my contracts:

pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts/proxy/Clones.sol";


contract TokenFactory{
    address immutable tokenImplementation;

    constructor () {
        tokenImplementation = address(new Token());
    }

    function createToken(string calldata name, string calldata symbol, uint8 decimals, uint256 initialSupply, address owner, address[] memory airdropDestinations, uint256[] memory airdropValues) external returns (address){
        address clone = Clones.clone(tokenImplementation);
        Token(clone).initialize(name, symbol, decimals, initialSupply, owner, airdropDestinations, airdropValues);
        return clone;
    }
}


contract Token is Initializable, ERC20 {
    uint8  private _decimals;
    string private _name;
    string private _symbol;
    address  private _owner;

    function initialize(string memory name, string memory symbol, uint8 decimals_, uint256 supply, address owner, address[] memory airdropDestinations, uint256[] memory airdropValues) public initializer{
        require(supply > 0);
        ERC20.initialize(name, symbol);
        _name = name;
        _decimals = decimals_;
        _owner = owner;
        _mint(owner, supply);
        _airdrop(airdropDestinations, airdropValues);
    }

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

    function _airdrop(address[] memory destinations, uint256[] memory values) private {
        uint256 i = 0;
        while (i < destinations.length) {
           _transfer(_owner, destinations[i], values[i]);
           i += 1;
        }
    }
}

I am getting an error that ERC20 is not initializable, which is understandable, because it doesn't have initialize method. Anyway, if I skip initializing it, then the will be an error that I need to call ERC20 constructor, which I don't need to.

Answer 1

You can use this code:

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.11;

import "@openzeppelin/contracts-upgradeable/token/ERC20/presets/ERC20PresetFixedSupplyUpgradeable.sol";
import "@openzeppelin/contracts/proxy/Clones.sol";

contract FactoryClone {
    address immutable tokenImplementation;

    constructor() {
        tokenImplementation = address(new ERC20PresetFixedSupplyUpgradeable());
    }

    function createToken(string calldata name, string calldata symbol, uint256 initialSupply) external returns (address) {
        address clone = Clones.clone(tokenImplementation);
        ERC20PresetFixedSupplyUpgradeable(clone).initialize(name, symbol, initialSupply, msg.sender);
        return clone;
    }
}

Some notes:

• If you don't use Remix, you maybe need to change the path of the ERC20PresetFixedSupplyUpgradeable.sol contract
• Clones.sol actually defines a library, and ERC20PresetFixedSupplyUpgradeable.sol is just a token smart contract with predefined functions, and you can change it with another one of your choice

Once the factory is deployed (~1.1M gas in total, ~200K more than the token contract deployment), it takes ~180K gas to deploy a new token contract.

This technique is cheaper during the deployment phase, but it's a bit more expensive than a native token contract regarding other operations like transfers and so on. It's up to you to understand if you want to pay more now, and let your users pay less in the long term, or viceversa.

You can find more info about different gas costs in this OpenZeppelin worship repository, and in this video you can watch a full deep dive into gas cost comparison between FactoryNaive.sol, FactoryProxy.sol and FactoryClone.sol.