Develop NFT Minting Platform

This skill covers NFT minting platforms - smart-contract development, blockchain integration, metadata standards, and decentralized storage, spanning the complete stack from Solidity contracts to frontend Web3 integration. Smart-contract architecture follows ERC-721/ERC-1155 standards with minting controls, pricing, and access management, demonstrated via a minting contract:

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

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Counters.sol";

contract NFTMintingPlatform is ERC721, Ownable, ReentrancyGuard {
    using Counters for Counters.Counter;
    Counters.Counter private _tokenIds;
    
    uint256 public constant MAX_SUPPLY = 10000;
    uint256 public constant MAX_PER_WALLET = 5;
    uint256 public mintPrice = 0.08 ether;
    string private _baseTokenURI;
    
    mapping(address => uint256) public mintedCount;
    bool public mintingActive = false;
    
    constructor(string memory baseURI) ERC721("MyNFT", "MNFT") {
        _baseTokenURI = baseURI;
    }
    
    function mint(uint256 quantity) external payable nonReentrant {
        require(mintingActive, "Minting not active");
        require(quantity > 0 && quantity <= MAX_PER_WALLET, "Invalid quantity");
        require(_tokenIds.current() + quantity <= MAX_SUPPLY, "Exceeds max supply");
        require(mintedCount[msg.sender] + quantity <= MAX_PER_WALLET, "Exceeds wallet limit");
        require(msg.value >= mintPrice * quantity, "Insufficient payment");
        
        mintedCount[msg.sender] += quantity;
        
        for (uint256 i = 0; i < quantity; i++) {
            _tokenIds.increment();
            _safeMint(msg.sender, _tokenIds.current());
        }
    }
    
    function _baseURI() internal view override returns (string memory) {
        return _baseTokenURI;
    }
}

enforcing a max supply, a max-per-wallet limit, a configurable mint price, an active/inactive minting flag, and reentrancy protection.

Frontend Web3 integration is shown via a minter class using ethers.js: connecting a wallet (requesting MetaMask account access and constructing a signer-bound contract instance), minting (fetching the current mint price, computing total cost, sending the mint transaction with a gas limit, and returning the transaction hash and gas used or an error), and reading contract info (fetching max supply, current supply, mint price, and minting-active status in parallel). Metadata management is shown via a manager class connecting to an IPFS HTTP client, generating per-token metadata (name, description, an ipfs:// image URI, attributes), and uploading metadata or batches of images to IPFS.

Deployment configuration uses Hardhat: a config setting the Solidity compiler version and optimizer runs, network definitions for mainnet and a Goerli testnet (RPC URL, private key, gas price), an Etherscan API key for verification, and a deploy script that deploys the contract with a base IPFS metadata URI and verifies it on Etherscan.

Security best practices: reentrancy guards on all payable functions, OpenZeppelin's audited contracts as base implementations, circuit breakers for emergency stops, role-based access controls, input validation and edge-case handling, safe math to prevent overflow/underflow, withdrawal patterns for fund management, and rate limiting/bot protection. Gas optimization: batching operations, packed structs and optimized storage layout, lazy minting for large collections, ERC-1155 for multiple token types, events for off-chain indexing instead of on-chain queries, and optimized loops with minimized external calls. Testing strategy: comprehensive tests covering minting scenarios, edge cases, and security vulnerabilities, gas-consumption and contract-limit testing, frontend integration testing, static analysis with Slither, and thorough audits before mainnet deployment.

Use it when building an NFT minting platform end to end - the Solidity contract, wallet-connected frontend minting flow, IPFS metadata and image storage, or Hardhat deployment and verification. It is not a general smart-contract or DeFi-protocol guide beyond NFTs - it is scoped specifically to NFT minting, metadata, and the Web3 frontend that drives it.

Given collection parameters (supply, price, per-wallet limit) and asset/metadata files, it produces a deployable ERC-721/1155 Solidity contract, a wallet-connected minting frontend, IPFS-uploaded metadata and images, and a Hardhat deployment and verification script.

Built on Solidity with OpenZeppelin contracts (ERC721, Ownable, ReentrancyGuard, Counters), ethers.js for frontend Web3 integration, an IPFS HTTP client for decentralized storage, and Hardhat with Etherscan verification for deployment.

Web3 developers building an NFT collection's smart contract, minting frontend, and metadata pipeline.