NFT Ecosystem Guide — ERC-721, ERC-1155, Minting, and Marketplaces

// IERC721.sol — Core interface
interface IERC721 {
    function balanceOf(address owner) external view returns (uint256);
    function ownerOf(uint256 tokenId) external view returns (address);
    function safeTransferFrom(address from, address to, uint256 tokenId) external;
    function transferFrom(address from, address to, uint256 tokenId) external;
    function approve(address to, uint256 tokenId) external;
    function getApproved(uint256 tokenId) external view returns (address);
    function setApprovalForAll(address operator, bool approved) external;
    function isApprovedForAll(address owner, address operator) external view returns (bool);
}

// DodaNFT.sol
// 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 DodaNFT is ERC721URIStorage, Ownable {
    using Counters for Counters.Counter;
    Counters.Counter private _tokenIds;
    
    uint256 public mintPrice = 0.01 ether;
    uint256 public maxSupply = 100;
    
    constructor() ERC721("DodaNFT", "DNFT") Ownable(msg.sender) {}
    
    function mintNFT(address recipient, string memory tokenURI) 
        public payable returns (uint256) 
    {
        require(_tokenIds.current() < maxSupply, "Max supply reached");
        require(msg.value >= mintPrice, "Insufficient payment");
        
        _tokenIds.increment();
        uint256 newTokenId = _tokenIds.current();
        
        _safeMint(recipient, newTokenId);
        _setTokenURI(newTokenId, tokenURI);
        
        return newTokenId;
    }
    
    function totalSupply() public view returns (uint256) {
        return _tokenIds.current();
    }
    
    function withdraw() public onlyOwner {
        uint256 balance = address(this).balance;
        require(balance > 0, "No balance to withdraw");
        payable(owner()).transfer(balance);
    }
}

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

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

contract DodaGameItems is ERC1155, Ownable {
    uint256 public constant SWORD = 0;
    uint256 public constant SHIELD = 1;
    uint256 public constant LEGENDARY_ARMOR = 2;  // NFT (supply = 1)
    
    mapping(uint256 => uint256) public maxSupply;
    
    constructor() ERC1155("https://api.dodatech.io/items/{id}.json") Ownable(msg.sender) {
        maxSupply[SWORD] = 1000;     // 1000 swords (fungible)
        maxSupply[SHIELD] = 500;      // 500 shields (fungible)
        maxSupply[LEGENDARY_ARMOR] = 1;  // 1 unique armor (NFT)
    }
    
    function mint(address account, uint256 id, uint256 amount) external onlyOwner {
        require(totalSupply(id) + amount <= maxSupply[id], "Max supply");
        _mint(account, id, amount, "");
    }
    
    function mintBatch(address to, uint256[] memory ids, uint256[] memory amounts) 
        external onlyOwner 
    {
        _mintBatch(to, ids, amounts, "");
    }
}

// mint_nft.js
// Full minting flow with ethers.js
import { ethers } from "ethers";

const CONTRACT_ADDRESS = "0xYourContractAddress";
const ABI = [
    "function mintNFT(address recipient, string memory tokenURI) public payable returns (uint256)",
    "function totalSupply() public view returns (uint256)",
    "function mintPrice() public view returns (uint256)",
];

async function mintNFT() {
    // Connect to Ethereum (use MetaMask or private key)
    const provider = new ethers.JsonRpcProvider("https://sepolia.infura.io/v3/YOUR_KEY");
    const wallet = new ethers.Wallet("YOUR_PRIVATE_KEY", provider);
    const contract = new ethers.Contract(CONTRACT_ADDRESS, ABI, wallet);
    
    // 1. Prepare metadata (already uploaded to IPFS)
    const tokenURI = "ipfs://QmXoypizjW3WknFiJnKLwHCnL72vedxjQkDDP1mXWo6uco/1.json";
    
    // 2. Get mint price
    const price = await contract.mintPrice();
    console.log(`Mint price: ${ethers.formatEther(price)} ETH`);
    
    // 3. Execute mint
    const tx = await contract.mintNFT(wallet.address, tokenURI, {
        value: price,
    });
    console.log(`Transaction sent: ${tx.hash}`);
    
    // 4. Wait for confirmation
    const receipt = await tx.wait();
    console.log(`Minted! Block: ${receipt.blockNumber}`);
    
    // 5. Get token ID from event
    const mintEvent = receipt.logs.find(log => 
        contract.interface.parseLog({
            topics: log.topics,
            data: log.data,
        })?.name === "Transfer"
    );
    console.log("NFT minted successfully!");
}

mintNFT().catch(console.error);

// ipfs://QmXoypizjW3WknFiJnKLwHCnL72vedxjQkDDP1mXWo6uco/1.json
{
    "name": "DodaPixel Art #1",
    "description": "A unique pixel art piece from the DodaTech collection.",
    "image": "ipfs://QmYwAPJzv5CZsnA625s3Xf2nemtYgPpHdWEz79ojWnPbdG/art_1.webp",
    "attributes": [
        {"trait_type": "Background", "value": "Cosmic"},
        {"trait_type": "Rarity", "value": "Legendary"},
        {"trait_type": "Color", "value": "Neon Blue"},
        {"display_type": "boost_number", "trait_type": "Power", "value": 95}
    ],
    "external_url": "https://dodatech.io/nft/1"
}

// upload_ipfs.js
// Upload metadata to IPFS via Pinata
import axios from "axios";
import FormData from "form-data";
import fs from "fs";

