┌─────────────────────────────────────────────────────────────────────────────┐
│                    TOKEN ENGINEERING FRAMEWORK                              │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  1. OBJECTIVE DEFINITION                                                    │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • What is the purpose of the token?                                 │   │
│  │ • What behaviours are being incentivised?                           │   │
│  │ • What is the desired outcome?                                      │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  2. MECHANISM DESIGN                                                       │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • How will tokens be distributed?                                   │   │
│  │ • How will value accrue?                                            │   │
│  │ • What are the incentive structures?                               │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  3. GAME THEORETIC ANALYSIS                                                │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • What are the strategic interactions?                              │   │
│  │ • What are the equilibrium outcomes?                                │   │
│  │ • Are there potential attacks?                                      │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  4. SIMULATION & MODELLING                                                 │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Model participant behaviour                                       │   │
│  │ • Simulate different scenarios                                      │   │
│  │ • Test robustness                                                    │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  5. IMPLEMENTATION & MONITORING                                            │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Deploy tokenomics                                                 │   │
│  │ • Monitor outcomes                                                 │   │
│  │ • Adjust as needed                                                 │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    TOKENOMIC ARCHITECTURES                                  │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  1. SINGLE TOKEN MODEL                                                     │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • One token serves all functions                                   │   │
│  │ • Examples: ETH, BTC, SOL                                          │   │
│  │ • Pros: Simple, widely understood                                   │   │
│  │ • Cons: Conflicting incentives                                     │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  2. DUAL TOKEN MODEL                                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Governance token + Utility token                                 │   │
│  │ • Examples: MKR (governance) + DAI (utility)                       │   │
│  │ • Pros: Specialised functions                                       │   │
│  │ • Cons: Complexity, arbitrage                                      │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  3. TOKENOMIC LAYERS                                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Multiple layers with different functions                         │   │
│  │ • Examples: veTokens, xTokens, etc.                                │   │
│  │ • Pros: Granular control                                             │   │
│  │ • Cons: High complexity                                             │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  4. HYBRID MODEL                                                           │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Combination of token types                                         │   │
│  │ • Examples: Protocol-owned liquidity tokens                        │   │
│  │ • Pros: Flexible                                                     │   │
│  │ • Cons: Unclear value accrual                                       │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# ===================================================================
# MODULE 9, LESSON 7: ADVANCED TOKENOMICS AND ECONOMIC DESIGN
# ===================================================================

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from typing import Dict, List, Tuple
import random
import warnings
warnings.filterwarnings('ignore')

print("="*70)
print("ADVANCED TOKENOMICS AND ECONOMIC DESIGN")
print("="*70)

# ----------------------------------------------------------------
# PART A: TOKENOMIC SIMULATION FRAMEWORK
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART A: Tokenomic Simulation Framework")
print("-"*60)

class TokenomicSimulation:
    """
    Advanced tokenomic simulation with game theoretic components.
    """
    def __init__(self, name: str, initial_supply: int, max_supply: int):
        self.name = name
        self.supply = initial_supply
        self.max_supply = max_supply
        self.price = 1.0
        self.demand = 0.5
        self.velocity = 1.0
        self.inflation_rate = 0.05
        self.burn_rate = 0.01
        self.stakers = {}
        self.history = []
        self.time = 0
    
    def set_inflation(self, rate: float):
        self.inflation_rate = rate
    
    def set_burn_rate(self, rate: float):
        self.burn_rate = rate
    
    def add_staker(self, address: str, amount: int):
        self.stakers[address] = amount
    
    def step(self) -> Dict:
        """Simulate one time step."""
        self.time += 1
        
        # Inflation: mint new tokens
        minted = self.supply * self.inflation_rate
        self.supply += minted
        
        # Burns: destroy tokens
        burned = self.supply * self.burn_rate
        self.supply -= burned
        
        # Demand simulation (simplified)
        self.demand = 0.5 + 0.3 * self.time / 100 + random.uniform(-0.05, 0.05)
        self.demand = max(0.1, min(1.0, self.demand))
        
        # Velocity simulation (stakers reduce velocity)
        staked_pct = sum(self.stakers.values()) / self.supply if self.supply > 0 else 0
        self.velocity = 1.0 - 0.8 * staked_pct
        
        # Price simulation (MV = PQ)
        # Simplified: price = demand / (supply * velocity)
        self.price = self.demand / (self.supply * self.velocity)
        self.price = max(0.1, self.price)
        
        result = {
            'time': self.time,
            'supply': self.supply,
            'price': self.price,
            'demand': self.demand,
            'velocity': self.velocity,
            'minted': minted,
            'burned': burned,
            'staked_pct': staked_pct
        }
        self.history.append(result)
        return result
    
    def get_metrics(self) -> Dict:
        if not self.history:
            return {}
        last = self.history[-1]
        return {
            'name': self.name,
            'supply': last['supply'],
            'price': last['price'],
            'market_cap': last['supply'] * last['price'],
            'velocity': last['velocity'],
            'staked_pct': last['staked_pct'],
            'steps': self.time
        }

# Simulate token economies
print("Tokenomic Simulation Results:")

# Scenario 1: Healthy tokenomics
token1 = TokenomicSimulation("Healthy Token", 1000000, 10000000)
token1.set_inflation(0.02)  # 2% inflation
token1.set_burn_rate(0.01)  # 1% burn
# Add stakers
for i in range(10):
    token1.add_staker(f"Staker{i}", random.randint(5000, 20000))

for _ in range(50):
    token1.step()

