# 가상환경 만들기 (선택사항이지만 강력 추천!)
python -m venv nft-env
source nft-env/bin/activate  # Mac/Linux
# nft-env\Scripts\activate  # Windows

# 필요한 패키지 설치
pip install requests
pip install web3
pip install python-dotenv
pip install Pillow

nft-upload-system/
├── .env                    # API 키 (절대 git에 올리지 마!)
├── .gitignore              # .env 포함시키기
├── requirements.txt        # 의존성 목록
├── images/                 # 업로드할 이미지들
│   ├── nft_001.png
│   ├── nft_002.png
│   └── ...
├── metadata/               # 생성된 메타데이터 저장
├── upload_to_ipfs.py       # 이미지 업로드 모듈
├── create_metadata.py      # 메타데이터 생성 모듈
├── mint_nft.py             # 민팅 모듈
└── main.py                 # 메인 실행 파일

# .env 파일 내용
PINATA_API_KEY=your_api_key_here
PINATA_API_SECRET=your_api_secret_here
PINATA_JWT=your_jwt_token_here
INFURA_PROJECT_ID=your_infura_id
PRIVATE_KEY=your_wallet_private_key
CONTRACT_ADDRESS=your_contract_address

import requests
import os
import json
from pathlib import Path
from dotenv import load_dotenv

# .env 파일에서 환경변수 로드
load_dotenv()

class IPFSUploader:
    """Pinata를 통한 IPFS 업로드 클래스"""
    
    def __init__(self):
        self.jwt = os.getenv("PINATA_JWT")
        self.api_key = os.getenv("PINATA_API_KEY")
        self.api_secret = os.getenv("PINATA_API_SECRET")
        
        # Pinata API 엔드포인트
        self.pin_file_url = "https://api.pinata.cloud/pinning/pinFileToIPFS"
        self.pin_json_url = "https://api.pinata.cloud/pinning/pinJSONToIPFS"
        
        # JWT 헤더 (권장 방식)
        self.headers = {
            "Authorization": f"Bearer {self.jwt}"
        }
    
    def validate_image(self, image_path: str) -> bool:
        """이미지 파일 유효성 검사"""
        path = Path(image_path)
        
        # 파일 존재 여부 확인
        if not path.exists():
            raise FileNotFoundError(f"파일을 찾을 수 없어요: {image_path}")
        
        # 지원 형식 확인
        supported_formats = {'.png', '.jpg', '.jpeg', '.gif', '.webp', '.svg'}
        if path.suffix.lower() not in supported_formats:
            raise ValueError(f"지원하지 않는 형식이에요. 지원 형식: {supported_formats}")
        
        # 파일 크기 확인 (Pinata 무료 플랜: 100MB 제한)
        file_size_mb = path.stat().st_size / (1024 * 1024)
        if file_size_mb > 100:
            raise ValueError(f"파일이 너무 커요: {file_size_mb:.2f}MB (최대 100MB)")
        
        print(f"✅ 이미지 검증 완료: {path.name} ({file_size_mb:.2f}MB)")
        return True
    
    def upload_image(self, image_path: str, nft_name: str = None) -> dict:
        """
        이미지를 IPFS에 업로드하고 CID를 반환
        
        Args:
            image_path: 업로드할 이미지 파일 경로
            nft_name: NFT 이름 (메타데이터용)
        
        Returns:
            dict: {'cid': str, 'ipfs_url': str, 'gateway_url': str}
        """
        # 유효성 검사
        self.validate_image(image_path)
        
        path = Path(image_path)
        pin_name = nft_name or path.stem  # 이름 없으면 파일명 사용
        
        # Pinata 메타데이터 (IPFS 메타데이터와 다름! Pinata 관리용)
        pinata_metadata = {
            "name": pin_name,
            "keyvalues": {
                "type": "nft-image",
                "original_filename": path.name
            }
        }
        
        # Pinata 옵션
        pinata_options = {
            "cidVersion": 1  # CIDv1 사용 (더 최신 형식)
        }
        
        print(f"📤 IPFS 업로드 시작: {path.name}")
        
        try:
            with open(image_path, 'rb') as img_file:
                # multipart/form-data 형식으로 전송
                files = {
                    'file': (path.name, img_file, self._get_mime_type(path.suffix))
                }
                data = {
                    'pinataMetadata': json.dumps(pinata_metadata),
                    'pinataOptions': json.dumps(pinata_options)
                }
                
                response = requests.post(
                    self.pin_file_url,
                    headers=self.headers,
                    files=files,
                    data=data,
                    timeout=60  # 60초 타임아웃
                )
                
                response.raise_for_status()  # HTTP 에러 체크
                result = response.json()
                
                cid = result['IpfsHash']
                
                return {
                    'cid': cid,
                    'ipfs_url': f"ipfs://{cid}",
                    'gateway_url': f"https://gateway.pinata.cloud/ipfs/{cid}",
                    'public_gateway': f"https://ipfs.io/ipfs/{cid}",
                    'pin_size': result.get('PinSize', 0),
                    'timestamp': result.get('Timestamp', '')
                }
                
        except requests.exceptions.RequestException as e:
            raise ConnectionError(f"API 호출 실패: {str(e)}")
    
    def _get_mime_type(self, suffix: str) -> str:
        """파일 확장자에 따른 MIME 타입 반환"""
        mime_types = {
            '.png': 'image/png',
            '.jpg': 'image/jpeg',
            '.jpeg': 'image/jpeg',
            '.gif': 'image/gif',
            '.webp': 'image/webp',
            '.svg': 'image/svg+xml'
        }
        return mime_types.get(suffix.lower(), 'application/octet-stream')
    
    def upload_batch(self, image_folder: str) -> list:
        """
        폴더 내 모든 이미지를 일괄 업로드
        
        Args:
            image_folder: 이미지가 있는 폴더 경로
        
        Returns:
            list: 각 이미지의 업로드 결과 목록
        """
        folder = Path(image_folder)
        if not folder.is_dir():
            raise NotADirectoryError(f"폴더를 찾을 수 없어요: {image_folder}")
        
        # 지원 형식 이미지만 필터링
        image_extensions = {'.png', '.jpg', '.jpeg', '.gif', '.webp'}
        images = sorted([
            f for f in folder.iterdir() 
            if f.suffix.lower() in image_extensions
        ])
        
        if not images:
            raise ValueError(f"업로드할 이미지가 없어요: {image_folder}")
        
        print(f"🗂️ 총 {len(images)}개 이미지 일괄 업로드 시작!")
        
        results = []
        for idx, img_path in enumerate(images, 1):
            print(f"\n[{idx}/{len(images)}] 처리 중...")
            try:
                result = self.upload_image(str(img_path))
                result['filename'] = img_path.name
                result['index'] = idx
                results.append(result)
                print(f"✅ 완료! CID: {result['cid'][:20]}...")
            except Exception as e:
                print(f"❌ 실패: {img_path.name} - {str(e)}")
                results.append({
                    'filename': img_path.name,
                    'index': idx,
                    'error': str(e)
                })
        
        return results

