🎯 NFT가 뭔데? 게임 아이템과 무슨 관계야?

🏗️ 게임 아이템 NFT화의 전체 구조

📋 1단계: 게임 아이템 데이터 설계

{
  "name": "드래곤 슬레이어",
  "description": "고대 드래곤을 물리친 전설의 검",
  "image": "ipfs://QmX7x8x9x.../dragon-slayer.png",
  "attributes": [
    {
      "trait_type": "등급",
      "value": "전설"
    },
    {
      "trait_type": "공격력",
      "value": 250
    },
    {
      "trait_type": "강화",
      "value": 15
    },
    {
      "trait_type": "특수능력",
      "value": "드래곤 킬러"
    }
  ],
  "game_stats": {
    "durability": 100,
    "acquired_date": "2024-01-15",
    "level_requirement": 50
  }
}

⚙️ 2단계: 블록체인 네트워크 선택

📝 3단계: 스마트 컨트랙트 개발

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

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";

contract GameItemNFT is ERC721, ERC721URIStorage, Ownable {
    using Counters for Counters.Counter;
    Counters.Counter private _tokenIds;
    
    // 아이템 속성 구조체
    struct ItemStats {
        string itemName;
        uint256 attackPower;
        uint256 defense;
        uint256 rarity; // 1: 일반, 2: 희귀, 3: 영웅, 4: 전설
        uint256 level;
        bool isUpgradeable;
    }
    
    // 토큰 ID별 아이템 속성 매핑
    mapping(uint256 => ItemStats) public itemStats;
    
    // 게임 서버 주소 (아이템 발행 권한)
    address public gameServer;
    
    constructor() ERC721("GameItem", "GITEM") {
        gameServer = msg.sender;
    }
    
    // 게임 서버만 아이템 발행 가능
    modifier onlyGameServer() {
        require(msg.sender == gameServer, "Only game server can mint");
        _;
    }
    
    // 새로운 게임 아이템 NFT 발행
    function mintItem(
        address player,
        string memory tokenURI,
        string memory itemName,
        uint256 attackPower,
        uint256 defense,
        uint256 rarity,
        uint256 level
    ) public onlyGameServer returns (uint256) {
        _tokenIds.increment();
        uint256 newItemId = _tokenIds.current();
        
        _mint(player, newItemId);
        _setTokenURI(newItemId, tokenURI);
        
        // 아이템 속성 저장
        itemStats[newItemId] = ItemStats({
            itemName: itemName,
            attackPower: attackPower,
            defense: defense,
            rarity: rarity,
            level: level,
            isUpgradeable: true
        });
        
        return newItemId;
    }
    
    // 아이템 강화 기능
    function upgradeItem(uint256 tokenId, uint256 newAttackPower) 
        public onlyGameServer {
        require(_exists(tokenId), "Item does not exist");
        require(itemStats[tokenId].isUpgradeable, "Item cannot be upgraded");
        
        itemStats[tokenId].attackPower = newAttackPower;
        itemStats[tokenId].level += 1;
    }
    
    // 아이템 정보 조회
    function getItemStats(uint256 tokenId) 
        public view returns (ItemStats memory) {
        require(_exists(tokenId), "Item does not exist");
        return itemStats[tokenId];
    }
    
    // 게임 서버 주소 변경
    function setGameServer(address newGameServer) public onlyOwner {
        gameServer = newGameServer;
    }
    
    // 필수 오버라이드 함수들
    function _burn(uint256 tokenId) 
        internal override(ERC721, ERC721URIStorage) {
        super._burn(tokenId);
    }
    
    function tokenURI(uint256 tokenId)
        public view override(ERC721, ERC721URIStorage)
        returns (string memory) {
        return super.tokenURI(tokenId);
    }
}

🔗 4단계: 게임 서버와 블록체인 연동

const Web3 = require('web3');
const contractABI = require('./GameItemNFT.json');

// 블록체인 연결 설정
const web3 = new Web3('https://polygon-rpc.com'); // 폴리곤 RPC
const contractAddress = '0x1234567890abcdef...'; // 배포된 컨트랙트 주소

// 게임 서버 지갑 설정
const gameServerPrivateKey = process.env.GAME_SERVER_PRIVATE_KEY;
const gameServerAccount = web3.eth.accounts.privateKeyToAccount(gameServerPrivateKey);
web3.eth.accounts.wallet.add(gameServerAccount);

