🎯 왜 토큰 거래 내역 조회 시스템이 필요할까?

안녕, 친구! 요즘 블록체인과 암호화폐 시장이 정말 뜨겁지? 🔥 비트코인, 이더리움은 물론이고 수많은 토큰들이 매일 거래되고 있어. 그런데 말이야, 이런 토큰들의 거래 내역을 제대로 추적하고 분석하려면 어떻게 해야 할까?

대부분의 사람들은 거래소 앱이나 블록 익스플로러(Block Explorer)를 사용하지. 하지만 개발자라면, 특히 블록체인 기술에 관심이 있다면, 직접 토큰 거래 내역 조회 시스템을 구축해보는 건 정말 값진 경험이 될 거야!

이런 시스템을 만들면 뭐가 좋냐고? 일단 실시간으로 특정 지갑 주소의 거래 내역을 모니터링할 수 있고, 대량의 거래 데이터를 분석해서 패턴을 찾을 수도 있어. 게다가 세금 신고를 위한 거래 내역 정리도 훨씬 쉬워지지. 💰

🧱 블록체인과 토큰 거래의 기본 이해

본격적으로 시스템을 구축하기 전에, 블록체인에서 토큰 거래가 어떻게 이루어지는지 이해해야 해. 이게 기초 체력이거든! 💪

블록체인은 쉽게 말해서 분산된 거래 장부야. 은행 장부처럼 중앙에서 관리하는 게 아니라, 수천 개의 컴퓨터가 동시에 같은 장부를 가지고 있는 거지. 누군가 거래를 하면, 그 거래 내역이 블록이라는 단위로 묶여서 체인처럼 연결돼.

토큰은 이 블록체인 위에서 작동하는 디지털 자산이야. 이더리움 블록체인을 예로 들면, ERC-20이라는 표준을 따르는 토큰들이 있어. 이 토큰들은 스마트 컨트랙트(Smart Contract)라는 프로그램으로 관리되는데, 이게 핵심이야!

📊 토큰 거래의 구조

토큰 거래를 조회하려면 거래 데이터의 구조를 알아야 해. 일반적인 토큰 거래에는 다음과 같은 정보가 포함돼:

이런 정보들이 블록체인에 영구적으로 기록되고, 우리는 이 데이터를 읽어와서 사용자에게 보여주는 거야. 📖

🛠️ 개발 환경 준비하기

자, 이제 본격적으로 개발을 시작해볼까? 먼저 필요한 도구들을 준비해야 해. 요리를 하려면 재료와 도구가 필요하듯이 말이야! 👨‍🍳

📦 필수 패키지 및 라이브러리

💻 설치 과정

먼저 가상환경을 만들어주자. 가상환경은 프로젝트마다 독립적인 파이썬 환경을 만들어주는 거야. 이렇게 하면 패키지 버전 충돌을 방지할 수 있어!

# 가상환경 생성
python -m venv token_tracker_env

# 가상환경 활성화 (Windows)
token_tracker_env\Scripts\activate

# 가상환경 활성화 (Mac/Linux)
source token_tracker_env/bin/activate

# 필수 패키지 설치
pip install django==4.2.0
pip install web3==6.0.0
pip install djangorestframework==3.14.0
pip install celery==5.3.0
pip install redis==4.5.0
pip install psycopg2-binary==2.9.6
pip install python-dotenv==1.0.0
pip install requests==2.31.0

🔑 블록체인 노드 접근 설정

블록체인 데이터를 읽어오려면 블록체인 노드에 접근해야 해. 직접 노드를 운영할 수도 있지만, 초보자에게는 부담스러울 수 있어. 다행히 Infura나 Alchemy 같은 서비스를 사용하면 쉽게 접근할 수 있어! 🌐

Infura를 예로 들어볼게:

API 키를 받았으면, 프로젝트 루트 디렉토리에 .env 파일을 만들어서 저장해:

# .env 파일
INFURA_PROJECT_ID=your_project_id_here
INFURA_PROJECT_SECRET=your_project_secret_here
ETHEREUM_NETWORK=mainnet  # 또는 goerli, sepolia 등 테스트넷
DATABASE_URL=postgresql://user:password@localhost:5432/token_tracker
REDIS_URL=redis://localhost:6379/0
SECRET_KEY=your_django_secret_key_here
DEBUG=True

🏗️ Django 프로젝트 구조 설계

이제 Django 프로젝트를 만들어볼 거야. 프로젝트 구조를 잘 설계하는 게 정말 중요해. 나중에 기능을 추가하거나 수정할 때 훨씬 편하거든! 🏛️

📁 프로젝트 생성

# Django 프로젝트 생성
django-admin startproject token_tracker

# 프로젝트 디렉토리로 이동
cd token_tracker

# 앱 생성
python manage.py startapp blockchain
python manage.py startapp api
python manage.py startapp dashboard

이렇게 하면 다음과 같은 구조가 만들어져:

token_tracker/
├── token_tracker/          # 프로젝트 설정 디렉토리
│   ├── __init__.py
│   ├── settings.py        # 프로젝트 설정
│   ├── urls.py            # URL 라우팅
│   ├── wsgi.py
│   └── asgi.py
├── blockchain/             # 블록체인 관련 로직
│   ├── migrations/
│   ├── __init__.py
│   ├── models.py          # 데이터 모델
│   ├── views.py
│   ├── services.py        # 비즈니스 로직
│   └── utils.py           # 유틸리티 함수
├── api/                    # REST API
│   ├── migrations/
│   ├── __init__.py
│   ├── serializers.py     # 데이터 직렬화
│   ├── views.py           # API 뷰
│   └── urls.py
├── dashboard/              # 프론트엔드 대시보드
│   ├── templates/
│   ├── static/
│   └── views.py
├── .env                    # 환경 변수
├── manage.py
└── requirements.txt        # 패키지 목록

⚙️ settings.py 설정

Django의 핵심 설정 파일인 settings.py를 수정해야 해. 여기서 데이터베이스, 앱, 미들웨어 등을 설정해:

# token_tracker/settings.py
import os
from pathlib import Path
from dotenv import load_dotenv

load_dotenv()

BASE_DIR = Path(__file__).resolve().parent.parent

SECRET_KEY = os.getenv('SECRET_KEY')
DEBUG = os.getenv('DEBUG', 'False') == 'True'

ALLOWED_HOSTS = ['localhost', '127.0.0.1']

# 설치된 앱
INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    
    # Third party apps
    'rest_framework',
    'corsheaders',
    
    # Local apps
    'blockchain',
    'api',
    'dashboard',
]

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'corsheaders.middleware.CorsMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

# 데이터베이스 설정
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'token_tracker',
        'USER': 'postgres',
        'PASSWORD': 'your_password',
        'HOST': 'localhost',
        'PORT': '5432',
    }
}

# REST Framework 설정
REST_FRAMEWORK = {
    'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.PageNumberPagination',
    'PAGE_SIZE': 50,
    'DEFAULT_RENDERER_CLASSES': [
        'rest_framework.renderers.JSONRenderer',
    ],
}

# Celery 설정
CELERY_BROKER_URL = os.getenv('REDIS_URL', 'redis://localhost:6379/0')
CELERY_RESULT_BACKEND = os.getenv('REDIS_URL', 'redis://localhost:6379/0')
CELERY_ACCEPT_CONTENT = ['json']
CELERY_TASK_SERIALIZER = 'json'
CELERY_RESULT_SERIALIZER = 'json'

# 블록체인 설정
INFURA_PROJECT_ID = os.getenv('INFURA_PROJECT_ID')
ETHEREUM_NETWORK = os.getenv('ETHEREUM_NETWORK', 'mainnet')

🗄️ 데이터 모델 설계

데이터베이스 모델을 설계할 시간이야! 토큰 거래 내역을 저장하기 위한 테이블 구조를 만들어보자. 📊

우리가 추적해야 할 주요 데이터는 다음과 같아:

📝 models.py 작성

# blockchain/models.py
from django.db import models
from django.core.validators import MinValueValidator
from decimal import Decimal

class Token(models.Model):
    """토큰 정보 모델"""
    contract_address = models.CharField(
        max_length=42, 
        unique=True,
        db_index=True,
        help_text="토큰 스마트 컨트랙트 주소"
    )
    name = models.CharField(max_length=100, help_text="토큰 이름")
    symbol = models.CharField(max_length=10, help_text="토큰 심볼")
    decimals = models.IntegerField(
        default=18,
        help_text="토큰 소수점 자릿수"
    )
    total_supply = models.DecimalField(
        max_digits=78,
        decimal_places=0,
        null=True,
        blank=True,
        help_text="총 발행량"
    )
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    
    class Meta:
        db_table = 'tokens'
        verbose_name = 'Token'
        verbose_name_plural = 'Tokens'
        ordering = ['-created_at']
    
    def __str__(self):
        return f"{self.name} ({self.symbol})"


class Wallet(models.Model):
    """지갑 주소 모델"""
    address = models.CharField(
        max_length=42,
        unique=True,
        db_index=True,
        help_text="지갑 주소"
    )
    label = models.CharField(
        max_length=100,
        blank=True,
        help_text="지갑 라벨 (선택사항)"
    )
    is_contract = models.BooleanField(
        default=False,
        help_text="컨트랙트 주소 여부"
    )
    first_seen = models.DateTimeField(auto_now_add=True)
    last_activity = models.DateTimeField(null=True, blank=True)
    
    class Meta:
        db_table = 'wallets'
        verbose_name = 'Wallet'
        verbose_name_plural = 'Wallets'
        ordering = ['-last_activity']
    
    def __str__(self):
        return self.label if self.label else self.address[:10] + "..."