# 단일 이미지 업로드 테스트
if __name__ == "__main__":
    uploader = IPFSUploader()
    
    # 단일 이미지 업로드
    result = uploader.upload_image(
        image_path="images/nft_001.png",
        nft_name="My Awesome NFT #001"
    )
    
    print("\n🎉 업로드 성공!")
    print(f"CID: {result['cid']}")
    print(f"IPFS URL: {result['ipfs_url']}")
    print(f"게이트웨이 URL: {result['gateway_url']}")
    print(f"파일 크기: {result['pin_size']} bytes")

# NFT 메타데이터 표준 형식 예시
{
    "name": "My Awesome NFT #001",
    "description": "이 NFT는 정말 멋진 작품이야! 파이썬으로 만들었어.",
    "image": "ipfs://bafkreihdwdcefgh4dqkjv67uzcmw7ojee6xedzdetojuzgivvzsqiotiqe",
    "external_url": "https://www.jaenung.net",
    "attributes": [
        {
            "trait_type": "배경",
            "value": "파란 하늘"
        },
        {
            "trait_type": "희귀도",
            "value": "레어"
        },
        {
            "trait_type": "레벨",
            "display_type": "number",
            "value": 5
        },
        {
            "trait_type": "생성일",
            "display_type": "date",
            "value": 1704067200
        }
    ]
}

import json
import os
import time
from pathlib import Path
from upload_to_ipfs import IPFSUploader

