🎯 토큰 발행량 제어가 뭐길래?

🔍 실제 프로젝트 사례 분석

🛠️ 개발 환경 준비하기

pip install web3
pip install eth-brownie
pip install python-dotenv
pip install requests

💻 기본 토큰 컨트랙트 구조 이해하기

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

contract ControlledToken {
    string public name = "Controlled Token";
    string public symbol = "CTK";
    uint8 public decimals = 18;
    uint256 public totalSupply;
    uint256 public maxSupply = 1000000 * 10**18; // 100만 개 제한
    
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;
    
    address public owner;
    uint256 public emissionRate = 100 * 10**18; // 블록당 100개
    uint256 public lastMintBlock;
    
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Mint(address indexed to, uint256 amount);
    event Burn(address indexed from, uint256 amount);
    
    modifier onlyOwner() {
        require(msg.sender == owner, "Not owner");
        _;
    }
    
    constructor() {
        owner = msg.sender;
        lastMintBlock = block.number;
    }
    
    function mint(address to, uint256 amount) public onlyOwner {
        require(totalSupply + amount <= maxSupply, "Exceeds max supply");
        totalSupply += amount;
        balanceOf[to] += amount;
        emit Mint(to, amount);
        emit Transfer(address(0), to, amount);
    }
    
    function burn(uint256 amount) public {
        require(balanceOf[msg.sender] >= amount, "Insufficient balance");
        balanceOf[msg.sender] -= amount;
        totalSupply -= amount;
        emit Burn(msg.sender, amount);
        emit Transfer(msg.sender, address(0), amount);
    }
    
    function autoMint() public {
        uint256 blocksPassed = block.number - lastMintBlock;
        uint256 mintAmount = blocksPassed * emissionRate;
        
        if (totalSupply + mintAmount > maxSupply) {
            mintAmount = maxSupply - totalSupply;
        }
        
        if (mintAmount > 0) {
            mint(owner, mintAmount);
            lastMintBlock = block.number;
        }
    }
}

🐍 파이썬으로 토큰 발행량 모니터링 스크립트 만들기

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

load_dotenv()