class Transaction(models.Model):
    """토큰 거래 내역 모델"""
    
    STATUS_CHOICES = [
        ('pending', 'Pending'),
        ('success', 'Success'),
        ('failed', 'Failed'),
    ]
    
    transaction_hash = models.CharField(
        max_length=66,
        unique=True,
        db_index=True,
        help_text="거래 해시"
    )
    token = models.ForeignKey(
        Token,
        on_delete=models.CASCADE,
        related_name='transactions',
        help_text="관련 토큰"
    )
    from_address = models.ForeignKey(
        Wallet,
        on_delete=models.CASCADE,
        related_name='sent_transactions',
        help_text="송신자 주소"
    )
    to_address = models.ForeignKey(
        Wallet,
        on_delete=models.CASCADE,
        related_name='received_transactions',
        help_text="수신자 주소"
    )
    value = models.DecimalField(
        max_digits=78,
        decimal_places=18,
        validators=[MinValueValidator(Decimal('0'))],
        help_text="전송 금액"
    )
    block_number = models.BigIntegerField(
        db_index=True,
        help_text="블록 번호"
    )
    block_timestamp = models.DateTimeField(
        db_index=True,
        help_text="블록 타임스탬프"
    )
    gas_price = models.DecimalField(
        max_digits=78,
        decimal_places=0,
        help_text="가스 가격 (wei)"
    )
    gas_used = models.BigIntegerField(help_text="사용된 가스")
    transaction_fee = models.DecimalField(
        max_digits=78,
        decimal_places=18,
        help_text="거래 수수료 (ETH)"
    )
    status = models.CharField(
        max_length=10,
        choices=STATUS_CHOICES,
        default='success',
        help_text="거래 상태"
    )
    created_at = models.DateTimeField(auto_now_add=True)
    
    class Meta:
        db_table = 'transactions'
        verbose_name = 'Transaction'
        verbose_name_plural = 'Transactions'
        ordering = ['-block_timestamp']
        indexes = [
            models.Index(fields=['-block_timestamp']),
            models.Index(fields=['from_address', '-block_timestamp']),
            models.Index(fields=['to_address', '-block_timestamp']),
            models.Index(fields=['token', '-block_timestamp']),
        ]
    
    def __str__(self):
        return f"{self.transaction_hash[:10]}... ({self.value} {self.token.symbol})"
    
    @property
    def value_formatted(self):
        """토큰 decimals를 고려한 실제 값"""
        return self.value / (10 ** self.token.decimals)


class Block(models.Model):
    """블록 정보 모델 (선택사항)"""
    block_number = models.BigIntegerField(
        unique=True,
        db_index=True,
        help_text="블록 번호"
    )
    block_hash = models.CharField(
        max_length=66,
        unique=True,
        help_text="블록 해시"
    )
    timestamp = models.DateTimeField(
        db_index=True,
        help_text="블록 생성 시간"
    )
    transaction_count = models.IntegerField(
        default=0,
        help_text="블록 내 거래 수"
    )
    miner = models.CharField(
        max_length=42,
        help_text="채굴자 주소"
    )
    
    class Meta:
        db_table = 'blocks'
        verbose_name = 'Block'
        verbose_name_plural = 'Blocks'
        ordering = ['-block_number']
    
    def __str__(self):
        return f"Block #{self.block_number}"

모델을 만들었으면 데이터베이스에 반영해야 해:

# 마이그레이션 파일 생성
python manage.py makemigrations

# 데이터베이스에 적용
python manage.py migrate

🔌 Web3.py로 블록체인 데이터 조회하기

드디어 블록체인과 직접 소통할 시간이야! Web3.py를 사용하면 파이썬에서 이더리움 블록체인과 상호작용할 수 있어. 🌐

먼저 Web3 연결을 설정하는 유틸리티 함수를 만들어보자:

🔧 Web3 연결 설정

# blockchain/utils.py
from web3 import Web3
from web3.middleware import geth_poa_middleware
from django.conf import settings
import logging

logger = logging.getLogger(__name__)

class Web3Connection:
    """Web3 연결 관리 클래스"""
    
    _instance = None
    _w3 = None
    
    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance
    
    def __init__(self):
        if self._w3 is None:
            self._initialize_connection()
    
    def _initialize_connection(self):
        """Web3 연결 초기화"""
        try:
            # Infura 엔드포인트 설정
            infura_url = f"https://{settings.ETHEREUM_NETWORK}.infura.io/v3/{settings.INFURA_PROJECT_ID}"
            
            # Web3 인스턴스 생성
            self._w3 = Web3(Web3.HTTPProvider(infura_url))
            
            # PoA 체인을 위한 미들웨어 추가 (테스트넷용)
            if settings.ETHEREUM_NETWORK != 'mainnet':
                self._w3.middleware_onion.inject(geth_poa_middleware, layer=0)
            
            # 연결 확인
            if self._w3.is_connected():
                logger.info(f"Web3 연결 성공: {settings.ETHEREUM_NETWORK}")
                logger.info(f"현재 블록: {self._w3.eth.block_number}")
            else:
                logger.error("Web3 연결 실패")
                raise ConnectionError("블록체인 노드에 연결할 수 없습니다")
                
        except Exception as e:
            logger.error(f"Web3 초기화 오류: {str(e)}")
            raise
    
    @property
    def w3(self):
        """Web3 인스턴스 반환"""
        if self._w3 is None or not self._w3.is_connected():
            self._initialize_connection()
        return self._w3
    
    def get_latest_block_number(self):
        """최신 블록 번호 조회"""
        return self.w3.eth.block_number
    
    def get_block(self, block_number):
        """특정 블록 정보 조회"""
        return self.w3.eth.get_block(block_number, full_transactions=True)
    
    def get_transaction(self, tx_hash):
        """거래 정보 조회"""
        return self.w3.eth.get_transaction(tx_hash)
    
    def get_transaction_receipt(self, tx_hash):
        """거래 영수증 조회"""
        return self.w3.eth.get_transaction_receipt(tx_hash)


# 싱글톤 인스턴스
web3_connection = Web3Connection()

📜 ERC-20 토큰 컨트랙트 상호작용

ERC-20 토큰의 거래 내역을 조회하려면 토큰 컨트랙트와 상호작용해야 해. ERC-20 표준 ABI(Application Binary Interface)를 사용하면 돼:

# blockchain/contracts.py
from web3 import Web3
from .utils import web3_connection
import logging

logger = logging.getLogger(__name__)

# ERC-20 표준 ABI (주요 함수만)
ERC20_ABI = [
    {
        "constant": True,
        "inputs": [],
        "name": "name",
        "outputs": [{"name": "", "type": "string"}],
        "type": "function"
    },
    {
        "constant": True,
        "inputs": [],
        "name": "symbol",
        "outputs": [{"name": "", "type": "string"}],
        "type": "function"
    },
    {
        "constant": True,
        "inputs": [],
        "name": "decimals",
        "outputs": [{"name": "", "type": "uint8"}],
        "type": "function"
    },
    {
        "constant": True,
        "inputs": [],
        "name": "totalSupply",
        "outputs": [{"name": "", "type": "uint256"}],
        "type": "function"
    },
    {
        "constant": True,
        "inputs": [{"name": "_owner", "type": "address"}],
        "name": "balanceOf",
        "outputs": [{"name": "balance", "type": "uint256"}],
        "type": "function"
    },
    {
        "anonymous": False,
        "inputs": [
            {"indexed": True, "name": "from", "type": "address"},
            {"indexed": True, "name": "to", "type": "address"},
            {"indexed": False, "name": "value", "type": "uint256"}
        ],
        "name": "Transfer",
        "type": "event"
    }
]