class NFTMetadataCreator:
    """NFT 메타데이터 생성 및 IPFS 업로드 클래스"""
    
    def __init__(self):
        self.uploader = IPFSUploader()
        self.metadata_dir = Path("metadata")
        self.metadata_dir.mkdir(exist_ok=True)
    
    def create_metadata(
        self,
        token_id: int,
        name: str,
        description: str,
        image_cid: str,
        attributes: list = None,
        external_url: str = None
    ) -> dict:
        """
        NFT 메타데이터 JSON 생성
        
        Args:
            token_id: NFT 토큰 ID
            name: NFT 이름
            description: NFT 설명
            image_cid: 이미지의 IPFS CID
            attributes: 속성 목록 (OpenSea 표준)
            external_url: 외부 링크 URL
        
        Returns:
            dict: 메타데이터 딕셔너리
        """
        metadata = {
            "name": name,
            "description": description,
            "image": f"ipfs://{image_cid}",
            "token_id": token_id,
            "created_at": int(time.time())
        }
        
        if external_url:
            metadata["external_url"] = external_url
        
        if attributes:
            # 속성 유효성 검사
            validated_attrs = []
            for attr in attributes:
                if "trait_type" not in attr or "value" not in attr:
                    print(f"⚠️ 잘못된 속성 형식 건너뜀: {attr}")
                    continue
                validated_attrs.append(attr)
            metadata["attributes"] = validated_attrs
        
        return metadata
    
    def save_metadata_locally(self, token_id: int, metadata: dict) -> str:
        """메타데이터를 로컬에 JSON으로 저장"""
        file_path = self.metadata_dir / f"{token_id}.json"
        with open(file_path, 'w', encoding='utf-8') as f:
            json.dump(metadata, f, ensure_ascii=False, indent=2)
        print(f"💾 메타데이터 로컬 저장: {file_path}")
        return str(file_path)
    
    def upload_metadata_to_ipfs(self, metadata: dict, name: str) -> dict:
        """
        메타데이터 JSON을 IPFS에 업로드
        
        Args:
            metadata: 업로드할 메타데이터 딕셔너리
            name: Pinata에서 관리할 이름
        
        Returns:
            dict: {'cid': str, 'ipfs_url': str}
        """
        pinata_metadata = {
            "name": name,
            "keyvalues": {
                "type": "nft-metadata"
            }
        }
        
        payload = {
            "pinataContent": metadata,
            "pinataMetadata": pinata_metadata,
            "pinataOptions": {
                "cidVersion": 1
            }
        }
        
        import requests
        headers = {
            "Authorization": f"Bearer {self.uploader.jwt}",
            "Content-Type": "application/json"
        }
        
        print(f"📤 메타데이터 IPFS 업로드 중...")
        
        response = requests.post(
            self.uploader.pin_json_url,
            headers=headers,
            json=payload,
            timeout=30
        )
        response.raise_for_status()
        result = response.json()
        
        cid = result['IpfsHash']
        return {
            'cid': cid,
            'ipfs_url': f"ipfs://{cid}",
            'gateway_url': f"https://gateway.pinata.cloud/ipfs/{cid}"
        }
    
    def process_nft(
        self,
        token_id: int,
        image_path: str,
        name: str,
        description: str,
        attributes: list = None,
        external_url: str = None
    ) -> dict:
        """
        이미지 업로드 → 메타데이터 생성 → 메타데이터 업로드 전체 파이프라인
        
        Returns:
            dict: 전체 처리 결과 (이미지 CID, 메타데이터 CID, tokenURI 포함)
        """
        print(f"\n{'='*50}")
        print(f"🚀 NFT #{token_id} 처리 시작: {name}")
        print(f"{'='*50}")
        
        # 1단계: 이미지 IPFS 업로드
        print("\n[1/3] 이미지 업로드 중...")
        image_result = self.uploader.upload_image(image_path, name)
        print(f"✅ 이미지 CID: {image_result['cid']}")
        
        # 2단계: 메타데이터 생성
        print("\n[2/3] 메타데이터 생성 중...")
        metadata = self.create_metadata(
            token_id=token_id,
            name=name,
            description=description,
            image_cid=image_result['cid'],
            attributes=attributes,
            external_url=external_url
        )
        
        # 로컬 저장
        self.save_metadata_locally(token_id, metadata)
        
        # 3단계: 메타데이터 IPFS 업로드
        print("\n[3/3] 메타데이터 업로드 중...")
        metadata_result = self.upload_metadata_to_ipfs(
            metadata, 
            f"NFT #{token_id} Metadata"
        )
        print(f"✅ 메타데이터 CID: {metadata_result['cid']}")
        
        token_uri = metadata_result['ipfs_url']
        
        print(f"\n🎉 NFT #{token_id} 처리 완료!")
        print(f"tokenURI: {token_uri}")
        
        return {
            'token_id': token_id,
            'name': name,
            'image_cid': image_result['cid'],
            'image_url': image_result['ipfs_url'],
            'metadata_cid': metadata_result['cid'],
            'token_uri': token_uri,
            'gateway_url': metadata_result['gateway_url']
        }

// 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/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";

