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

contract NFT is ERC721URIStorage {
    using Counters for Counters.Counter;
    Counters.Counter private _tokenIds;
    address contractAddress;

    constructor(address marketplaceAddress) ERC721("Metaverse Tokens", "METT") {
        contractAddress = marketplaceAddress;
    }

    function createToken(string memory tokenURI) public returns (uint) {
        _tokenIds.increment();
        uint256 newItemId = _tokenIds.current();

        _mint(msg.sender, newItemId);
        _setTokenURI(newItemId, tokenURI);
        setApprovalForAll(contractAddress, true);
        
        return newItemId;
    }
}

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

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

contract NFTMarketplace is ReentrancyGuard {
    using Counters for Counters.Counter;
    Counters.Counter private _itemIds;
    Counters.Counter private _itemsSold;

    address payable owner;
    uint256 listingPrice = 0.025 ether;

    constructor() {
        owner = payable(msg.sender);
    }

    struct MarketItem {
        uint itemId;
        address nftContract;
        uint256 tokenId;
        address payable seller;
        address payable owner;
        uint256 price;
        bool sold;
    }

    mapping(uint256 => MarketItem) private idToMarketItem;

    event MarketItemCreated (
        uint indexed itemId,
        address indexed nftContract,
        uint256 indexed tokenId,
        address seller,
        address owner,
        uint256 price,
        bool sold
    );

    function getListingPrice() public view returns (uint256) {
        return listingPrice;
    }

    function createMarketItem(
        address nftContract,
        uint256 tokenId,
        uint256 price
    ) public payable nonReentrant {
        require(price > 0, "Price must be at least 1 wei");
        require(msg.value == listingPrice, "Price must be equal to listing price");

        _itemIds.increment();
        uint256 itemId = _itemIds.current();

        idToMarketItem[itemId] = MarketItem(
            itemId,
            nftContract,
            tokenId,
            payable(msg.sender),
            payable(address(0)),
            price,
            false
        );

        IERC721(nftContract).transferFrom(msg.sender, address(this), tokenId);

        emit MarketItemCreated(
            itemId,
            nftContract,
            tokenId,
            msg.sender,
            address(0),
            price,
            false
        );
    }

    function createMarketSale(
        address nftContract,
        uint256 itemId
    ) public payable nonReentrant {
        uint price = idToMarketItem[itemId].price;
        uint tokenId = idToMarketItem[itemId].tokenId;
        
        require(msg.value == price, "Please submit the asking price");

        idToMarketItem[itemId].seller.transfer(msg.value);
        IERC721(nftContract).transferFrom(address(this), msg.sender, tokenId);
        idToMarketItem[itemId].owner = payable(msg.sender);
        idToMarketItem[itemId].sold = true;
        _itemsSold.increment();
        
        payable(owner).transfer(listingPrice);
    }

    function fetchMarketItems() public view returns (MarketItem[] memory) {
        uint itemCount = _itemIds.current();
        uint unsoldItemCount = _itemIds.current() - _itemsSold.current();
        uint currentIndex = 0;

        MarketItem[] memory items = new MarketItem[](unsoldItemCount);
        for (uint i = 0; i < itemCount; i++) {
            if (idToMarketItem[i + 1].owner == address(0)) {
                uint currentId = i + 1;
                MarketItem storage currentItem = idToMarketItem[currentId];
                items[currentIndex] = currentItem;
                currentIndex += 1;
            }
        }
        return items;
    }

    function fetchMyNFTs() public view returns (MarketItem[] memory) {
        uint totalItemCount = _itemIds.current();
        uint itemCount = 0;
        uint currentIndex = 0;

        for (uint i = 0; i < totalItemCount; i++) {
            if (idToMarketItem[i + 1].owner == msg.sender) {
                itemCount += 1;
            }
        }

        MarketItem[] memory items = new MarketItem[](itemCount);
        for (uint i = 0; i < totalItemCount; i++) {
            if (idToMarketItem[i + 1].owner == msg.sender) {
                uint currentId = i + 1;
                MarketItem storage currentItem = idToMarketItem[currentId];
                items[currentIndex] = currentItem;
                currentIndex += 1;
            }
        }
        return items;
    }

    function fetchItemsCreated() public view returns (MarketItem[] memory) {
        uint totalItemCount = _itemIds.current();
        uint itemCount = 0;
        uint currentIndex = 0;

        for (uint i = 0; i < totalItemCount; i++) {
            if (idToMarketItem[i + 1].seller == msg.sender) {
                itemCount += 1;
            }
        }

        MarketItem[] memory items = new MarketItem[](itemCount);
        for (uint i = 0; i < totalItemCount; i++) {
            if (idToMarketItem[i + 1].seller == msg.sender) {
                uint currentId = i + 1;
                MarketItem storage currentItem = idToMarketItem[currentId];
                items[currentIndex] = currentItem;
                currentIndex += 1;
            }
        }
        return items;
    }
}