class ERC20Token:
    """ERC-20 토큰 컨트랙트 래퍼 클래스"""
    
    def __init__(self, contract_address):
        """
        Args:
            contract_address: 토큰 컨트랙트 주소
        """
        self.w3 = web3_connection.w3
        self.contract_address = Web3.to_checksum_address(contract_address)
        self.contract = self.w3.eth.contract(
            address=self.contract_address,
            abi=ERC20_ABI
        )
    
    def get_name(self):
        """토큰 이름 조회"""
        try:
            return self.contract.functions.name().call()
        except Exception as e:
            logger.error(f"토큰 이름 조회 실패: {str(e)}")
            return None
    
    def get_symbol(self):
        """토큰 심볼 조회"""
        try:
            return self.contract.functions.symbol().call()
        except Exception as e:
            logger.error(f"토큰 심볼 조회 실패: {str(e)}")
            return None
    
    def get_decimals(self):
        """토큰 소수점 자릿수 조회"""
        try:
            return self.contract.functions.decimals().call()
        except Exception as e:
            logger.error(f"토큰 decimals 조회 실패: {str(e)}")
            return 18  # 기본값
    
    def get_total_supply(self):
        """총 발행량 조회"""
        try:
            return self.contract.functions.totalSupply().call()
        except Exception as e:
            logger.error(f"총 발행량 조회 실패: {str(e)}")
            return None
    
    def get_balance(self, address):
        """특정 주소의 토큰 잔액 조회"""
        try:
            checksum_address = Web3.to_checksum_address(address)
            balance = self.contract.functions.balanceOf(checksum_address).call()
            return balance
        except Exception as e:
            logger.error(f"잔액 조회 실패: {str(e)}")
            return 0
    
    def get_transfer_events(self, from_block, to_block, address=None):
        """Transfer 이벤트 조회
        
        Args:
            from_block: 시작 블록
            to_block: 종료 블록
            address: 특정 주소 필터 (선택사항)
        
        Returns:
            Transfer 이벤트 리스트
        """
        try:
            # 이벤트 필터 생성
            event_filter = {
                'fromBlock': from_block,
                'toBlock': to_block,
            }
            
            # 특정 주소 필터링
            if address:
                checksum_address = Web3.to_checksum_address(address)
                # from 또는 to가 해당 주소인 이벤트만 조회
                events_from = self.contract.events.Transfer.create_filter(
                    fromBlock=from_block,
                    toBlock=to_block,
                    argument_filters={'from': checksum_address}
                ).get_all_entries()
                
                events_to = self.contract.events.Transfer.create_filter(
                    fromBlock=from_block,
                    toBlock=to_block,
                    argument_filters={'to': checksum_address}
                ).get_all_entries()
                
                # 중복 제거 및 병합
                all_events = list({event['transactionHash']: event 
                                  for event in events_from + events_to}.values())
                return all_events
            else:
                # 모든 Transfer 이벤트 조회
                return self.contract.events.Transfer.create_filter(
                    **event_filter
                ).get_all_entries()
                
        except Exception as e:
            logger.error(f"Transfer 이벤트 조회 실패: {str(e)}")
            return []
    
    def get_token_info(self):
        """토큰 전체 정보 조회"""
        return {
            'address': self.contract_address,
            'name': self.get_name(),
            'symbol': self.get_symbol(),
            'decimals': self.get_decimals(),
            'total_supply': self.get_total_supply(),
        }

⚙️ 비즈니스 로직 구현

이제 실제로 토큰 거래 내역을 조회하고 데이터베이스에 저장하는 로직을 만들어보자. 이 부분이 시스템의 핵심이야! 💎

📊 토큰 거래 수집 서비스

# blockchain/services.py
from django.utils import timezone
from django.db import transaction as db_transaction
from datetime import datetime
from decimal import Decimal
from .models import Token, Wallet, Transaction, Block
from .contracts import ERC20Token
from .utils import web3_connection
import logging

logger = logging.getLogger(__name__)


class TokenService:
    """토큰 관련 비즈니스 로직"""
    
    @staticmethod
    def register_token(contract_address):
        """토큰 등록
        
        Args:
            contract_address: 토큰 컨트랙트 주소
        
        Returns:
            Token 인스턴스
        """
        try:
            # 이미 등록된 토큰인지 확인
            token = Token.objects.filter(
                contract_address=contract_address
            ).first()
            
            if token:
                logger.info(f"이미 등록된 토큰: {token.symbol}")
                return token
            
            # 토큰 정보 조회
            erc20 = ERC20Token(contract_address)
            token_info = erc20.get_token_info()
            
            if not token_info['name']:
                raise ValueError("유효하지 않은 토큰 컨트랙트")
            
            # 토큰 생성
            token = Token.objects.create(
                contract_address=contract_address,
                name=token_info['name'],
                symbol=token_info['symbol'],
                decimals=token_info['decimals'],
                total_supply=token_info['total_supply']
            )
            
            logger.info(f"토큰 등록 완료: {token.symbol}")
            return token
            
        except Exception as e:
            logger.error(f"토큰 등록 실패: {str(e)}")
            raise


class TransactionService:
    """거래 내역 관련 비즈니스 로직"""
    
    @staticmethod
    def get_or_create_wallet(address, is_contract=False):
        """지갑 주소 조회 또는 생성"""
        wallet, created = Wallet.objects.get_or_create(
            address=address,
            defaults={'is_contract': is_contract}
        )
        if created:
            logger.debug(f"새 지갑 생성: {address}")
        return wallet
    
    @staticmethod
    def sync_token_transactions(token, from_block, to_block, target_address=None):
        """토큰 거래 내역 동기화
        
        Args:
            token: Token 인스턴스
            from_block: 시작 블록
            to_block: 종료 블록
            target_address: 특정 주소만 조회 (선택사항)
        
        Returns:
            저장된 거래 수
        """
        try:
            w3 = web3_connection.w3
            erc20 = ERC20Token(token.contract_address)
            
            # Transfer 이벤트 조회
            events = erc20.get_transfer_events(
                from_block=from_block,
                to_block=to_block,
                address=target_address
            )
            
            logger.info(f"{len(events)}개의 Transfer 이벤트 발견")
            
            saved_count = 0
            
            # 각 이벤트 처리
            for event in events:
                try:
                    # 이미 저장된 거래인지 확인
                    tx_hash = event['transactionHash'].hex()
                    if Transaction.objects.filter(transaction_hash=tx_hash).exists():
                        continue
                    
                    # 거래 상세 정보 조회
                    tx = w3.eth.get_transaction(event['transactionHash'])
                    receipt = w3.eth.get_transaction_receipt(event['transactionHash'])
                    block = w3.eth.get_block(event['blockNumber'])
                    
                    # 지갑 주소 처리
                    from_wallet = TransactionService.get_or_create_wallet(
                        event['args']['from']
                    )
                    to_wallet = TransactionService.get_or_create_wallet(
                        event['args']['to']
                    )
                    
                    # 거래 수수료 계산
                    gas_price = tx['gasPrice']
                    gas_used = receipt['gasUsed']
                    tx_fee = Decimal(gas_price * gas_used) / Decimal(10**18)
                    
                    # 거래 상태 확인
                    status = 'success' if receipt['status'] == 1 else 'failed'
                    
                    # 거래 저장
                    with db_transaction.atomic():
                        Transaction.objects.create(
                            transaction_hash=tx_hash,
                            token=token,
                            from_address=from_wallet,
                            to_address=to_wallet,
                            value=event['args']['value'],
                            block_number=event['blockNumber'],
                            block_timestamp=datetime.fromtimestamp(
                                block['timestamp'],
                                tz=timezone.utc
                            ),
                            gas_price=gas_price,
                            gas_used=gas_used,
                            transaction_fee=tx_fee,
                            status=status
                        )
                        
                        # 지갑 마지막 활동 시간 업데이트
                        from_wallet.last_activity = datetime.fromtimestamp(
                            block['timestamp'],
                            tz=timezone.utc
                        )
                        from_wallet.save()
                        
                        to_wallet.last_activity = datetime.fromtimestamp(
                            block['timestamp'],
                            tz=timezone.utc
                        )
                        to_wallet.save()
                    
                    saved_count += 1
                    
                except Exception as e:
                    logger.error(f"거래 처리 실패 ({tx_hash}): {str(e)}")
                    continue
            
            logger.info(f"{saved_count}개의 거래 저장 완료")
            return saved_count
            
        except Exception as e:
            logger.error(f"거래 동기화 실패: {str(e)}")
            raise
    
    @staticmethod
    def sync_wallet_transactions(wallet_address, token_address, lookback_blocks=10000):
        """특정 지갑의 토큰 거래 내역 동기화
        
        Args:
            wallet_address: 지갑 주소
            token_address: 토큰 컨트랙트 주소
            lookback_blocks: 조회할 과거 블록 수
        
        Returns:
            저장된 거래 수
        """
        try:
            # 토큰 등록 (없으면 생성)
            token = TokenService.register_token(token_address)
            
            # 현재 블록 번호
            w3 = web3_connection.w3
            current_block = w3.eth.block_number
            from_block = max(0, current_block - lookback_blocks)
            
            logger.info(f"블록 {from_block} ~ {current_block} 범위 조회")
            
            # 거래 동기화
            return TransactionService.sync_token_transactions(
                token=token,
                from_block=from_block,
                to_block=current_block,
                target_address=wallet_address
            )
            
        except Exception as e:
            logger.error(f"지갑 거래 동기화 실패: {str(e)}")
            raise

이제 이 서비스를 사용해서 실제로 거래 내역을 조회할 수 있어! 예를 들어, USDT 토큰의 거래 내역을 조회하고 싶다면:

# Django shell에서 테스트
python manage.py shell

from blockchain.services import TokenService, TransactionService

# USDT 토큰 주소 (이더리움 메인넷)
usdt_address = "0xdAC17F958D2ee523a2206206994597C13D831ec7"

# 특정 지갑의 USDT 거래 내역 조회
wallet_address = "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb"
TransactionService.sync_wallet_transactions(
    wallet_address=wallet_address,
    token_address=usdt_address,
    lookback_blocks=5000
)

🔄 Celery로 비동기 작업 처리하기

블록체인 데이터를 조회하는 건 시간이 꽤 걸리는 작업이야. 사용자가 요청할 때마다 동기적으로 처리하면 응답이 너무 느려져서 사용자 경험이 나빠지지. 😰

이럴 때 Celery를 사용하면 백그라운드에서 비동기적으로 작업을 처리할 수 있어! 사용자는 즉시 응답을 받고, 실제 데이터 수집은 뒤에서 천천히 진행되는 거지.