contract MyNFTCollection is ERC721URIStorage, Ownable {
    using Counters for Counters.Counter;
    Counters.Counter private _tokenIds;
    
    // 민팅 이벤트
    event NFTMinted(
        address indexed to,
        uint256 indexed tokenId,
        string tokenURI
    );
    
    constructor() ERC721("My NFT Collection", "MNFT") Ownable(msg.sender) {}
    
    /**
     * @dev NFT 민팅 함수 (오너만 호출 가능)
     * @param recipient 받을 지갑 주소
     * @param tokenURI IPFS 메타데이터 URI
     */
    function mintNFT(
        address recipient,
        string memory tokenURI
    ) public onlyOwner returns (uint256) {
        _tokenIds.increment();
        uint256 newTokenId = _tokenIds.current();
        
        _safeMint(recipient, newTokenId);
        _setTokenURI(newTokenId, tokenURI);
        
        emit NFTMinted(recipient, newTokenId, tokenURI);
        
        return newTokenId;
    }
    
    /**
     * @dev 배치 민팅 (여러 개 한 번에)
     */
    function batchMint(
        address recipient,
        string[] memory tokenURIs
    ) public onlyOwner returns (uint256[] memory) {
        uint256[] memory tokenIds = new uint256[](tokenURIs.length);
        
        for (uint256 i = 0; i < tokenURIs.length; i++) {
            tokenIds[i] = mintNFT(recipient, tokenURIs[i]);
        }
        
        return tokenIds;
    }
    
    // 현재까지 발행된 총 NFT 수
    function totalSupply() public view returns (uint256) {
        return _tokenIds.current();
    }
}

from web3 import Web3
import os
import json
from dotenv import load_dotenv

load_dotenv()

class NFTMinter:
    """web3.py를 사용한 NFT 민팅 클래스"""
    
    # ERC-721 민팅에 필요한 최소 ABI
    MINT_ABI = [
        {
            "inputs": [
                {"internalType": "address", "name": "recipient", "type": "address"},
                {"internalType": "string", "name": "tokenURI", "type": "string"}
            ],
            "name": "mintNFT",
            "outputs": [{"internalType": "uint256", "name": "", "type": "uint256"}],
            "stateMutability": "nonpayable",
            "type": "function"
        },
        {
            "inputs": [],
            "name": "totalSupply",
            "outputs": [{"internalType": "uint256", "name": "", "type": "uint256"}],
            "stateMutability": "view",
            "type": "function"
        },
        {
            "anonymous": False,
            "inputs": [
                {"indexed": True, "name": "to", "type": "address"},
                {"indexed": True, "name": "tokenId", "type": "uint256"},
                {"indexed": False, "name": "tokenURI", "type": "string"}
            ],
            "name": "NFTMinted",
            "type": "event"
        }
    ]
    
    def __init__(self, network: str = "sepolia"):
        """
        Args:
            network: 'sepolia' (테스트넷) 또는 'mainnet'
        """
        # Infura 또는 Alchemy RPC URL 설정
        if network == "sepolia":
            rpc_url = f"https://sepolia.infura.io/v3/{os.getenv('INFURA_PROJECT_ID')}"
        elif network == "polygon":
            rpc_url = f"https://polygon-mainnet.infura.io/v3/{os.getenv('INFURA_PROJECT_ID')}"
        else:
            rpc_url = f"https://mainnet.infura.io/v3/{os.getenv('INFURA_PROJECT_ID')}"
        
        self.w3 = Web3(Web3.HTTPProvider(rpc_url))
        
        if not self.w3.is_connected():
            raise ConnectionError(f"블록체인 연결 실패: {rpc_url}")
        
        print(f"✅ {network} 네트워크 연결 성공!")
        print(f"현재 블록: {self.w3.eth.block_number}")
        
        # 지갑 설정
        self.private_key = os.getenv("PRIVATE_KEY")
        self.account = self.w3.eth.account.from_key(self.private_key)
        self.wallet_address = self.account.address
        
        print(f"지갑 주소: {self.wallet_address}")
        
        # 컨트랙트 설정
        contract_address = os.getenv("CONTRACT_ADDRESS")
        self.contract = self.w3.eth.contract(
            address=Web3.to_checksum_address(contract_address),
            abi=self.MINT_ABI
        )
    
    def get_balance(self) -> float:
        """지갑 ETH 잔액 확인"""
        balance_wei = self.w3.eth.get_balance(self.wallet_address)
        balance_eth = self.w3.from_wei(balance_wei, 'ether')
        return float(balance_eth)
    
    def estimate_gas(self, recipient: str, token_uri: str) -> int:
        """가스비 예측"""
        return self.contract.functions.mintNFT(
            Web3.to_checksum_address(recipient),
            token_uri
        ).estimate_gas({'from': self.wallet_address})
    
    def mint_nft(self, recipient: str, token_uri: str) -> dict:
        """
        NFT 민팅 실행
        
        Args:
            recipient: NFT를 받을 지갑 주소
            token_uri: IPFS 메타데이터 URI (ipfs://...)
        
        Returns:
            dict: 트랜잭션 결과
        """
        print(f"\n🔨 NFT 민팅 시작...")
        print(f"수신자: {recipient}")
        print(f"tokenURI: {token_uri}")
        
        # 잔액 확인
        balance = self.get_balance()
        print(f"지갑 잔액: {balance:.4f} ETH")
        
        if balance < 0.001:
            raise ValueError("ETH 잔액이 부족해요! 테스트넷 faucet에서 받아와.")
        
        # 가스비 예측
        estimated_gas = self.estimate_gas(recipient, token_uri)
        gas_price = self.w3.eth.gas_price
        gas_cost_eth = self.w3.from_wei(estimated_gas * gas_price, 'ether')
        
        print(f"예상 가스: {estimated_gas}")
        print(f"예상 가스비: {gas_cost_eth:.6f} ETH")
        
        # 트랜잭션 빌드
        nonce = self.w3.eth.get_transaction_count(self.wallet_address)
        
        transaction = self.contract.functions.mintNFT(
            Web3.to_checksum_address(recipient),
            token_uri
        ).build_transaction({
            'from': self.wallet_address,
            'nonce': nonce,
            'gas': int(estimated_gas * 1.2),  # 20% 여유분
            'gasPrice': gas_price,
            'chainId': self.w3.eth.chain_id
        })
        
        # 트랜잭션 서명
        signed_txn = self.w3.eth.account.sign_transaction(
            transaction, 
            private_key=self.private_key
        )
        
        # 트랜잭션 전송
        tx_hash = self.w3.eth.send_raw_transaction(signed_txn.rawTransaction)
        print(f"\n📡 트랜잭션 전송됨!")
        print(f"TX Hash: {tx_hash.hex()}")
        print("⏳ 컨펌 대기 중...")
        
        # 트랜잭션 영수증 대기 (최대 120초)
        receipt = self.w3.eth.wait_for_transaction_receipt(tx_hash, timeout=120)
        
        if receipt['status'] == 1:
            print(f"\n🎉 민팅 성공!")
            print(f"블록 번호: {receipt['blockNumber']}")
            print(f"가스 사용량: {receipt['gasUsed']}")
            
            return {
                'success': True,
                'tx_hash': tx_hash.hex(),
                'block_number': receipt['blockNumber'],
                'gas_used': receipt['gasUsed'],
                'token_uri': token_uri
            }
        else:
            raise Exception(f"트랜잭션 실패! TX: {tx_hash.hex()}")