const { expect } = require("chai");
const { ethers } = require("hardhat");

describe("NFTMarketplace", function () {
  let nft;
  let marketplace;
  let owner;
  let buyer;
  let listingPrice;

  beforeEach(async function () {
    [owner, buyer] = await ethers.getSigners();

    const NFT = await ethers.getContractFactory("NFT");
    const Marketplace = await ethers.getContractFactory("NFTMarketplace");

    marketplace = await Marketplace.deploy();
    await marketplace.deployed();

    nft = await NFT.deploy(marketplace.address);
    await nft.deployed();

    listingPrice = await marketplace.getListingPrice();
  });

  it("Should create and execute market sales", async function () {
    const tokenURI = "https://ipfs.io/ipfs/QmTest123";
    
    await nft.createToken(tokenURI);
    await nft.createToken(tokenURI);

    const auctionPrice = ethers.utils.parseUnits("1", "ether");

    await marketplace.createMarketItem(nft.address, 1, auctionPrice, {
      value: listingPrice,
    });
    await marketplace.createMarketItem(nft.address, 2, auctionPrice, {
      value: listingPrice,
    });

    await marketplace
      .connect(buyer)
      .createMarketSale(nft.address, 1, { value: auctionPrice });

    let items = await marketplace.fetchMarketItems();
    expect(items.length).to.equal(1);

    items = await marketplace.connect(buyer).fetchMyNFTs();
    expect(items.length).to.equal(1);
  });

  it("Should return correct listing price", async function () {
    const price = await marketplace.getListingPrice();
    expect(price).to.equal(ethers.utils.parseEther("0.025"));
  });

  it("Should fail if price is not met", async function () {
    const tokenURI = "https://ipfs.io/ipfs/QmTest456";
    await nft.createToken(tokenURI);

    const auctionPrice = ethers.utils.parseUnits("1", "ether");
    await marketplace.createMarketItem(nft.address, 1, auctionPrice, {
      value: listingPrice,
    });

    await expect(
      marketplace
        .connect(buyer)
        .createMarketSale(nft.address, 1, { 
          value: ethers.utils.parseUnits("0.5", "ether") 
        })
    ).to.be.revertedWith("Please submit the asking price");
  });
});

npx hardhat test

const hre = require("hardhat");

async function main() {
  const NFTMarketplace = await hre.ethers.getContractFactory("NFTMarketplace");
  const marketplace = await NFTMarketplace.deploy();
  await marketplace.deployed();
  console.log("NFTMarketplace deployed to:", marketplace.address);

  const NFT = await hre.ethers.getContractFactory("NFT");
  const nft = await NFT.deploy(marketplace.address);
  await nft.deployed();
  console.log("NFT contract deployed to:", nft.address);
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });

require("@nomiclabs/hardhat-waffle");
require("dotenv").config();

module.exports = {
  solidity: "0.8.20",
  networks: {
    hardhat: {
      chainId: 1337
    },
    sepolia: {
      url: process.env.SEPOLIA_RPC_URL,
      accounts: [process.env.PRIVATE_KEY]
    },
    polygon: {
      url: process.env.POLYGON_RPC_URL,
      accounts: [process.env.PRIVATE_KEY]
    }
  }
};

npx hardhat run scripts/deploy.js --network sepolia

npm install ethers@5.7.2 axios ipfs-http-client
npx create-react-app client
cd client
npm install ethers@5.7.2 axios

import { ethers } from 'ethers';
import NFTMarketplace from '../artifacts/contracts/NFTMarketplace.sol/NFTMarketplace.json';
import NFT from '../artifacts/contracts/NFT.sol/NFT.json';

const marketplaceAddress = "YOUR_MARKETPLACE_CONTRACT_ADDRESS";
const nftAddress = "YOUR_NFT_CONTRACT_ADDRESS";