⚙️ Celery 설정

# token_tracker/celery.py
import os
from celery import Celery
from celery.schedules import crontab

# Django 설정 모듈 지정
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'token_tracker.settings')

# Celery 앱 생성
app = Celery('token_tracker')

# Django 설정에서 Celery 설정 로드
app.config_from_object('django.conf:settings', namespace='CELERY')

# Django 앱에서 task 자동 발견
app.autodiscover_tasks()

# 주기적 작업 스케줄 설정
app.conf.beat_schedule = {
    'sync-recent-transactions': {
        'task': 'blockchain.tasks.sync_recent_transactions',
        'schedule': crontab(minute='*/10'),  # 10분마다 실행
    },
    'update-token-prices': {
        'task': 'blockchain.tasks.update_token_prices',
        'schedule': crontab(minute='*/5'),  # 5분마다 실행
    },
}

@app.task(bind=True)
def debug_task(self):
    print(f'Request: {self.request!r}')

# token_tracker/__init__.py
from .celery import app as celery_app

__all__ = ('celery_app',)

📝 Celery Task 작성

# blockchain/tasks.py
from celery import shared_task
from celery.utils.log import get_task_logger
from django.utils import timezone
from datetime import timedelta
from .models import Token, Wallet
from .services import TransactionService
from .utils import web3_connection

logger = get_task_logger(__name__)


@shared_task(bind=True, max_retries=3)
def sync_wallet_transactions_task(self, wallet_address, token_address, lookback_blocks=1000):
    """지갑 거래 내역 동기화 작업
    
    Args:
        wallet_address: 지갑 주소
        token_address: 토큰 컨트랙트 주소
        lookback_blocks: 조회할 과거 블록 수
    
    Returns:
        저장된 거래 수
    """
    try:
        logger.info(f"거래 동기화 시작: {wallet_address}")
        
        count = TransactionService.sync_wallet_transactions(
            wallet_address=wallet_address,
            token_address=token_address,
            lookback_blocks=lookback_blocks
        )
        
        logger.info(f"거래 동기화 완료: {count}개 저장")
        return {
            'status': 'success',
            'wallet_address': wallet_address,
            'token_address': token_address,
            'saved_count': count
        }
        
    except Exception as exc:
        logger.error(f"거래 동기화 실패: {str(exc)}")
        # 재시도
        raise self.retry(exc=exc, countdown=60)


@shared_task
def sync_recent_transactions():
    """최근 거래 내역 자동 동기화 (주기적 실행)"""
    try:
        logger.info("최근 거래 자동 동기화 시작")
        
        # 최근 24시간 내 활동이 있었던 지갑들
        recent_wallets = Wallet.objects.filter(
            last_activity__gte=timezone.now() - timedelta(days=1)
        ).exclude(is_contract=True)
        
        # 등록된 모든 토큰
        tokens = Token.objects.all()
        
        total_synced = 0
        
        for wallet in recent_wallets[:50]:  # 한 번에 최대 50개 지갑
            for token in tokens:
                try:
                    count = TransactionService.sync_token_transactions(
                        token=token,
                        from_block=web3_connection.get_latest_block_number() - 100,
                        to_block='latest',
                        target_address=wallet.address
                    )
                    total_synced += count
                except Exception as e:
                    logger.error(f"동기화 실패 ({wallet.address}, {token.symbol}): {str(e)}")
                    continue
        
        logger.info(f"자동 동기화 완료: {total_synced}개 거래 저장")
        return total_synced
        
    except Exception as e:
        logger.error(f"자동 동기화 실패: {str(e)}")
        return 0


@shared_task
def bulk_sync_token_transactions(token_address, from_block, to_block, chunk_size=1000):
    """대량 거래 내역 동기화 (블록 범위를 나눠서 처리)
    
    Args:
        token_address: 토큰 컨트랙트 주소
        from_block: 시작 블록
        to_block: 종료 블록
        chunk_size: 한 번에 처리할 블록 수
    """
    try:
        from .services import TokenService
        
        logger.info(f"대량 동기화 시작: {from_block} ~ {to_block}")
        
        token = TokenService.register_token(token_address)
        total_saved = 0
        
        # 블록 범위를 chunk_size로 나눠서 처리
        current_block = from_block
        while current_block <= to_block:
            end_block = min(current_block + chunk_size, to_block)
            
            try:
                count = TransactionService.sync_token_transactions(
                    token=token,
                    from_block=current_block,
                    to_block=end_block
                )
                total_saved += count
                logger.info(f"블록 {current_block}~{end_block}: {count}개 저장")
                
            except Exception as e:
                logger.error(f"블록 {current_block}~{end_block} 처리 실패: {str(e)}")
            
            current_block = end_block + 1
        
        logger.info(f"대량 동기화 완료: 총 {total_saved}개 거래 저장")
        return total_saved
        
    except Exception as e:
        logger.error(f"대량 동기화 실패: {str(e)}")
        raise


@shared_task
def update_token_prices():
    """토큰 가격 업데이트 (주기적 실행)"""
    # 실제로는 CoinGecko API 등을 사용해서 가격 정보를 가져와야 함
    # 여기서는 간단한 예시만 보여줌
    try:
        logger.info("토큰 가격 업데이트 시작")
        tokens = Token.objects.all()
        
        for token in tokens:
            # TODO: 실제 가격 API 호출
            logger.debug(f"가격 업데이트: {token.symbol}")
        
        logger.info("토큰 가격 업데이트 완료")
        
    except Exception as e:
        logger.error(f"가격 업데이트 실패: {str(e)}")

🚀 Celery 실행

Celery를 실행하려면 별도의 터미널에서 다음 명령어를 실행해:

# Celery Worker 실행
celery -A token_tracker worker --loglevel=info

# Celery Beat 실행 (주기적 작업 스케줄러)
celery -A token_tracker beat --loglevel=info

# 또는 둘 다 한 번에 실행
celery -A token_tracker worker --beat --loglevel=info

# Django view나 shell에서 task 호출
from blockchain.tasks import sync_wallet_transactions_task

# 비동기 실행
result = sync_wallet_transactions_task.delay(
    wallet_address="0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb",
    token_address="0xdAC17F958D2ee523a2206206994597C13D831ec7",
    lookback_blocks=5000
)

# Task ID 확인
print(f"Task ID: {result.id}")

# Task 상태 확인
print(f"Status: {result.status}")

# 결과 대기 (blocking)
result.get(timeout=300)  # 최대 5분 대기

🌐 REST API 구축하기

이제 프론트엔드나 외부 서비스에서 우리 시스템을 사용할 수 있도록 REST API를 만들어보자! Django REST Framework를 사용하면 정말 쉽게 만들 수 있어. 🎨

📦 Serializer 작성

Serializer는 Django 모델을 JSON으로 변환해주는 역할을 해:

# api/serializers.py
from rest_framework import serializers
from blockchain.models import Token, Wallet, Transaction
from decimal import Decimal


class TokenSerializer(serializers.ModelSerializer):
    """토큰 시리얼라이저"""
    
    transaction_count = serializers.SerializerMethodField()
    
    class Meta:
        model = Token
        fields = [
            'id', 'contract_address', 'name', 'symbol', 
            'decimals', 'total_supply', 'transaction_count',
            'created_at', 'updated_at'
        ]
    
    def get_transaction_count(self, obj):
        return obj.transactions.count()


class WalletSerializer(serializers.ModelSerializer):
    """지갑 시리얼라이저"""
    
    sent_count = serializers.SerializerMethodField()
    received_count = serializers.SerializerMethodField()
    
    class Meta:
        model = Wallet
        fields = [
            'id', 'address', 'label', 'is_contract',
            'sent_count', 'received_count',
            'first_seen', 'last_activity'
        ]
    
    def get_sent_count(self, obj):
        return obj.sent_transactions.count()
    
    def get_received_count(self, obj):
        return obj.received_transactions.count()


class TransactionSerializer(serializers.ModelSerializer):
    """거래 내역 시리얼라이저"""
    
    token_symbol = serializers.CharField(source='token.symbol', read_only=True)
    token_name = serializers.CharField(source='token.name', read_only=True)
    from_address_str = serializers.CharField(source='from_address.address', read_only=True)
    to_address_str = serializers.CharField(source='to_address.address', read_only=True)
    value_formatted = serializers.SerializerMethodField()
    
    class Meta:
        model = Transaction
        fields = [
            'id', 'transaction_hash', 'token', 'token_symbol', 'token_name',
            'from_address', 'from_address_str', 'to_address', 'to_address_str',
            'value', 'value_formatted', 'block_number', 'block_timestamp',
            'gas_price', 'gas_used', 'transaction_fee', 'status', 'created_at'
        ]
    
    def get_value_formatted(self, obj):
        """토큰 decimals를 고려한 실제 값"""
        decimals = obj.token.decimals
        value = Decimal(obj.value) / (Decimal(10) ** decimals)
        return str(value)


class TransactionDetailSerializer(TransactionSerializer):
    """거래 상세 정보 시리얼라이저"""
    
    token = TokenSerializer(read_only=True)
    from_address = WalletSerializer(read_only=True)
    to_address = WalletSerializer(read_only=True)
    
    class Meta(TransactionSerializer.Meta):
        fields = TransactionSerializer.Meta.fields