import json
import csv
from pathlib import Path
from create_metadata import NFTMetadataCreator
from mint_nft import NFTMinter

def load_nft_config(config_file: str) -> list:
    """
    NFT 설정 파일 로드 (JSON 형식)
    
    config.json 예시:
    [
        {
            "token_id": 1,
            "image": "images/nft_001.png",
            "name": "My NFT #001",
            "description": "첫 번째 NFT야!",
            "attributes": [
                {"trait_type": "배경", "value": "파란색"},
                {"trait_type": "희귀도", "value": "레어"}
            ]
        }
    ]
    """
    with open(config_file, 'r', encoding='utf-8') as f:
        return json.load(f)

def save_results(results: list, output_file: str = "mint_results.json"):
    """민팅 결과를 JSON으로 저장"""
    with open(output_file, 'w', encoding='utf-8') as f:
        json.dump(results, f, ensure_ascii=False, indent=2)
    print(f"\n💾 결과 저장 완료: {output_file}")

def main():
    print("🚀 NFT 업로드 & 민팅 시스템 시작!")
    print("="*60)
    
    # 설정 로드
    config = load_nft_config("nft_config.json")
    print(f"총 {len(config)}개 NFT 처리 예정")
    
    # 메타데이터 생성기 초기화
    creator = NFTMetadataCreator()
    
    # 민터 초기화 (테스트넷)
    minter = NFTMinter(network="sepolia")
    
    results = []
    
    for nft_config in config:
        try:
            # 1. 이미지 업로드 + 메타데이터 생성 + IPFS 업로드
            nft_data = creator.process_nft(
                token_id=nft_config['token_id'],
                image_path=nft_config['image'],
                name=nft_config['name'],
                description=nft_config['description'],
                attributes=nft_config.get('attributes', []),
                external_url=nft_config.get('external_url')
            )
            
            # 2. 블록체인 민팅
            mint_result = minter.mint_nft(
                recipient=minter.wallet_address,  # 자기 지갑으로 민팅
                token_uri=nft_data['token_uri']
            )
            
            # 결과 합치기
            final_result = {**nft_data, **mint_result}
            results.append(final_result)
            
            print(f"\n✅ NFT #{nft_config['token_id']} 완료!")
            
        except Exception as e:
            print(f"\n❌ NFT #{nft_config['token_id']} 실패: {str(e)}")
            results.append({
                'token_id': nft_config['token_id'],
                'error': str(e)
            })
    
    # 결과 저장
    save_results(results)
    
    # 요약 출력
    success_count = sum(1 for r in results if 'error' not in r)
    print(f"\n{'='*60}")
    print(f"🏁 처리 완료!")
    print(f"성공: {success_count}/{len(config)}")
    print(f"실패: {len(config) - success_count}/{len(config)}")