export async function connectWallet() {
  if (typeof window.ethereum !== 'undefined') {
    try {
      await window.ethereum.request({ method: 'eth_requestAccounts' });
      const provider = new ethers.providers.Web3Provider(window.ethereum);
      const signer = provider.getSigner();
      return { provider, signer };
    } catch (error) {
      console.error("User denied account access");
      throw error;
    }
  } else {
    alert('Please install MetaMask!');
    throw new Error('MetaMask not installed');
  }
}

export async function getMarketplaceContract(signer) {
  return new ethers.Contract(marketplaceAddress, NFTMarketplace.abi, signer);
}

export async function getNFTContract(signer) {
  return new ethers.Contract(nftAddress, NFT.abi, signer);
}

import React, { useState, useEffect } from 'react';
import { ethers } from 'ethers';
import { connectWallet, getMarketplaceContract, getNFTContract } from './utils/web3';

function Marketplace() {
  const [nfts, setNfts] = useState([]);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    loadNFTs();
  }, []);

  async function loadNFTs() {
    try {
      const { provider, signer } = await connectWallet();
      const marketplaceContract = await getMarketplaceContract(signer);
      const nftContract = await getNFTContract(signer);

      const data = await marketplaceContract.fetchMarketItems();

      const items = await Promise.all(data.map(async i => {
        const tokenUri = await nftContract.tokenURI(i.tokenId);
        const meta = await fetch(tokenUri).then(res => res.json());
        
        let price = ethers.utils.formatUnits(i.price.toString(), 'ether');
        
        return {
          price,
          tokenId: i.tokenId.toNumber(),
          seller: i.seller,
          owner: i.owner,
          image: meta.image,
          name: meta.name,
          description: meta.description,
        };
      }));

      setNfts(items);
      setLoading(false);
    } catch (error) {
      console.error("Error loading NFTs:", error);
      setLoading(false);
    }
  }

  async function buyNft(nft) {
    try {
      const { signer } = await connectWallet();
      const marketplaceContract = await getMarketplaceContract(signer);

      const price = ethers.utils.parseUnits(nft.price.toString(), 'ether');
      const transaction = await marketplaceContract.createMarketSale(
        nftAddress,
        nft.tokenId,
        { value: price }
      );

      await transaction.wait();
      alert('NFT purchased successfully!');
      loadNFTs();
    } catch (error) {
      console.error("Error buying NFT:", error);
      alert('Purchase failed!');
    }
  }

  if (loading) return <div>Loading...</div>;

  return (
    <div className="marketplace">
      <h1>NFT Marketplace</h1>
      <div className="nft-grid">
        {nfts.map((nft, i) => (
          <div key={i} className="nft-card">
            <img src={nft.image} alt={nft.name} />
            <h3>{nft.name}</h3>
            <p>{nft.description}</p>
            <p className="price">{nft.price} ETH</p>
            <button onClick={() => buyNft(nft)}>Buy Now</button>
          </div>
        ))}
      </div>
    </div>
  );
}

export default Marketplace;

import { create } from 'ipfs-http-client';

const projectId = 'YOUR_INFURA_PROJECT_ID';
const projectSecret = 'YOUR_INFURA_PROJECT_SECRET';
const auth = 'Basic ' + Buffer.from(projectId + ':' + projectSecret).toString('base64');

const client = create({
  host: 'ipfs.infura.io',
  port: 5001,
  protocol: 'https',
  headers: {
    authorization: auth,
  },
});

export async function uploadToIPFS(file) {
  try {
    const added = await client.add(file);
    const url = `https://ipfs.io/ipfs/${added.path}`;
    return url;
  } catch (error) {
    console.error('Error uploading file:', error);
    throw error;
  }
}

export async function uploadMetadata(metadata) {
  try {
    const added = await client.add(JSON.stringify(metadata));
    const url = `https://ipfs.io/ipfs/${added.path}`;
    return url;
  } catch (error) {
    console.error('Error uploading metadata:', error);
    throw error;
  }
}

import React, { useState } from 'react';
import { uploadToIPFS, uploadMetadata } from './utils/ipfs';
import { connectWallet, getNFTContract, getMarketplaceContract } from './utils/web3';
import { ethers } from 'ethers';

