pip install fastapi uvicorn web3 python-dotenv redis pydantic aiohttp

blockchain-validator/
├── app/
│   ├── __init__.py
│   ├── main.py              # FastAPI 애플리케이션 진입점
│   ├── config.py            # 설정 관리
│   ├── models/
│   │   ├── __init__.py
│   │   ├── blockchain.py    # 블록체인 데이터 모델
│   │   └── response.py      # API 응답 모델
│   ├── services/
│   │   ├── __init__.py
│   │   ├── blockchain.py    # 블록체인 서비스 로직
│   │   ├── validator.py     # 검증 로직
│   │   └── cache.py         # 캐싱 로직
│   ├── api/
│   │   ├── __init__.py
│   │   ├── routes.py        # API 라우트
│   │   └── dependencies.py  # 의존성 주입
│   └── utils/
│       ├── __init__.py
│       ├── helpers.py       # 헬퍼 함수들
│       └── exceptions.py    # 커스텀 예외
├── tests/
│   ├── __init__.py
│   └── test_validator.py
├── .env                      # 환경 변수
├── requirements.txt
└── README.md

# .env
ETHEREUM_RPC_URL=https://mainnet.infura.io/v3/YOUR_PROJECT_ID
REDIS_HOST=localhost
REDIS_PORT=6379
REDIS_DB=0
CACHE_TTL=300
API_KEY=your_secret_api_key_here

from pydantic import BaseSettings
from functools import lru_cache

class Settings(BaseSettings):
    ethereum_rpc_url: str
    redis_host: str = "localhost"
    redis_port: int = 6379
    redis_db: int = 0
    cache_ttl: int = 300
    api_key: str
    
    class Config:
        env_file = ".env"

@lru_cache()
def get_settings():
    return Settings()

settings = get_settings()

from web3 import Web3
from web3.middleware import geth_poa_middleware
from app.config import settings
import logging

logger = logging.getLogger(__name__)

class BlockchainService:
    def __init__(self):
        self.w3 = Web3(Web3.HTTPProvider(settings.ethereum_rpc_url))
        
        # PoA 네트워크를 위한 미들웨어 추가 (필요시)
        self.w3.middleware_onion.inject(geth_poa_middleware, layer=0)
        
        if not self.w3.is_connected():
            raise ConnectionError("블록체인 노드에 연결할 수 없습니다")
        
        logger.info("블록체인 노드 연결 성공")
    
    async def get_block(self, block_number: int):
        """특정 블록 정보 조회"""
        try:
            block = self.w3.eth.get_block(block_number)
            return block
        except Exception as e:
            logger.error(f"블록 조회 실패: {e}")
            raise
    
    async def get_transaction(self, tx_hash: str):
        """트랜잭션 정보 조회"""
        try:
            tx = self.w3.eth.get_transaction(tx_hash)
            return tx
        except Exception as e:
            logger.error(f"트랜잭션 조회 실패: {e}")
            raise
    
    async def get_latest_block_number(self):
        """최신 블록 번호 조회"""
        return self.w3.eth.block_number
    
    def verify_transaction_hash(self, tx_hash: str) -> bool:
        """트랜잭션 해시 형식 검증"""
        return self.w3.is_address(tx_hash) or len(tx_hash) == 66

blockchain_service = BlockchainService()

from typing import Dict, Any, Optional
from web3 import Web3
from app.services.blockchain import blockchain_service
import hashlib
import logging

logger = logging.getLogger(__name__)