class TokenSupplyController:
    def __init__(self, contract_address, abi_path, rpc_url):
        """
        토큰 발행량 제어 클래스 초기화
        """
        self.w3 = Web3(Web3.HTTPProvider(rpc_url))
        
        # 연결 확인
        if not self.w3.is_connected():
            raise Exception("블록체인 연결 실패!")
        
        # 컨트랙트 로드
        with open(abi_path, 'r') as f:
            abi = json.load(f)
        
        self.contract = self.w3.eth.contract(
            address=Web3.to_checksum_address(contract_address),
            abi=abi
        )
        
        self.owner_address = os.getenv('OWNER_ADDRESS')
        self.private_key = os.getenv('PRIVATE_KEY')
        
        print(f"✅ 컨트랙트 연결 완료: {contract_address}")
    
    def get_supply_info(self):
        """
        현재 토큰 발행량 정보 조회
        """
        try:
            total_supply = self.contract.functions.totalSupply().call()
            max_supply = self.contract.functions.maxSupply().call()
            emission_rate = self.contract.functions.emissionRate().call()
            
            # Wei를 토큰 단위로 변환
            total_supply_tokens = self.w3.from_wei(total_supply, 'ether')
            max_supply_tokens = self.w3.from_wei(max_supply, 'ether')
            emission_rate_tokens = self.w3.from_wei(emission_rate, 'ether')
            
            supply_percentage = (total_supply / max_supply) * 100
            
            info = {
                'total_supply': float(total_supply_tokens),
                'max_supply': float(max_supply_tokens),
                'emission_rate': float(emission_rate_tokens),
                'supply_percentage': supply_percentage,
                'remaining': float(max_supply_tokens - total_supply_tokens),
                'timestamp': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
            }
            
            return info
        
        except Exception as e:
            print(f"❌ 정보 조회 실패: {str(e)}")
            return None
    
    def print_supply_dashboard(self):
        """
        발행량 대시보드 출력
        """
        info = self.get_supply_info()
        
        if info:
            print("\n" + "="*60)
            print("🪙 토큰 발행량 대시보드")
            print("="*60)
            print(f"📅 조회 시간: {info['timestamp']}")
            print(f"💰 현재 발행량: {info['total_supply']:,.2f} 토큰")
            print(f"🎯 최대 발행량: {info['max_supply']:,.2f} 토큰")
            print(f"📊 발행 비율: {info['supply_percentage']:.2f}%")
            print(f"⏰ 블록당 발행: {info['emission_rate']:,.2f} 토큰")
            print(f"🔄 남은 발행량: {info['remaining']:,.2f} 토큰")
            print("="*60 + "\n")
            
            # 진행률 바 표시
            bar_length = 50
            filled = int(bar_length * info['supply_percentage'] / 100)
            bar = '█' * filled + '░' * (bar_length - filled)
            print(f"진행률: [{bar}] {info['supply_percentage']:.1f}%\n")
    
    def calculate_emission_schedule(self, days=365):
        """
        향후 발행 스케줄 계산
        """
        info = self.get_supply_info()
        
        if not info:
            return None
        
        # 이더리움 기준 하루 약 6500 블록
        blocks_per_day = 6500
        daily_emission = info['emission_rate'] * blocks_per_day
        
        schedule = []
        current_supply = info['total_supply']
        
        for day in range(1, days + 1):
            projected_supply = current_supply + (daily_emission * day)
            
            # 최대 발행량 초과 체크
            if projected_supply > info['max_supply']:
                projected_supply = info['max_supply']
                schedule.append({
                    'day': day,
                    'supply': projected_supply,
                    'note': '최대 발행량 도달'
                })
                break
            
            if day % 30 == 0:  # 매월 기록
                schedule.append({
                    'day': day,
                    'supply': projected_supply,
                    'percentage': (projected_supply / info['max_supply']) * 100
                })
        
        return schedule
    
    def check_supply_alerts(self):
        """
        발행량 알림 체크
        """
        info = self.get_supply_info()
        
        if not info:
            return
        
        alerts = []
        
        # 90% 도달 알림
        if info['supply_percentage'] >= 90:
            alerts.append("⚠️ 경고: 발행량이 90%를 초과했습니다!")
        
        # 95% 도달 알림
        if info['supply_percentage'] >= 95:
            alerts.append("🚨 긴급: 발행량이 95%를 초과했습니다!")
        
        # 99% 도달 알림
        if info['supply_percentage'] >= 99:
            alerts.append("🔴 최고 경고: 발행량이 거의 한계에 도달했습니다!")
        
        for alert in alerts:
            print(alert)
        
        return alerts
    
    def mint_tokens(self, to_address, amount):
        """
        토큰 발행 (owner만 가능)
        """
        try:
            # Wei 단위로 변환
            amount_wei = self.w3.to_wei(amount, 'ether')
            
            # 트랜잭션 준비
            nonce = self.w3.eth.get_transaction_count(self.owner_address)
            
            transaction = self.contract.functions.mint(
                Web3.to_checksum_address(to_address),
                amount_wei
            ).build_transaction({
                'from': self.owner_address,
                'nonce': nonce,
                'gas': 200000,
                'gasPrice': self.w3.eth.gas_price
            })
            
            # 트랜잭션 서명
            signed_txn = self.w3.eth.account.sign_transaction(
                transaction,
                private_key=self.private_key
            )
            
            # 트랜잭션 전송
            tx_hash = self.w3.eth.send_raw_transaction(signed_txn.rawTransaction)
            
            print(f"⏳ 토큰 발행 중... TX: {tx_hash.hex()}")
            
            # 트랜잭션 완료 대기
            receipt = self.w3.eth.wait_for_transaction_receipt(tx_hash)
            
            if receipt['status'] == 1:
                print(f"✅ {amount} 토큰 발행 완료!")
                return tx_hash.hex()
            else:
                print("❌ 트랜잭션 실패")
                return None
        
        except Exception as e:
            print(f"❌ 발행 실패: {str(e)}")
            return None
    
    def monitor_continuous(self, interval=60):
        """
        지속적인 모니터링
        """
        print("🔄 지속 모니터링 시작...")
        print(f"⏰ 갱신 주기: {interval}초\n")
        
        try:
            while True:
                self.print_supply_dashboard()
                self.check_supply_alerts()
                time.sleep(interval)
        
        except KeyboardInterrupt:
            print("\n⏹️ 모니터링 종료")


# 사용 예시
if __name__ == "__main__":
    # 설정
    CONTRACT_ADDRESS = "0x..."  # 실제 컨트랙트 주소
    ABI_PATH = "token_abi.json"
    RPC_URL = "https://mainnet.infura.io/v3/YOUR_PROJECT_ID"
    
    # 컨트롤러 초기화
    controller = TokenSupplyController(CONTRACT_ADDRESS, ABI_PATH, RPC_URL)
    
    # 현재 상태 확인
    controller.print_supply_dashboard()
    
    # 발행 스케줄 계산
    schedule = controller.calculate_emission_schedule(365)
    
    if schedule:
        print("\n📅 향후 12개월 발행 예측:")
        print("-" * 60)
        for item in schedule:
            if 'note' in item:
                print(f"Day {item['day']}: {item['supply']:,.2f} - {item['note']}")
            else:
                print(f"Day {item['day']}: {item['supply']:,.2f} ({item['percentage']:.1f}%)")
    
    # 알림 체크
    controller.check_supply_alerts()
    
    # 지속 모니터링 (선택사항)
    # controller.monitor_continuous(interval=300)  # 5분마다

🎮 고급 발행량 제어 전략

⏰ 시간 기반 베스팅 (Time-based Vesting)

import time
from datetime import datetime, timedelta
from typing import List, Dict

