Understanding about OpenZeppelin

ERC721 is a type of technique that is used for non-fungible Tokens in the Ethereum blockchain. Unlike ERC20 tokens, which are fungible and identical to each other, ERC721 tokens are unique and distinguishable from one another. It represented digital art, collectibles, and real estate.

Features of "ERC721" provided by OpenZeppelin Contracts Wizard.

• Mintable: The explanation is the same as "ERC20".
• Auto Increment ID: It is a feature of a token contract in which the Incremental ‘ID’ of new tokens is automatically assigned. This is commonly used for each new entity (such as a token, user, or record) that needs a distinct identifier.
• Burnable: The explanation is the same as "ERC20".
• Pausable: The explanation is the same as "ERC20".
• Enumerable: It is a feature of token contract that refers to the ability to enumerate tokens on-chain. It means that the smart contract includes functionality to list all tokens or all tokens owned by a specific address.
• URI Storage: URI storage in the context of Ethereum tokens, refers to the way metadata (such as images, descriptions, and other attributes) associated with a token is stored and accessed.
• Block Numbers: It is a feature of Ethereum smart contracts that refers to the specific number assigned to a block in the blockchain. This can be useful in on-chain governance, where past token balances might determine voting power at the time a proposal was created.
• Roles: It is part of smart contracts in which all access control is more granularly than the single-owner model provided by the Ownable pattern. Roles allow multiple accounts to have different permissions to perform specific actions within the contract.
• Managed: It is also part of contracts that refers to a type of access control where a central contract, often called a manager or management contract, defines a policy that allows certain callers to access certain functions of the managed contract.
• UUPS: It stands for (Universal Upgradeable Proxy Standard) is a design pattern used for creating upgradeable smart contracts on Ethereum. It is a variation of the proxy pattern and is considered more efficient and flexible than the traditional transparent proxy pattern.

Code Example

// SPDX-License-Identifier: MIT
// Compatible with OpenZeppelin Contracts ^5.0.0
pragma solidity ^0.8.20;

import "@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/ERC721EnumerableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/ERC721URIStorageUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/ERC721PausableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/ERC721BurnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/cryptography/EIP712Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/ERC721VotesUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";

contract MyToken is Initializable, ERC721Upgradeable, ERC721EnumerableUpgradeable, ERC721URIStorageUpgradeable, ERC721PausableUpgradeable, AccessControlUpgradeable, ERC721BurnableUpgradeable, EIP712Upgradeable, ERC721VotesUpgradeable, UUPSUpgradeable {
    bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
    uint256 private _nextTokenId;
    bytes32 public constant UPGRADER_ROLE = keccak256("UPGRADER_ROLE");
    /// @custom:oz-upgrades-unsafe-allow constructor
    constructor() {
        _disableInitializers();
    }
    function initialize(address defaultAdmin, address pauser, address minter, address upgrader)
        initializer public
    {
        __ERC721_init("MyToken", "MTK");
        __ERC721Enumerable_init();
        __ERC721URIStorage_init();
        __ERC721Pausable_init();
        __AccessControl_init();
        __ERC721Burnable_init();
        __EIP712_init("MyToken", "1");
        __ERC721Votes_init();
        __UUPSUpgradeable_init();
        _grantRole(DEFAULT_ADMIN_ROLE, defaultAdmin);
        _grantRole(PAUSER_ROLE, pauser);
        _grantRole(MINTER_ROLE, minter);
        _grantRole(UPGRADER_ROLE, upgrader);
    }
    function pause() public onlyRole(PAUSER_ROLE) {
        _pause();
    }
    function unpause() public onlyRole(PAUSER_ROLE) {
        _unpause();
    }
    function safeMint(address to, string memory uri) public onlyRole(MINTER_ROLE) {
        uint256 tokenId = _nextTokenId++;
        _safeMint(to, tokenId);
        _setTokenURI(tokenId, uri);
    }
    function _authorizeUpgrade(address newImplementation)
        internal
        onlyRole(UPGRADER_ROLE)
        override
    {}
    // The following functions are overrides required by Solidity.
    function _update(address to, uint256 tokenId, address auth)
        internal
        override(ERC721Upgradeable, ERC721EnumerableUpgradeable, ERC721PausableUpgradeable, ERC721VotesUpgradeable)
        returns (address)
    {
        return super._update(to, tokenId, auth);
    }
    function _increaseBalance(address account, uint128 value)
        internal
        override(ERC721Upgradeable, ERC721EnumerableUpgradeable, ERC721VotesUpgradeable)
    {
        super._increaseBalance(account, value);
    }
    function tokenURI(uint256 tokenId)
        public
        view
        override(ERC721Upgradeable, ERC721URIStorageUpgradeable)
        returns (string memory)
    {
        return super.tokenURI(tokenId);
    }
    function supportsInterface(bytes4 interfaceId)
        public
        view
        override(ERC721Upgradeable, ERC721EnumerableUpgradeable, ERC721URIStorageUpgradeable, AccessControlUpgradeable)
        returns (bool)
    {
        return super.supportsInterface(interfaceId);
    }
}