class BlockchainValidator:
    
    @staticmethod
    def verify_block_hash(block_data: Dict[str, Any]) -> bool:
        """블록 해시 검증"""
        try:
            # 블록 데이터에서 해시 제외
            block_without_hash = {
                k: v for k, v in block_data.items() 
                if k not in ['hash', 'proofOfWork']
            }
            
            # 블록 데이터를 문자열로 변환
            block_string = str(sorted(block_without_hash.items()))
            
            # SHA-256 해시 계산
            calculated_hash = hashlib.sha256(
                block_string.encode()
            ).hexdigest()
            
            # 원본 해시와 비교
            original_hash = block_data.get('hash', '').replace('0x', '')
            
            return calculated_hash == original_hash
            
        except Exception as e:
            logger.error(f"블록 해시 검증 실패: {e}")
            return False
    
    @staticmethod
    async def verify_transaction_inclusion(
        tx_hash: str, 
        block_number: int
    ) -> bool:
        """트랜잭션이 특정 블록에 포함되어 있는지 검증"""
        try:
            # 트랜잭션 정보 조회
            tx = await blockchain_service.get_transaction(tx_hash)
            
            if tx is None:
                return False
            
            # 블록 번호 확인
            return tx.get('blockNumber') == block_number
            
        except Exception as e:
            logger.error(f"트랜잭션 포함 검증 실패: {e}")
            return False
    
    @staticmethod
    async def verify_transaction_receipt(tx_hash: str) -> Dict[str, Any]:
        """트랜잭션 영수증 검증 및 상태 확인"""
        try:
            w3 = blockchain_service.w3
            receipt = w3.eth.get_transaction_receipt(tx_hash)
            
            if receipt is None:
                return {
                    "valid": False,
                    "status": "not_found",
                    "message": "트랜잭션을 찾을 수 없습니다"
                }
            
            # 트랜잭션 성공 여부 확인
            status = receipt.get('status', 0)
            
            return {
                "valid": True,
                "status": "success" if status == 1 else "failed",
                "block_number": receipt.get('blockNumber'),
                "gas_used": receipt.get('gasUsed'),
                "confirmations": await blockchain_service.get_latest_block_number() 
                                - receipt.get('blockNumber')
            }
            
        except Exception as e:
            logger.error(f"트랜잭션 영수증 검증 실패: {e}")
            return {
                "valid": False,
                "status": "error",
                "message": str(e)
            }
    
    @staticmethod
    def verify_address_format(address: str) -> bool:
        """이더리움 주소 형식 검증"""
        try:
            return Web3.is_address(address)
        except:
            return False
    
    @staticmethod
    def verify_signature(
        message: str, 
        signature: str, 
        expected_address: str
    ) -> bool:
        """메시지 서명 검증"""
        try:
            w3 = blockchain_service.w3
            
            # 메시지 해시 생성
            message_hash = Web3.keccak(text=message)
            
            # 서명에서 주소 복구
            recovered_address = w3.eth.account.recover_message(
                message_hash,
                signature=signature
            )
            
            # 예상 주소와 비교
            return recovered_address.lower() == expected_address.lower()
            
        except Exception as e:
            logger.error(f"서명 검증 실패: {e}")
            return False

validator = BlockchainValidator()

import redis
import json
from typing import Optional, Any
from app.config import settings
import logging

logger = logging.getLogger(__name__)