class VestingScheduler:
    def __init__(self):
        self.schedules = {}
    
    def create_vesting_schedule(
        self,
        beneficiary: str,
        total_amount: float,
        start_date: datetime,
        cliff_months: int,
        vesting_months: int,
        release_frequency: str = 'monthly'
    ):
        """
        베스팅 스케줄 생성
        
        Args:
            beneficiary: 수혜자 주소
            total_amount: 총 토큰 양
            start_date: 시작 날짜
            cliff_months: 클리프 기간 (이 기간 동안은 0개)
            vesting_months: 총 베스팅 기간
            release_frequency: 릴리즈 주기 (monthly, quarterly, etc.)
        """
        
        schedule = {
            'beneficiary': beneficiary,
            'total_amount': total_amount,
            'start_date': start_date,
            'cliff_date': start_date + timedelta(days=cliff_months * 30),
            'end_date': start_date + timedelta(days=vesting_months * 30),
            'cliff_months': cliff_months,
            'vesting_months': vesting_months,
            'released_amount': 0,
            'release_frequency': release_frequency,
            'releases': []
        }
        
        # 릴리즈 스케줄 계산
        if release_frequency == 'monthly':
            periods = vesting_months - cliff_months
            amount_per_period = total_amount / vesting_months
            
            for i in range(periods):
                release_date = schedule['cliff_date'] + timedelta(days=(i+1) * 30)
                schedule['releases'].append({
                    'date': release_date,
                    'amount': amount_per_period,
                    'released': False
                })
        
        self.schedules[beneficiary] = schedule
        
        print(f"✅ 베스팅 스케줄 생성 완료")
        print(f"   수혜자: {beneficiary}")
        print(f"   총액: {total_amount:,.2f} 토큰")
        print(f"   클리프: {cliff_months}개월")
        print(f"   베스팅: {vesting_months}개월")
        
        return schedule
    
    def get_vested_amount(self, beneficiary: str) -> float:
        """
        현재까지 베스팅된 금액 계산
        """
        if beneficiary not in self.schedules:
            return 0
        
        schedule = self.schedules[beneficiary]
        now = datetime.now()
        
        # 클리프 기간 체크
        if now < schedule['cliff_date']:
            return 0
        
        # 베스팅 완료 체크
        if now >= schedule['end_date']:
            return schedule['total_amount']
        
        # 선형 베스팅 계산
        total_days = (schedule['end_date'] - schedule['cliff_date']).days
        elapsed_days = (now - schedule['cliff_date']).days
        
        vested_amount = (schedule['total_amount'] * elapsed_days) / total_days
        
        return vested_amount
    
    def get_releasable_amount(self, beneficiary: str) -> float:
        """
        현재 릴리즈 가능한 금액 계산
        """
        vested = self.get_vested_amount(beneficiary)
        schedule = self.schedules.get(beneficiary)
        
        if not schedule:
            return 0
        
        releasable = vested - schedule['released_amount']
        return max(0, releasable)
    
    def release_tokens(self, beneficiary: str) -> Dict:
        """
        토큰 릴리즈 실행
        """
        releasable = self.get_releasable_amount(beneficiary)
        
        if releasable <= 0:
            return {
                'success': False,
                'message': '릴리즈 가능한 토큰이 없습니다.'
            }
        
        schedule = self.schedules[beneficiary]
        schedule['released_amount'] += releasable
        
        return {
            'success': True,
            'amount': releasable,
            'total_released': schedule['released_amount'],
            'remaining': schedule['total_amount'] - schedule['released_amount']
        }
    
    def print_vesting_status(self, beneficiary: str):
        """
        베스팅 상태 출력
        """
        if beneficiary not in self.schedules:
            print("❌ 베스팅 스케줄을 찾을 수 없습니다.")
            return
        
        schedule = self.schedules[beneficiary]
        vested = self.get_vested_amount(beneficiary)
        releasable = self.get_releasable_amount(beneficiary)
        
        print("\n" + "="*60)
        print(f"🔐 베스팅 상태: {beneficiary[:10]}...")
        print("="*60)
        print(f"💰 총 할당량: {schedule['total_amount']:,.2f} 토큰")
        print(f"✅ 베스팅 완료: {vested:,.2f} 토큰 ({vested/schedule['total_amount']*100:.1f}%)")
        print(f"🎁 릴리즈 완료: {schedule['released_amount']:,.2f} 토큰")
        print(f"🔓 릴리즈 가능: {releasable:,.2f} 토큰")
        print(f"🔒 잠금 상태: {schedule['total_amount'] - vested:,.2f} 토큰")
        print(f"📅 시작일: {schedule['start_date'].strftime('%Y-%m-%d')}")
        print(f"⏰ 클리프 종료: {schedule['cliff_date'].strftime('%Y-%m-%d')}")
        print(f"🏁 베스팅 종료: {schedule['end_date'].strftime('%Y-%m-%d')}")
        print("="*60 + "\n")


# 사용 예시
if __name__ == "__main__":
    scheduler = VestingScheduler()
    
    # 팀 토큰 베스팅 (12개월 클리프, 48개월 베스팅)
    team_schedule = scheduler.create_vesting_schedule(
        beneficiary="0xTeamWallet...",
        total_amount=1000000,  # 100만 토큰
        start_date=datetime.now(),
        cliff_months=12,
        vesting_months=48,
        release_frequency='monthly'
    )
    
    # 투자자 토큰 베스팅 (6개월 클리프, 24개월 베스팅)
    investor_schedule = scheduler.create_vesting_schedule(
        beneficiary="0xInvestorWallet...",
        total_amount=500000,  # 50만 토큰
        start_date=datetime.now(),
        cliff_months=6,
        vesting_months=24,
        release_frequency='monthly'
    )
    
    # 상태 확인
    scheduler.print_vesting_status("0xTeamWallet...")
    
    # 릴리즈 가능 여부 체크
    result = scheduler.release_tokens("0xTeamWallet...")
    print(f"릴리즈 결과: {result}")