const PINATA_API_KEY = "YOUR_KEY";
const PINATA_SECRET_KEY = "YOUR_SECRET";

async function uploadToIPFS(metadata, imagePath) {
    // Upload image first
    const imageForm = new FormData();
    imageForm.append("file", fs.createReadStream(imagePath));
    
    const imageRes = await axios.post(
        "https://api.pinata.cloud/pinning/pinFileToIPFS",
        imageForm,
        {
            headers: {
                "Content-Type": `multipart/form-data; boundary=${imageForm._boundary}`,
                pinata_api_key: PINATA_API_KEY,
                pinata_secret_api_key: PINATA_SECRET_KEY,
            },
        }
    );
    
    const imageHash = imageRes.data.IpfsHash;
    console.log(`Image uploaded: ipfs://${imageHash}`);
    
    // Update metadata with image hash
    metadata.image = `ipfs://${imageHash}`;
    
    // Upload metadata
    const metadataRes = await axios.post(
        "https://api.pinata.cloud/pinning/pinJSONToIPFS",
        metadata,
        {
            headers: {
                pinata_api_key: PINATA_API_KEY,
                pinata_secret_api_key: PINATA_SECRET_KEY,
            },
        }
    );
    
    console.log(`Metadata uploaded: ipfs://${metadataRes.data.IpfsHash}`);
    return `ipfs://${metadataRes.data.IpfsHash}`;
}

const nftMetadata = {
    name: "DodaPixel Art #1",
    description: "A unique pixel art piece.",
    attributes: [
        { trait_type: "Rarity", value: "Legendary" },
    ],
};

uploadToIPFS(nftMetadata, "./art_1.webp").catch(console.error);

// rarity.js
// Calculate NFT rarity from trait frequencies
const collection = [
    { id: 1, traits: { Background: "Cosmic", Rarity: "Legendary", Color: "Neon Blue" }},
    { id: 2, traits: { Background: "Space", Rarity: "Common", Color: "Red" }},
    { id: 3, traits: { Background: "Cosmic", Rarity: "Uncommon", Color: "Neon Blue" }},
    { id: 4, traits: { Background: "Galaxy", Rarity: "Common", Color: "Green" }},
    { id: 5, traits: { Background: "Space", Rarity: "Common", Color: "Blue" }},
];

function calculateRarity(nfts) {
    // Count trait frequencies
    const traitCounts = {};
    for (const nft of nfts) {
        for (const [trait, value] of Object.entries(nft.traits)) {
            if (!traitCounts[trait]) traitCounts[trait] = {};
            if (!traitCounts[trait][value]) traitCounts[trait][value] = 0;
            traitCounts[trait][value]++;
        }
    }
    
    // Calculate rarity score (1 / frequency for each trait)
    const total = nfts.length;
    for (const nft of nfts) {
        let score = 0;
        for (const [trait, value] of Object.entries(nft.traits)) {
            const frequency = traitCounts[trait][value] / total;
            score += 1 / frequency;  // Lower frequency = higher score
        }
        nft.rarityScore = score;
    }
    
    // Sort by rarity (highest first)
    nfts.sort((a, b) => b.rarityScore - a.rarityScore);
    return nfts;
}

const ranked = calculateRarity(collection);
console.log("Rarity Rankings:");
for (const nft of ranked) {
    console.log(`  #${nft.id}: score ${nft.rarityScore.toFixed(2)} | ${nft.traits.Rarity}`);
}

// ERC-2981 Royalty implementation
import "@openzeppelin/contracts/token/common/ERC2981.sol";

contract DodaNFTWithRoyalty is ERC721URIStorage, ERC2981, Ownable {
    constructor() ERC721("DodaNFT", "DNFT") Ownable(msg.sender) {
        // 5% royalty
        _setDefaultRoyalty(msg.sender, 500);  // 500 = 5% (basis points)
    }
    
    function setRoyalty(address receiver, uint96 feeNumerator) external onlyOwner {
        _setDefaultRoyalty(receiver, feeNumerator);
    }
    
    // Override required by Solidity
    function supportsInterface(bytes4 interfaceId)
        public view override(ERC721URIStorage, ERC2981) returns (bool) {
        return super.supportsInterface(interfaceId);
    }
}

// nft_gallery.js
// Fetch and display owned NFTs using Alchemy API
import axios from "axios";

const ALCHEMY_URL = "https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY";
const WALLET_ADDRESS = "0xYourWallet...";

async function fetchNFTs(owner) {
    const response = await axios.post(ALCHEMY_URL, {
        jsonrpc: "2.0",
        method: "alchemy_getNFTs",
        params: [owner, { contractAddresses: [], pageSize: 10 }],
        id: 1,
    });
    
    const nfts = response.data.result.ownedNfts;
    console.log(`Found ${nfts.length} NFTs for ${owner}\n`);
    
    for (const nft of nfts) {
        const metadata = nft.metadata || {};
        const attributes = (metadata.attributes || [])
            .map(a => `${a.trait_type}: ${a.value}`)
            .join(", ");
        
        console.log(`Name: ${metadata.name || nft.title}`);
        console.log(`Contract: ${nft.contract.address}`);
        console.log(`Token ID: ${nft.id.tokenId}`);
        console.log(`Type: ${nft.id.tokenMetadata?.tokenType || "Unknown"}`);
        console.log(`Attributes: ${attributes || "None"}`);
        console.log(`Image: ${metadata.image || "N/A"}`);
        console.log("---");
    }
}

fetchNFTs(WALLET_ADDRESS).catch(console.error);