class WalletBalanceSerializer(serializers.Serializer):
    """지갑 잔액 시리얼라이저"""
    
    token = TokenSerializer(read_only=True)
    balance = serializers.DecimalField(max_digits=78, decimal_places=18)
    balance_formatted = serializers.CharField()


class SyncRequestSerializer(serializers.Serializer):
    """동기화 요청 시리얼라이저"""
    
    wallet_address = serializers.CharField(max_length=42, required=True)
    token_address = serializers.CharField(max_length=42, required=True)
    lookback_blocks = serializers.IntegerField(default=1000, min_value=1, max_value=10000)

🎯 API View 작성

# api/views.py
from rest_framework import viewsets, status
from rest_framework.decorators import action
from rest_framework.response import Response
from rest_framework.pagination import PageNumberPagination
from django.db.models import Q, Count, Sum
from django.shortcuts import get_object_or_404
from blockchain.models import Token, Wallet, Transaction
from blockchain.tasks import sync_wallet_transactions_task
from blockchain.contracts import ERC20Token
from .serializers import (
    TokenSerializer, WalletSerializer, TransactionSerializer,
    TransactionDetailSerializer, WalletBalanceSerializer,
    SyncRequestSerializer
)
import logging

logger = logging.getLogger(__name__)


class StandardResultsSetPagination(PageNumberPagination):
    """표준 페이지네이션"""
    page_size = 50
    page_size_query_param = 'page_size'
    max_page_size = 200


class TokenViewSet(viewsets.ReadOnlyModelViewSet):
    """토큰 API ViewSet"""
    
    queryset = Token.objects.all()
    serializer_class = TokenSerializer
    pagination_class = StandardResultsSetPagination
    
    def get_queryset(self):
        queryset = super().get_queryset()
        
        # 검색 필터
        search = self.request.query_params.get('search', None)
        if search:
            queryset = queryset.filter(
                Q(name__icontains=search) | 
                Q(symbol__icontains=search) |
                Q(contract_address__icontains=search)
            )
        
        return queryset.annotate(
            transaction_count=Count('transactions')
        ).order_by('-transaction_count')
    
    @action(detail=True, methods=['get'])
    def transactions(self, request, pk=None):
        """특정 토큰의 거래 내역 조회"""
        token = self.get_object()
        transactions = Transaction.objects.filter(token=token).select_related(
            'from_address', 'to_address'
        )
        
        page = self.paginate_queryset(transactions)
        if page is not None:
            serializer = TransactionSerializer(page, many=True)
            return self.get_paginated_response(serializer.data)
        
        serializer = TransactionSerializer(transactions, many=True)
        return Response(serializer.data)
    
    @action(detail=True, methods=['get'])
    def stats(self, request, pk=None):
        """토큰 통계 정보"""
        token = self.get_object()
        
        transactions = Transaction.objects.filter(token=token)
        
        stats = {
            'total_transactions': transactions.count(),
            'total_volume': transactions.aggregate(Sum('value'))['value__sum'] or 0,
            'unique_senders': transactions.values('from_address').distinct().count(),
            'unique_receivers': transactions.values('to_address').distinct().count(),
            'avg_transaction_value': transactions.aggregate(
                avg=Sum('value')
            )['avg'] or 0,
        }
        
        return Response(stats)


class WalletViewSet(viewsets.ReadOnlyModelViewSet):
    """지갑 API ViewSet"""
    
    queryset = Wallet.objects.all()
    serializer_class = WalletSerializer
    pagination_class = StandardResultsSetPagination
    lookup_field = 'address'
    
    def get_queryset(self):
        queryset = super().get_queryset()
        
        # 컨트랙트 제외 필터
        exclude_contracts = self.request.query_params.get('exclude_contracts', 'false')
        if exclude_contracts.lower() == 'true':
            queryset = queryset.filter(is_contract=False)
        
        return queryset.order_by('-last_activity')
    
    @action(detail=True, methods=['get'])
    def transactions(self, request, address=None):
        """특정 지갑의 거래 내역 조회"""
        wallet = self.get_object()
        
        # 송신/수신 거래 모두 조회
        transactions = Transaction.objects.filter(
            Q(from_address=wallet) | Q(to_address=wallet)
        ).select_related('token', 'from_address', 'to_address')
        
        # 토큰 필터
        token_address = request.query_params.get('token', None)
        if token_address:
            transactions = transactions.filter(token__contract_address=token_address)
        
        # 날짜 필터
        from_date = request.query_params.get('from_date', None)
        to_date = request.query_params.get('to_date', None)
        if from_date:
            transactions = transactions.filter(block_timestamp__gte=from_date)
        if to_date:
            transactions = transactions.filter(block_timestamp__lte=to_date)
        
        page = self.paginate_queryset(transactions)
        if page is not None:
            serializer = TransactionSerializer(page, many=True)
            return self.get_paginated_response(serializer.data)
        
        serializer = TransactionSerializer(transactions, many=True)
        return Response(serializer.data)
    
    @action(detail=True, methods=['get'])
    def balance(self, request, address=None):
        """지갑의 토큰 잔액 조회"""
        wallet = self.get_object()
        token_address = request.query_params.get('token', None)
        
        if not token_address:
            return Response(
                {'error': 'token 파라미터가 필요합니다'},
                status=status.HTTP_400_BAD_REQUEST
            )
        
        try:
            token = Token.objects.get(contract_address=token_address)
            erc20 = ERC20Token(token_address)
            balance = erc20.get_balance(wallet.address)
            
            balance_formatted = balance / (10 ** token.decimals)
            
            data = {
                'token': TokenSerializer(token).data,
                'balance': balance,
                'balance_formatted': str(balance_formatted)
            }
            
            return Response(data)
            
        except Token.DoesNotExist:
            return Response(
                {'error': '등록되지 않은 토큰입니다'},
                status=status.HTTP_404_NOT_FOUND
            )
        except Exception as e:
            logger.error(f"잔액 조회 실패: {str(e)}")
            return Response(
                {'error': '잔액 조회에 실패했습니다'},
                status=status.HTTP_500_INTERNAL_SERVER_ERROR
            )
    
    @action(detail=True, methods=['post'])
    def sync(self, request, address=None):
        """지갑 거래 내역 동기화 요청"""
        wallet = self.get_object()
        serializer = SyncRequestSerializer(data=request.data)
        
        if not serializer.is_valid():
            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
        
        token_address = serializer.validated_data['token_address']
        lookback_blocks = serializer.validated_data['lookback_blocks']
        
        # Celery task 실행
        task = sync_wallet_transactions_task.delay(
            wallet_address=wallet.address,
            token_address=token_address,
            lookback_blocks=lookback_blocks
        )
        
        return Response({
            'status': 'processing',
            'task_id': task.id,
            'message': '거래 내역 동기화가 시작되었습니다'
        }, status=status.HTTP_202_ACCEPTED)


class TransactionViewSet(viewsets.ReadOnlyModelViewSet):
    """거래 내역 API ViewSet"""
    
    queryset = Transaction.objects.all().select_related(
        'token', 'from_address', 'to_address'
    )
    pagination_class = StandardResultsSetPagination
    lookup_field = 'transaction_hash'
    
    def get_serializer_class(self):
        if self.action == 'retrieve':
            return TransactionDetailSerializer
        return TransactionSerializer
    
    def get_queryset(self):
        queryset = super().get_queryset()
        
        # 토큰 필터
        token = self.request.query_params.get('token', None)
        if token:
            queryset = queryset.filter(token__contract_address=token)
        
        # 지갑 필터
        wallet = self.request.query_params.get('wallet', None)
        if wallet:
            queryset = queryset.filter(
                Q(from_address__address=wallet) | Q(to_address__address=wallet)
            )
        
        # 상태 필터
        status_filter = self.request.query_params.get('status', None)
        if status_filter:
            queryset = queryset.filter(status=status_filter)
        
        # 날짜 범위 필터
        from_date = self.request.query_params.get('from_date', None)
        to_date = self.request.query_params.get('to_date', None)
        if from_date:
            queryset = queryset.filter(block_timestamp__gte=from_date)
        if to_date:
            queryset = queryset.filter(block_timestamp__lte=to_date)
        
        return queryset.order_by('-block_timestamp')

🛣️ URL 라우팅

# api/urls.py
from django.urls import path, include
from rest_framework.routers import DefaultRouter
from .views import TokenViewSet, WalletViewSet, TransactionViewSet

router = DefaultRouter()
router.register(r'tokens', TokenViewSet, basename='token')
router.register(r'wallets', WalletViewSet, basename='wallet')
router.register(r'transactions', TransactionViewSet, basename='transaction')

urlpatterns = [
    path('', include(router.urls)),
]

# token_tracker/urls.py
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/v1/', include('api.urls')),
]

이제 API를 사용할 수 있어! 몇 가지 예시를 보자:

🎨 프론트엔드 대시보드 만들기

API만 있으면 뭐해, 사용자가 볼 수 있는 화면이 있어야지! 간단한 대시보드를 만들어보자. 🖥️

여기서는 Django 템플릿과 바닐라 JavaScript를 사용할 거야. 물론 React나 Vue.js를 사용해도 되지만, 간단하게 시작하는 게 좋잖아?