// 스마트 컨트랙트 인스턴스 생성
const gameItemContract = new web3.eth.Contract(contractABI, contractAddress);

// 아이템 NFT 발행 함수
async function mintItemNFT(playerAddress, itemData) {
    try {
        console.log('NFT 발행 시작...');
        
        // IPFS에 메타데이터 업로드 (실제로는 IPFS 클라이언트 사용)
        const metadataURI = await uploadToIPFS(itemData);
        
        // 가스 가격 추정
        const gasPrice = await web3.eth.getGasPrice();
        
        // 트랜잭션 생성 및 전송
        const tx = gameItemContract.methods.mintItem(
            playerAddress,
            metadataURI,
            itemData.name,
            itemData.attackPower,
            itemData.defense,
            itemData.rarity,
            itemData.level
        );
        
        const gas = await tx.estimateGas({ from: gameServerAccount.address });
        
        const receipt = await tx.send({
            from: gameServerAccount.address,
            gas: gas,
            gasPrice: gasPrice
        });
        
        console.log('NFT 발행 완료!');
        console.log('트랜잭션 해시:', receipt.transactionHash);
        console.log('토큰 ID:', receipt.events.Transfer.returnValues.tokenId);
        
        return {
            success: true,
            tokenId: receipt.events.Transfer.returnValues.tokenId,
            txHash: receipt.transactionHash
        };
        
    } catch (error) {
        console.error('NFT 발행 실패:', error);
        return {
            success: false,
            error: error.message
        };
    }
}

// IPFS 업로드 함수 (간단한 예시)
async function uploadToIPFS(itemData) {
    // 실제로는 Pinata, NFT.Storage 같은 서비스 사용
    const metadata = {
        name: itemData.name,
        description: itemData.description,
        image: itemData.imageUrl,
        attributes: [
            { trait_type: "공격력", value: itemData.attackPower },
            { trait_type: "방어력", value: itemData.defense },
            { trait_type: "희귀도", value: itemData.rarity },
            { trait_type: "레벨", value: itemData.level }
        ]
    };
    
    // IPFS 업로드 로직
    // ...
    
    return 'ipfs://QmX7x8x9x.../metadata.json';
}

// 게임 이벤트 리스너 예시
function onPlayerObtainedItem(playerId, itemData) {
    // 플레이어의 지갑 주소 조회
    const playerWalletAddress = getPlayerWalletAddress(playerId);
    
    // NFT 발행
    mintItemNFT(playerWalletAddress, itemData)
        .then(result => {
            if (result.success) {
                // 게임 내 알림 전송
                notifyPlayer(playerId, {
                    message: `${itemData.name} NFT를 획득했습니다!`,
                    tokenId: result.tokenId,
                    txHash: result.txHash
                });
                
                // 데이터베이스에 기록
                saveNFTRecord(playerId, result.tokenId, itemData);
            }
        })
        .catch(error => {
            console.error('NFT 발행 중 오류:', error);
        });
}

module.exports = {
    mintItemNFT,
    onPlayerObtainedItem
};

👛 5단계: 지갑 연동 및 사용자 경험

// React 환경에서 MetaMask 연동 예시
import { useState, useEffect } from 'react';
import Web3 from 'web3';

