A Comprehensive Guide to Creating BEP-721 NFTs on the Binance Smart Chain with TypeScript

Part I: Foundational Concepts and Strategic Overview

This report provides an exhaustive, expert-level technical guide for developers on the end-to-end process of creating, deploying, and minting a BEP-721 Non-Fungible Token (NFT) on the Binance Smart Chain (BSC). The methodology detailed herein exclusively utilizes TypeScript for scripting and command-line operations, reflecting professional software development standards for building robust and maintainable blockchain applications.

Section 1: Deconstructing the BEP-721 Standard on Binance Smart Chain

Before engaging in the practical aspects of development, a deep understanding of the underlying token standard is paramount. The BEP-721 standard is the cornerstone protocol for unique digital assets within the BSC ecosystem, and its architecture dictates the capabilities and constraints of the NFTs created.

Architectural Analysis of BEP-721

The BEP-721 token standard is the protocol that supports the creation and management of non-fungible tokens on the BNB Chain.1 The term "non-fungible" signifies that each token is unique and not interchangeable with any other token, a stark contrast to fungible tokens like BEP-20, where any token is identical to another.3 This uniqueness is the core architectural principle of BEP-721.

The mechanism for achieving this uniqueness is the assignment of a unique identifier, the tokenId, to each token minted under a given smart contract.1 While a BEP-20 contract can issue billions of identical tokens, a BEP-721 contract manages a collection of distinct items, each tracked by its

tokenId. This architecture enables the tokenization of ownership for unique digital or physical assets, such as digital art, collectibles, in-game items, or even tokenized real estate.3

Comparative Analysis: BEP-721 vs. ERC-721

A critical aspect of the BEP-721 standard is that it is a direct extension of Ethereum's ERC-721 standard.1 This is not a superficial similarity; it is a fundamental design choice with profound implications for the developer ecosystem. The Binance Smart Chain is designed to be fully compatible with the Ethereum Virtual Machine (EVM), the runtime environment for Ethereum smart contracts.3

This EVM compatibility means that smart contracts written in Solidity for Ethereum's ERC-721 standard can be deployed on the Binance Smart Chain as BEP-721 tokens with minimal to no modification.6 The same development tools, programming languages (like Solidity), and client-side libraries (like Ethers.js) are applicable to both ecosystems. This strategic decision was instrumental in BSC's rapid growth, as it lowered the barrier to entry for the vast pool of existing Ethereum developers who were seeking alternatives due to Ethereum's high transaction fees and network congestion.5

The primary practical differences for a developer are environmental rather than logical:

1. Gas Token: Transactions on BSC are paid for using BNB, whereas Ethereum uses ETH.3
2. Network Endpoints: To interact with the BSC network, developers must connect to BSC-specific JSON-RPC endpoints.
3. Block Explorers: Transaction and contract verification is performed on BscScan, the BSC equivalent of Ethereum's Etherscan.

The knowledge and skills acquired in developing BEP-721 tokens are, therefore, highly transferable to Ethereum and other EVM-compatible chains like Polygon, Avalanche, and Base, making this a valuable and broadly applicable area of expertise.

The Anatomy of a BEP-721 Contract

The BEP-721 standard, inheriting from EIP-721, mandates a specific set of functions and events that a compliant smart contract must implement. This standardization ensures that NFTs are interoperable with wallets, marketplaces, and other applications within the ecosystem.4

Key functions include:

• name(): Returns the name of the token collection (e.g., "CryptoPunks").3
• symbol(): Returns a short symbol for the token collection (e.g., "PUNK").3
• balanceOf(address _owner): Returns the number of NFTs in an owner's account.3
• totalSupply(): Returns the total number of NFTs that have been minted.3
• ownerOf(uint256 _tokenId): Returns the address of the owner of a specific NFT, identified by its tokenId.4
• safeTransferFrom(address _from, address _to, uint256 _tokenId): Safely transfers the ownership of an NFT from one address to another. This function includes checks to ensure the recipient is capable of receiving NFTs, preventing accidental loss of assets.
• tokenURI(uint256 _tokenId): This is arguably the most critical function for the perceived value of an NFT. It returns a Uniform Resource Identifier (URI) for a given tokenId, which points to a JSON file containing the token's metadata.3 This metadata includes the name, description, image, and other attributes of the specific asset the token represents.