class CacheService:
    def __init__(self):
        self.redis_client = redis.Redis(
            host=settings.redis_host,
            port=settings.redis_port,
            db=settings.redis_db,
            decode_responses=True
        )
        
        # 연결 테스트
        try:
            self.redis_client.ping()
            logger.info("Redis 연결 성공")
        except redis.ConnectionError:
            logger.error("Redis 연결 실패")
            raise
    
    def get(self, key: str) -> Optional[Any]:
        """캐시에서 데이터 조회"""
        try:
            data = self.redis_client.get(key)
            if data:
                return json.loads(data)
            return None
        except Exception as e:
            logger.error(f"캐시 조회 실패: {e}")
            return None
    
    def set(
        self, 
        key: str, 
        value: Any, 
        ttl: Optional[int] = None
    ) -> bool:
        """캐시에 데이터 저장"""
        try:
            ttl = ttl or settings.cache_ttl
            serialized = json.dumps(value, default=str)
            self.redis_client.setex(key, ttl, serialized)
            return True
        except Exception as e:
            logger.error(f"캐시 저장 실패: {e}")
            return False
    
    def delete(self, key: str) -> bool:
        """캐시에서 데이터 삭제"""
        try:
            self.redis_client.delete(key)
            return True
        except Exception as e:
            logger.error(f"캐시 삭제 실패: {e}")
            return False
    
    def exists(self, key: str) -> bool:
        """캐시에 키가 존재하는지 확인"""
        try:
            return self.redis_client.exists(key) > 0
        except Exception as e:
            logger.error(f"캐시 존재 확인 실패: {e}")
            return False
    
    def get_or_set(
        self, 
        key: str, 
        fetch_func, 
        ttl: Optional[int] = None
    ) -> Optional[Any]:
        """캐시에서 조회하고, 없으면 fetch_func 실행 후 저장"""
        cached = self.get(key)
        if cached is not None:
            logger.info(f"캐시 히트: {key}")
            return cached
        
        logger.info(f"캐시 미스: {key}")
        data = fetch_func()
        
        if data is not None:
            self.set(key, data, ttl)
        
        return data

cache_service = CacheService()

from pydantic import BaseModel, Field, validator
from typing import Optional, List
from datetime import datetime

class BlockModel(BaseModel):
    number: int = Field(..., description="블록 번호")
    hash: str = Field(..., description="블록 해시")
    parent_hash: str = Field(..., description="이전 블록 해시")
    timestamp: int = Field(..., description="블록 생성 시간")
    transactions: List[str] = Field(default=[], description="트랜잭션 목록")
    miner: str = Field(..., description="채굴자 주소")
    difficulty: int = Field(..., description="난이도")
    gas_used: int = Field(..., description="사용된 가스")
    gas_limit: int = Field(..., description="가스 한도")
    
    @validator('hash', 'parent_hash')
    def validate_hash(cls, v):
        if not v.startswith('0x') or len(v) != 66:
            raise ValueError('유효하지 않은 해시 형식')
        return v

class TransactionModel(BaseModel):
    hash: str = Field(..., description="트랜잭션 해시")
    from_address: str = Field(..., alias="from", description="발신자 주소")
    to_address: Optional[str] = Field(None, alias="to", description="수신자 주소")
    value: int = Field(..., description="전송 금액 (wei)")
    gas: int = Field(..., description="가스 한도")
    gas_price: int = Field(..., description="가스 가격")
    nonce: int = Field(..., description="논스")
    block_number: Optional[int] = Field(None, description="블록 번호")
    
    class Config:
        allow_population_by_field_name = True

class ValidationRequest(BaseModel):
    tx_hash: str = Field(..., description="검증할 트랜잭션 해시")
    block_number: Optional[int] = Field(None, description="블록 번호")
    
    @validator('tx_hash')
    def validate_tx_hash(cls, v):
        if not v.startswith('0x') or len(v) != 66:
            raise ValueError('유효하지 않은 트랜잭션 해시')
        return v

class ValidationResponse(BaseModel):
    valid: bool = Field(..., description="검증 결과")
    status: str = Field(..., description="상태")
    message: Optional[str] = Field(None, description="메시지")
    data: Optional[dict] = Field(None, description="추가 데이터")
    timestamp: datetime = Field(default_factory=datetime.now)

from fastapi import APIRouter, HTTPException, Depends, Header
from typing import Optional
from app.models.blockchain import (
    ValidationRequest, 
    ValidationResponse,
    BlockModel,
    TransactionModel
)
from app.services.blockchain import blockchain_service
from app.services.validator import validator
from app.services.cache import cache_service
from app.config import settings
import logging

logger = logging.getLogger(__name__)
router = APIRouter(prefix="/api/v1", tags=["blockchain"])

async def verify_api_key(x_api_key: str = Header(...)):
    """API 키 검증"""
    if x_api_key != settings.api_key:
        raise HTTPException(status_code=401, detail="유효하지 않은 API 키")
    return x_api_key