metrics1 = token1.get_metrics()
print(f"\n{metrics1['name']}:")
print(f"  Supply: {metrics1['supply']:,.0f}")
print(f"  Price: ${metrics1['price']:.2f}")
print(f"  Market Cap: ${metrics1['market_cap']:,.0f}")
print(f"  Velocity: {metrics1['velocity']:.2f}")
print(f"  Staked: {metrics1['staked_pct']:.1%}")

# Scenario 2: Poor tokenomics (high inflation, no burns)
token2 = TokenomicSimulation("Poor Token", 1000000, 10000000)
token2.set_inflation(0.15)  # 15% inflation
token2.set_burn_rate(0)  # No burns
# Few stakers
for i in range(3):
    token2.add_staker(f"Staker{i}", random.randint(1000, 5000))

for _ in range(50):
    token2.step()

metrics2 = token2.get_metrics()
print(f"\n{metrics2['name']}:")
print(f"  Supply: {metrics2['supply']:,.0f}")
print(f"  Price: ${metrics2['price']:.2f}")
print(f"  Market Cap: ${metrics2['market_cap']:,.0f}")
print(f"  Velocity: {metrics2['velocity']:.2f}")
print(f"  Staked: {metrics2['staked_pct']:.1%}")

# Scenario 3: Deflationary token
token3 = TokenomicSimulation("Deflationary Token", 1000000, 10000000)
token3.set_inflation(0.005)  # 0.5% inflation
token3.set_burn_rate(0.02)  # 2% burn
# Many stakers
for i in range(20):
    token3.add_staker(f"Staker{i}", random.randint(10000, 50000))

for _ in range(50):
    token3.step()

metrics3 = token3.get_metrics()
print(f"\n{metrics3['name']}:")
print(f"  Supply: {metrics3['supply']:,.0f}")
print(f"  Price: ${metrics3['price']:.2f}")
print(f"  Market Cap: ${metrics3['market_cap']:,.0f}")
print(f"  Velocity: {metrics3['velocity']:.2f}")
print(f"  Staked: {metrics3['staked_pct']:.1%}")

# ----------------------------------------------------------------
# PART B: TOKENOMIC ARCHITECTURE COMPARISON
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART B: Tokenomic Architecture Comparison")
print("-"*60)

architecture_data = {
    'Model': ['Single Token', 'Dual Token', 'Tokenomic Layers', 'Hybrid'],
    'Complexity': ['Low', 'Medium', 'High', 'High'],
    'Flexibility': ['Low', 'Medium', 'High', 'Medium'],
    'Value Accrual': ['Medium', 'High', 'High', 'Medium'],
    'Examples': ['BTC, ETH', 'MKR/DAI', 'veTokens', 'POL Tokens']
}

architecture_df = pd.DataFrame(architecture_data)
print(architecture_df.to_string(index=False))

# ----------------------------------------------------------------
# PART C: SUSTAINABLE TOKENOMICS PRINCIPLES
# -----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: Sustainable Tokenomics Principles")
print("-"*60)

principles_data = {
    'Principle': ['Aligned Incentives', 'Clear Utility', 'Sustainable Supply', 'Value Accrual', 'Community Ownership', 'Adaptability'],
    'Description': [
        'All stakeholders aligned',
        'Token has real use case',
        'Supply mechanisms sustainable',
        'Token captures protocol value',
        'Fair and decentralised distribution',
        'Can evolve over time'
    ],
    'Criticality': ['High', 'High', 'High', 'High', 'Medium', 'Medium']
}

principles_df = pd.DataFrame(principles_data)
print(principles_df.to_string(index=False))

# ----------------------------------------------------------------
# PART D: GAME THEORY IN TOKENOMICS
# -----------------------------------------------------------------

print("\n" + "-"*60)
print("PART D: Game Theory in Tokenomics")
print("-"*60)

game_data = {
    'Concept': ['Nash Equilibrium', 'Prisoner\'s Dilemma', 'Tragedy of the Commons', 'Coordination Games', 'Signalling Games', 'Auction Theory'],
    'Token Application': [
        'Token holding patterns',
        'MEV extraction',
        'Security budgets',
        'Governance voting',
        'Token burns/buybacks',
        'Token sales'
    ],
    'Key Insight': [
        'Stable states emerge',
        'Individual rationality can harm collective',
        'Overuse of resources',
        'Achieving collective outcomes',
        'Communication of information',
        'Value discovery'
    ]
}

game_df = pd.DataFrame(game_data)
print(game_df.to_string(index=False))

# ----------------------------------------------------------------
# PART E: SUMMARY AND RECOMMENDATIONS
# -----------------------------------------------------------------

print("\n" + "="*70)
print("PART E: Summary and Recommendations")
print("="*70)

print("""
Advanced Tokenomics and Economic Design – Key Takeaways:

1. Token engineering: objective definition, mechanism design, game theory, simulation, implementation.
2. Game theory concepts: Nash equilibrium, prisoner's dilemma, coordination games, signalling.
3. Token architectures: single token, dual token, tokenomic layers, hybrid.
4. Value accrual: burn, buyback, revenue share, staking rewards, governance.
5. Sustainability factors: utility, inflation, burn, velocity, adoption, revenue.
6. Common pitfalls: excessive inflation, no value accrual, whale dominance.
7. Principles: aligned incentives, clear utility, sustainable supply, value accrual.

Recommendations:
  - Design tokenomics with clear objectives.
  - Use game theory to anticipate behaviours.
  - Simulate tokenomic scenarios before deployment.
  - Ensure value accrual mechanisms.
  - Balance inflation and deflation.
  - Monitor tokenomic metrics continuously.
  - Be prepared to adapt tokenomics.
""")