The separation of on-chain ownership data (the tokenId and its owner) from the potentially large and complex off-chain metadata (the asset's details) is a deliberate architectural pattern. Storing extensive data like high-resolution images or detailed attributes directly on the blockchain is prohibitively expensive due to gas costs.10 The

tokenURI function serves as an immutable, on-chain link between the token and its off-chain descriptive data, providing a cost-effective and scalable solution.10

Section 2: Architecting the Development Stack: Hardhat and TypeScript

Choosing the right development environment and tools is a strategic decision that significantly impacts productivity, code quality, and project maintainability. For professional blockchain development, Hardhat combined with TypeScript offers a superior and robust stack.

Rationale for Selecting Hardhat

Hardhat is a state-of-the-art development environment for Ethereum and EVM-compatible chains.12 It facilitates every stage of the smart contract lifecycle, including compiling, deploying, testing, and debugging. Its key advantages include:

• Integrated Local Network: Hardhat comes with a built-in local Ethereum network designed for development, which provides features like stack traces for failed transactions and console.log() functionality directly within Solidity code for easier debugging.12
• Extensible Plugin System: Hardhat's functionality can be easily extended through a rich ecosystem of plugins, such as hardhat-ethers for seamless integration with the Ethers.js library and hardhat-verify for automatic contract source code verification.15
• Superior TypeScript Integration: Hardhat is designed with first-class support for TypeScript, providing type safety and autocompletion for configuration, scripts, and tests, which is a core requirement for this guide.12

While Truffle is another established development framework, Hardhat is often preferred in modern projects for its flexibility, performance, and stronger alignment with contemporary JavaScript and TypeScript development practices.12

The Role of TypeScript

TypeScript, a superset of JavaScript, introduces static typing to the development process. For writing deployment scripts, automated tests, and backend interactions with smart contracts, using TypeScript offers significant benefits:

• Error Prevention: Static typing allows the compiler to catch a wide range of common errors during the development phase, long before the code is executed on a live network where mistakes can be costly.15
• Code Clarity and Maintainability: Explicit types make the code more self-documenting and easier for developers to understand and maintain, which is crucial for complex projects.
• Enhanced Tooling: TypeScript enables powerful editor features like intelligent code completion, refactoring, and advanced error checking, boosting developer productivity.

Overview of the End-to-End Workflow

The process of creating a BEP-721 NFT can be visualized as a sequential workflow:

1. Environment Setup: Configure the development workstation with Node.js, MetaMask, and the BSC Testnet.
2. Project Initialization: Scaffold a new project using Hardhat with TypeScript support.
3. Contract Authoring: Write the BEP-721 smart contract in Solidity, leveraging OpenZeppelin's secure base contracts.
4. Metadata Preparation: Create the NFT's visual asset (e.g., an image) and its corresponding JSON metadata file, and upload both to a decentralized storage solution like IPFS.
5. Compilation: Compile the Solidity smart contract into bytecode and ABI using Hardhat.
6. Deployment: Write and execute a TypeScript script to deploy the compiled contract to the BSC Testnet.
7. Minting: Write and execute a TypeScript script to call the deployed contract's minting function, creating a new NFT and assigning it to a recipient.
8. Verification: Verify the deployed contract's source code on BscScan and inspect the minted NFT using the block explorer.

Feature	Hardhat	Truffle	Expert Recommendation
TypeScript Support	Native, first-class integration with type-safe configurations and plugins.12	Supported, but often requires more manual configuration and can be less seamless.18	Hardhat is the superior choice for projects prioritizing TypeScript.
Local Test Network	Built-in Hardhat Network with advanced debugging features like console.log in Solidity.12	Typically relies on an external tool, Ganache, for a local blockchain GUI and CLI.20	Hardhat provides a more integrated and powerful debugging experience out of the box.
Debugging	Provides detailed Solidity stack traces for reverted transactions, simplifying error diagnosis.12	Debugging capabilities are present but are often considered less intuitive than Hardhat's.18	Hardhat offers a more developer-friendly and informative debugging workflow.
Plugin Ecosystem	Modern, flexible, and growing ecosystem of community-developed plugins.15	Mature ecosystem, but can sometimes feel more monolithic compared to Hardhat's composable approach.18	Both are strong, but Hardhat's plugin architecture aligns better with modern development.
Community Momentum	Has seen a significant rise in adoption and is often the default choice for new projects.12	A long-standing and respected framework, but has seen some of its market share shift to Hardhat.17	Hardhat currently has stronger momentum and is more aligned with the evolving toolchain.

Part II: Environment Configuration and Project Initialization

This section provides a meticulous, step-by-step guide to configuring a professional-grade development environment, which is a prerequisite for building and deploying the BEP-721 smart contract.

Section 3: Preparing the Developer Workstation and Wallet

A correctly configured workstation and crypto wallet are the foundational elements of the development setup.

System Prerequisites

Before proceeding, ensure the development machine has Node.js installed. It is recommended to use a Long-Term Support (LTS) version, preferably v22 or later, to ensure compatibility with modern development tools.21 Node.js can be downloaded from its official website. Its installation includes the Node Package Manager (npm), which will be used to manage project dependencies.

Wallet Setup: MetaMask

A non-custodial crypto wallet is required to interact with the Binance Smart Chain. MetaMask is the industry-standard browser extension wallet for EVM-compatible chains.22

1. Installation: Navigate to the official MetaMask website (metamask.io) and install the browser extension for Chrome, Firefox, or Brave.23
2. Wallet Creation: Follow the on-screen prompts to create a new wallet.
3. Seed Phrase Security: During setup, MetaMask will reveal a 12-word "secret recovery phrase" or "seed phrase." This phrase is the master key to the wallet and all its assets. It is absolutely critical to write this phrase down and store it in a secure, offline location. Never store the seed phrase on an internet-connected device or share it with anyone. Losing this phrase will result in the permanent loss of access to the wallet.22

Configuring MetaMask for BSC Testnet

By default, MetaMask is configured for the Ethereum network. To develop on BSC, the BSC Testnet must be added as a custom network.22

1. Open MetaMask and click on the network dropdown menu at the top.
2. Select "Add network."
3. A new browser tab will open. Select "Add a network manually."
4. Enter the following parameters exactly to configure the BSC Testnet 22:

• Network Name: Binance Smart Chain Testnet
• New RPC URL: https://data-seed-prebsc-1-s1.binance.org:8545/
• ChainID: 97
• Symbol: tBNB
• Block Explorer URL: https://testnet.bscscan.com

1. Click "Save." MetaMask is now configured to interact with the BSC Testnet.

Acquiring Testnet Assets (tBNB)

Deploying contracts and sending transactions on any blockchain requires payment of gas fees. On the BSC Testnet, these fees are paid with test BNB (tBNB), a token with no real-world value used exclusively for development and testing.24

To obtain tBNB, use a BSC Testnet Faucet. A popular one is available at https://testnet.bnbchain.org/faucet-smart. The process typically involves pasting the wallet address from MetaMask into the faucet's input field and completing a captcha to receive a small amount of tBNB.

Section 4: Initializing the Hardhat Project

With the foundational tools in place, the next step is to create and structure the project using Hardhat.

Step-by-Step Project Scaffolding

1. Open a terminal or command prompt.
2. Create a new directory for the project and navigate into it:
   Bash
   mkdir bsc-nft-project
   cd bsc-nft-project
3. Initialize the Hardhat project by running the following command 21:
   Bash
   npx hardhat init
4. The Hardhat command-line interface (CLI) will prompt with several options. It is crucial to select Create a TypeScript project to align with the objectives of this guide.15
5. Accept the default options for the remaining prompts, including the project root location, adding a .gitignore file, and installing the sample project's dependencies (@nomicfoundation/hardhat-toolbox).

Installing Essential Dependencies

The Hardhat initialization process installs the hardhat-toolbox, which bundles many essential plugins. However, two additional packages are required for a professional workflow:

• @openzeppelin/contracts: Provides secure, community-vetted base smart contract implementations for standards like ERC-721.14
• dotenv: A utility to load environment variables from a .env file into the application, which is a best practice for managing sensitive data like private keys and API keys.16

Install these dependencies using npm:

Bash

npm install @openzeppelin/contracts dotenv

Deep Dive into the Project Structure

After initialization, Hardhat creates a standardized project structure 13:

• contracts/: This directory is for all Solidity smart contract source files (.sol).
• scripts/: This directory will contain the TypeScript scripts for automating tasks like deploying contracts and minting NFTs.
• test/: This directory is for automated test files, which are essential for verifying contract functionality.
• hardhat.config.ts: The central configuration file for the entire Hardhat project. This is where networks, compiler versions, and plugins are defined.
• tsconfig.json: The configuration file for the TypeScript compiler, defining how .ts files are transpiled into JavaScript.
• package.json: The standard Node.js project manifest file, listing project dependencies and scripts.
• node_modules/: The directory where all installed npm packages are stored.

Section 5: Configuring Hardhat for Binance Smart Chain

The hardhat.config.ts file is the control center of the project. It must be configured to connect to the BSC Testnet and manage the credentials required for deployment.

Crafting the hardhat.config.ts File

The configuration involves defining the Solidity compiler version, setting up the BSC Testnet network details, and adding configuration for BscScan to enable automated contract verification.

Securely Managing Credentials

To deploy contracts, the deployment script needs access to a wallet's private key to sign transactions. To verify contracts on BscScan, an API key is required. Hard-coding this sensitive information directly into the hardhat.config.ts file is a severe security risk, as it could be accidentally committed to a public version control system like GitHub.

The best practice is to use a .env file 16:

1. Create a file named .env in the root directory of the project.
2. Add the following lines to this file, replacing the placeholders with the actual values:
   BSC_TESTNET_PRIVATE_KEY="YOUR_METAMASK_PRIVATE_KEY"
   BSCSCAN_API_KEY="YOUR_BSCSCAN_API_KEY"

• To get the private key, open MetaMask, click the three dots next to the account name, select "Account details," and then "Show private key."
• To get a BscScan API key, create an account on bscscan.com and generate a new API key in the user dashboard.

1. Ensure the .env file is listed in the .gitignore file to prevent it from being tracked by Git. The Hardhat initialization process should have already added it.

Full Configuration Example

Replace the entire content of hardhat.config.ts with the following complete and robust configuration. This configuration imports the necessary types, loads the environment variables using dotenv, and defines the bsc_testnet network and etherscan verification settings.

TypeScript

import { HardhatUserConfig } from "hardhat/config";
import "@nomicfoundation/hardhat-toolbox";
import "dotenv/config";

// Ensure that the environment variables are set.
const privateKey = process.env.BSC_TESTNET_PRIVATE_KEY;
if (!privateKey) {
throw new Error("Please set your BSC_TESTNET_PRIVATE_KEY in a.env file");
}

const bscscanApiKey = process.env.BSCSCAN_API_KEY;
if (!bscscanApiKey) {
throw new Error("Please set your BSCSCAN_API_KEY in a.env file");
}

const config: HardhatUserConfig = {
solidity: "0.8.24",
networks: {
hardhat: {
// Configuration for the local Hardhat Network
},
bsc_testnet: {
url: "https://data-seed-prebsc-1-s1.binance.org:8545/",
chainId: 97,
accounts: [privateKey],
gasPrice: 20000000000, // 20 Gwei
},
},
etherscan: {
apiKey: {
bscTestnet: bscscanApiKey,
},
},
};

export default config;

This configuration establishes a professional, multi-environment workflow. The networks object decouples the application logic from the deployment target. By simply changing the --network flag in a command (e.g., --network bsc_testnet), the same deployment script can be targeted to different environments without any code changes, embodying a powerful abstraction that is a hallmark of the Hardhat framework.13

Parameter	BSC Testnet Value	BSC Mainnet Value
Network Name	Binance Smart Chain Testnet	Binance Smart Chain Mainnet
RPC URL	https://data-seed-prebsc-1-s1.binance.org:8545/	https://bsc-dataseed.binance.org/
Chain ID	97	56
Currency Symbol	tBNB	BNB
Block Explorer URL	https://testnet.bscscan.com	https://bscscan.com

Part III: Smart Contract and Metadata Development

This part transitions from environment setup to the core development tasks: authoring the on-chain smart contract and preparing the off-chain metadata that defines the NFT.

Section 6: Authoring the BEP-721 Smart Contract

Writing a smart contract from scratch is a complex and high-risk endeavor. Security vulnerabilities can lead to irreversible financial loss. Therefore, it is a non-negotiable best practice to build upon a foundation of secure, audited, and community-vetted code.

Leveraging OpenZeppelin

OpenZeppelin provides a library of modular, reusable, and secure smart contract implementations for the most common token standards, including ERC-721.10 By inheriting from OpenZeppelin's base contracts, developers can significantly reduce security risks and ensure compliance with the BEP-721 standard. The

@openzeppelin/contracts package was installed in the previous section for this purpose.

Code Walkthrough: MyNFT.sol

A new Solidity file named MyNFT.sol should be created inside the contracts/ directory. The default Lock.sol file created by Hardhat can be deleted. The following code provides a robust and production-ready template for a BEP-721 contract.

Solidity

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

import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";

contract MyNFT is ERC721URIStorage, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;

constructor(address initialOwner)  
    ERC721("My Awesome NFT", "MANFT")  
    Ownable(initialOwner)  
{}

function safeMint(address to, string memory uri) public onlyOwner {  
    uint256 tokenId \= \_tokenIds.current();  
    \_tokenIds.increment();  
    \_safeMint(to, tokenId);  
    \_setTokenURI(tokenId, uri);  
}  

}