function CreateNFT() {
  const [fileUrl, setFileUrl] = useState(null);
  const [formInput, updateFormInput] = useState({ 
    price: '', 
    name: '', 
    description: '' 
  });

  async function onChange(e) {
    const file = e.target.files[0];
    try {
      const url = await uploadToIPFS(file);
      setFileUrl(url);
    } catch (error) {
      console.error('Error uploading file:', error);
    }
  }

  async function createMarket() {
    const { name, description, price } = formInput;
    if (!name || !description || !price || !fileUrl) {
      alert('Please fill all fields!');
      return;
    }

    try {
      const metadata = {
        name,
        description,
        image: fileUrl,
      };

      const metadataUrl = await uploadMetadata(metadata);
      
      await mintAndList(metadataUrl, price);
    } catch (error) {
      console.error('Error creating NFT:', error);
    }
  }

  async function mintAndList(tokenURI, price) {
    try {
      const { signer } = await connectWallet();
      const nftContract = await getNFTContract(signer);
      const marketplaceContract = await getMarketplaceContract(signer);

      let transaction = await nftContract.createToken(tokenURI);
      let tx = await transaction.wait();
      
      let event = tx.events[0];
      let value = event.args[2];
      let tokenId = value.toNumber();

      const priceInWei = ethers.utils.parseUnits(price, 'ether');
      const listingPrice = await marketplaceContract.getListingPrice();

      transaction = await marketplaceContract.createMarketItem(
        nftContract.address,
        tokenId,
        priceInWei,
        { value: listingPrice }
      );
      
      await transaction.wait();
      alert('NFT created and listed successfully!');
    } catch (error) {
      console.error('Error minting NFT:', error);
      alert('Failed to create NFT!');
    }
  }

  return (
    <div className="create-nft">
      <h1>Create New NFT</h1>
      <input
        placeholder="Asset Name"
        onChange={e => updateFormInput({ ...formInput, name: e.target.value })}
      />
      <textarea
        placeholder="Asset Description"
        onChange={e => updateFormInput({ ...formInput, description: e.target.value })}
      />
      <input
        placeholder="Asset Price in ETH"
        type="number"
        onChange={e => updateFormInput({ ...formInput, price: e.target.value })}
      />
      <input
        type="file"
        name="Asset"
        onChange={onChange}
      />
      {fileUrl && (
        <img src={fileUrl} alt="Preview" style={{ width: '300px' }} />
      )}
      <button onClick={createMarket}>Create NFT</button>
    </div>
  );
}

export default CreateNFT;

struct Auction {
    uint256 tokenId;
    address payable seller;
    uint256 startPrice;
    uint256 highestBid;
    address payable highestBidder;
    uint256 endTime;
    bool ended;
}

mapping(uint256 => Auction) public auctions;

function createAuction(
    address nftContract,
    uint256 tokenId,
    uint256 startPrice,
    uint256 duration
) public {
    require(IERC721(nftContract).ownerOf(tokenId) == msg.sender, "Not owner");
    
    IERC721(nftContract).transferFrom(msg.sender, address(this), tokenId);
    
    auctions[tokenId] = Auction({
        tokenId: tokenId,
        seller: payable(msg.sender),
        startPrice: startPrice,
        highestBid: 0,
        highestBidder: payable(address(0)),
        endTime: block.timestamp + duration,
        ended: false
    });
}

function placeBid(uint256 tokenId) public payable {
    Auction storage auction = auctions[tokenId];
    
    require(block.timestamp < auction.endTime, "Auction ended");
    require(msg.value > auction.highestBid, "Bid too low");
    require(msg.value >= auction.startPrice, "Below start price");
    
    if (auction.highestBidder != address(0)) {
        auction.highestBidder.transfer(auction.highestBid);
    }
    
    auction.highestBid = msg.value;
    auction.highestBidder = payable(msg.sender);
}

function endAuction(address nftContract, uint256 tokenId) public {
    Auction storage auction = auctions[tokenId];
    
    require(block.timestamp >= auction.endTime, "Auction not ended");
    require(!auction.ended, "Already ended");
    
    auction.ended = true;
    
    if (auction.highestBidder != address(0)) {
        IERC721(nftContract).transferFrom(
            address(this),
            auction.highestBidder,
            tokenId
        );
        auction.seller.transfer(auction.highestBid);
    } else {
        IERC721(nftContract).transferFrom(
            address(this),
            auction.seller,
            tokenId
        );
    }
}

mapping(uint256 => address) public creators;
mapping(uint256 => uint256) public royaltyPercentage;