@router.get("/block/{block_number}", response_model=BlockModel)
async def get_block(
    block_number: int,
    api_key: str = Depends(verify_api_key)
):
    """특정 블록 정보 조회"""
    try:
        cache_key = f"block:{block_number}"
        
        # 캐시에서 조회
        cached_block = cache_service.get(cache_key)
        if cached_block:
            return cached_block
        
        # 블록체인에서 조회
        block = await blockchain_service.get_block(block_number)
        
        if block is None:
            raise HTTPException(
                status_code=404, 
                detail="블록을 찾을 수 없습니다"
            )
        
        # 블록 데이터 변환
        block_data = {
            "number": block.number,
            "hash": block.hash.hex(),
            "parent_hash": block.parentHash.hex(),
            "timestamp": block.timestamp,
            "transactions": [tx.hex() for tx in block.transactions],
            "miner": block.miner,
            "difficulty": block.difficulty,
            "gas_used": block.gasUsed,
            "gas_limit": block.gasLimit
        }
        
        # 캐시에 저장 (확정된 블록은 긴 TTL)
        cache_service.set(cache_key, block_data, ttl=3600)
        
        return block_data
        
    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"블록 조회 실패: {e}")
        raise HTTPException(status_code=500, detail="서버 오류")

@router.get("/transaction/{tx_hash}", response_model=TransactionModel)
async def get_transaction(
    tx_hash: str,
    api_key: str = Depends(verify_api_key)
):
    """트랜잭션 정보 조회"""
    try:
        cache_key = f"tx:{tx_hash}"
        
        # 캐시 확인
        cached_tx = cache_service.get(cache_key)
        if cached_tx:
            return cached_tx
        
        # 블록체인에서 조회
        tx = await blockchain_service.get_transaction(tx_hash)
        
        if tx is None:
            raise HTTPException(
                status_code=404,
                detail="트랜잭션을 찾을 수 없습니다"
            )
        
        # 트랜잭션 데이터 변환
        tx_data = {
            "hash": tx.hash.hex(),
            "from": tx["from"],
            "to": tx.get("to"),
            "value": tx.value,
            "gas": tx.gas,
            "gas_price": tx.gasPrice,
            "nonce": tx.nonce,
            "block_number": tx.get("blockNumber")
        }
        
        # 캐시 저장
        cache_service.set(cache_key, tx_data, ttl=1800)
        
        return tx_data
        
    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"트랜잭션 조회 실패: {e}")
        raise HTTPException(status_code=500, detail="서버 오류")

@router.post("/validate/transaction", response_model=ValidationResponse)
async def validate_transaction(
    request: ValidationRequest,
    api_key: str = Depends(verify_api_key)
):
    """트랜잭션 검증"""
    try:
        # 트랜잭션 영수증 검증
        result = await validator.verify_transaction_receipt(
            request.tx_hash
        )
        
        # 블록 번호가 제공된 경우 추가 검증
        if request.block_number:
            inclusion = await validator.verify_transaction_inclusion(
                request.tx_hash,
                request.block_number
            )
            result["block_inclusion"] = inclusion
        
        return ValidationResponse(
            valid=result.get("valid", False),
            status=result.get("status", "unknown"),
            message=result.get("message"),
            data=result
        )
        
    except Exception as e:
        logger.error(f"트랜잭션 검증 실패: {e}")
        raise HTTPException(status_code=500, detail="검증 실패")

@router.post("/validate/signature")
async def validate_signature(
    message: str,
    signature: str,
    address: str,
    api_key: str = Depends(verify_api_key)
):
    """서명 검증"""
    try:
        # 주소 형식 검증
        if not validator.verify_address_format(address):
            raise HTTPException(
                status_code=400,
                detail="유효하지 않은 주소 형식"
            )
        
        # 서명 검증
        is_valid = validator.verify_signature(
            message,
            signature,
            address
        )
        
        return {
            "valid": is_valid,
            "message": "서명이 유효합니다" if is_valid else "서명이 유효하지 않습니다"
        }
        
    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"서명 검증 실패: {e}")
        raise HTTPException(status_code=500, detail="검증 실패")