Code Analysis:

• pragma solidity ^0.8.20;: Specifies the compatible Solidity compiler version.
• import statements: These lines import the necessary contracts from the OpenZeppelin library.
• ERC721URIStorage.sol: An extension of the base ERC-721 contract that includes functionality for storing a metadata URI for each token (_setTokenURI).10
• Ownable.sol: A simple and widely used contract for implementing access control, providing an onlyOwner modifier to restrict function access to a designated owner account.31
• Counters.sol: A utility library to provide a simple counter that can be safely incremented, used here for generating sequential tokenIds.10
• contract MyNFT is ERC721URIStorage, Ownable: The contract declaration. It inherits from both ERC721URIStorage and Ownable, gaining all their functionalities.
• constructor: The constructor is executed once when the contract is deployed.
• ERC721("My Awesome NFT", "MANFT"): Initializes the base ERC-721 contract with a name and symbol for the collection.
• Ownable(initialOwner): Sets the address that deploys the contract as the initial owner, granting it exclusive rights to call functions protected by the onlyOwner modifier.
• safeMint(address to, string memory uri) public onlyOwner: This is the custom function for creating new NFTs.
• public: The function can be called externally.
• onlyOwner: This modifier, inherited from Ownable, ensures that only the owner of the contract (the deployer) can execute this function. This is a critical security measure to prevent unauthorized minting.10
• _tokenIds.current() and _tokenIds.increment(): These lines use the counter to get the next available tokenId and then increment the counter for the subsequent mint.
• _safeMint(to, tokenId): This internal function from the base ERC-721 contract creates the new token with the specified tokenId and assigns its ownership to the to address.
• _setTokenURI(tokenId, uri): This function, from ERC721URIStorage, associates the provided metadata uri with the newly minted tokenId.10

