How to Mint an NFT Using Ethers.js

A Quick Reminder

Minting an NFT represents the process of publishing a unique instance of your ERC721 token on the blockchain. This fundamental operation is the cornerstone of non-fungible token creation on Ethereum. The ERC721 standard defines a set of rules and functions that enable the creation, ownership transfer, and management of unique digital assets. When you mint an NFT from a contract, you are essentially creating a new token with a unique identifier and associating it with a specific wallet address on the Ethereum blockchain. This tutorial assumes prior successful deployment of a smart contract to a test network, building upon foundational knowledge from Part I of the NFT tutorial series. Understanding this concept is essential before proceeding with the implementation details discussed in the following sections.

Create your Solidity contract

OpenZeppelin is a widely-recognized library for secure smart contract development that provides battle-tested implementations of popular token standards. Rather than writing complex smart contracts from scratch, developers can inherit from OpenZeppelin's implementations of standards such as ERC20 or ERC721, then extend the behavior to meet their specific requirements. This approach significantly reduces security vulnerabilities and development time. For this tutorial on how to mint NFT from contract, the smart contract file should be placed at contracts/MyNFT.sol. The contract inherits from ERC721URIStorage, which provides functionality for storing token URIs that point to metadata describing each NFT. The contract includes a counter to track token IDs, ensuring each minted NFT receives a unique identifier. The mintNFT function accepts a recipient address and token URI, increments the token counter, mints a new token to the recipient, and associates it with the provided URI before returning the new token ID.

Create Hardhat tasks to deploy our contract and mint NFT's

Hardhat tasks provide a convenient way to automate common operations in your development workflow. Creating task files allows you to encapsulate deployment and minting logic in reusable, testable components. The file tasks/nft.ts should contain two primary tasks: one for deploying the contract and another for minting NFTs. The deploy-contract task retrieves the contract factory and deploys it to the network, returning the contract address for future reference. The mint-nft task accepts a token URI parameter and executes the minting function on the deployed contract, specifying a gas limit to ensure sufficient resources for the transaction. These tasks abstract away the complexity of direct contract interaction and provide a clean command-line interface for common operations.

Create helpers

Helper functions are essential utilities that support the main task logic by providing reusable functionality for common operations. The contract.ts helper retrieves a deployed contract instance using the contract name, Hardhat runtime environment, and wallet. The env.ts helper safely retrieves environment variables, throwing an error if a required variable is undefined, which prevents runtime failures from missing configuration. The provider.ts helper establishes a connection to the Ethereum network through various RPC providers, with support for network selection. The wallet.ts helper creates an Ethers wallet instance from private key credentials, enabling transaction signing and contract deployment. Together, these helpers provide the foundational utilities necessary for interacting with smart contracts and the blockchain network.

Create tests

Comprehensive testing ensures your smart contract functions correctly and securely handles various scenarios. Unit tests verify individual contract functions, while integration tests validate the interaction between tasks and contract functions. The unit test suite for MyNFT includes tests for minting functionality such as verifying Transfer events are emitted correctly, confirming the returned token ID, and ensuring token IDs increment properly. Additional tests validate security constraints, such as preventing minting to the zero address. The integration tests verify that Hardhat tasks execute successfully and produce expected outputs. The test helper file provides utilities for deploying contracts in test environments and retrieving test wallets from the Hardhat network. These tests are foundational examples demonstrating how to build more robust test suites that cover edge cases and potential vulnerabilities.

Configuration

The hardhat.config.ts file provides essential configuration for the Hardhat development environment. It specifies the Solidity compiler version (0.8.6) and conditionally loads the dotenv library to manage environment variables. The configuration includes logic to import dotenv only when not running tests, preventing potential issues with environment variable handling during test execution. This setup ensures that sensitive information such as private keys and API credentials are managed securely through environment variables rather than being hardcoded in the repository. The configuration file also imports the custom NFT tasks, making them available through the Hardhat command-line interface.

Running Our Tasks

With the task files properly configured, you can execute NFT operations directly from the command line. Running hardhat without arguments displays all available tasks, including the custom deploy-contract and mint-nft tasks alongside Hardhat's built-in tasks. Each task is listed with its description, providing clear documentation of available operations. If you need detailed information about a specific task's parameters and usage, running hardhat help [task-name] displays comprehensive usage information. This command-line interface makes it easy to manage your NFT infrastructure without writing additional scripts or repeating complex command patterns.

Running Our Tests

Executing tests validates that your smart contract and supporting code function correctly before deployment to production networks. Running hardhat test discovers and executes all test files in your project, providing detailed output about test results. The test output shows organized test suites grouped by contract or functionality, with individual test results indicated by checkmarks for passing tests. The test results demonstrate coverage of critical functionality including Transfer event emission, token ID assignment, token ID incrementing, address validation, and balance tracking. Successful test execution confirms that the contract behaves as expected and handles edge cases appropriately, providing confidence for deployment and use in production environments.

Conclusion

This tutorial provides a comprehensive foundation for implementing a well-tested, production-ready NFT infrastructure using Solidity, Ethers.js, and Hardhat. By following these steps, you have established a complete development environment that includes smart contract implementation, automated task execution, comprehensive testing, and proper configuration management. The use of OpenZeppelin libraries ensures security best practices, while the Hardhat and Waffle testing framework enables robust validation of contract functionality. The helper functions and task abstractions create a maintainable codebase that scales with your project's complexity. The local test network with preloaded ETH balances provides a safe, fast development environment for iterating on your NFT contracts. This architecture and approach can be extended and adapted for more complex NFT requirements, multi-contract systems, and production deployment scenarios.

FAQ

How to mint NFT from contract etherscan?

Locate the contract address on Etherscan, navigate to the Contract tab, find the mint function, input required parameters, and execute the transaction. Approve gas fees and confirm to complete NFT minting.

How much does it cost to mint 10,000 NFTs?

Minting 10,000 NFTs typically costs between $5,000 and $1 million, depending on the blockchain network and gas fees. Ethereum is more expensive, while Layer 2 solutions offer lower costs. Batch minting can help reduce overall expenses.

How easy is it to mint an NFT?

Minting an NFT is straightforward with modern tools. You can use no-code platforms or smart contracts to create and mint NFTs on blockchain. Basic requirements include a wallet, gas fees, and digital assets. Most users can complete the process in minutes without extensive technical knowledge.

Is minting an NFT free?

Minting an NFT typically requires gas fees on most blockchains, but some platforms offer gasless minting options or Layer 2 solutions with minimal costs. Free minting is possible on specific platforms and chains.

What are the prerequisites and setup steps to mint an NFT from a smart contract?

You need a wallet with sufficient tokens for gas fees, access to the blockchain network, and the smart contract address. Deploy or interact with an NFT collection contract, prepare metadata, then send a mint transaction with required parameters like item owner address and amount to the contract.

What is the difference between minting NFTs directly from a contract versus using an NFT platform?

Direct contract minting requires technical knowledge and blockchain interaction, offering full control and lower fees. NFT platforms provide user-friendly interfaces and simplified processes, but charge platform fees and offer less customization.