if __name__ == "__main__":
    main()

[
    {
        "token_id": 1,
        "image": "images/nft_001.png",
        "name": "파이썬 드래곤 #001",
        "description": "파이썬으로 탄생한 전설의 드래곤. 코드를 먹고 자란다.",
        "external_url": "https://www.jaenung.net",
        "attributes": [
            {"trait_type": "종족", "value": "드래곤"},
            {"trait_type": "원소", "value": "파이어"},
            {"trait_type": "희귀도", "value": "레전더리"},
            {
                "trait_type": "공격력",
                "display_type": "number",
                "value": 95,
                "max_value": 100
            },
            {
                "trait_type": "생성 타임스탬프",
                "display_type": "date",
                "value": 1704067200
            }
        ]
    },
    {
        "token_id": 2,
        "image": "images/nft_002.png",
        "name": "IPFS 마법사 #002",
        "description": "분산 네트워크를 지배하는 마법사. CID를 자유자재로 다룬다.",
        "attributes": [
            {"trait_type": "직업", "value": "마법사"},
            {"trait_type": "원소", "value": "아이스"},
            {"trait_type": "희귀도", "value": "에픽"},
            {
                "trait_type": "마력",
                "display_type": "number",
                "value": 88,
                "max_value": 100
            }
        ]
    }
]

import time
import functools

def retry(max_attempts: int = 3, delay: float = 2.0, backoff: float = 2.0):
    """
    재시도 데코레이터
    네트워크 오류나 일시적 API 오류 시 자동 재시도
    """
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            attempt = 0
            current_delay = delay
            
            while attempt < max_attempts:
                try:
                    return func(*args, **kwargs)
                except (ConnectionError, TimeoutError) as e:
                    attempt += 1
                    if attempt == max_attempts:
                        raise
                    print(f"⚠️ 시도 {attempt}/{max_attempts} 실패: {e}")
                    print(f"⏳ {current_delay}초 후 재시도...")
                    time.sleep(current_delay)
                    current_delay *= backoff  # 지수 백오프
        return wrapper
    return decorator

# 사용 예시
class IPFSUploaderWithRetry(IPFSUploader):
    
    @retry(max_attempts=3, delay=2.0)
    def upload_image(self, image_path: str, nft_name: str = None) -> dict:
        return super().upload_image(image_path, nft_name)

# 트랜잭션 상태 모니터링
def monitor_transaction(w3, tx_hash: str, timeout: int = 300) -> dict:
    """
    트랜잭션 상태를 주기적으로 확인
    
    Args:
        w3: Web3 인스턴스
        tx_hash: 트랜잭션 해시
        timeout: 최대 대기 시간 (초)
    """
    start_time = time.time()
    
    while time.time() - start_time < timeout:
        try:
            receipt = w3.eth.get_transaction_receipt(tx_hash)
            
            if receipt is not None:
                if receipt['status'] == 1:
                    return {'status': 'success', 'receipt': receipt}
                else:
                    return {'status': 'failed', 'receipt': receipt}
            
            # 아직 처리 중
            elapsed = int(time.time() - start_time)
            print(f"⏳ 대기 중... ({elapsed}초 경과)")
            time.sleep(5)
            
        except Exception as e:
            print(f"⚠️ 상태 확인 오류: {e}")
            time.sleep(5)
    
    return {'status': 'timeout', 'tx_hash': tx_hash}

import asyncio
import aiohttp
import aiofiles
import os
from pathlib import Path