📄 템플릿 작성

<!-- dashboard/templates/dashboard/index.html -->
<!DOCTYPE html>
<html lang="ko">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>토큰 거래 내역 조회 시스템</title>
    <style>
        * { margin: 0; padding: 0; box-sizing: border-box; }
        body { font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; background: #f5f7fa; }
        .container { max-width: 1400px; margin: 0 auto; padding: 20px; }
        .header { background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 30px; border-radius: 12px; margin-bottom: 30px; }
        .header h1 { font-size: 2em; margin-bottom: 10px; }
        .search-box { background: white; padding: 25px; border-radius: 12px; box-shadow: 0 2px 8px rgba(0,0,0,0.1); margin-bottom: 30px; }
        .search-box input { width: 100%; padding: 12px; border: 2px solid #e0e0e0; border-radius: 8px; font-size: 1em; }
        .search-box button { margin-top: 15px; padding: 12px 30px; background: #667eea; color: white; border: none; border-radius: 8px; cursor: pointer; font-size: 1em; }
        .search-box button:hover { background: #5568d3; }
        .results { background: white; padding: 25px; border-radius: 12px; box-shadow: 0 2px 8px rgba(0,0,0,0.1); }
        .transaction-item { border-bottom: 1px solid #e0e0e0; padding: 15px 0; }
        .transaction-item:last-child { border-bottom: none; }
        .tx-hash { font-family: monospace; color: #667eea; font-weight: bold; }
        .amount { font-size: 1.2em; font-weight: bold; color: #4caf50; }
        .loading { text-align: center; padding: 40px; color: #999; }
        .error { background: #ffebee; color: #c62828; padding: 15px; border-radius: 8px; margin-bottom: 20px; }
    </style>
</head>
<body>
    <div class="container">
        <div class="header">
            <h1>🚀 토큰 거래 내역 조회 시스템</h1>
            <p>블록체인 데이터를 실시간으로 조회하세요</p>
        </div>
        
        <div class="search-box">
            <h2>지갑 주소 검색</h2>
            <input type="text" id="walletAddress" placeholder="0x로 시작하는 지갑 주소를 입력하세요">
            <input type="text" id="tokenAddress" placeholder="토큰 컨트랙트 주소 (선택사항)">
            <button onclick="searchTransactions()">검색</button>
        </div>
        
        <div id="errorMessage"></div>
        
        <div class="results" id="results">
            <div class="loading">지갑 주소를 입력하고 검색 버튼을 클릭하세요</div>
        </div>
    </div>
    
    <script>
        async function searchTransactions() {
            const walletAddress = document.getElementById('walletAddress').value.trim();
            const tokenAddress = document.getElementById('tokenAddress').value.trim();
            const resultsDiv = document.getElementById('results');
            const errorDiv = document.getElementById('errorMessage');
            
            errorDiv.innerHTML = '';
            
            if (!walletAddress) {
                errorDiv.innerHTML = '<div class="error">지갑 주소를 입력해주세요</div>';
                return;
            }
            
            resultsDiv.innerHTML = '<div class="loading">거래 내역을 조회 중입니다...</div>';
            
            try {
                let url = `/api/v1/wallets/${walletAddress}/transactions/`;
                if (tokenAddress) {
                    url += `?token=${tokenAddress}`;
                }
                
                const response = await fetch(url);
                
                if (!response.ok) {
                    throw new Error('거래 내역 조회에 실패했습니다');
                }
                
                const data = await response.json();
                displayTransactions(data.results || data);
                
            } catch (error) {
                errorDiv.innerHTML = `<div class="error">${error.message}</div>`;
                resultsDiv.innerHTML = '';
            }
        }
        
        function displayTransactions(transactions) {
            const resultsDiv = document.getElementById('results');
            
            if (transactions.length === 0) {
                resultsDiv.innerHTML = '<div class="loading">거래 내역이 없습니다</div>';
                return;
            }
            
            let html = '<h2>거래 내역 (' + transactions.length + '건)</h2>';
            
            transactions.forEach(tx => {
                const date = new Date(tx.block_timestamp).toLocaleString('ko-KR');
                html += `
                    <div class="transaction-item">
                        <div class="tx-hash">${tx.transaction_hash}</div>
                        <div>
                            <strong>토큰:</strong> ${tx.token_symbol} | 
                            <strong>금액:</strong> <span class="amount">${tx.value_formatted}</span> | 
                            <strong>시간:</strong> ${date}
                        </div>
                        <div>
                            <strong>From:</strong> ${tx.from_address_str} → 
                            <strong>To:</strong> ${tx.to_address_str}
                        </div>
                    </div>
                `;
            });
            
            resultsDiv.innerHTML = html;
        }
    </script>
</body>
</html>

# dashboard/views.py
from django.shortcuts import render

def index(request):
    """대시보드 메인 페이지"""
    return render(request, 'dashboard/index.html')

# dashboard/urls.py
from django.urls import path
from . import views

urlpatterns = [
    path('', views.index, name='dashboard'),
]

# token_tracker/urls.py에 추가
urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/v1/', include('api.urls')),
    path('', include('dashboard.urls')),  # 추가
]

이제 브라우저에서 http://localhost:8000/에 접속하면 대시보드를 볼 수 있어! 🎉

⚡ 성능 최적화 전략

시스템이 잘 작동한다고 끝이 아니야! 사용자가 많아지면 성능 문제가 생길 수 있거든. 미리 최적화를 해두면 나중에 고생을 덜 수 있어. 🚀

1️⃣ 데이터베이스 쿼리 최적화

transactions = Transaction.objects.all()
for tx in transactions:
    print(tx.token.name)  # 매번 DB 조회!

transactions = Transaction.objects.select_related('token', 'from_address', 'to_address')
for tx in transactions:
    print(tx.token.name)  # 이미 로드됨!

2️⃣ Redis 캐싱 활용

자주 조회되는 데이터는 Redis에 캐싱하면 응답 속도가 엄청 빨라져:

# blockchain/cache.py
from django.core.cache import cache
from django.conf import settings
import json

class TransactionCache:
    """거래 내역 캐시 관리"""
    
    CACHE_TTL = 300  # 5분
    
    @staticmethod
    def get_wallet_transactions_key(wallet_address, token_address=None):
        """캐시 키 생성"""
        if token_address:
            return f"wallet_tx:{wallet_address}:{token_address}"
        return f"wallet_tx:{wallet_address}:all"
    
    @classmethod
    def get_transactions(cls, wallet_address, token_address=None):
        """캐시에서 거래 내역 조회"""
        key = cls.get_wallet_transactions_key(wallet_address, token_address)
        cached_data = cache.get(key)
        
        if cached_data:
            return json.loads(cached_data)
        return None
    
    @classmethod
    def set_transactions(cls, wallet_address, transactions, token_address=None):
        """거래 내역 캐시에 저장"""
        key = cls.get_wallet_transactions_key(wallet_address, token_address)
        cache.set(key, json.dumps(transactions), cls.CACHE_TTL)
    
    @classmethod
    def invalidate(cls, wallet_address, token_address=None):
        """캐시 무효화"""
        key = cls.get_wallet_transactions_key(wallet_address, token_address)
        cache.delete(key)

API View에서 캐시 사용:

# api/views.py에 추가
from blockchain.cache import TransactionCache

class WalletViewSet(viewsets.ReadOnlyModelViewSet):
    # ... 기존 코드 ...
    
    @action(detail=True, methods=['get'])
    def transactions(self, request, address=None):
        """특정 지갑의 거래 내역 조회 (캐싱 적용)"""
        wallet = self.get_object()
        token_address = request.query_params.get('token', None)
        
        # 캐시 확인
        cached_data = TransactionCache.get_transactions(
            wallet.address, 
            token_address
        )
        
        if cached_data:
            return Response(cached_data)
        
        # 캐시 미스 - DB에서 조회
        transactions = Transaction.objects.filter(
            Q(from_address=wallet) | Q(to_address=wallet)
        ).select_related('token', 'from_address', 'to_address')
        
        if token_address:
            transactions = transactions.filter(token__contract_address=token_address)
        
        serializer = TransactionSerializer(transactions[:100], many=True)
        
        # 캐시에 저장
        TransactionCache.set_transactions(
            wallet.address,
            serializer.data,
            token_address
        )
        
        return Response(serializer.data)

3️⃣ 데이터베이스 인덱스 추가

자주 검색하는 필드에 인덱스를 추가하면 조회 속도가 크게 향상돼:

# 마이그레이션 파일 생성
python manage.py makemigrations --empty blockchain

# 생성된 마이그레이션 파일 수정
from django.db import migrations, models

class Migration(migrations.Migration):
    dependencies = [
        ('blockchain', '0001_initial'),
    ]
    
    operations = [
        # 복합 인덱스 추가
        migrations.AddIndex(
            model_name='transaction',
            index=models.Index(
                fields=['from_address', 'token', '-block_timestamp'],
                name='tx_from_token_time_idx'
            ),
        ),
        migrations.AddIndex(
            model_name='transaction',
            index=models.Index(
                fields=['to_address', 'token', '-block_timestamp'],
                name='tx_to_token_time_idx'
            ),
        ),
    ]

4️⃣ 페이지네이션 최적화

대량의 데이터를 한 번에 조회하면 메모리와 네트워크 대역폭을 많이 사용해. 커서 기반 페이지네이션을 사용하면 더 효율적이야:

# api/pagination.py
from rest_framework.pagination import CursorPagination

class TransactionCursorPagination(CursorPagination):
    """커서 기반 페이지네이션"""
    page_size = 50
    ordering = '-block_timestamp'
    cursor_query_param = 'cursor'

5️⃣ 배치 처리 최적화

대량의 데이터를 저장할 때는 bulk_create를 사용하면 훨씬 빨라:

# blockchain/services.py 수정
@staticmethod
def sync_token_transactions_bulk(token, from_block, to_block):
    """대량 거래 내역 동기화 (최적화 버전)"""
    try:
        w3 = web3_connection.w3
        erc20 = ERC20Token(token.contract_address)
        
        events = erc20.get_transfer_events(from_block, to_block)
        
        # 기존 거래 해시 조회 (한 번만)
        existing_hashes = set(
            Transaction.objects.filter(
                transaction_hash__in=[e['transactionHash'].hex() for e in events]
            ).values_list('transaction_hash', flat=True)
        )
        
        # 새로운 거래만 필터링
        new_events = [e for e in events if e['transactionHash'].hex() not in existing_hashes]
        
        if not new_events:
            return 0
        
        # 지갑 주소 일괄 생성
        addresses = set()
        for event in new_events:
            addresses.add(event['args']['from'])
            addresses.add(event['args']['to'])
        
        existing_wallets = {
            w.address: w for w in Wallet.objects.filter(address__in=addresses)
        }
        
        new_wallets = []
        for addr in addresses:
            if addr not in existing_wallets:
                new_wallets.append(Wallet(address=addr))
        
        if new_wallets:
            Wallet.objects.bulk_create(new_wallets, ignore_conflicts=True)
            # 다시 조회
            existing_wallets = {
                w.address: w for w in Wallet.objects.filter(address__in=addresses)
            }
        
        # 거래 객체 생성
        transactions = []
        for event in new_events:
            tx = w3.eth.get_transaction(event['transactionHash'])
            receipt = w3.eth.get_transaction_receipt(event['transactionHash'])
            block = w3.eth.get_block(event['blockNumber'])
            
            transactions.append(Transaction(
                transaction_hash=event['transactionHash'].hex(),
                token=token,
                from_address=existing_wallets[event['args']['from']],
                to_address=existing_wallets[event['args']['to']],
                value=event['args']['value'],
                block_number=event['blockNumber'],
                block_timestamp=datetime.fromtimestamp(block['timestamp'], tz=timezone.utc),
                gas_price=tx['gasPrice'],
                gas_used=receipt['gasUsed'],
                transaction_fee=Decimal(tx['gasPrice'] * receipt['gasUsed']) / Decimal(10**18),
                status='success' if receipt['status'] == 1 else 'failed'
            ))
        
        # 일괄 저장
        Transaction.objects.bulk_create(transactions, batch_size=1000)
        
        return len(transactions)
        
    except Exception as e:
        logger.error(f"대량 동기화 실패: {str(e)}")
        raise

🔒 보안 고려사항

블록체인 시스템을 다루다 보면 보안이 정말 중요해. 특히 API 키나 개인 정보를 다룰 때는 더욱 조심해야 해! 🛡️

1️⃣ 환경 변수 보호

2️⃣ API 요청 제한 (Rate Limiting)

무분별한 API 호출을 방지하기 위해 요청 제한을 걸어야 해:

# settings.py에 추가
REST_FRAMEWORK = {
    # ... 기존 설정 ...
    'DEFAULT_THROTTLE_CLASSES': [
        'rest_framework.throttling.AnonRateThrottle',
        'rest_framework.throttling.UserRateThrottle'
    ],
    'DEFAULT_THROTTLE_RATES': {
        'anon': '100/hour',  # 익명 사용자: 시간당 100회
        'user': '1000/hour',  # 인증 사용자: 시간당 1000회
    }
}

3️⃣ 입력 값 검증

사용자 입력은 항상 검증해야 해. 특히 블록체인 주소는 형식이 정해져 있으니까 확실히 체크하자:

# api/validators.py
from rest_framework import serializers
from web3 import Web3

def validate_ethereum_address(value):
    """이더리움 주소 검증"""
    if not value:
        raise serializers.ValidationError("주소를 입력해주세요")
    
    if not value.startswith('0x'):
        raise serializers.ValidationError("주소는 0x로 시작해야 합니다")
    
    if len(value) != 42:
        raise serializers.ValidationError("주소 길이가 올바르지 않습니다")
    
    if not Web3.is_address(value):
        raise serializers.ValidationError("유효하지 않은 이더리움 주소입니다")
    
    return Web3.to_checksum_address(value)


# serializers.py에서 사용
class WalletAddressSerializer(serializers.Serializer):
    address = serializers.CharField(validators=[validate_ethereum_address])

4️⃣ CORS 설정

프론트엔드가 다른 도메인에 있다면 CORS 설정이 필요해:

# settings.py
INSTALLED_APPS = [
    # ...
    'corsheaders',
]

MIDDLEWARE = [
    'corsheaders.middleware.CorsMiddleware',
    # ...
]

# 개발 환경
CORS_ALLOWED_ORIGINS = [
    "http://localhost:3000",
    "http://127.0.0.1:3000",
]

# 프로덕션 환경에서는 실제 도메인만 허용
# CORS_ALLOWED_ORIGINS = [
#     "https://yourdomain.com",
# ]

5️⃣ SQL Injection 방지

Django ORM을 사용하면 대부분 자동으로 방지되지만, raw SQL을 사용할 때는 조심해야 해:

# ❌ 위험한 코드
def get_transactions_unsafe(wallet_address):
    query = f"SELECT * FROM transactions WHERE from_address = '{wallet_address}'"
    return Transaction.objects.raw(query)

# ✅ 안전한 코드
def get_transactions_safe(wallet_address):
    query = "SELECT * FROM transactions WHERE from_address = %s"
    return Transaction.objects.raw(query, [wallet_address])

🧪 테스트 코드 작성

테스트 코드는 귀찮아 보이지만, 나중에 버그를 찾고 수정하는 시간을 엄청 줄여줘. 특히 블록체인 같은 복잡한 시스템에서는 필수야! 🔬

📝 단위 테스트 (Unit Test)

# blockchain/tests/test_models.py
from django.test import TestCase
from django.utils import timezone
from decimal import Decimal
from blockchain.models import Token, Wallet, Transaction

class TokenModelTest(TestCase):
    """Token 모델 테스트"""
    
    def setUp(self):
        self.token = Token.objects.create(
            contract_address="0x1234567890123456789012345678901234567890",
            name="Test Token",
            symbol="TEST",
            decimals=18,
            total_supply=1000000
        )
    
    def test_token_creation(self):
        """토큰 생성 테스트"""
        self.assertEqual(self.token.name, "Test Token")
        self.assertEqual(self.token.symbol, "TEST")
        self.assertEqual(self.token.decimals, 18)
    
    def test_token_str(self):
        """토큰 문자열 표현 테스트"""
        self.assertEqual(str(self.token), "Test Token (TEST)")


class TransactionModelTest(TestCase):
    """Transaction 모델 테스트"""
    
    def setUp(self):
        self.token = Token.objects.create(
            contract_address="0x1234567890123456789012345678901234567890",
            name="Test Token",
            symbol="TEST",
            decimals=18
        )
        
        self.from_wallet = Wallet.objects.create(
            address="0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
        )
        
        self.to_wallet = Wallet.objects.create(
            address="0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
        )
        
        self.transaction = Transaction.objects.create(
            transaction_hash="0xabcdef1234567890",
            token=self.token,
            from_address=self.from_wallet,
            to_address=self.to_wallet,
            value=Decimal("1000000000000000000"),  # 1 token
            block_number=12345678,
            block_timestamp=timezone.now(),
            gas_price=20000000000,
            gas_used=21000,
            transaction_fee=Decimal("0.00042"),
            status='success'
        )
    
    def test_transaction_creation(self):
        """거래 생성 테스트"""
        self.assertEqual(self.transaction.token, self.token)
        self.assertEqual(self.transaction.from_address, self.from_wallet)
        self.assertEqual(self.transaction.to_address, self.to_wallet)
        self.assertEqual(self.transaction.status, 'success')
    
    def test_value_formatted(self):
        """포맷된 값 테스트"""
        # 1000000000000000000 / 10^18 = 1.0
        self.assertEqual(self.transaction.value_formatted, Decimal('1.0'))

🔗 통합 테스트 (Integration Test)

# blockchain/tests/test_services.py
from django.test import TestCase
from unittest.mock import patch, MagicMock
from blockchain.services import TokenService, TransactionService
from blockchain.models import Token

class TokenServiceTest(TestCase):
    """TokenService 테스트"""
    
    @patch('blockchain.services.ERC20Token')
    def test_register_token(self, mock_erc20):
        """토큰 등록 테스트"""
        # Mock 설정
        mock_instance = MagicMock()
        mock_instance.get_token_info.return_value = {
            'address': '0x1234567890123456789012345678901234567890',
            'name': 'Mock Token',
            'symbol': 'MOCK',
            'decimals': 18,
            'total_supply': 1000000
        }
        mock_erc20.return_value = mock_instance
        
        # 토큰 등록
        token = TokenService.register_token(
            '0x1234567890123456789012345678901234567890'
        )
        
        # 검증
        self.assertIsNotNone(token)
        self.assertEqual(token.name, 'Mock Token')
        self.assertEqual(token.symbol, 'MOCK')
        
        # 중복 등록 테스트
        token2 = TokenService.register_token(
            '0x1234567890123456789012345678901234567890'
        )
        self.assertEqual(token.id, token2.id)

🌐 API 테스트

# api/tests/test_views.py
from django.test import TestCase
from django.urls import reverse
from rest_framework.test import APIClient
from rest_framework import status
from blockchain.models import Token, Wallet, Transaction
from django.utils import timezone
from decimal import Decimal

class TokenAPITest(TestCase):
    """Token API 테스트"""
    
    def setUp(self):
        self.client = APIClient()
        self.token = Token.objects.create(
            contract_address="0x1234567890123456789012345678901234567890",
            name="Test Token",
            symbol="TEST",
            decimals=18
        )
    
    def test_list_tokens(self):
        """토큰 목록 조회 테스트"""
        url = reverse('token-list')
        response = self.client.get(url)
        
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(len(response.data['results']), 1)
        self.assertEqual(response.data['results'][0]['symbol'], 'TEST')
    
    def test_retrieve_token(self):
        """토큰 상세 조회 테스트"""
        url = reverse('token-detail', args=[self.token.id])
        response = self.client.get(url)
        
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(response.data['name'], 'Test Token')


class WalletAPITest(TestCase):
    """Wallet API 테스트"""
    
    def setUp(self):
        self.client = APIClient()
        self.wallet = Wallet.objects.create(
            address="0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
            label="Test Wallet"
        )
    
    def test_retrieve_wallet(self):
        """지갑 조회 테스트"""
        url = reverse('wallet-detail', args=[self.wallet.address])
        response = self.client.get(url)
        
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(response.data['address'], self.wallet.address)
        self.assertEqual(response.data['label'], 'Test Wallet')

테스트 실행:

# 모든 테스트 실행
python manage.py test

# 특정 앱만 테스트
python manage.py test blockchain

# 커버리지 측정
pip install coverage
coverage run --source='.' manage.py test
coverage report
coverage html  # HTML 리포트 생성

🚀 배포 및 운영

개발이 끝났다면 이제 실제 서버에 배포할 차례야! 여기서는 간단한 배포 방법을 소개할게. ☁️

🐳 Docker를 이용한 배포

Docker를 사용하면 어떤 환경에서든 동일하게 실행할 수 있어:

# Dockerfile
FROM python:3.10-slim

# 작업 디렉토리 설정
WORKDIR /app

# 시스템 패키지 설치
RUN apt-get update && apt-get install -y \
    postgresql-client \
    && rm -rf /var/lib/apt/lists/*

# Python 패키지 설치
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

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

# 정적 파일 수집
RUN python manage.py collectstatic --noinput

# 포트 노출
EXPOSE 8000

# 실행 명령
CMD ["gunicorn", "token_tracker.wsgi:application", "--bind", "0.0.0.0:8000"]

# docker-compose.yml
version: '3.8'

services:
  db:
    image: postgres:14
    volumes:
      - postgres_data:/var/lib/postgresql/data
    environment:
      - POSTGRES_DB=token_tracker
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=your_password
    ports:
      - "5432:5432"
  
  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
  
  web:
    build: .
    command: gunicorn token_tracker.wsgi:application --bind 0.0.0.0:8000
    volumes:
      - .:/app
      - static_volume:/app/staticfiles
    ports:
      - "8000:8000"
    env_file:
      - .env
    depends_on:
      - db
      - redis
  
  celery:
    build: .
    command: celery -A token_tracker worker --loglevel=info
    volumes:
      - .:/app
    env_file:
      - .env
    depends_on:
      - db
      - redis
  
  celery-beat:
    build: .
    command: celery -A token_tracker beat --loglevel=info
    volumes:
      - .:/app
    env_file:
      - .env
    depends_on:
      - db
      - redis

volumes:
  postgres_data:
  static_volume:

Docker Compose로 실행:

# 빌드 및 실행
docker-compose up -d

# 마이그레이션
docker-compose exec web python manage.py migrate

# 슈퍼유저 생성
docker-compose exec web python manage.py createsuperuser

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

# 중지
docker-compose down

☁️ 클라우드 배포 (AWS 예시)

# EC2에 접속
ssh -i your-key.pem ubuntu@your-ec2-ip

# Docker 설치
sudo apt-get update
sudo apt-get install docker.io docker-compose

# 코드 클론
git clone your-repository-url
cd token_tracker

# 환경 변수 설정
nano .env

# 배포
docker-compose up -d

# /etc/nginx/sites-available/token_tracker
server {
    listen 80;
    server_name your-domain.com;
    
    location / {
        proxy_pass http://localhost:8000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
    
    location /static/ {
        alias /path/to/staticfiles/;
    }
}

📊 모니터링 설정

시스템이 잘 작동하는지 모니터링하는 것도 중요해:

# requirements.txt에 추가
sentry-sdk==1.40.0
django-prometheus==2.3.1

# settings.py에 추가
import sentry_sdk
from sentry_sdk.integrations.django import DjangoIntegration

sentry_sdk.init(
    dsn="your-sentry-dsn",
    integrations=[DjangoIntegration()],
    traces_sample_rate=1.0,
    send_default_pii=True
)

INSTALLED_APPS = [
    # ...
    'django_prometheus',
]

MIDDLEWARE = [
    'django_prometheus.middleware.PrometheusBeforeMiddleware',
    # ... 기존 미들웨어 ...
    'django_prometheus.middleware.PrometheusAfterMiddleware',
]

🎓 실전 프로젝트 확장 아이디어

기본 시스템을 만들었다면, 이제 더 재미있는 기능들을 추가해볼 수 있어! 💡

1️⃣ 실시간 알림 시스템

특정 조건이 만족되면 사용자에게 알림을 보내는 기능:

2️⃣ 데이터 분석 및 시각화

거래 데이터를 분석해서 유용한 인사이트를 제공:

3️⃣ DeFi 프로토콜 통합

Uniswap, Aave 같은 DeFi 프로토콜과 연동:

4️⃣ NFT 거래 추적

ERC-721, ERC-1155 NFT 거래도 추적:

5️⃣ 세금 신고 도우미

암호화폐 거래 세금 신고를 도와주는 기능:

6️⃣ 멀티체인 지원

이더리움뿐만 아니라 다른 블록체인도 지원:

멀티체인 지원을 위한 구조 수정:

# blockchain/models.py에 추가
class Blockchain(models.Model):
    """블록체인 네트워크 모델"""
    
    CHAIN_CHOICES = [
        ('ethereum', 'Ethereum'),
        ('bsc', 'Binance Smart Chain'),
        ('polygon', 'Polygon'),
        ('avalanche', 'Avalanche'),
    ]
    
    name = models.CharField(max_length=50, choices=CHAIN_CHOICES, unique=True)
    chain_id = models.IntegerField(unique=True)
    rpc_url = models.URLField()
    explorer_url = models.URLField()
    is_active = models.BooleanField(default=True)
    
    def __str__(self):
        return self.get_name_display()


# Token 모델에 blockchain 필드 추가
class Token(models.Model):
    blockchain = models.ForeignKey(
        Blockchain,
        on_delete=models.CASCADE,
        related_name='tokens'
    )
    # ... 기존 필드들 ...

🎯 마무리하며

와! 여기까지 오느라 수고했어! 🎉

우리는 파이썬과 장고를 사용해서 토큰 거래 내역 조회 시스템을 처음부터 끝까지 만들어봤어. 블록체인 데이터 구조 이해부터 시작해서, Web3.py로 데이터 조회하고, Django로 백엔드 구축하고, REST API 만들고, 심지어 배포까지!

이 시스템은 단순히 거래 내역을 보여주는 것 이상의 가치가 있어. 블록체인 데이터를 다루는 방법을 배웠고, 대용량 데이터를 효율적으로 처리하는 방법도 익혔지. 그리고 무엇보다 실제로 작동하는 프로젝트를 만들었다는 게 중요해!

📚 핵심 요약

🚀 다음 단계

이제 이 시스템을 기반으로 더 발전시킬 수 있어:

💪 실전 프로젝트 아이디어

배운 내용을 활용해서 이런 프로젝트들을 만들어볼 수 있어:

🌟 마지막 조언

블록체인 개발은 계속 진화하는 분야야. 새로운 기술과 프로토콜이 끊임없이 나오고 있어. 중요한 건 기초를 탄탄히 하고, 꾸준히 학습하는 것이야. 📖

그리고 혼자 하기 어려울 때는 커뮤니티의 도움을 받는 것도 좋아. 재능넷 같은 플랫폼에서 다른 개발자들과 협업하거나, 멘토를 찾아서 배우는 것도 훌륭한 방법이지!

이 글이 도움이 되었기를 바라! 궁금한 점이 있거나 막히는 부분이 있으면 언제든지 커뮤니티에 질문해봐. 우리 모두 처음에는 초보였으니까! 😊

자, 이제 당신만의 멋진 블록체인 프로젝트를 만들어볼 시간이야! 화이팅! 🚀💪