@router.get("/stats")
async def get_stats(api_key: str = Depends(verify_api_key)):
    """블록체인 통계 정보"""
    try:
        latest_block = await blockchain_service.get_latest_block_number()
        
        return {
            "latest_block": latest_block,
            "network": "ethereum",
            "status": "connected"
        }
        
    except Exception as e:
        logger.error(f"통계 조회 실패: {e}")
        raise HTTPException(status_code=500, detail="서버 오류")

from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import JSONResponse
import logging
from app.api.routes import router
from app.config import settings

# 로깅 설정
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)

logger = logging.getLogger(__name__)

# FastAPI 앱 생성
app = FastAPI(
    title="Blockchain Data Validator",
    description="블록체인 데이터 검증 API 서버",
    version="1.0.0",
    docs_url="/docs",
    redoc_url="/redoc"
)

# CORS 설정
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],  # 프로덕션에서는 특정 도메인만 허용
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# 라우터 등록
app.include_router(router)

@app.on_event("startup")
async def startup_event():
    """서버 시작 시 실행"""
    logger.info("🚀 블록체인 검증 서버 시작")
    logger.info(f"📡 RPC URL: {settings.ethereum_rpc_url}")

@app.on_event("shutdown")
async def shutdown_event():
    """서버 종료 시 실행"""
    logger.info("👋 서버 종료")

@app.get("/")
async def root():
    """루트 엔드포인트"""
    return {
        "message": "Blockchain Data Validator API",
        "version": "1.0.0",
        "docs": "/docs"
    }

@app.get("/health")
async def health_check():
    """헬스 체크"""
    return {
        "status": "healthy",
        "service": "blockchain-validator"
    }

# 전역 예외 핸들러
@app.exception_handler(Exception)
async def global_exception_handler(request, exc):
    logger.error(f"예상치 못한 오류: {exc}")
    return JSONResponse(
        status_code=500,
        content={
            "detail": "서버 내부 오류가 발생했습니다",
            "type": type(exc).__name__
        }
    )

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(
        "app.main:app",
        host="0.0.0.0",
        port=8000,
        reload=True,  # 개발 모드에서만 사용
        log_level="info"
    )

import pytest
from fastapi.testclient import TestClient
from app.main import app
from app.services.validator import validator

client = TestClient(app)

# 테스트용 API 키
TEST_API_KEY = "test_api_key_12345"

def test_health_check():
    """헬스 체크 테스트"""
    response = client.get("/health")
    assert response.status_code == 200
    assert response.json()["status"] == "healthy"

def test_get_block_without_api_key():
    """API 키 없이 블록 조회 시도"""
    response = client.get("/api/v1/block/1")
    assert response.status_code == 401

def test_verify_address_format():
    """주소 형식 검증 테스트"""
    valid_address = "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb"
    invalid_address = "invalid_address"
    
    assert validator.verify_address_format(valid_address) == True
    assert validator.verify_address_format(invalid_address) == False

def test_transaction_hash_validation():
    """트랜잭션 해시 검증 테스트"""
    valid_hash = "0x" + "a" * 64
    invalid_hash = "0x123"
    
    from app.services.blockchain import blockchain_service
    
    assert blockchain_service.verify_transaction_hash(valid_hash) == True
    assert blockchain_service.verify_transaction_hash(invalid_hash) == False

@pytest.mark.asyncio
async def test_get_latest_block_number():
    """최신 블록 번호 조회 테스트"""
    from app.services.blockchain import blockchain_service
    
    block_number = await blockchain_service.get_latest_block_number()
    assert isinstance(block_number, int)
    assert block_number > 0