function setRoyalty(uint256 tokenId, uint256 percentage) public {
    require(creators[tokenId] == msg.sender, "Not creator");
    require(percentage <= 10, "Max 10%");
    royaltyPercentage[tokenId] = percentage;
}

function createMarketSaleWithRoyalty(
    address nftContract,
    uint256 itemId
) public payable nonReentrant {
    uint price = idToMarketItem[itemId].price;
    uint tokenId = idToMarketItem[itemId].tokenId;
    
    require(msg.value == price, "Incorrect price");
    
    uint royalty = (price * royaltyPercentage[tokenId]) / 100;
    uint sellerAmount = price - royalty;
    
    if (royalty > 0 && creators[tokenId] != address(0)) {
        payable(creators[tokenId]).transfer(royalty);
    }
    
    idToMarketItem[itemId].seller.transfer(sellerAmount);
    IERC721(nftContract).transferFrom(address(this), msg.sender, tokenId);
    
    idToMarketItem[itemId].owner = payable(msg.sender);
    idToMarketItem[itemId].sold = true;
    _itemsSold.increment();
}

struct Collection {
    string name;
    string symbol;
    address creator;
    uint256[] tokenIds;
}

mapping(uint256 => Collection) public collections;
uint256 public collectionCount;

function createCollection(
    string memory name,
    string memory symbol
) public returns (uint256) {
    collectionCount++;
    
    collections[collectionCount] = Collection({
        name: name,
        symbol: symbol,
        creator: msg.sender,
        tokenIds: new uint256[](0)
    });
    
    return collectionCount;
}

function addToCollection(
    uint256 collectionId,
    uint256 tokenId
) public {
    require(
        collections[collectionId].creator == msg.sender,
        "Not collection owner"
    );
    
    collections[collectionId].tokenIds.push(tokenId);
}

import WalletConnect from "@walletconnect/client";
import QRCodeModal from "@walletconnect/qrcode-modal";

const connector = new WalletConnect({
  bridge: "https://bridge.walletconnect.org",
  qrcodeModal: QRCodeModal,
});

async function connectMobile() {
  if (!connector.connected) {
    await connector.createSession();
  }
  
  connector.on("connect", (error, payload) => {
    if (error) {
      throw error;
    }
    
    const { accounts, chainId } = payload.params[0];
    console.log("Connected:", accounts[0]);
  });
}

async function sendTransaction(tx) {
  if (!connector.connected) {
    await connectMobile();
  }
  
  const result = await connector.sendTransaction(tx);
  return result;
}

function fetchItemsByPriceRange(
    uint256 minPrice,
    uint256 maxPrice
) public view returns (MarketItem[] memory) {
    uint totalItemCount = _itemIds.current();
    uint itemCount = 0;
    
    for (uint i = 0; i < totalItemCount; i++) {
        if (
            idToMarketItem[i + 1].owner == address(0) &&
            idToMarketItem[i + 1].price >= minPrice &&
            idToMarketItem[i + 1].price <= maxPrice
        ) {
            itemCount += 1;
        }
    }
    
    MarketItem[] memory items = new MarketItem[](itemCount);
    uint currentIndex = 0;
    
    for (uint i = 0; i < totalItemCount; i++) {
        if (
            idToMarketItem[i + 1].owner == address(0) &&
            idToMarketItem[i + 1].price >= minPrice &&
            idToMarketItem[i + 1].price <= maxPrice
        ) {
            items[currentIndex] = idToMarketItem[i + 1];
            currentIndex += 1;
        }
    }
    
    return items;
}

function fetchItemsBySeller(address seller) 
    public view returns (MarketItem[] memory) {
    uint totalItemCount = _itemIds.current();
    uint itemCount = 0;
    
    for (uint i = 0; i < totalItemCount; i++) {
        if (idToMarketItem[i + 1].seller == seller) {
            itemCount += 1;
        }
    }
    
    MarketItem[] memory items = new MarketItem[](itemCount);
    uint currentIndex = 0;
    
    for (uint i = 0; i < totalItemCount; i++) {
        if (idToMarketItem[i + 1].seller == seller) {
            items[currentIndex] = idToMarketItem[i + 1];
            currentIndex += 1;
        }
    }
    
    return items;
}