🔥 동적 소각 메커니즘 (Dynamic Burn Mechanism)

class DynamicBurnController:
    def __init__(self, token_controller):
        self.controller = token_controller
        self.burn_history = []
        self.burn_strategies = {
            'fixed': self.fixed_burn,
            'percentage': self.percentage_burn,
            'dynamic': self.dynamic_burn
        }
    
    def fixed_burn(self, amount: float) -> Dict:
        """
        고정 금액 소각
        """
        info = self.controller.get_supply_info()
        
        if amount > info['total_supply']:
            return {
                'success': False,
                'message': '소각 금액이 총 발행량을 초과합니다.'
            }
        
        # 실제 소각 로직 (여기서는 시뮬레이션)
        new_supply = info['total_supply'] - amount
        
        burn_record = {
            'timestamp': datetime.now(),
            'strategy': 'fixed',
            'amount': amount,
            'supply_before': info['total_supply'],
            'supply_after': new_supply,
            'burn_percentage': (amount / info['total_supply']) * 100
        }
        
        self.burn_history.append(burn_record)
        
        return {
            'success': True,
            'burned': amount,
            'new_supply': new_supply,
            'deflation_rate': burn_record['burn_percentage']
        }
    
    def percentage_burn(self, percentage: float) -> Dict:
        """
        비율 기반 소각
        """
        info = self.controller.get_supply_info()
        burn_amount = info['total_supply'] * (percentage / 100)
        
        return self.fixed_burn(burn_amount)
    
    def dynamic_burn(self, transaction_volume: float, burn_rate: float = 0.1) -> Dict:
        """
        거래량 기반 동적 소각 (EIP-1559 스타일)
        
        Args:
            transaction_volume: 거래량
            burn_rate: 소각 비율 (기본 10%)
        """
        burn_amount = transaction_volume * burn_rate
        
        result = self.fixed_burn(burn_amount)
        result['transaction_volume'] = transaction_volume
        result['burn_rate'] = burn_rate
        
        return result
    
    def calculate_deflation_impact(self, burn_amount: float) -> Dict:
        """
        소각이 토큰 경제에 미치는 영향 계산
        """
        info = self.controller.get_supply_info()
        
        # 현재 가격 가정 (실제로는 오라클이나 DEX에서 가져와야 함)
        assumed_price = 1.0  # $1
        
        # 소각 후 공급량
        new_supply = info['total_supply'] - burn_amount
        
        # 단순 공급-수요 모델 (실제로는 훨씬 복잡함)
        supply_reduction = (burn_amount / info['total_supply']) * 100
        
        # 가격 상승 예측 (매우 단순화된 모델)
        # 실제로는 유동성, 거래량, 시장 심리 등 고려해야 함
        estimated_price_impact = supply_reduction * 0.5  # 50% 효과 가정
        
        return {
            'burn_amount': burn_amount,
            'supply_reduction_pct': supply_reduction,
            'new_supply': new_supply,
            'estimated_price_impact_pct': estimated_price_impact,
            'estimated_new_price': assumed_price * (1 + estimated_price_impact / 100)
        }
    
    def get_optimal_burn_rate(self, target_deflation: float, time_period_days: int) -> float:
        """
        목표 디플레이션율을 달성하기 위한 최적 소각률 계산
        
        Args:
            target_deflation: 목표 디플레이션율 (%)
            time_period_days: 기간 (일)
        """
        info = self.controller.get_supply_info()
        
        # 일일 소각량 계산
        total_burn_needed = info['total_supply'] * (target_deflation / 100)
        daily_burn = total_burn_needed / time_period_days
        
        # 일일 소각률
        daily_burn_rate = (daily_burn / info['total_supply']) * 100
        
        return {
            'target_deflation': target_deflation,
            'time_period_days': time_period_days,
            'total_burn_needed': total_burn_needed,
            'daily_burn_amount': daily_burn,
            'daily_burn_rate': daily_burn_rate
        }
    
    def print_burn_analytics(self):
        """
        소각 분석 리포트 출력
        """
        if not self.burn_history:
            print("📊 소각 기록이 없습니다.")
            return
        
        total_burned = sum(record['amount'] for record in self.burn_history)
        
        print("\n" + "="*60)
        print("🔥 소각 분석 리포트")
        print("="*60)
        print(f"📅 총 소각 횟수: {len(self.burn_history)}회")
        print(f"💰 총 소각량: {total_burned:,.2f} 토큰")
        print(f"📊 평균 소각량: {total_burned/len(self.burn_history):,.2f} 토큰")
        print("\n최근 소각 기록:")
        print("-"*60)
        
        for record in self.burn_history[-5:]:  # 최근 5개
            print(f"⏰ {record['timestamp'].strftime('%Y-%m-%d %H:%M:%S')}")
            print(f"   전략: {record['strategy']}")
            print(f"   소각량: {record['amount']:,.2f} ({record['burn_percentage']:.2f}%)")
            print(f"   공급량: {record['supply_before']:,.2f} → {record['supply_after']:,.2f}")
            print()
        
        print("="*60 + "\n")


