StoryNFT (ERC721)

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

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";

contract StoryNFT is ERC721URIStorage, AccessControl, ERC2981 {
    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
    uint256 private _nextTokenId;

    uint256 public mintFee = 0.001 ether;

    event NFTMinted(uint256 indexed tokenId, address indexed recipient, string uri, string collectionType);

    constructor(address defaultAdmin) ERC721("EStory Collections", "ESTORY") {
        _grantRole(DEFAULT_ADMIN_ROLE, defaultAdmin);
        _grantRole(MINTER_ROLE, defaultAdmin);
        _setDefaultRoyalty(defaultAdmin, 500); // 5%
    }

    // PUBLIC: Mint a book/collection (requires mint fee)
    function mintBook(string memory uri) external payable {
        require(msg.value >= mintFee, "Insufficient mint fee");
        uint256 tokenId = ++_nextTokenId;
        _safeMint(msg.sender, tokenId);
        _setTokenURI(tokenId, uri);
        emit NFTMinted(tokenId, msg.sender, uri, "BOOK");
    }

    // ADMIN: Mint weekly winner NFT (free)
    function mintWeeklyWinner(address winner, string memory uri) external onlyRole(MINTER_ROLE) {
        uint256 tokenId = ++_nextTokenId;
        _safeMint(winner, tokenId);
        _setTokenURI(tokenId, uri);
        emit NFTMinted(tokenId, winner, uri, "WEEKLY_WINNER");
    }

    // Admin functions
    function setMintFee(uint256 _fee) external onlyRole(DEFAULT_ADMIN_ROLE) {
        mintFee = _fee;
    }

    function withdraw() external onlyRole(DEFAULT_ADMIN_ROLE) {
        uint256 balance = address(this).balance;
        require(balance > 0, "No balance to withdraw");
        (bool success, ) = payable(msg.sender).call{value: balance}("");
        require(success, "Withdrawal failed");
    }

    function setDefaultRoyalty(address receiver, uint96 feeNumerator) external onlyRole(DEFAULT_ADMIN_ROLE) {
        _setDefaultRoyalty(receiver, feeNumerator);
    }

    // Overrides
    function tokenURI(uint256 tokenId) public view override(ERC721URIStorage) returns (string memory) {
        return super.tokenURI(tokenId);
    }

    function supportsInterface(bytes4 interfaceId)
        public view override(ERC721URIStorage, AccessControl, ERC2981) returns (bool)
    {
        return super.supportsInterface(interfaceId);
    }
}

{
  "name": "My Life in 2026",
  "description": "A curated collection of 52 stories from my journey through 2026",
  "image": "ipfs://QmImageHash...",
  "attributes": [
    {
      "trait_type": "Story Count",
      "value": 52
    },
    {
      "trait_type": "Date Range",
      "value": "Jan 2026 - Dec 2026"
    },
    {
      "trait_type": "Word Count",
      "value": 12500
    },
    {
      "trait_type": "Collection Type",
      "value": "Annual Book"
    }
  ]
}

import { useReadContract } from 'wagmi';
import { STORY_NFT_ABI, STORY_NFT_ADDRESS } from '@/lib/contracts';

const { data: balance } = useReadContract({
  address: STORY_NFT_ADDRESS,
  abi: STORY_NFT_ABI,
  functionName: 'balanceOf',
  args: [userAddress]
});

console.log(`User owns ${balance} NFTs`);

import { publicClient } from '@/lib/wagmi';
import { STORY_NFT_ABI, STORY_NFT_ADDRESS } from '@/lib/contracts';

const tokenId = 1n;

// Get tokenURI
const uri = await publicClient.readContract({
  address: STORY_NFT_ADDRESS,
  abi: STORY_NFT_ABI,
  functionName: 'tokenURI',
  args: [tokenId]
});

// Fetch metadata from IPFS
const response = await fetch(uri.replace('ipfs://', 'https://ipfs.io/ipfs/'));
const metadata = await response.json();

console.log("NFT Name:", metadata.name);
console.log("Description:", metadata.description);
console.log("Image:", metadata.image);

import { createWalletClient, http } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';
import { baseSepolia } from 'viem/chains';
import { STORY_NFT_ABI, STORY_NFT_ADDRESS } from '@/lib/contracts';

const account = privateKeyToAccount(process.env.MINTER_PRIVATE_KEY);
const walletClient = createWalletClient({
  account,
  chain: baseSepolia,
  transport: http()
});

// Upload winner metadata to IPFS
const ipfsUri = await uploadWinnerMetadata(winnerId);

// Mint free NFT
const tx = await walletClient.writeContract({
  address: STORY_NFT_ADDRESS,
  abi: STORY_NFT_ABI,
  functionName: 'mintWeeklyWinner',
  args: [winnerAddress, ipfsUri]
});

await publicClient.waitForTransactionReceipt({ hash: tx });
console.log("Weekly winner NFT minted!");

function royaltyInfo(uint256 tokenId, uint256 salePrice) 
    external 
    view 
    returns (address receiver, uint256 royaltyAmount)

export const STORY_NFT_ABI = [
  "function mintBook(string memory uri)",
  "function balanceOf(address owner) view returns (uint256)",
  "function tokenURI(uint256 tokenId) view returns (string)",
  "event NFTMinted(uint256 indexed tokenId, address indexed recipient, string uri, string collectionType)"
] as const;