Web3Codes
HomeToolsStoreBlogAbout
Explore ToolsCheck Approvals

Smart Contract Generator

ERC-20, ERC-721, or ERC-1155 — pick your features, get a ready-to-deploy Solidity contract.

Leave blank for no premint — useful if minting is fully dynamic instead.

Who can mint/pause/manage?

One address (Ownable) controls every privileged function.

Generated contract

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract MyToken is ERC20, Ownable {
    constructor(address initialOwner)
        ERC20("My Token", "MTK")
        Ownable(initialOwner)
    {
        _mint(msg.sender, 1000000 * 10 ** decimals());
    }

    function mint(address to, uint256 amount) public onlyOwner {
        _mint(to, amount);
    }
}

Built on OpenZeppelin, not reinvented

Every generated contract inherits from OpenZeppelin Contracts — the standard, heavily-audited base that most production tokens and NFT collections are already built on. This tool just assembles the pieces (which extensions, which constructor arguments, which access-control model) based on what you pick, instead of you hand-writing the inheritance and import boilerplate yourself.

What’s actually available

ERC-20: mintable, burnable, pausable, capped supply, EIP-2612 permit (gasless approvals), and ERC20Votes for on-chain governance. ERC-721: mintable, burnable, pausable, Enumerable, and ERC-2981 resale royalties. ERC-1155: mintable, burnable, pausable, supply tracking, and royalties. Every standard can be gated by a single owner or by separate mint/pause roles via AccessControl.

Every combination resolves Solidity’s override rules correctly

Combining extensions that each hook into the same internal function (like Pausable and Votes both touching transfers) requires the final contract to explicitly reconcile that overlap, or it won’t compile. Every combination this tool can produce generates that reconciliation code automatically and correctly — you don’t need to know the override rules to get code that respects them.

Frequently asked questions

No — the underlying building blocks (ERC20, ERC721, ERC1155, Ownable, AccessControl, and every extension) come from OpenZeppelin Contracts, one of the most widely audited Solidity libraries in the ecosystem. But your specific combination, and anything you add on top, hasn't been independently audited. Get a real review before putting meaningful value behind it.

Single owner (Ownable) means one address can mint, pause, and manage everything — simple, but a single point of failure/trust. Role-based (AccessControl) splits that into separate MINTER_ROLE and PAUSER_ROLE grants, so you can hand minting to one address (say, a sale contract) and pausing to another (say, a multisig), and revoke either independently without touching the other.

Without a cap, nothing stops a future mint call (yours or, if compromised, an attacker's) from exceeding whatever total you originally intended — it's a social/operational limit, not an enforced one. A capped supply makes every mint revert once the cap is hit, on-chain and permanently, regardless of who calls it.

Only if you want on-chain vote-weight tracking and delegation (the pattern OpenZeppelin's own Governor contracts read from) — most DAO tokens built on OZ use it. If your governance happens off-chain (Snapshot, a multisig, etc.), you likely don't need it.

No — ERC-2981 is a standard way to publish "here's the royalty this collection expects," but enforcing it is up to each marketplace, and several major ones don't (or make it optional for buyers). Treat it as a strong signal, not a guarantee of payment.

Copy or download it, drop it into Remix, Hardhat, or Foundry, install @openzeppelin/contracts as a dependency, compile, and deploy like any other Solidity contract. This tool only generates the source — it doesn't compile or deploy anything, so always compile and test before it touches real funds.

More free tools

View all tools
Token Approval CheckerUnit ConverterABI Encoder/Decoder