# 사용 예시
if __name__ == "__main__":
    # 기존 컨트롤러 사용
    burn_controller = DynamicBurnController(controller)
    
    # 고정 금액 소각
    result = burn_controller.fixed_burn(1000)
    print(f"소각 결과: {result}")
    
    # 거래량 기반 동적 소각
    result = burn_controller.dynamic_burn(
        transaction_volume=10000,  # $10,000 거래량
        burn_rate=0.1  # 10% 소각
    )
    print(f"동적 소각 결과: {result}")
    
    # 소각 영향 분석
    impact = burn_controller.calculate_deflation_impact(5000)
    print(f"\n소각 영향 분석:")
    print(f"  공급 감소: {impact['supply_reduction_pct']:.2f}%")
    print(f"  예상 가격 영향: +{impact['estimated_price_impact_pct']:.2f}%")
    
    # 최적 소각률 계산
    optimal = burn_controller.get_optimal_burn_rate(
        target_deflation=5.0,  # 5% 디플레이션 목표
        time_period_days=365  # 1년
    )
    print(f"\n최적 소각 전략:")
    print(f"  일일 소각량: {optimal['daily_burn_amount']:,.2f} 토큰")
    print(f"  일일 소각률: {optimal['daily_burn_rate']:.4f}%")
    
    # 분석 리포트
    burn_controller.print_burn_analytics()

📊 실시간 대시보드 구축하기

from flask import Flask, render_template, jsonify
import plotly.graph_objs as go
import plotly.express as px
from datetime import datetime, timedelta
import json

app = Flask(__name__)

class TokenDashboard:
    def __init__(self, controller, burn_controller, vesting_scheduler):
        self.controller = controller
        self.burn_controller = burn_controller
        self.vesting_scheduler = vesting_scheduler
    
    def get_supply_chart_data(self):
        """
        발행량 차트 데이터 생성
        """
        info = self.controller.get_supply_info()
        
        labels = ['발행됨', '남은 발행량']
        values = [info['total_supply'], info['remaining']]
        colors = ['#66bb6a', '#e0e0e0']
        
        fig = go.Figure(data=[go.Pie(
            labels=labels,
            values=values,
            hole=0.4,
            marker=dict(colors=colors),
            textinfo='label+percent',
            textfont=dict(size=16)
        )])
        
        fig.update_layout(
            title='토큰 발행 현황',
            showlegend=True,
            height=400
        )
        
        return fig.to_json()
    
    def get_emission_projection_data(self, days=365):
        """
        발행 예측 차트 데이터
        """
        schedule = self.controller.calculate_emission_schedule(days)
        
        if not schedule:
            return None
        
        dates = [datetime.now() + timedelta(days=item['day']) for item in schedule]
        supplies = [item['supply'] for item in schedule]
        
        fig = go.Figure()
        
        fig.add_trace(go.Scatter(
            x=dates,
            y=supplies,
            mode='lines+markers',
            name='예상 발행량',
            line=dict(color='#5e35b1', width=3),
            marker=dict(size=6)
        ))
        
        # 최대 발행량 라인
        info = self.controller.get_supply_info()
        fig.add_hline(
            y=info['max_supply'],
            line_dash="dash",
            line_color="red",
            annotation_text="최대 발행량"
        )
        
        fig.update_layout(
            title='향후 발행량 예측',
            xaxis_title='날짜',
            yaxis_title='토큰 수량',
            hovermode='x unified',
            height=400
        )
        
        return fig.to_json()
    
    def get_burn_history_data(self):
        """
        소각 히스토리 차트
        """
        if not self.burn_controller.burn_history:
            return None
        
        dates = [record['timestamp'] for record in self.burn_controller.burn_history]
        amounts = [record['amount'] for record in self.burn_controller.burn_history]
        
        fig = go.Figure()
        
        fig.add_trace(go.Bar(
            x=dates,
            y=amounts,
            name='소각량',
            marker=dict(color='#ff6b6b')
        ))
        
        fig.update_layout(
            title='소각 히스토리',
            xaxis_title='날짜',
            yaxis_title='소각량',
            height=400
        )
        
        return fig.to_json()
    
    def get_metrics_summary(self):
        """
        주요 지표 요약
        """
        info = self.controller.get_supply_info()
        
        # 소각 통계
        total_burned = sum(
            record['amount'] 
            for record in self.burn_controller.burn_history
        ) if self.burn_controller.burn_history else 0
        
        # 베스팅 통계
        total_vested = 0
        total_locked = 0
        for beneficiary, schedule in self.vesting_scheduler.schedules.items():
            vested = self.vesting_scheduler.get_vested_amount(beneficiary)
            total_vested += vested
            total_locked += schedule['total_amount'] - vested
        
        return {
            'current_supply': info['total_supply'],
            'max_supply': info['max_supply'],
            'supply_percentage': info['supply_percentage'],
            'total_burned': total_burned,
            'total_vested': total_vested,
            'total_locked': total_locked,
            'circulating_supply': info['total_supply'] - total_locked
        }