function GameWalletConnect() {
    const [account, setAccount] = useState(null);
    const [web3, setWeb3] = useState(null);
    const [nftBalance, setNftBalance] = useState(0);
    
    // MetaMask 연결
    const connectWallet = async () => {
        try {
            // MetaMask 설치 확인
            if (typeof window.ethereum === 'undefined') {
                alert('MetaMask를 설치해주세요!');
                return;
            }
            
            // 계정 연결 요청
            const accounts = await window.ethereum.request({
                method: 'eth_requestAccounts'
            });
            
            const web3Instance = new Web3(window.ethereum);
            setWeb3(web3Instance);
            setAccount(accounts[0]);
            
            // 네트워크 확인 (폴리곤인지 체크)
            const chainId = await web3Instance.eth.getChainId();
            if (chainId !== 137) { // 폴리곤 메인넷
                alert('폴리곤 네트워크로 전환해주세요!');
                await switchToPolygon();
            }
            
            // NFT 잔액 조회
            await loadNFTBalance(accounts[0], web3Instance);
            
        } catch (error) {
            console.error('지갑 연결 실패:', error);
        }
    };
    
    // 폴리곤 네트워크로 전환
    const switchToPolygon = async () => {
        try {
            await window.ethereum.request({
                method: 'wallet_switchEthereumChain',
                params: [{ chainId: '0x89' }], // 137을 16진수로
            });
        } catch (error) {
            // 네트워크가 추가되지 않은 경우
            if (error.code === 4902) {
                await window.ethereum.request({
                    method: 'wallet_addEthereumChain',
                    params: [{
                        chainId: '0x89',
                        chainName: 'Polygon Mainnet',
                        nativeCurrency: {
                            name: 'MATIC',
                            symbol: 'MATIC',
                            decimals: 18
                        },
                        rpcUrls: ['https://polygon-rpc.com/'],
                        blockExplorerUrls: ['https://polygonscan.com/']
                    }]
                });
            }
        }
    };
    
    // NFT 잔액 조회
    const loadNFTBalance = async (address, web3Instance) => {
        const contractAddress = '0x1234567890abcdef...';
        const contractABI = [...]; // 컨트랙트 ABI
        
        const contract = new web3Instance.eth.Contract(
            contractABI,
            contractAddress
        );
        
        const balance = await contract.methods.balanceOf(address).call();
        setNftBalance(balance);
        
        // 소유한 NFT 목록 조회
        const tokenIds = [];
        for (let i = 0; i < balance; i++) {
            const tokenId = await contract.methods
                .tokenOfOwnerByIndex(address, i)
                .call();
            tokenIds.push(tokenId);
        }
        
        // 각 NFT의 메타데이터 로드
        const nfts = await Promise.all(
            tokenIds.map(async (tokenId) => {
                const tokenURI = await contract.methods
                    .tokenURI(tokenId)
                    .call();
                const metadata = await fetch(tokenURI).then(r => r.json());
                return { tokenId, ...metadata };
            })
        );
        
        console.log('내 NFT 목록:', nfts);
    };
    
    // 계정 변경 감지
    useEffect(() => {
        if (window.ethereum) {
            window.ethereum.on('accountsChanged', (accounts) => {
                setAccount(accounts[0]);
                if (accounts[0] && web3) {
                    loadNFTBalance(accounts[0], web3);
                }
            });
            
            window.ethereum.on('chainChanged', () => {
                window.location.reload();
            });
        }
    }, [web3]);
    
    return (
        <div className="wallet-connect">
            {!account ? (
                <button onClick={connectWallet}>
                    🦊 지갑 연결하기
                </button>
            ) : (
                <div>
                    <p>연결된 지갑: {account.slice(0, 6)}...{account.slice(-4)}</p>
                    <p>보유 NFT: {nftBalance}개</p>
                </div>
            )}
        </div>
    );
}

export default GameWalletConnect;

🎨 NFT 메타데이터와 IPFS 저장

📦 IPFS란 무엇인가?

📄 NFT 메타데이터 표준 구조

{
  "name": "드래곤 슬레이어 +15",
  "description": "고대 드래곤을 물리친 전설의 검. 강화 수치 +15로 업그레이드되어 막강한 힘을 자랑합니다.",
  "image": "ipfs://QmX7x8x9xAbCdEfGhIjKlMnOpQrStUvWxYz/dragon-slayer.png",
  "external_url": "https://mygame.com/items/12345",
  "animation_url": "ipfs://QmY8y9y0yBcDeFgHiJkLmNoPqRsTuVwXyZ/dragon-slayer-3d.glb",
  "attributes": [
    {
      "trait_type": "무기 종류",
      "value": "양손검"
    },
    {
      "trait_type": "등급",
      "value": "전설"
    },
    {
      "trait_type": "공격력",
      "value": 250,
      "max_value": 300
    },
    {
      "trait_type": "강화 수치",
      "value": 15,
      "max_value": 20
    },
    {
      "trait_type": "특수 능력",
      "value": "드래곤 킬러"
    },
    {
      "trait_type": "내구도",
      "value": 100,
      "max_value": 100,
      "display_type": "boost_percentage"
    },
    {
      "trait_type": "획득 날짜",
      "value": 1705276800,
      "display_type": "date"
    }
  ],
  "background_color": "8B0000",
  "properties": {
    "game_id": "dragon-quest-online",
    "item_id": "sword_001",
    "rarity_score": 95,
    "is_tradeable": true,
    "is_upgradeable": true,
    "level_requirement": 50,
    "class_requirement": ["전사", "기사"]
  }
}