def test_cache_operations():
    """캐시 작동 테스트"""
    from app.services.cache import cache_service
    
    test_key = "test:key"
    test_value = {"data": "test"}
    
    # 저장
    cache_service.set(test_key, test_value, ttl=60)
    
    # 조회
    cached = cache_service.get(test_key)
    assert cached == test_value
    
    # 삭제
    cache_service.delete(test_key)
    assert cache_service.get(test_key) is None

pytest tests/ -v

import asyncio
from typing import List

async def get_multiple_blocks(block_numbers: List[int]):
    """여러 블록을 동시에 조회"""
    tasks = [
        blockchain_service.get_block(num) 
        for num in block_numbers
    ]
    
    # 모든 블록을 동시에 조회
    blocks = await asyncio.gather(*tasks)
    return blocks

from web3 import Web3, HTTPProvider
from web3.providers.rpc import HTTPProvider as BaseHTTPProvider

class PooledHTTPProvider(BaseHTTPProvider):
    def __init__(self, endpoint_uri, request_kwargs=None):
        if request_kwargs is None:
            request_kwargs = {}
        
        # 연결 풀 설정
        request_kwargs['pool_connections'] = 10
        request_kwargs['pool_maxsize'] = 50
        
        super().__init__(endpoint_uri, request_kwargs)

@router.post("/validate/batch")
async def validate_batch(
    tx_hashes: List[str],
    api_key: str = Depends(verify_api_key)
):
    """여러 트랜잭션을 한 번에 검증"""
    results = []
    
    for tx_hash in tx_hashes:
        result = await validator.verify_transaction_receipt(tx_hash)
        results.append({
            "tx_hash": tx_hash,
            "result": result
        })
    
    return {"results": results}

async def warm_cache():
    """자주 사용되는 데이터를 미리 캐싱"""
    latest_block = await blockchain_service.get_latest_block_number()
    
    # 최근 100개 블록을 캐싱
    for i in range(100):
        block_num = latest_block - i
        cache_key = f"block:{block_num}"
        
        if not cache_service.exists(cache_key):
            block = await blockchain_service.get_block(block_num)
            cache_service.set(cache_key, block, ttl=3600)

from slowapi import Limiter, _rate_limit_exceeded_handler
from slowapi.util import get_remote_address
from slowapi.errors import RateLimitExceeded

limiter = Limiter(key_func=get_remote_address)
app.state.limiter = limiter
app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)

@router.get("/block/{block_number}")
@limiter.limit("10/minute")
async def get_block_with_limit(
    request: Request,
    block_number: int,
    api_key: str = Depends(verify_api_key)
):
    # 기존 로직...

from pydantic import validator, Field

class SecureValidationRequest(BaseModel):
    tx_hash: str = Field(..., min_length=66, max_length=66)
    
    @validator('tx_hash')
    def validate_tx_hash(cls, v):
        # 16진수 문자만 허용
        if not v.startswith('0x'):
            raise ValueError('트랜잭션 해시는 0x로 시작해야 합니다')
        
        hex_part = v[2:]
        if not all(c in '0123456789abcdefABCDEF' for c in hex_part):
            raise ValueError('유효하지 않은 16진수 형식')
        
        return v.lower()

from sqlalchemy import create_engine, Column, String, Integer
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

Base = declarative_base()

class Transaction(Base):
    __tablename__ = 'transactions'
    
    id = Column(Integer, primary_key=True)
    tx_hash = Column(String, unique=True)
    block_number = Column(Integer)
    status = Column(String)

# 안전한 쿼리
def get_transaction_safe(tx_hash: str):
    session = Session()
    return session.query(Transaction).filter(
        Transaction.tx_hash == tx_hash
    ).first()

FROM python:3.9-slim

WORKDIR /app

# 의존성 설치
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# 애플리케이션 코드 복사
COPY . .

# 포트 노출
EXPOSE 8000

# 서버 실행
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