class AsyncIPFSUploader:
    """비동기 IPFS 업로드 클래스 - 대량 업로드에 최적화"""
    
    def __init__(self, max_concurrent: int = 5):
        """
        Args:
            max_concurrent: 동시 업로드 최대 수 (Pinata 무료 플랜: 5 권장)
        """
        self.jwt = os.getenv("PINATA_JWT")
        self.pin_file_url = "https://api.pinata.cloud/pinning/pinFileToIPFS"
        self.semaphore = asyncio.Semaphore(max_concurrent)
    
    async def upload_single(
        self, 
        session: aiohttp.ClientSession, 
        image_path: str,
        index: int
    ) -> dict:
        """단일 이미지 비동기 업로드"""
        async with self.semaphore:  # 동시 요청 수 제한
            path = Path(image_path)
            
            async with aiofiles.open(image_path, 'rb') as f:
                file_data = await f.read()
            
            form_data = aiohttp.FormData()
            form_data.add_field(
                'file',
                file_data,
                filename=path.name,
                content_type='image/png'
            )
            form_data.add_field(
                'pinataMetadata',
                f'{{"name": "NFT #{index}"}}'
            )
            
            headers = {"Authorization": f"Bearer {self.jwt}"}
            
            async with session.post(
                self.pin_file_url,
                headers=headers,
                data=form_data,
                timeout=aiohttp.ClientTimeout(total=60)
            ) as response:
                result = await response.json()
                return {
                    'index': index,
                    'filename': path.name,
                    'cid': result['IpfsHash'],
                    'ipfs_url': f"ipfs://{result['IpfsHash']}"
                }
    
    async def upload_batch_async(self, image_paths: list) -> list:
        """여러 이미지 비동기 병렬 업로드"""
        async with aiohttp.ClientSession() as session:
            tasks = [
                self.upload_single(session, path, idx+1)
                for idx, path in enumerate(image_paths)
            ]
            
            # 진행 상황 표시와 함께 실행
            results = []
            for coro in asyncio.as_completed(tasks):
                result = await coro
                results.append(result)
                print(f"✅ [{len(results)}/{len(tasks)}] {result['filename']} 완료")
            
            return sorted(results, key=lambda x: x['index'])

# 실행 예시
async def main_async():
    uploader = AsyncIPFSUploader(max_concurrent=5)
    
    # 이미지 목록 가져오기
    images = list(Path("images").glob("*.png"))
    image_paths = [str(img) for img in sorted(images)]
    
    print(f"🚀 {len(image_paths)}개 이미지 비동기 업로드 시작!")
    
    results = await uploader.upload_batch_async(image_paths)
    
    print(f"\n🎉 완료! {len(results)}개 업로드됨")
    return results

# asyncio 실행
if __name__ == "__main__":
    results = asyncio.run(main_async())

from PIL import Image
import random
import os
from pathlib import Path

class NFTImageGenerator:
    """레이어 기반 NFT 이미지 자동 생성기"""
    
    def __init__(self, layers_dir: str, output_dir: str, size: tuple = (1000, 1000)):
        """
        Args:
            layers_dir: 레이어 폴더 경로
            output_dir: 생성된 이미지 저장 폴더
            size: 이미지 크기 (width, height)
        
        레이어 폴더 구조:
        layers/
        ├── 01_background/    (배경)
        │   ├── blue.png
        │   └── red.png
        ├── 02_body/          (몸통)
        │   ├── normal.png
        │   └── robot.png
        ├── 03_eyes/          (눈)
        │   ├── happy.png
        │   └── sad.png
        └── 04_accessory/     (악세서리)
            ├── hat.png
            └── glasses.png
        """
        self.layers_dir = Path(layers_dir)
        self.output_dir = Path(output_dir)
        self.output_dir.mkdir(exist_ok=True)
        self.size = size
        
        # 레이어 로드 (폴더명 순서대로 정렬)
        self.layers = self._load_layers()
        print(f"✅ {len(self.layers)}개 레이어 로드 완료")
    
    def _load_layers(self) -> dict:
        """레이어 폴더 구조 로드"""
        layers = {}
        
        for layer_dir in sorted(self.layers_dir.iterdir()):
            if layer_dir.is_dir():
                layer_name = layer_dir.name.split('_', 1)[-1]  # 번호 제거
                traits = list(layer_dir.glob("*.png"))
                
                if traits:
                    layers[layer_name] = traits
                    print(f"  레이어 '{layer_name}': {len(traits)}개 트레잇")
        
        return layers
    
    def generate_single(self, token_id: int, seed: int = None) -> dict:
        """
        단일 NFT 이미지 생성
        
        Returns:
            dict: {'image_path': str, 'attributes': list}
        """
        if seed:
            random.seed(seed)
        
        # 베이스 이미지 (투명 배경)
        composite = Image.new('RGBA', self.size, (0, 0, 0, 0))
        
        selected_traits = {}
        attributes = []
        
        for layer_name, trait_files in self.layers.items():
            # 랜덤으로 트레잇 선택
            selected_file = random.choice(trait_files)
            trait_name = selected_file.stem  # 파일명 (확장자 제외)
            
            # 레이어 합성
            layer_img = Image.open(selected_file).convert('RGBA')
            layer_img = layer_img.resize(self.size, Image.LANCZOS)
            composite = Image.alpha_composite(composite, layer_img)
            
            selected_traits[layer_name] = trait_name
            attributes.append({
                "trait_type": layer_name,
                "value": trait_name
            })
        
        # PNG로 저장
        output_path = self.output_dir / f"{token_id}.png"
        composite.convert('RGB').save(output_path, 'PNG', optimize=True)
        
        return {
            'image_path': str(output_path),
            'attributes': attributes,
            'traits': selected_traits
        }
    
    def generate_collection(
        self, 
        count: int, 
        ensure_unique: bool = True
    ) -> list:
        """
        NFT 컬렉션 전체 생성
        
        Args:
            count: 생성할 NFT 수
            ensure_unique: 중복 조합 방지 여부
        """
        print(f"\n🎨 {count}개 NFT 이미지 생성 시작!")
        
        generated = []
        used_combinations = set()
        
        for i in range(1, count + 1):
            attempts = 0
            
            while True:
                result = self.generate_single(i)
                
                # 중복 체크
                combo_key = str(sorted(result['traits'].items()))
                
                if not ensure_unique or combo_key not in used_combinations:
                    used_combinations.add(combo_key)
                    result['token_id'] = i
                    generated.append(result)
                    
                    if i % 100 == 0:
                        print(f"  진행: {i}/{count}")
                    break
                
                attempts += 1
                if attempts > 100:
                    print(f"⚠️ #{i}: 고유 조합 찾기 실패, 중복 허용")
                    result['token_id'] = i
                    generated.append(result)
                    break
        
        print(f"✅ {len(generated)}개 이미지 생성 완료!")
        return generated