☁️ IPFS 업로드 실전 코드

const axios = require('axios');
const FormData = require('form-data');
const fs = require('fs');
const pinataApiKey = process.env.PINATA_API_KEY;
const pinataSecretApiKey = process.env.PINATA_SECRET_API_KEY;

// 이미지 파일을 IPFS에 업로드
async function uploadImageToIPFS(imagePath) {
    const url = 'https://api.pinata.cloud/pinning/pinFileToIPFS';
    
    let data = new FormData();
    data.append('file', fs.createReadStream(imagePath));
    
    const metadata = JSON.stringify({
        name: 'Game Item Image',
        keyvalues: {
            type: 'game-item',
            game: 'dragon-quest-online'
        }
    });
    data.append('pinataMetadata', metadata);
    
    const options = JSON.stringify({
        cidVersion: 1,
    });
    data.append('pinataOptions', options);
    
    try {
        const response = await axios.post(url, data, {
            maxBodyLength: 'Infinity',
            headers: {
                'Content-Type': `multipart/form-data; boundary=${data._boundary}`,
                'pinata_api_key': pinataApiKey,
                'pinata_secret_api_key': pinataSecretApiKey
            }
        });
        
        console.log('이미지 업로드 완료:', response.data.IpfsHash);
        return `ipfs://${response.data.IpfsHash}`;
        
    } catch (error) {
        console.error('이미지 업로드 실패:', error);
        throw error;
    }
}

// 메타데이터를 IPFS에 업로드
async function uploadMetadataToIPFS(metadata) {
    const url = 'https://api.pinata.cloud/pinning/pinJSONToIPFS';
    
    try {
        const response = await axios.post(url, metadata, {
            headers: {
                'Content-Type': 'application/json',
                'pinata_api_key': pinataApiKey,
                'pinata_secret_api_key': pinataSecretApiKey
            }
        });
        
        console.log('메타데이터 업로드 완료:', response.data.IpfsHash);
        return `ipfs://${response.data.IpfsHash}`;
        
    } catch (error) {
        console.error('메타데이터 업로드 실패:', error);
        throw error;
    }
}

// 전체 NFT 생성 프로세스
async function createGameItemNFT(itemData) {
    try {
        // 1. 이미지 업로드
        console.log('1단계: 이미지 업로드 중...');
        const imageURI = await uploadImageToIPFS(itemData.imagePath);
        
        // 2. 메타데이터 생성
        console.log('2단계: 메타데이터 생성 중...');
        const metadata = {
            name: itemData.name,
            description: itemData.description,
            image: imageURI,
            attributes: [
                { trait_type: "공격력", value: itemData.attackPower },
                { trait_type: "방어력", value: itemData.defense },
                { trait_type: "희귀도", value: itemData.rarity },
                { trait_type: "강화", value: itemData.enhancement }
            ],
            properties: {
                game_id: "dragon-quest-online",
                item_id: itemData.itemId,
                is_tradeable: true
            }
        };
        
        // 3. 메타데이터 업로드
        console.log('3단계: 메타데이터 업로드 중...');
        const metadataURI = await uploadMetadataToIPFS(metadata);
        
        console.log('✅ NFT 준비 완료!');
        console.log('메타데이터 URI:', metadataURI);
        
        return metadataURI;
        
    } catch (error) {
        console.error('NFT 생성 실패:', error);
        throw error;
    }
}

// 사용 예시
const itemData = {
    name: "드래곤 슬레이어 +15",
    description: "고대 드래곤을 물리친 전설의 검",
    imagePath: "./assets/dragon-slayer.png",
    attackPower: 250,
    defense: 50,
    rarity: "전설",
    enhancement: 15,
    itemId: "sword_001"
};

createGameItemNFT(itemData)
    .then(uri => {
        console.log('이제 이 URI로 NFT를 민팅하면 됩니다:', uri);
    })
    .catch(error => {
        console.error('오류 발생:', error);
    });

module.exports = {
    uploadImageToIPFS,
    uploadMetadataToIPFS,
    createGameItemNFT
};

💰 NFT 거래 시스템 구축

🛒 마켓플레이스 구조

📜 마켓플레이스 스마트 컨트랙트

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

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

contract GameItemMarketplace is ReentrancyGuard, Ownable {
    
    // 판매 정보 구조체
    struct Listing {
        address seller;
        address nftContract;
        uint256 tokenId;
        uint256 price;
        bool isActive;
    }
    
    // 판매 ID별 판매 정보
    mapping(uint256 => Listing) public listings;
    uint256 public listingCounter;
    
    // 마켓플레이스 수수료 (2.5%)
    uint256 public feePercentage = 250; // 250 = 2.5%
    uint256 public constant FEE_DENOMINATOR = 10000;
    
    // 누적 수수료
    uint256 public accumulatedFees;
    
    // 이벤트
    event ItemListed(
        uint256 indexed listingId,
        address indexed seller,
        address indexed nftContract,
        uint256 tokenId,
        uint256 price
    );
    
    event ItemSold(
        uint256 indexed listingId,
        address indexed buyer,
        address indexed seller,
        uint256 price
    );
    
    event ListingCancelled(uint256 indexed listingId);
    
    event PriceUpdated(uint256 indexed listingId, uint256 newPrice);
    
    // 아이템 판매 등록
    function listItem(
        address nftContract,
        uint256 tokenId,
        uint256 price
    ) external nonReentrant returns (uint256) {
        require(price > 0, "Price must be greater than 0");
        
        IERC721 nft = IERC721(nftContract);
        require(nft.ownerOf(tokenId) == msg.sender, "Not the owner");
        require(
            nft.isApprovedForAll(msg.sender, address(this)) ||
            nft.getApproved(tokenId) == address(this),
            "Marketplace not approved"
        );
        
        listingCounter++;
        uint256 listingId = listingCounter;
        
        listings[listingId] = Listing({
            seller: msg.sender,
            nftContract: nftContract,
            tokenId: tokenId,
            price: price,
            isActive: true
        });
        
        emit ItemListed(listingId, msg.sender, nftContract, tokenId, price);
        
        return listingId;
    }
    
    // 아이템 구매
    function buyItem(uint256 listingId) 
        external 
        payable 
        nonReentrant 
    {
        Listing storage listing = listings[listingId];
        require(listing.isActive, "Listing is not active");
        require(msg.value >= listing.price, "Insufficient payment");
        require(msg.sender != listing.seller, "Cannot buy your own item");
        
        IERC721 nft = IERC721(listing.nftContract);
        require(
            nft.ownerOf(listing.tokenId) == listing.seller,
            "Seller no longer owns the item"
        );
        
        // 수수료 계산
        uint256 fee = (listing.price * feePercentage) / FEE_DENOMINATOR;
        uint256 sellerAmount = listing.price - fee;
        
        // 판매 완료 처리
        listing.isActive = false;
        accumulatedFees += fee;
        
        // NFT 전송
        nft.safeTransferFrom(listing.seller, msg.sender, listing.tokenId);
        
        // 판매자에게 대금 전송
        (bool success, ) = payable(listing.seller).call{value: sellerAmount}("");
        require(success, "Transfer to seller failed");
        
        // 초과 지불액 반환
        if (msg.value > listing.price) {
            (bool refundSuccess, ) = payable(msg.sender).call{
                value: msg.value - listing.price
            }("");
            require(refundSuccess, "Refund failed");
        }
        
        emit ItemSold(listingId, msg.sender, listing.seller, listing.price);
    }
    
    // 판매 취소
    function cancelListing(uint256 listingId) external nonReentrant {
        Listing storage listing = listings[listingId];
        require(listing.isActive, "Listing is not active");
        require(listing.seller == msg.sender, "Not the seller");
        
        listing.isActive = false;
        
        emit ListingCancelled(listingId);
    }
    
    // 가격 변경
    function updatePrice(uint256 listingId, uint256 newPrice) 
        external 
        nonReentrant 
    {
        Listing storage listing = listings[listingId];
        require(listing.isActive, "Listing is not active");
        require(listing.seller == msg.sender, "Not the seller");
        require(newPrice > 0, "Price must be greater than 0");
        
        listing.price = newPrice;
        
        emit PriceUpdated(listingId, newPrice);
    }
    
    // 활성 판매 목록 조회
    function getActiveListing(uint256 listingId) 
        external 
        view 
        returns (Listing memory) 
    {
        require(listings[listingId].isActive, "Listing is not active");
        return listings[listingId];
    }
    
    // 수수료율 변경 (관리자만)
    function setFeePercentage(uint256 newFee) external onlyOwner {
        require(newFee <= 1000, "Fee too high"); // 최대 10%
        feePercentage = newFee;
    }
    
    // 수수료 인출 (관리자만)
    function withdrawFees() external onlyOwner {
        uint256 amount = accumulatedFees;
        accumulatedFees = 0;
        
        (bool success, ) = payable(owner()).call{value: amount}("");
        require(success, "Withdrawal failed");
    }
    
    // 긴급 상황 대비 함수
    function emergencyWithdraw() external onlyOwner {
        (bool success, ) = payable(owner()).call{value: address(this).balance}("");
        require(success, "Emergency withdrawal failed");
    }
}

🖥️ 마켓플레이스 프론트엔드

import React, { useState, useEffect } from 'react';
import Web3 from 'web3';

function NFTMarketplace() {
    const [web3, setWeb3] = useState(null);
    const [account, setAccount] = useState(null);
    const [listings, setListings] = useState([]);
    const [myNFTs, setMyNFTs] = useState([]);
    
    const marketplaceAddress = '0xMarketplace...';
    const nftContractAddress = '0xNFTContract...';
    
    // 초기화
    useEffect(() => {
        initWeb3();
    }, []);
    
    const initWeb3 = async () => {
        if (window.ethereum) {
            const web3Instance = new Web3(window.ethereum);
            setWeb3(web3Instance);
            
            const accounts = await window.ethereum.request({
                method: 'eth_requestAccounts'
            });
            setAccount(accounts[0]);
            
            await loadMarketplace(web3Instance, accounts[0]);
        }
    };
    
    // 마켓플레이스 데이터 로드
    const loadMarketplace = async (web3Instance, userAccount) => {
        const marketplaceContract = new web3Instance.eth.Contract(
            marketplaceABI,
            marketplaceAddress
        );
        
        const nftContract = new web3Instance.eth.Contract(
            nftABI,
            nftContractAddress
        );
        
        // 활성 판매 목록 로드
        const listingCounter = await marketplaceContract.methods
            .listingCounter()
            .call();
        
        const activeListings = [];
        for (let i = 1; i <= listingCounter; i++) {
            try {
                const listing = await marketplaceContract.methods
                    .getActiveListing(i)
                    .call();
                
                // NFT 메타데이터 로드
                const tokenURI = await nftContract.methods
                    .tokenURI(listing.tokenId)
                    .call();
                
                const metadata = await fetch(
                    tokenURI.replace('ipfs://', 'https://ipfs.io/ipfs/')
                ).then(r => r.json());
                
                activeListings.push({
                    listingId: i,
                    ...listing,
                    metadata
                });
            } catch (error) {
                // 비활성 판매는 건너뛰기
                continue;
            }
        }
        
        setListings(activeListings);
        
        // 내 NFT 로드
        const balance = await nftContract.methods
            .balanceOf(userAccount)
            .call();
        
        const myNFTList = [];
        for (let i = 0; i < balance; i++) {
            const tokenId = await nftContract.methods
                .tokenOfOwnerByIndex(userAccount, i)
                .call();
            
            const tokenURI = await nftContract.methods
                .tokenURI(tokenId)
                .call();
            
            const metadata = await fetch(
                tokenURI.replace('ipfs://', 'https://ipfs.io/ipfs/')
            ).then(r => r.json());
            
            myNFTList.push({ tokenId, metadata });
        }
        
        setMyNFTs(myNFTList);
    };
    
    // NFT 구매
    const buyNFT = async (listingId, price) => {
        try {
            const marketplaceContract = new web3.eth.Contract(
                marketplaceABI,
                marketplaceAddress
            );
            
            await marketplaceContract.methods
                .buyItem(listingId)
                .send({
                    from: account,
                    value: price
                });
            
            alert('구매 완료! 🎉');
            await loadMarketplace(web3, account);
            
        } catch (error) {
            console.error('구매 실패:', error);
            alert('구매에 실패했습니다.');
        }
    };
    
    // NFT 판매 등록
    const listNFT = async (tokenId, price) => {
        try {
            const nftContract = new web3.eth.Contract(
                nftABI,
                nftContractAddress
            );
            
            const marketplaceContract = new web3.eth.Contract(
                marketplaceABI,
                marketplaceAddress
            );
            
            // 1. 마켓플레이스에 승인
            await nftContract.methods
                .approve(marketplaceAddress, tokenId)
                .send({ from: account });
            
            // 2. 판매 등록
            const priceInWei = web3.utils.toWei(price.toString(), 'ether');
            await marketplaceContract.methods
                .listItem(nftContractAddress, tokenId, priceInWei)
                .send({ from: account });
            
            alert('판매 등록 완료! 🏪');
            await loadMarketplace(web3, account);
            
        } catch (error) {
            console.error('판매 등록 실패:', error);
            alert('판매 등록에 실패했습니다.');
        }
    };
    
    return (
        <div className="marketplace">
            <h1>🎮 게임 아이템 마켓플레이스</h1>
            
            {/* 판매 중인 아이템 */}
            <section className="listings-section">
                <h2>🛒 판매 중인 아이템</h2>
                <div className="nft-grid">
                    {listings.map(listing => (
                        <div key={listing.listingId} className="nft-card">
                            <img 
                                src={listing.metadata.image.replace(
                                    'ipfs://', 
                                    'https://ipfs.io/ipfs/'
                                )} 
                                alt={listing.metadata.name}
                            />
                            <h3>{listing.metadata.name}</h3>
                            <p className="price">
                                {web3.utils.fromWei(listing.price, 'ether')} MATIC
                            </p>
                            <div className="attributes">
                                {listing.metadata.attributes.map((attr, i) => (
                                    <span key={i} className="attribute">
                                        {attr.trait_type}: {attr.value}
                                    </span>
                                ))}
                            </div>
                            {listing.seller.toLowerCase() !== account.toLowerCase() && (
                                <button 
                                    onClick={() => buyNFT(
                                        listing.listingId, 
                                        listing.price
                                    )}
                                >
                                    구매하기
                                </button>
                            )}
                        </div>
                    ))}
                </div>
            </section>
            
            {/* 내 아이템 */}
            <section className="my-nfts-section">
                <h2>🎒 내 아이템</h2>
                <div className="nft-grid">
                    {myNFTs.map(nft => (
                        <div key={nft.tokenId} className="nft-card">
                            <img 
                                src={nft.metadata.image.replace(
                                    'ipfs://', 
                                    'https://ipfs.io/ipfs/'
                                )} 
                                alt={nft.metadata.name}
                            />
                            <h3>{nft.metadata.name}</h3>
                            <div className="sell-form">
                                <input 
                                    type="number" 
                                    placeholder="가격 (MATIC)"
                                    id={`price-${nft.tokenId}`}
                                />
                                <button onClick={() => {
                                    const price = document.getElementById(
                                        `price-${nft.tokenId}`
                                    ).value;
                                    listNFT(nft.tokenId, price);
                                }}>
                                    판매 등록
                                </button>
                            </div>
                        </div>
                    ))}
                </div>
            </section>
        </div>
    );
}

export default NFTMarketplace;

🔐 보안과 스마트 컨트랙트 감사

⚠️ 주요 보안 위협

✅ 보안 체크리스트

🧪 테스트 코드 예시

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

describe("GameItemNFT", function () {
    let gameItemNFT;
    let marketplace;
    let owner;
    let player1;
    let player2;
    
    beforeEach(async function () {
        // 계정 설정
        [owner, player1, player2] = await ethers.getSigners();
        
        // NFT 컨트랙트 배포
        const GameItemNFT = await ethers.getContractFactory("GameItemNFT");
        gameItemNFT = await GameItemNFT.deploy();
        await gameItemNFT.deployed();
        
        // 마켓플레이스 컨트랙트 배포
        const Marketplace = await ethers.getContractFactory("GameItemMarketplace");
        marketplace = await Marketplace.deploy();
        await marketplace.deployed();
    });
    
    describe("NFT 발행", function () {
        it("게임 서버가 NFT를 발행할 수 있어야 함", async function () {
            const tokenURI = "ipfs://QmTest123";
            
            await gameItemNFT.mintItem(
                player1.address,
                tokenURI,
                "드래곤 슬레이어",
                250, // attackPower
                50,  // defense
                4,   // rarity (전설)
                1    // level
            );
            
            expect(await gameItemNFT.ownerOf(1)).to.equal(player1.address);
            expect(await gameItemNFT.tokenURI(1)).to.equal(tokenURI);
        });
        
        it("일반 사용자는 NFT를 발행할 수 없어야 함", async function () {
            await expect(
                gameItemNFT.connect(player1).mintItem(
                    player1.address,
                    "ipfs://QmTest123",
                    "드래곤 슬레이어",
                    250, 50, 4, 1
                )
            ).to.be.revertedWith("Only game server can mint");
        });
    });
    
    describe("아이템 강화", function () {
        beforeEach(async function () {
            await gameItemNFT.mintItem(
                player1.address,
                "ipfs://QmTest123",
                "드래곤 슬레이어",
                250, 50, 4, 1
            );
        });
        
        it("아이템을 강화할 수 있어야 함", async function () {
            await gameItemNFT.upgradeItem(1, 300);
            
            const stats = await gameItemNFT.getItemStats(1);
            expect(stats.attackPower).to.equal(300);
            expect(stats.level).to.equal(2);
        });
    });
    
    describe("마켓플레이스", function () {
        beforeEach(async function () {
            // NFT 발행
            await gameItemNFT.mintItem(
                player1.address,
                "ipfs://QmTest123",
                "드래곤 슬레이어",
                250, 50, 4, 1
            );
            
            // 마켓플레이스에 승인
            await gameItemNFT.connect(player1)
                .approve(marketplace.address, 1);
        });
        
        it("NFT를 판매 등록할 수 있어야 함", async function () {
            const price = ethers.utils.parseEther("10");
            
            await marketplace.connect(player1).listItem(
                gameItemNFT.address,
                1,
                price
            );
            
            const listing = await marketplace.getActiveListing(1);
            expect(listing.seller).to.equal(player1.address);
            expect(listing.price).to.equal(price);
        });
        
        it("NFT를 구매할 수 있어야 함", async function () {
            const price = ethers.utils.parseEther("10");
            
            // 판매 등록
            await marketplace.connect(player1).listItem(
                gameItemNFT.address,
                1,
                price
            );
            
            // 구매
            await marketplace.connect(player2).buyItem(1, {
                value: price
            });
            
            // 소유권 확인
            expect(await gameItemNFT.ownerOf(1)).to.equal(player2.address);
        });
        
        it("수수료가 올바르게 계산되어야 함", async function () {
            const price = ethers.utils.parseEther("100");
            const expectedFee = price.mul(250).div(10000); // 2.5%
            
            await marketplace.connect(player1).listItem(
                gameItemNFT.address,
                1,
                price
            );
            
            const player1BalanceBefore = await ethers.provider.getBalance(
                player1.address
            );
            
            await marketplace.connect(player2).buyItem(1, {
                value: price
            });
            
            const accumulatedFees = await marketplace.accumulatedFees();
            expect(accumulatedFees).to.equal(expectedFee);
        });
        
        it("자신의 NFT는 구매할 수 없어야 함", async function () {
            const price = ethers.utils.parseEther("10");
            
            await marketplace.connect(player1).listItem(
                gameItemNFT.address,
                1,
                price
            );
            
            await expect(
                marketplace.connect(player1).buyItem(1, {
                    value: price
                })
            ).to.be.revertedWith("Cannot buy your own item");
        });
    });
    
    describe("가스 최적화", function () {
        it("배치 민팅의 가스 비용 측정", async function () {
            const tx = await gameItemNFT.mintItem(
                player1.address,
                "ipfs://QmTest123",
                "드래곤 슬레이어",
                250, 50, 4, 1
            );
            
            const receipt = await tx.wait();
            console.log("민팅 가스 사용량:", receipt.gasUsed.toString());
            
            // 가스 사용량이 합리적인 범위 내인지 확인
            expect(receipt.gasUsed).to.be.below(200000);
        });
    });
});

🎯 실제 게임 적용 사례

🏆 성공 사례

📊 비즈니스 모델

🚀 성공 요인 분석

🔮 미래 전망과 발전 방향

🌟 떠오르는 트렌드

🛠️ 기술 발전 방향

💡 실용적인 조언

🎓 마치며