function SearchAndFilter() {
  const [nfts, setNfts] = useState([]);
  const [filteredNfts, setFilteredNfts] = useState([]);
  const [searchTerm, setSearchTerm] = useState('');
  const [priceRange, setPriceRange] = useState({ min: 0, max: 100 });
  const [sortBy, setSortBy] = useState('newest');

  useEffect(() => {
    filterAndSort();
  }, [searchTerm, priceRange, sortBy, nfts]);

  function filterAndSort() {
    let filtered = nfts.filter(nft => {
      const matchesSearch = nft.name.toLowerCase()
        .includes(searchTerm.toLowerCase());
      const matchesPrice = nft.price >= priceRange.min && 
        nft.price <= priceRange.max;
      return matchesSearch && matchesPrice;
    });

    if (sortBy === 'price-low') {
      filtered.sort((a, b) => a.price - b.price);
    } else if (sortBy === 'price-high') {
      filtered.sort((a, b) => b.price - a.price);
    } else if (sortBy === 'newest') {
      filtered.sort((a, b) => b.tokenId - a.tokenId);
    }

    setFilteredNfts(filtered);
  }

  return (
    <div className="search-filter">
      <input
        type="text"
        placeholder="Search NFTs..."
        value={searchTerm}
        onChange={(e) => setSearchTerm(e.target.value)}
      />
      
      <div className="price-filter">
        <label>Price Range:</label>
        <input
          type="number"
          placeholder="Min"
          value={priceRange.min}
          onChange={(e) => setPriceRange({
            ...priceRange,
            min: parseFloat(e.target.value)
          })}
        />
        <input
          type="number"
          placeholder="Max"
          value={priceRange.max}
          onChange={(e) => setPriceRange({
            ...priceRange,
            max: parseFloat(e.target.value)
          })}
        />
      </div>
      
      <select value={sortBy} onChange={(e) => setSortBy(e.target.value)}>
        <option value="newest">Newest First</option>
        <option value="price-low">Price: Low to High</option>
        <option value="price-high">Price: High to Low</option>
      </select>
      
      <div className="nft-grid">
        {filteredNfts.map((nft, i) => (
          <NFTCard key={i} nft={nft} />
        ))}
      </div>
    </div>
  );
}

struct Statistics {
    uint256 totalVolume;
    uint256 totalSales;
    uint256 totalListings;
    uint256 activeUsers;
}

Statistics public stats;

function updateStats(uint256 salePrice) internal {
    stats.totalVolume += salePrice;
    stats.totalSales += 1;
}

function getMarketStats() public view returns (
    uint256 totalVolume,
    uint256 totalSales,
    uint256 totalListings,
    uint256 averagePrice
) {
    totalVolume = stats.totalVolume;
    totalSales = stats.totalSales;
    totalListings = _itemIds.current() - _itemsSold.current();
    
    if (stats.totalSales > 0) {
        averagePrice = stats.totalVolume / stats.totalSales;
    } else {
        averagePrice = 0;
    }
    
    return (totalVolume, totalSales, totalListings, averagePrice);
}

function getTopSellers(uint256 limit) 
    public view returns (address[] memory, uint256[] memory) {
    // 판매량 기준 상위 판매자 반환
    // 실제 구현은 더 복잡하지만 개념은 이해했을 거야!
}

function Dashboard() {
  const [stats, setStats] = useState({
    totalVolume: 0,
    totalSales: 0,
    totalListings: 0,
    averagePrice: 0
  });

  useEffect(() => {
    loadStats();
  }, []);

  async function loadStats() {
    const { signer } = await connectWallet();
    const marketplace = await getMarketplaceContract(signer);
    
    const data = await marketplace.getMarketStats();
    
    setStats({
      totalVolume: ethers.utils.formatEther(data.totalVolume),
      totalSales: data.totalSales.toNumber(),
      totalListings: data.totalListings.toNumber(),
      averagePrice: ethers.utils.formatEther(data.averagePrice)
    });
  }

  return (
    <div className="dashboard">
      <h1>Marketplace Statistics</h1>
      
      <div className="stats-grid">
        <div className="stat-card">
          <h3>Total Volume</h3>
          <p>{stats.totalVolume} ETH</p>
        </div>
        
        <div className="stat-card">
          <h3>Total Sales</h3>
          <p>{stats.totalSales}</p>
        </div>
        
        <div className="stat-card">
          <h3>Active Listings</h3>
          <p>{stats.totalListings}</p>
        </div>
        
        <div className="stat-card">
          <h3>Average Price</h3>
          <p>{stats.averagePrice} ETH</p>
        </div>
      </div>
    </div>
  );
}