version: '3.8'

services:
  api:
    build: .
    ports:
      - "8000:8000"
    environment:
      - ETHEREUM_RPC_URL=${ETHEREUM_RPC_URL}
      - REDIS_HOST=redis
      - REDIS_PORT=6379
    depends_on:
      - redis
    restart: unless-stopped
  
  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data
    restart: unless-stopped

volumes:
  redis_data:

# 이미지 빌드
docker-compose build

# 서비스 시작
docker-compose up -d

# 로그 확인
docker-compose logs -f api

import structlog
from datetime import datetime

# 구조화된 로거 설정
structlog.configure(
    processors=[
        structlog.stdlib.filter_by_level,
        structlog.stdlib.add_logger_name,
        structlog.stdlib.add_log_level,
        structlog.stdlib.PositionalArgumentsFormatter(),
        structlog.processors.TimeStamper(fmt="iso"),
        structlog.processors.StackInfoRenderer(),
        structlog.processors.format_exc_info,
        structlog.processors.JSONRenderer()
    ],
    wrapper_class=structlog.stdlib.BoundLogger,
    logger_factory=structlog.stdlib.LoggerFactory(),
)

logger = structlog.get_logger()

# 사용 예시
logger.info(
    "block_retrieved",
    block_number=12345,
    tx_count=150,
    gas_used=8000000,
    duration_ms=250
)

from prometheus_client import Counter, Histogram, Gauge
import time

# 메트릭 정의
request_count = Counter(
    'api_requests_total',
    'Total API requests',
    ['method', 'endpoint', 'status']
)

request_duration = Histogram(
    'api_request_duration_seconds',
    'API request duration',
    ['method', 'endpoint']
)

cache_hit_rate = Gauge(
    'cache_hit_rate',
    'Cache hit rate'
)

# 미들웨어로 메트릭 수집
@app.middleware("http")
async def metrics_middleware(request, call_next):
    start_time = time.time()
    
    response = await call_next(request)
    
    duration = time.time() - start_time
    
    request_count.labels(
        method=request.method,
        endpoint=request.url.path,
        status=response.status_code
    ).inc()
    
    request_duration.labels(
        method=request.method,
        endpoint=request.url.path
    ).observe(duration)
    
    return response

async def verify_nft_purchase(tx_hash: str, buyer_address: str):
    """NFT 구매 트랜잭션 검증"""
    
    # 트랜잭션 영수증 확인
    receipt = await validator.verify_transaction_receipt(tx_hash)
    
    if not receipt['valid']:
        return {"success": False, "message": "유효하지 않은 트랜잭션"}
    
    # 트랜잭션 상세 정보 조회
    tx = await blockchain_service.get_transaction(tx_hash)
    
    # 구매자 주소 확인
    if tx['from'].lower() != buyer_address.lower():
        return {"success": False, "message": "구매자 주소 불일치"}
    
    # 컨펌 수 확인 (최소 12개 권장)
    if receipt['confirmations'] < 12:
        return {
            "success": False,
            "message": f"컨펌 대기 중 ({receipt['confirmations']}/12)"
        }
    
    return {
        "success": True,
        "message": "NFT 구매 확인됨",
        "data": receipt
    }

async def verify_defi_transaction(
    tx_hash: str,
    contract_address: str,
    expected_function: str
):
    """DeFi 트랜잭션 검증"""
    
    tx = await blockchain_service.get_transaction(tx_hash)
    
    # 컨트랙트 주소 확인
    if tx['to'].lower() != contract_address.lower():
        return {"valid": False, "reason": "잘못된 컨트랙트 주소"}
    
    # 함수 시그니처 확인
    input_data = tx['input']
    function_selector = input_data[:10]  # 처음 4바이트
    
    # 예상 함수와 비교
    from web3 import Web3
    expected_selector = Web3.keccak(
        text=expected_function
    )[:4].hex()
    
    if function_selector != '0x' + expected_selector:
        return {"valid": False, "reason": "잘못된 함수 호출"}
    
    return {"valid": True, "data": tx}