Above the code has been generated in the open Zeppelin contracts wizard used by its type "ERC721". And enables several features, votes utilities, access control, and upgradeability like Mintable, Auto Increment Ids, Burnable, Pausable, Enumerable, URI Storage, Block Numbers, Roles, and UUPS. If you open this code then use " REMIX-Ethereum. IDE " to run the code.

Library 3. ERC1155

The ERC-1155 is a level of standard in smart contracts. ERC1155 is a multi-token standard that allows the creation and management of multiple types of tokens within a single contract. This implementation is designed to be modular, making it easy to extend and customize according to the needs of different projects.

Features of "ERC1155" provided by OpenZeppelin Contracts Wizard.

• Mintable: The explanation is the same as "ERC20".
• Burnable: The explanation is the same as "ERC20".
• Supply Tracking: It is the feature of the smart contract that refers to the ability to monitor and manage the total supply of each individual token ID within a single smart contract. ERC1155 is a multi-token standard on the Ethereum blockchain that supports fungible and non-fungible tokens in one contract. In ERC1155 that allows for multiple types of tokens to be managed under one contract address.
• Pausable: The explanation is the same as "ERC20".
• Updatable URI: In this feature of smart contract. An updatable URI is used for its ability to change the Uniform Resource Identifier (URI) which is connected with a specific token ID after the token has been created. The URI points to the JSON file that contains the metadata about the token, its name, description, image, and other attributes.
• Managed: The explanation is the same as "ERC721".
• Transparent: The explanation is the same as "ERC20".

Code Example

// SPDX-License-Identifier: MIT
// Compatible with OpenZeppelin Contracts ^5.0.0
pragma solidity ^0.8.20;

import "@openzeppelin/contracts-upgradeable/token/ERC1155/ERC1155Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/manager/AccessManagedUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC1155/extensions/ERC1155PausableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC1155/extensions/ERC1155BurnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC1155/extensions/ERC1155SupplyUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
contract MyToken is Initializable, ERC1155Upgradeable, AccessManagedUpgradeable, ERC1155PausableUpgradeable, ERC1155BurnableUpgradeable, ERC1155SupplyUpgradeable {
    /// @custom:oz-upgrades-unsafe-allow constructor
    constructor() {
        _disableInitializers();
    }
    function initialize(address initialAuthority) initializer public {
        __ERC1155_init("");
        __AccessManaged_init(initialAuthority);
        __ERC1155Pausable_init();
        __ERC1155Burnable_init();
        __ERC1155Supply_init();
    }
    function setURI(string memory newuri) public restricted {
        _setURI(newuri);
    }
    function pause() public restricted {
        _pause();
    }
    function unpause() public restricted {
        _unpause();
    }
    function mint(address account, uint256 id, uint256 amount, bytes memory data) public restricted {
        _mint(account, id, amount, data);
    }
    function mintBatch(address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data) public restricted {
        _mintBatch(to, ids, amounts, data);
    }
    // The following functions are overrides required by Solidity.
    function _update(address from, address to, uint256[] memory ids, uint256[] memory values) internal override(ERC1155Upgradeable, ERC1155PausableUpgradeable, ERC1155SupplyUpgradeable) {
        super._update(from, to, ids, values);
    }
}

Above the code has been created in the open zeppelin contracts wizard used by its type "ERC1155". And enables its all several features, votes utilities, access control, and upgradeability like Mintable, Burnable, Supply Tracking, Pausable, Updatable URI, Managed, and Transparent. If you open this code then use " REMIX-Ethereum. IDE " to run the code.

Conclusion

OpenZeppelin plays a crucial role in advancing blockchain technology by providing tools and resources that make it easier and safer to develop decentralized applications. Their efforts contribute significantly to the overall security and accessibility of the blockchain ecosystem.