# 네트워크별 설정 딕셔너리
NETWORK_CONFIG = {
    "ethereum": {
        "rpc": f"https://mainnet.infura.io/v3/{os.getenv('INFURA_PROJECT_ID')}",
        "chain_id": 1,
        "explorer": "https://etherscan.io"
    },
    "polygon": {
        "rpc": "https://polygon-rpc.com",
        "chain_id": 137,
        "explorer": "https://polygonscan.com"
    },
    "arbitrum": {
        "rpc": "https://arb1.arbitrum.io/rpc",
        "chain_id": 42161,
        "explorer": "https://arbiscan.io"
    },
    "sepolia": {
        "rpc": f"https://sepolia.infura.io/v3/{os.getenv('INFURA_PROJECT_ID')}",
        "chain_id": 11155111,
        "explorer": "https://sepolia.etherscan.io"
    }
}

def get_minter(network: str) -> NFTMinter:
    """네트워크 이름으로 민터 인스턴스 생성"""
    config = NETWORK_CONFIG.get(network)
    if not config:
        raise ValueError(f"지원하지 않는 네트워크: {network}")
    
    w3 = Web3(Web3.HTTPProvider(config['rpc']))
    # ... 나머지 설정
    return minter

# 자주 쓰는 디버깅 유틸리티

def check_ipfs_availability(cid: str, timeout: int = 10) -> bool:
    """IPFS CID 접근 가능 여부 확인"""
    gateways = [
        f"https://gateway.pinata.cloud/ipfs/{cid}",
        f"https://ipfs.io/ipfs/{cid}",
        f"https://cloudflare-ipfs.com/ipfs/{cid}"
    ]
    
    for gateway in gateways:
        try:
            response = requests.head(gateway, timeout=timeout)
            if response.status_code == 200:
                print(f"✅ 접근 가능: {gateway}")
                return True
        except:
            pass
    
    print(f"❌ 모든 게이트웨이에서 접근 불가: {cid}")
    return False

def verify_metadata(token_uri: str) -> dict:
    """tokenURI의 메타데이터 내용 검증"""
    # ipfs:// → https:// 변환
    if token_uri.startswith("ipfs://"):
        cid = token_uri.replace("ipfs://", "")
        url = f"https://gateway.pinata.cloud/ipfs/{cid}"
    else:
        url = token_uri
    
    response = requests.get(url, timeout=30)
    response.raise_for_status()
    metadata = response.json()
    
    # 필수 필드 확인
    required_fields = ['name', 'description', 'image']
    missing = [f for f in required_fields if f not in metadata]
    
    if missing:
        print(f"⚠️ 누락된 필드: {missing}")
    else:
        print(f"✅ 메타데이터 검증 완료!")
        print(f"  이름: {metadata['name']}")
        print(f"  이미지: {metadata['image']}")
    
    return metadata