Section 7: Mastering NFT Metadata

The value and richness of an NFT are defined by its metadata. This metadata links the on-chain token to its off-chain representation, such as a piece of art, a collectible card, or a game item.

The ERC-721 Metadata Standard

The tokenURI function in the contract is expected to point to a JSON file that conforms to a specific schema.9 This standardization allows marketplaces like OpenSea and wallets to correctly display the NFT's properties.

A typical metadata JSON file looks like this:

JSON

{
"name": "My First NFT",
"description": "An awesome digital creation stored decentrally.",
"image": "ipfs://QmQEVVLJUR1WLN15S49rzDJsSP7za9DxeqpUzWuG4aondg",
"attributes":
}

• name, description, image: These are the core fields. The image field should point to the URI of the actual media file (e.g., a PNG, GIF, or video).
• attributes: This optional array allows for defining specific traits of the NFT, which are often used by marketplaces for filtering and displaying rarity statistics.

Decentralized Asset Storage (IPFS)

Storing NFT assets on a centralized server (e.g., AWS S3) is considered an anti-pattern. If the server goes down or the company hosting it ceases to exist, the link breaks, and the NFT effectively points to nothing. This undermines the principle of permanence that blockchain technology offers.

The InterPlanetary File System (IPFS) is the industry-standard solution for decentralized storage.9 IPFS is a peer-to-peer network for storing and sharing data in a distributed file system. Files on IPFS are content-addressed, meaning the URI of a file is a cryptographic hash of its content. This ensures that if the file is ever changed, its URI will also change, providing a form of verifiability.