# Flask 라우트
@app.route('/')
def index():
    return '''
    <!DOCTYPE html>
    <html>
    <head>
        <title>토큰 발행량 대시보드</title>
        <script src="https://cdn.plot.ly/plotly-latest.min.js"></script>
        <style>
            body {
                font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
                margin: 0;
                padding: 20px;
                background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            }
            .container {
                max-width: 1400px;
                margin: 0 auto;
                background: white;
                border-radius: 20px;
                padding: 30px;
                box-shadow: 0 10px 40px rgba(0,0,0,0.2);
            }
            h1 {
                color: #5e35b1;
                text-align: center;
                margin-bottom: 40px;
            }
            .metrics {
                display: grid;
                grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
                gap: 20px;
                margin-bottom: 40px;
            }
            .metric-card {
                background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
                color: white;
                padding: 25px;
                border-radius: 15px;
                box-shadow: 0 5px 15px rgba(0,0,0,0.1);
            }
            .metric-value {
                font-size: 2em;
                font-weight: bold;
                margin: 10px 0;
            }
            .metric-label {
                font-size: 0.9em;
                opacity: 0.9;
            }
            .charts {
                display: grid;
                grid-template-columns: repeat(auto-fit, minmax(500px, 1fr));
                gap: 30px;
            }
            .chart-container {
                background: #f8f9fa;
                padding: 20px;
                border-radius: 15px;
            }
        </style>
    </head>
    <body>
        <div class="container">
            <h1>🪙 토큰 발행량 제어 대시보드</h1>
            
            <div class="metrics" id="metrics"></div>
            
            <div class="charts">
                <div class="chart-container">
                    <div id="supply-chart"></div>
                </div>
                <div class="chart-container">
                    <div id="emission-chart"></div>
                </div>
                <div class="chart-container">
                    <div id="burn-chart"></div>
                </div>
            </div>
        </div>
        
        <script>
            // 데이터 로드 및 차트 렌더링
            async function loadDashboard() {
                // 메트릭 로드
                const metrics = await fetch('/api/metrics').then(r => r.json());
                renderMetrics(metrics);
                
                // 차트 로드
                const supplyChart = await fetch('/api/supply-chart').then(r => r.json());
                Plotly.newPlot('supply-chart', JSON.parse(supplyChart).data, JSON.parse(supplyChart).layout);
                
                const emissionChart = await fetch('/api/emission-chart').then(r => r.json());
                Plotly.newPlot('emission-chart', JSON.parse(emissionChart).data, JSON.parse(emissionChart).layout);
                
                const burnChart = await fetch('/api/burn-chart').then(r => r.json());
                if (burnChart) {
                    Plotly.newPlot('burn-chart', JSON.parse(burnChart).data, JSON.parse(burnChart).layout);
                }
            }
            
            function renderMetrics(metrics) {
                const container = document.getElementById('metrics');
                container.innerHTML = `
                    <div class="metric-card">
                        <div class="metric-label">현재 발행량</div>
                        <div class="metric-value">${metrics.current_supply.toLocaleString()}</div>
                    </div>
                    <div class="metric-card">
                        <div class="metric-label">발행률</div>
                        <div class="metric-value">${metrics.supply_percentage.toFixed(1)}%</div>
                    </div>
                    <div class="metric-card">
                        <div class="metric-label">총 소각량</div>
                        <div class="metric-value">${metrics.total_burned.toLocaleString()}</div>
                    </div>
                    <div class="metric-card">
                        <div class="metric-label">유통량</div>
                        <div class="metric-value">${metrics.circulating_supply.toLocaleString()}</div>
                    </div>
                `;
            }
            
            // 5초마다 자동 갱신
            loadDashboard();
            setInterval(loadDashboard, 5000);
        </script>
    </body>
    </html>
    '''

@app.route('/api/metrics')
def api_metrics():
    dashboard = TokenDashboard(controller, burn_controller, vesting_scheduler)
    return jsonify(dashboard.get_metrics_summary())

@app.route('/api/supply-chart')
def api_supply_chart():
    dashboard = TokenDashboard(controller, burn_controller, vesting_scheduler)
    return dashboard.get_supply_chart_data()

@app.route('/api/emission-chart')
def api_emission_chart():
    dashboard = TokenDashboard(controller, burn_controller, vesting_scheduler)
    return dashboard.get_emission_projection_data()

@app.route('/api/burn-chart')
def api_burn_chart():
    dashboard = TokenDashboard(controller, burn_controller, vesting_scheduler)
    return dashboard.get_burn_history_data()

if __name__ == '__main__':
    app.run(debug=True, port=5000)

🔐 보안 고려사항

import hashlib
import hmac
from cryptography.fernet import Fernet
import logging
from datetime import datetime

class SecureTokenController:
    def __init__(self, controller):
        self.controller = controller
        self.setup_logging()
        self.setup_encryption()
        self.action_history = []
    
    def setup_logging(self):
        """
        감사 로그 설정
        """
        logging.basicConfig(
            filename='token_operations.log',
            level=logging.INFO,
            format='%(asctime)s - %(levelname)s - %(message)s'
        )
        self.logger = logging.getLogger(__name__)
    
    def setup_encryption(self):
        """
        암호화 설정
        """
        # 실제로는 안전한 곳에서 키를 가져와야 함
        self.encryption_key = Fernet.generate_key()
        self.cipher = Fernet(self.encryption_key)
    
    def verify_signature(self, message: str, signature: str, secret: str) -> bool:
        """
        HMAC 서명 검증
        """
        expected_signature = hmac.new(
            secret.encode(),
            message.encode(),
            hashlib.sha256
        ).hexdigest()
        
        return hmac.compare_digest(signature, expected_signature)
    
    def log_action(self, action: str, details: dict, user: str):
        """
        모든 액션 로깅
        """
        log_entry = {
            'timestamp': datetime.now().isoformat(),
            'action': action,
            'user': user,
            'details': details
        }
        
        self.action_history.append(log_entry)
        self.logger.info(f"Action: {action} | User: {user} | Details: {details}")
    
    def require_multisig(self, action: str, approvers: list, required_approvals: int = 2):
        """
        멀티시그 승인 시뮬레이션
        """
        print(f"\n🔐 멀티시그 승인 필요: {action}")
        print(f"   필요한 승인 수: {required_approvals}/{len(approvers)}")
        
        approvals = []
        
        for approver in approvers:
            # 실제로는 각 승인자의 서명을 받아야 함
            approval = input(f"   {approver}의 승인을 받았습니까? (y/n): ")
            if approval.lower() == 'y':
                approvals.append(approver)
            
            if len(approvals) >= required_approvals:
                print(f"✅ 충분한 승인을 받았습니다! ({len(approvals)}/{required_approvals})")
                return True
        
        print(f"❌ 승인이 부족합니다. ({len(approvals)}/{required_approvals})")
        return False
    
    def secure_mint(self, to_address: str, amount: float, user: str, approvers: list):
        """
        보안 강화된 토큰 발행
        """
        # 1. 멀티시그 승인
        if not self.require_multisig(f"Mint {amount} tokens", approvers):
            self.log_action('mint_rejected', {
                'to': to_address,
                'amount': amount,
                'reason': 'insufficient_approvals'
            }, user)
            return False
        
        # 2. 발행량 제한 체크
        info = self.controller.get_supply_info()
        if info['total_supply'] + amount > info['max_supply']:
            self.log_action('mint_rejected', {
                'to': to_address,
                'amount': amount,
                'reason': 'exceeds_max_supply'
            }, user)
            return False
        
        # 3. 실제 발행
        try:
            result = self.controller.mint_tokens(to_address, amount)
            
            self.log_action('mint_success', {
                'to': to_address,
                'amount': amount,
                'tx_hash': result
            }, user)
            
            return True
        
        except Exception as e:
            self.log_action('mint_error', {
                'to': to_address,
                'amount': amount,
                'error': str(e)
            }, user)
            return False
    
    def get_audit_report(self, days: int = 30):
        """
        감사 리포트 생성
        """
        cutoff_date = datetime.now() - timedelta(days=days)
        
        recent_actions = [
            action for action in self.action_history
            if datetime.fromisoformat(action['timestamp']) > cutoff_date
        ]
        
        print(f"\n📋 최근 {days}일 감사 리포트")
        print("="*60)
        print(f"총 액션 수: {len(recent_actions)}")
        
        # 액션 타입별 집계
        action_types = {}
        for action in recent_actions:
            action_type = action['action']
            action_types[action_type] = action_types.get(action_type, 0) + 1
        
        print("\n액션 타입별 통계:")
        for action_type, count in action_types.items():
            print(f"  {action_type}: {count}회")
        
        print("\n최근 액션:")
        for action in recent_actions[-10:]:
            print(f"  [{action['timestamp']}] {action['action']} by {action['user']}")
        
        print("="*60 + "\n")


# 사용 예시
if __name__ == "__main__":
    secure_controller = SecureTokenController(controller)
    
    # 보안 강화된 발행
    approvers = ['Admin1', 'Admin2', 'Admin3']
    
    secure_controller.secure_mint(
        to_address="0x...",
        amount=10000,
        user="Admin1",
        approvers=approvers
    )
    
    # 감사 리포트
    secure_controller.get_audit_report(days=30)

🌐 실전 프로젝트 적용 사례

💡 사례 1: DeFi 프로토콜의 거버넌스 토큰

class DeFiTokenController:
    def __init__(self, base_controller):
        self.controller = base_controller
        self.liquidity_mining_pool = 50000000  # 5천만 개
        self.daily_reward_rate = 0.001  # 0.1% per day
        self.fee_burn_rate = 0.5  # 50% of fees
    
    def calculate_liquidity_rewards(self, user_liquidity: float, total_liquidity: float) -> float:
        """
        유동성 채굴 보상 계산
        """
        # 사용자의 유동성 비율
        user_share = user_liquidity / total_liquidity
        
        # 일일 총 보상
        daily_total_reward = self.liquidity_mining_pool * self.daily_reward_rate
        
        # 사용자 보상
        user_reward = daily_total_reward * user_share
        
        return user_reward
    
    def process_trading_fees(self, fee_amount: float, token_price: float):
        """
        거래 수수료 처리 (일부 소각)
        """
        # 소각할 토큰 양 계산
        burn_amount = (fee_amount * self.fee_burn_rate) / token_price
        
        print(f"💰 거래 수수료: ${fee_amount:.2f}")
        print(f"🔥 소각 예정: {burn_amount:.2f} 토큰")
        
        # 실제 소각 실행
        # burn_controller.fixed_burn(burn_amount)
        
        return burn_amount
    
    def adjust_emission_rate(self, new_rate: float, dao_approval: bool):
        """
        발행 속도 조정 (DAO 거버넌스)
        """
        if not dao_approval:
            print("❌ DAO 승인이 필요합니다!")
            return False
        
        old_rate = self.daily_reward_rate
        self.daily_reward_rate = new_rate
        
        print(f"✅ 발행 속도 조정 완료")
        print(f"   이전: {old_rate*100:.3f}% per day")
        print(f"   변경: {new_rate*100:.3f}% per day")
        
        return True


# 실제 사용
defi_controller = DeFiTokenController(controller)

# 유동성 보상 계산
user_liquidity = 100000  # $100,000
total_liquidity = 10000000  # $10,000,000

reward = defi_controller.calculate_liquidity_rewards(user_liquidity, total_liquidity)
print(f"일일 보상: {reward:.2f} 토큰")

# 거래 수수료 처리
defi_controller.process_trading_fees(fee_amount=1000, token_price=2.5)

🎮 사례 2: 게임 내 토큰 경제

class GameTokenEconomy:
    def __init__(self):
        self.total_minted = 0
        self.total_burned = 0
        self.daily_mint_limit = 1000000
        self.target_inflation = 0.05  # 5%
        self.base_reward = 100
    
    def calculate_quest_reward(self, difficulty: str, player_level: int) -> float:
        """
        퀘스트 보상 계산
        """
        difficulty_multiplier = {
            'easy': 1.0,
            'medium': 2.0,
            'hard': 3.5,
            'legendary': 5.0
        }
        
        base = self.base_reward
        diff_mult = difficulty_multiplier.get(difficulty, 1.0)
        level_mult = 1 + (player_level * 0.1)
        
        # 인플레이션 조정
        inflation_rate = self.get_inflation_rate()
        if inflation_rate > self.target_inflation:
            inflation_penalty = 0.8  # 20% 감소
        else:
            inflation_penalty = 1.0
        
        reward = base * diff_mult * level_mult * inflation_penalty
        
        return reward
    
    def process_item_purchase(self, item_price: float, burn_rate: float = 0.3):
        """
        아이템 구매 처리 (일부 소각)
        """
        burn_amount = item_price * burn_rate
        
        self.total_burned += burn_amount
        
        print(f"🛒 아이템 구매: {item_price:.2f} 토큰")
        print(f"🔥 소각: {burn_amount:.2f} 토큰")
        print(f"💰 판매자 수령: {item_price - burn_amount:.2f} 토큰")
        
        return burn_amount
    
    def get_inflation_rate(self) -> float:
        """
        현재 인플레이션율 계산
        """
        if self.total_burned == 0:
            return 1.0
        
        net_supply = self.total_minted - self.total_burned
        inflation = (self.total_minted - self.total_burned) / self.total_minted
        
        return inflation
    
    def daily_economy_report(self):
        """
        일일 경제 리포트
        """
        inflation = self.get_inflation_rate()
        net_supply = self.total_minted - self.total_burned
        
        print("\n" + "="*60)
        print("🎮 게임 경제 일일 리포트")
        print("="*60)
        print(f"💰 총 발행: {self.total_minted:,.2f} 토큰")
        print(f"🔥 총 소각: {self.total_burned:,.2f} 토큰")
        print(f"📊 순 공급: {net_supply:,.2f} 토큰")
        print(f"📈 인플레이션: {inflation*100:.2f}%")
        
        if inflation > self.target_inflation:
            print(f"⚠️ 경고: 목표 인플레이션({self.target_inflation*100}%)을 초과했습니다!")
            print(f"   보상이 자동으로 조정됩니다.")
        else:
            print(f"✅ 경제가 안정적입니다.")
        
        print("="*60 + "\n")


# 게임 경제 시뮬레이션
game_economy = GameTokenEconomy()

# 플레이어들이 퀘스트 완료
for i in range(100):
    reward = game_economy.calculate_quest_reward('medium', player_level=10)
    game_economy.total_minted += reward

# 아이템 구매
for i in range(50):
    game_economy.process_item_purchase(item_price=200)

# 일일 리포트
game_economy.daily_economy_report()

🔧 실전 팁과 베스트 프랙티스

🎓 학습 리소스와 다음 단계

🎯 마무리하며