async def verify_item_transfer(
    tx_hash: str,
    from_address: str,
    to_address: str,
    token_id: int
):
    """게임 아이템 전송 검증"""
    
    # 트랜잭션 영수증 조회
    receipt = await validator.verify_transaction_receipt(tx_hash)
    
    if not receipt['valid']:
        return {"success": False}
    
    # 이벤트 로그 파싱
    w3 = blockchain_service.w3
    logs = receipt.get('logs', [])
    
    # Transfer 이벤트 찾기
    transfer_event = None
    for log in logs:
        topics = log.get('topics', [])
        if len(topics) > 0:
            # Transfer 이벤트 시그니처
            if topics[0].hex() == w3.keccak(
                text="Transfer(address,address,uint256)"
            ).hex():
                transfer_event = log
                break
    
    if not transfer_event:
        return {"success": False, "message": "Transfer 이벤트 없음"}
    
    # 이벤트 데이터 검증
    # (실제로는 더 복잡한 파싱이 필요)
    
    return {
        "success": True,
        "message": "아이템 전송 확인됨",
        "confirmations": receipt['confirmations']
    }

# 연결 테스트
from web3 import Web3

w3 = Web3(Web3.HTTPProvider('YOUR_RPC_URL'))
print(f"연결 상태: {w3.is_connected()}")
print(f"최신 블록: {w3.eth.block_number}")

# 캐시 통계 확인
def get_cache_stats():
    info = cache_service.redis_client.info('stats')
    return {
        "hits": info.get('keyspace_hits', 0),
        "misses": info.get('keyspace_misses', 0),
        "hit_rate": info.get('keyspace_hits', 0) / 
                   (info.get('keyspace_hits', 0) + 
                    info.get('keyspace_misses', 1)) * 100
    }

import gc
import psutil
import os

def get_memory_usage():
    process = psutil.Process(os.getpid())
    return {
        "rss": process.memory_info().rss / 1024 / 1024,  # MB
        "vms": process.memory_info().vms / 1024 / 1024,
        "percent": process.memory_percent()
    }

# 주기적으로 가비지 컬렉션 실행
gc.collect()

import asyncio
from collections import deque
from datetime import datetime, timedelta

class RateLimiter:
    def __init__(self, max_requests: int, time_window: int):
        self.max_requests = max_requests
        self.time_window = time_window
        self.requests = deque()
    
    async def acquire(self):
        now = datetime.now()
        
        # 오래된 요청 제거
        while self.requests and \
              self.requests[0] < now - timedelta(seconds=self.time_window):
            self.requests.popleft()
        
        # 제한 확인
        if len(self.requests) >= self.max_requests:
            wait_time = (self.requests[0] + 
                        timedelta(seconds=self.time_window) - 
                        now).total_seconds()
            await asyncio.sleep(wait_time)
        
        self.requests.append(now)

# 사용 예시
limiter = RateLimiter(max_requests=10, time_window=60)

async def rate_limited_request():
    await limiter.acquire()
    # 실제 요청 수행
    return await blockchain_service.get_block(12345)

from locust import HttpUser, task, between

class BlockchainAPIUser(HttpUser):
    wait_time = between(1, 3)
    
    @task(3)
    def get_block(self):
        block_num = random.randint(15000000, 15001000)
        self.client.get(
            f"/api/v1/block/{block_num}",
            headers={"X-API-Key": "test_key"}
        )
    
    @task(2)
    def validate_transaction(self):
        self.client.post(
            "/api/v1/validate/transaction",
            json={
                "tx_hash": "0x" + "a" * 64
            },
            headers={"X-API-Key": "test_key"}
        )
    
    @task(1)
    def get_stats(self):
        self.client.get(
            "/api/v1/stats",
            headers={"X-API-Key": "test_key"}
        )