To ensure data persistence on IPFS, files must be "pinned" by one or more nodes. Services like Pinata, NFT.Storage, or QuickNode's IPFS service provide an easy way to upload and pin files.32

Constructing and Uploading the tokenURI JSON

The process for preparing the metadata is as follows:

1. Upload the Asset: Upload the primary media file (e.g., my-nft-image.png) to an IPFS pinning service. This will return an IPFS URI (e.g., ipfs://Qm…).
2. Create the Metadata JSON: Create a local JSON file (e.g., metadata.json) and populate it according to the schema described above. Paste the IPFS URI from step 1 into the image field of the JSON file.
3. Upload the Metadata JSON: Upload the metadata.json file to the IPFS pinning service. This will yield a second, final IPFS URI. This URI is the value that will be passed to the safeMint function's uri parameter. It is the tokenURI for the NFT.32

Part IV: Deployment, Minting, and Verification

This final part brings all the preceding elements together, executing the scripts to deploy the smart contract, mint the NFT on the BSC Testnet, and verify the results on the blockchain.

Section 8: Compiling and Deploying the Smart Contract

With the smart contract authored and the environment configured, the next step is to compile and deploy it.

The Compilation Process

Hardhat simplifies the compilation process. From the project's root directory, run the following command in the terminal 12:

Bash

npx hardhat compile

This command instructs Hardhat to:

1. Read the solidity version from hardhat.config.ts.
2. Find all .sol files in the contracts/ directory.
3. Compile the Solidity code into EVM bytecode (the machine code that runs on the blockchain) and the Application Binary Interface (ABI).
4. Store these compilation outputs, known as "artifacts," in a new artifacts/ directory. The ABI is a JSON file that defines the contract's functions and is essential for interacting with the contract from external scripts.12

Writing the TypeScript Deployment Script (deploy.ts)

In the scripts/ directory, delete the sample script and create a new file named deploy.ts. This script will programmatically deploy the MyNFT contract.

TypeScript

import { ethers } from "hardhat";

async function main() {
const [deployer] = await ethers.getSigners();
console.log("Deploying contracts with the account:", deployer.address);

const MyNFT = await ethers.getContractFactory("MyNFT");

// Pass the deployer's address to the Ownable constructor
const myNFT = await MyNFT.deploy(deployer.address);

await myNFT.waitForDeployment();

const contractAddress = await myNFT.getAddress();
console.log("MyNFT contract deployed to:", contractAddress);
}

main().catch((error) => {
console.error(error);
process.exitCode = 1;
});

Script Analysis:

• ethers.getSigners(): Retrieves the wallet account configured in hardhat.config.ts to act as the deployer.
• ethers.getContractFactory("MyNFT"): Creates an instance of the contract factory using the compiled artifacts. This is an abstraction used to deploy new smart contracts.
• MyNFT.deploy(deployer.address): This is the action that sends the transaction to the network to create the contract. The deployer's address is passed as an argument to the contract's constructor.
• myNFT.waitForDeployment(): Pauses the script's execution until the deployment transaction has been mined and included in a block.
• myNFT.getAddress(): Retrieves the address of the newly deployed contract. This address is crucial for all future interactions.

Executing the Deployment

To deploy the contract to the BSC Testnet, execute the script using the Hardhat runner, specifying the target network with the --network flag 13:

Bash

npx hardhat run scripts/deploy.ts --network bsc_testnet

The terminal will output the deployer's address and, after a short wait, the address of the newly deployed MyNFT contract. This address should be saved for the next steps.

Section 9: Programmatic Minting of the NFT

With the contract live on the testnet, an NFT can now be minted by calling the safeMint function.

Writing a TypeScript Minting Script (mint-nft.ts)

Create a new file in the scripts/ directory named mint-nft.ts. This script will interact with the already-deployed contract.

TypeScript

import { ethers } from "hardhat";

// --- CONFIGURATION ---
const CONTRACT_ADDRESS = "YOUR_DEPLOYED_CONTRACT_ADDRESS"; // Replace with your contract's address
const RECIPIENT_ADDRESS = "RECIPIENT_WALLET_ADDRESS"; // Replace with the address to receive the NFT
const TOKEN_URI = "ipfs://YOUR_METADATA_JSON_IPFS_HASH"; // Replace with your metadata JSON's IPFS URI
// -------------------

async function main() {
const [signer] = await ethers.getSigners();
console.log("Minting NFT with the account:", signer.address);

// Get the contract instance
const myNFT = await ethers.getContractAt("MyNFT", CONTRACT_ADDRESS);

console.log(`Minting NFT for ${RECIPIENT_ADDRESS} with token URI ${TOKEN_URI}`);

// Call the safeMint function
const tx = await myNFT.safeMint(RECIPIENT_ADDRESS, TOKEN_URI);

console.log("Transaction sent. Waiting for confirmation…");

// Wait for the transaction to be mined
const receipt = await tx.wait();

console.log(`Transaction confirmed. Hash: ${receipt?.hash}`);

// Extract the tokenId from the Transfer event
const transferEvent = receipt?.logs.find(
(log: any) => log.eventName === 'Transfer'
);

if (transferEvent) {
const tokenId = transferEvent.args.tokenId;
console.log(`Successfully minted NFT with tokenId: ${tokenId.toString()}`);
} else {
console.error("Could not find Transfer event in transaction receipt.");
}
}

main().catch((error) => {
console.error(error);
process.exitCode = 1;
});

Script Analysis:

• Configuration: The script begins with constants for the contract address, recipient address, and the tokenURI. These must be populated with the correct values.
• ethers.getContractAt("MyNFT", CONTRACT_ADDRESS): This function retrieves an ethers.Contract object that is connected to the deployed contract at the specified address, allowing for interaction with its functions.
• myNFT.safeMint(…): This line calls the safeMint function on the contract instance, passing the recipient's address and the metadata URI. This initiates the minting transaction.
• tx.wait(): Waits for the minting transaction to be confirmed on the blockchain.
• Event Parsing: The script inspects the transaction receipt to find the Transfer event, which is emitted by the ERC-721 standard upon a successful mint. The tokenId of the newly created NFT is extracted from this event's data.

Executing the Mint Transaction

Run the minting script using the same Hardhat command structure:

Bash

npx hardhat run scripts/mint-nft.ts --network bsc_testnet

The script will output the transaction hash and, upon success, the tokenId of the newly minted NFT.

Section 10: Verifying and Inspecting the NFT on the Blockchain

The final step is to verify the contract's source code and inspect the results of the deployment and minting operations on a public block explorer.

Verifying the Smart Contract

Verifying the smart contract's source code on BscScan makes it publicly readable and auditable, which builds trust with users. The hardhat-verify plugin (included in the hardhat-toolbox) automates this process.

Run the following command, replacing DEPLOYED_CONTRACT_ADDRESS with the actual address from the deployment step and DEPLOYER_ADDRESS with the argument passed to the constructor:

Bash

npx hardhat verify --network bsc_testnet DEPLOYED_CONTRACT_ADDRESS "DEPLOYER_ADDRESS"

Hardhat will use the BSCSCAN_API_KEY from the .env file to communicate with BscScan and upload the source code for verification.29

Using BscScan

Navigate to the BSC Testnet explorer (testnet.bscscan.com) and search for the deployed contract address. After successful verification, a new "Contract" tab with a green checkmark will appear.

Using BscScan, one can:

1. View Source Code: In the "Contract" tab, the full, verified Solidity source code of MyNFT.sol and its inherited OpenZeppelin contracts will be visible.
2. Inspect Transactions: The "Transactions" tab will show the contract creation transaction and the subsequent safeMint transaction.
3. Read Contract State: The "Read Contract" tab provides a user interface to call all the view and pure functions of the contract. One can use this to:

• Call ownerOf with the minted tokenId to confirm that the recipient address is the on-chain owner.
• Call tokenURI with the minted tokenId to verify that the correct IPFS metadata link is stored on the blockchain.

This final verification on a public block explorer provides definitive, immutable proof that the BEP-721 NFT has been successfully created, deployed, and minted on the Binance Smart Chain.

Conclusion

This report has detailed the comprehensive, end-to-end process for creating a BEP-721 NFT on the Binance Smart Chain using a professional, code-centric approach with Hardhat and TypeScript. By following the structured methodology presented—from understanding the foundational BEP-721 standard and architecting a robust development stack to authoring a secure smart contract, managing decentralized metadata, and executing programmatic deployment and minting—developers are equipped with the knowledge to build and manage unique digital assets on the BSC ecosystem. The emphasis on security best practices, such as leveraging OpenZeppelin contracts and securely managing credentials, alongside the use of industry-standard tools, ensures that the resulting NFTs are not only functional but also secure and maintainable. The skills and architectural patterns outlined are highly transferable across the broader EVM-compatible landscape, positioning this knowledge as a valuable asset for any developer working in the Web3 space.

Works cited

1. BEP-721 | Learn - KuCoin, accessed September 24, 2025, https://www.kucoin.com/en-eu/learn/glossary/bep-721
2. BEP721 Token Development – To Create NFT on BNB Chain - Cryptocurrency Exchange Script, accessed September 24, 2025, https://www.coinsclone.com/bep-721-token-development/
3. BEP-721 - Binance Academy, accessed September 24, 2025, https://academy.binance.com/en/glossary/bep-721
4. The ERC-721 Token Standard - Base Documentation, accessed September 24, 2025, https://docs.base.org/learn/token-development/erc-721-token/erc-721-standard
5. BEP-721 Definition - CoinMarketCap, accessed September 24, 2025, https://coinmarketcap.com/academy/glossary/bep-721
6. BEP721 Token Development Services, accessed September 24, 2025, https://www.securitytokenizer.io/bep721-token-development
7. Creating BEP-721 Token on Binance Smart Chain - Antier Solutions, accessed September 24, 2025, https://www.antiersolutions.com/blogs/creating-bep-721-token-on-binance-smart-chain/
8. BEP-721 - NFTs - IQ.wiki, accessed September 24, 2025, https://iq.wiki/wiki/bep-721
9. How to Create and Mint an NFT with Hardhat - Sergio Martin Rubio, accessed September 24, 2025, https://sergiomartinrubio.com/articles/how-to-create-and-mint-an-nft-with-hardhat/
10. ERC721 - OpenZeppelin Docs, accessed September 24, 2025, https://docs.openzeppelin.com/contracts/4.x/erc721
11. ERC721 - OpenZeppelin Docs, accessed September 24, 2025, https://docs.openzeppelin.com/contracts/2.x/erc721
12. Setup Hardhat with Typescript - DEV Community, accessed September 24, 2025, https://dev.to/hayerhans/setup-hardhat-with-typescript-3o1o
13. Using Hardhat for Binance Smart Chain - BNB Chain Blog, accessed September 24, 2025, https://www.bnbchain.org/en/blog/using-hardhat-for-binance-smart-chain
14. Solidity Tutorial – How to Create NFTs with Hardhat - freeCodeCamp, accessed September 24, 2025, https://www.freecodecamp.org/news/solidity-tutorial-hardhat-nfts/
15. Hardhat Setup and Overview - Base Documentation, accessed September 24, 2025, https://docs.base.org/learn/hardhat/hardhat-setup-overview/hardhat-setup-overview-sbs
16. Deploying Smart Contracts - Base Documentation, accessed September 24, 2025, https://docs.base.org/learn/hardhat/hardhat-deploy/hardhat-deploy-sbs
17. Getting started with Truffle - Ethereum Blockchain Developer, accessed September 24, 2025, https://www.ethereum-blockchain-developer.com/courses/ethereum-course-2024/project-erc721-nft-with-remix-truffle-hardhat-and-foundry/install-and-configure-truffle
18. Truffle Suite: Home, accessed September 24, 2025, https://archive.trufflesuite.com/
19. Create a simple blockchain project by truffle + typescript - HackMD, accessed September 24, 2025, https://hackmd.io/@happyeric77/SJuBrA33j
20. Truffle quickstart - Truffle Suite, accessed September 24, 2025, https://archive.trufflesuite.com/docs/truffle/quickstart/
21. Getting started with Hardhat 3 | Ethereum development environment for professionals by Nomic Foundation, accessed September 24, 2025, https://hardhat.org/docs/getting-started
22. How-to Guide: Connecting MetaMask to Binance Smart Chain | by Blind Boxes - Medium, accessed September 24, 2025, https://medium.com/blind-boxes/how-to-guide-connecting-metamask-to-binance-smart-chain-7403c1f33170
23. Complete Guide: How to Mint and Transfer BEP-721 NFTs to MetaMask | by Blind Boxes, accessed September 24, 2025, https://medium.com/blind-boxes/complete-guide-how-to-mint-and-transfer-bep-721-nfts-to-metamask-29a916d6839a
24. Ultimate Guide to Deploying Smart Contracts on Base 2024 - Rapid Innovation, accessed September 24, 2025, https://www.rapidinnovation.io/post/deploy-a-smart-contract-on-base
25. Deploying Smart Contract on Test/Main Network Using Truffle - GeeksforGeeks, accessed September 24, 2025, https://www.geeksforgeeks.org/solidity/deploying-smart-contract-on-test-main-network-using-truffle/
26. Deploying a smart contract using Hardhat - Base Documentation, accessed September 24, 2025, https://docs.base.org/learn/hardhat/hardhat-tools-and-testing/deploy-with-hardhat
27. Contracts - OpenZeppelin Docs, accessed September 24, 2025, https://docs.openzeppelin.com/contracts/5.x/
28. How to Mint NFTs on Polygon using Hardhat - Part 1 - AllCode, accessed September 24, 2025, https://allcode.com/how-to-mint-nfts-on-polygon/
29. Deploying Smart Contract to BSC Testnet with Hardhat | by Melih …, accessed September 24, 2025, https://medium.com/@melihgunduz/deploying-smart-contract-to-bsc-testnet-with-hardhat-aa7b046eea1d
30. Base: Deploy an ERC-721 contract with Hardhat - Chainstack Docs, accessed September 24, 2025, https://docs.chainstack.com/docs/base-tutorial-deploy-an-erc-721-contract-with-hardhat
31. How to Mint & Burn an ERC-721 Token Using Hardhat and Ethers …, accessed September 24, 2025, https://docs.hedera.com/hedera/tutorials/smart-contracts/how-to-mint-and-burn-an-erc-721-token-using-hardhat-and-ethers-part-1
32. How to Create and Deploy an ERC-721 (NFT) | QuickNode Guides, accessed September 24, 2025, https://www.quicknode.com/guides/ethereum-development/nfts/how-to-create-and-deploy-an-erc-721-nft
33. Mint NFTs with Hardhat | Palm Network Docs, accessed September 24, 2025, https://docs.palm.io/howto/mint-nft-using-hardhat/
34. How to Create and Deploy a Smart Contract with Hardhat …, accessed September 24, 2025, https://www.quicknode.com/guides/ethereum-development/smart-contracts/how-to-create-and-deploy-a-smart-contract-with-hardhat