This document explains how to automatically write any smart contract using the OpenZeppelin Wizard. The resulting smart contract code can either be integrated with Remix by Clicking the Open in Remix button, or copied to clipboard and pasted in the user's intended IDE.

Getting Started

Navigate to the OpenZeppelin Wizard in your browser. First thing to notice is the Solidity Wizard and Cairo Wizard buttons.

One can choose any of the following tabs to begin creating an out-of-box smart contract code in either Solidity (for EVM chains) or Cairolang (useful for Starknet). These are:

• ERC20: for writing an ERC-20 token smart contract

• ERC721: for writing an NFT token smart contract

• ERC1155: for writing an ERC-1155 token smart contract

• Governor: for creating a DAO

• Custom: for writing a customized smart contract

Writing An NFT Contract

For illustration purpose, we will be creating a NFT smart contract. Suppose you wanted to create a Mintable, Burnable ERC721 token and specify an appropriate license for it.

1. Select the ERC721 tab.

2. Give your NFT a name and a symbol by filling the Name and Symbol fields.

3. Use the check-boxes on the left to select features of your token

• Put a tick on the Mintable check-box

• Put a tick on the Auto Increment Ids check-box, this ensures uniqueness of each minted NFT

• Put a tick on the Burnable check-box

Notice that new lines of code are automatically written each time a feature is selected.

Voila! Contract Ready

With the resulting lines of code, you now have the NFT token contract written in Solidity. As mentioned above, this source code can now be ported to an IDE of your choice or opened directly in Remix.

The below figure depicts the auto-written NFT smart contract code.

Verify Contracts

Once verified, a smart contract or token contract's source code becomes publicly available and verifiable, creating transparency and trust.

There are several ways to verify a contract, programmatically or manually on the UI.

Verify on the UI

1. Go the the page

2. Enter in the contract address you received during deployment. The dropdown will show you several available verification options. Select the one you would like to use and continue.

   1. Solidity (Flattended source code)

   2. Solidity (Standard JSON Input)

Solidity (Flattened Source Code)

1. Contract Address: The 0x address supplied on contract creation (added above)

2. Is Yul Contract: Select if the contract is coded in Yul for efficiency.

3. Include Nightly Builds: Select if you want to show nightly builds.

4. Compiler: derived from the first line in the contract pragma solidity X.X.X. Use the corresponding compiler version rather than the nightly build.

Solidity (Standard JSON Input)

1. Include nightly builds. You can choose Yes or No depending on your compiler.

2. Compiler. Choose the compiler version used to compile your smart contract. If you selected yes for nightly builds, use the compiler version rather than the build.

3. Standard Input JSON. Upload your Standard Input JSON file. File should follows solidity format and all the sources must be in Literal Content format, not a URL.

Click the Verify & publish button and wait for the response.

Verify Programmatically

To verify contracts please follow the Verifying a Smart Contract guide to learn the different options.

In particular, to be able to verify the contracts programatically we will need following steps:

1- Install @nomiclabs/hardhat-etherscan package:

2- Import into hardhat.config.ts

3- Update hardhat.config.ts following:

4- Verify the contract Once the config is updated, you can verofy the contract with

import Tabs from '@theme/Tabs'; import TabItem from '@theme/TabItem';

Hardhat is a popular smart contract development frameworks. In this tutorial, we will be using Hardhat to deploy a simple Counter smart contract to the Custom Rollup Testnet. We will explore the basics of creating a Hardhat project with a sample contract and a script to deploy it.

For the full instruction on how to use Hardhat, please refer to the official Hardhat documentation.

Create New Project

Start with creating an npm project by going to an empty folder, running npm init, and following its instructions. You can use another package manager, like yarn, but Hardhat recommends you use npm 7 or later, as it makes installing Hardhat plugins simpler.

Hardhat Smart Contract

To create the sample project, run npx hardhat init in your project folder:

• Press <ENTER> choose javascript, typescript or empty project

• Press <ENTER> to set the project root

• Press <ENTER> again to accept addition of .gitignore

Create deployer account

• Create the .env file in your project root folder and add the following line:

• Populate the .env file with your private key. You can get your private key from Metamask. See the section below on how to get your private key from Metamask.

:::warning Do not commit your private key to a public repository!

Verify that your .gitignore file contains .env to prevent your private key from being committed to a public repository. :::

Configure Hardhat

• Open the hardhat.config.js file and paste the code below:

Write Smart Contract

:::info Note: The existing smart contract code that comes with the sample project is a Lock.sol contract. Feel free to delete it or leave it. :::

• Create a new file, in the contracts folder, named Counter.sol:

• Copy the below code and paste it in the Counter.sol contract code:

Create Deploy Script

• Delete the content of the scripts/deploy.js file and add the code below:

Compile Contract

• Install dotenv package: npm install dotenv

• Compile your contract code (i.e., go back to the project root in the CLI),

Deploy Contract

• Run the deploy script: