ERC-721 토큰 (NFT)

// 전 세계적으로 고유한 NFT 식별
(컨트랙트 주소, tokenId) = 고유한 NFT

// ERC-721 컨트랙트 내부
mapping(uint256 => address) private _owners;
mapping(address => uint256) private _balances;

// 예시:
// _owners[1] = 0x1234...  ← Alice가 NFT #1 소유
// _owners[2] = 0x5678...  ← Bob이 NFT #2 소유
// _balances[alice] = 2    ← Alice는 총 2개의 NFT 소유

// NFT의 소유자 조회
// 특정 토큰 ID의 소유자 주소 반환
function ownerOf(uint256 tokenId) public view returns (address)

// 특정 주소가 소유한 NFT 개수 반환
function balanceOf(address owner) public view returns (uint256)

// 토큰의 메타데이터 URI 반환
// 이미지, 이름, 설명 등이 저장된 JSON 파일 위치
function tokenURI(uint256 tokenId) public view returns (string)

// 승인된 주소 조회
// 특정 NFT를 대신 전송할 수 있는 주소 확인
function getApproved(uint256 tokenId) public view returns (address)

// operator가 owner의 모든 NFT를 관리할 권한이 있는지 확인
function isApprovedForAll(address owner, address operator) public view returns (bool)

// NFT를 from에서 to로 전송
// 가장 기본적인 전송 방식
function transferFrom(address from, address to, uint256 tokenId) public

// transferFrom과 동일하지만 to가 컨트랙트인 경우 안전성 체크
// NFT가 컨트랙트에 갇히는 것을 방지
function safeTransferFrom(address from, address to, uint256 tokenId) public

// 특정 NFT를 approved 주소가 대신 전송할 수 있도록 승인
function approve(address approved, uint256 tokenId) public

// operator가 소유자의 모든 NFT를 관리할 수 있도록 승인/취소
// 마켓플레이스에서 주로 사용
function setApprovalForAll(address operator, bool approved) public

// NFT가 전송될 때마다 발생
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId)

// NFT 사용이 승인될 때 발생
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId)

// 전체 승인이 설정/해제될 때 발생
event ApprovalForAll(address indexed owner, address indexed operator, bool approved)

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

contract SimpleNFT {
    // NFT 정보
    string public name = "My NFT";
    string public symbol = "MNFT";

    // 각 토큰 ID의 소유자
    mapping(uint256 => address) private _owners;

    // 각 주소가 소유한 NFT 개수
    mapping(address => uint256) private _balances;

    // 각 토큰 ID의 승인된 주소
    mapping(uint256 => address) private _tokenApprovals;

    // 소유자가 operator에게 모든 NFT 관리 권한 부여
    mapping(address => mapping(address => bool)) private _operatorApprovals;

    // 이벤트
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    // NFT 발행
    function mint(address to, uint256 tokenId) public {
        require(to != address(0), "민팅 대상이 유효하지 않습니다");
        require(_owners[tokenId] == address(0), "이미 존재하는 토큰입니다");

        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(address(0), to, tokenId);
    }

    // 소유자 조회
    function ownerOf(uint256 tokenId) public view returns (address) {
        address owner = _owners[tokenId];
        require(owner != address(0), "존재하지 않는 토큰입니다");
        return owner;
    }

    // 잔액 조회
    function balanceOf(address owner) public view returns (uint256) {
        require(owner != address(0), "유효하지 않은 주소입니다");
        return _balances[owner];
    }

    // NFT 전송
    function transferFrom(address from, address to, uint256 tokenId) public {
        require(_isApprovedOrOwner(msg.sender, tokenId), "전송 권한이 없습니다");
        require(ownerOf(tokenId) == from, "소유자가 일치하지 않습니다");
        require(to != address(0), "유효하지 않은 수신 주소입니다");

        // 승인 초기화
        _approve(address(0), tokenId);

        _balances[from] -= 1;
        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);
    }

    // 승인
    function approve(address approved, uint256 tokenId) public {
        address owner = ownerOf(tokenId);
        require(msg.sender == owner, "소유자만 승인할 수 있습니다");
        require(approved != owner, "소유자에게 승인할 수 없습니다");

        _approve(approved, tokenId);
    }

    // 전체 승인
    function setApprovalForAll(address operator, bool approved) public {
        require(operator != msg.sender, "자신에게 승인할 수 없습니다");
        _operatorApprovals[msg.sender][operator] = approved;
        emit ApprovalForAll(msg.sender, operator, approved);
    }

    // 승인 조회
    function getApproved(uint256 tokenId) public view returns (address) {
        require(_owners[tokenId] != address(0), "존재하지 않는 토큰입니다");
        return _tokenApprovals[tokenId];
    }

    // 전체 승인 조회
    function isApprovedForAll(address owner, address operator) public view returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    // 내부 함수
    function _approve(address approved, uint256 tokenId) private {
        _tokenApprovals[tokenId] = approved;
        emit Approval(ownerOf(tokenId), approved, tokenId);
    }

    function _isApprovedOrOwner(address spender, uint256 tokenId) private view returns (bool) {
        address owner = ownerOf(tokenId);
        return (spender == owner ||
                getApproved(tokenId) == spender ||
                isApprovedForAll(owner, spender));
    }
}

// Alice가 Bob에게 NFT #5 전송
nft.transferFrom(aliceAddress, bobAddress, 5);

// 컨트랙트 내부에서 일어나는 일:
require(_isApprovedOrOwner(msg.sender, 5), "전송 권한이 없습니다");
_balances[alice] -= 1;  // Alice: 3개 → 2개
_balances[bob] += 1;    // Bob: 1개 → 2개
_owners[5] = bob;       // NFT #5의 소유자를 Bob으로 변경
emit Transfer(alice, bob, 5);

// Alice가 OpenSea에게 NFT #5만 전송 권한 부여
nft.approve(openSeaAddress, 5);

// Alice가 OpenSea에게 자신의 모든 NFT 전송 권한 부여
nft.setApprovalForAll(openSeaAddress, true);

// Alice가 OpenSea에게 NFT #5 전송 권한 승인
nft.approve(openSeaAddress, 5);

// 컨트랙트 내부:
_tokenApprovals[5] = openSea;
emit Approval(alice, openSea, 5);

// 또는 모든 NFT에 대한 권한 승인
nft.setApprovalForAll(openSeaAddress, true);

// 컨트랙트 내부:
_operatorApprovals[alice][openSea] = true;
emit ApprovalForAll(alice, openSea, true);

function tokenURI(uint256 tokenId) public view returns (string) {
    return string(abi.encodePacked(baseURI, tokenId.toString(), ".json"));
}

// 예시:
// tokenURI(1) => "https://api.example.com/metadata/1.json"
// tokenURI(2) => "https://api.example.com/metadata/2.json"

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";

contract MyNFT is ERC721 {
    constructor() ERC721("MyNFT", "MNFT") {}

    // baseURI 반환 (tokenURI 생성에 사용됨)
    // tokenURI(1) => "https://api.example.com/metadata/1"
    // tokenURI(2) => "https://api.example.com/metadata/2"
    function _baseURI() internal view override returns (string memory) {
        return "https://api.example.com/metadata/";
    }
}