NFTs (ERC-721 and ERC-1155): Minting and Marketplaces

// 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/utils/Strings.sol";

contract MyNFT is ERC721, Ownable {
    using Strings for uint256;
    
    uint256 private _tokenIdCounter;
    uint256 public constant MAX_SUPPLY = 10000;
    uint256 public constant MINT_PRICE = 0.01 ether;
    string private _baseTokenURI;
    
    constructor(string memory baseURI) ERC721("MyNFT Collection", "MNFT") Ownable(msg.sender) {
        _baseTokenURI = baseURI;
    }
    
    function mint() external payable {
        require(_tokenIdCounter < MAX_SUPPLY, "Max supply reached");
        require(msg.value == MINT_PRICE, "Incorrect payment");
        _tokenIdCounter++;
        _safeMint(msg.sender, _tokenIdCounter);
    }
    
    function _baseURI() internal view override returns (string memory) {
        return _baseTokenURI;
    }
    
    function setBaseURI(string memory baseURI) external onlyOwner {
        _baseTokenURI = baseURI;
    }
    
    function withdraw() external onlyOwner {
        payable(owner()).transfer(address(this).balance);
    }
}

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

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

contract GameItems is ERC1155, Ownable {
    uint256 public constant GOLD = 0;
    uint256 public constant SILVER = 1;
    uint256 public constant SWORD = 2;
    uint256 public constant SHIELD = 3;
    
    mapping(uint256 => uint256) public maxSupply;
    mapping(uint256 => uint256) public minted;
    
    constructor() ERC1155("ipfs://metadata/{id}.json") Ownable(msg.sender) {
        // Gold is fungible (10,000 supply)
        maxSupply[GOLD] = 10000;
        // Sword is a unique NFT (only 1)
        maxSupply[SWORD] = 1;
        maxSupply[SHIELD] = 100;
    }
    
    function mint(uint256 id, uint256 amount) external payable {
        require(minted[id] + amount <= maxSupply[id], "Exceeds max supply");
        _mint(msg.sender, id, amount, "");
        minted[id] += amount;
    }
    
    function uri(uint256 id) public view override returns (string memory) {
        return string(abi.encodePacked(super.uri(id), id.toString()));
    }
}

{
  "name": "MyNFT #1",
  "description": "A unique digital artwork from MyNFT Collection",
  "image": "ipfs://QmZ4tDuvesWe9iwSqGQF7NwmGmejVmZB8vFPpKp9xPx8F1",
  "attributes": [
    { "trait_type": "Background", "value": "Blue" },
    { "trait_type": "Eyes", "value": "Green" },
    { "trait_type": "Fur", "value": "Gold" },
    { "trait_type": "Rarity", "value": "Legendary" }
  ],
  "properties": {
    "files": [
      { "uri": "ipfs://QmZ4t...x8F1", "type": "image/png" }
    ],
    "category": "image"
  }
}

const pinataSDK = require("@pinata/sdk");
const pinata = new pinataSDK("YOUR_API_KEY", "YOUR_API_SECRET");
const fs = require("fs");

async function uploadToIPFS() {
  // Upload image
  const imageStream = fs.createReadStream("./nft-image.png");
  const imageResult = await pinata.pinFileToIPFS(imageStream, {
    pinataMetadata: { name: "nft-image.png" }
  });
  console.log("Image IPFS hash:", imageResult.IpfsHash);
  
  // Upload metadata
  const metadata = {
    name: "MyNFT #1",
    description: "A unique digital artwork",
    image: `ipfs://${imageResult.IpfsHash}`,
    attributes: [
      { trait_type: "Background", value: "Blue" }
    ]
  };
  
  const metadataResult = await pinata.pinJSONToIPFS(metadata, {
    pinataMetadata: { name: "nft-1.json" }
  });
  console.log("Metadata IPFS hash:", metadataResult.IpfsHash);
}

uploadToIPFS();
// Expected output:
// Image IPFS hash: QmZ4tDuvesWe9iwSqGQF7NwmGmejVmZB8vFPpKp9xPx8F1
// Metadata IPFS hash: QmXfTmdYTiBjxRKFfK5kMPF5xQLRPCv3GSFg4K8KjF9XqZ

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

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

contract NFTMarketplace is ReentrancyGuard, Ownable {
    struct Listing {
        address seller;
        address nftContract;
        uint256 tokenId;
        uint256 price;
        bool active;
    }
    
    uint256 public listingCount;
    mapping(uint256 => Listing) public listings;
    mapping(address => mapping(uint256 => bool)) public isListed;
    
    event Listed(uint256 indexed listingId, address indexed seller, address nftContract, uint256 tokenId, uint256 price);
    event Sold(uint256 indexed listingId, address indexed buyer, address nftContract, uint256 tokenId, uint256 price);
    event Cancelled(uint256 indexed listingId);
    
    function listNFT(address _nftContract, uint256 _tokenId, uint256 _price) external {
        require(_price > 0, "Price must be positive");
        IERC721 nft = IERC721(_nftContract);
        require(nft.ownerOf(_tokenId) == msg.sender, "Not the owner");
        require(!isListed[_nftContract][_tokenId], "Already listed");
        
        listingCount++;
        listings[listingCount] = Listing(msg.sender, _nftContract, _tokenId, _price, true);
        isListed[_nftContract][_tokenId] = true;
        
        emit Listed(listingCount, msg.sender, _nftContract, _tokenId, _price);
    }
    
    function buyNFT(uint256 _listingId) external payable nonReentrant {
        Listing storage listing = listings[_listingId];
        require(listing.active, "Listing not active");
        require(msg.value >= listing.price, "Insufficient payment");
        
        listing.active = false;
        isListed[listing.nftContract][listing.tokenId] = false;
        
        IERC721(listing.nftContract).safeTransferFrom(listing.seller, msg.sender, listing.tokenId);
        payable(listing.seller).transfer(listing.price);
        
        emit Sold(_listingId, msg.sender, listing.nftContract, listing.tokenId, listing.price);
    }
    
    function cancelListing(uint256 _listingId) external {
        Listing storage listing = listings[_listingId];
        require(listing.seller == msg.sender, "Not the seller");
        require(listing.active, "Not active");
        
        listing.active = false;
        isListed[listing.nftContract][listing.tokenId] = false;
        
        emit Cancelled(_listingId);
    }
}