SECTION 1: LEARNING OBJECTIVES

┌─────────────────────────────────────────────────────────────────────────────┐
│                    VALUATION CHALLENGES                                     │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    LACK OF CASH FLOWS                               │   │
│  │  Most tokens do not generate cash flows like traditional assets.    │   │
│  │  Valuation must rely on network effects and utility.               │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    HIGH VOLATILITY                                   │   │
│  │  Prices can be highly volatile and influenced by sentiment.         │   │
│  │  Short-term speculation dominates.                                 │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    LIMITED HISTORICAL DATA                          │   │
│  │  Most assets are less than a decade old.                           │   │
│  │  Limited data for time-series analysis.                            │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    MARKET INEFFICIENCY                              │   │
│  │  Markets may be inefficient due to information asymmetry.          │   │
│  │  Manipulation and wash trading exist.                              │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    REGULATORY UNCERTAINTY                          │   │
│  │  Regulatory changes can significantly impact value.               │   │
│  │  Jurisdictional differences create complexity.                    │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

V = k × n²

Where:
V = Network value
n = Number of users
k = Proportionality constant

NVT = Market Cap / Daily Transaction Volume

- High NVT: Asset may be overvalued
- Low NVT: Asset may be undervalued

Velocity = Daily Transaction Volume / Circulating Supply

- High velocity: Tokens used for transactions → Lower price
- Low velocity: Tokens held for investment → Higher price

M × V = P × Q

Where:
M = Token supply
V = Velocity
P = Price per unit of value
Q = Quantity of goods/services

Stock = Existing supply
Flow = New supply per year
S2F Ratio = Stock / Flow

- MVRV > 1: Market in profit
- MVRV < 1: Market in loss
- High MVRV: Overvalued
- Low MVRV: Undervalued

# ===================================================================
# MODULE 6, LESSON 4: VALUATION MODELS FOR DIGITAL ASSETS
# ===================================================================

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

print("="*70)
print("VALUATION MODELS FOR DIGITAL ASSETS")
print("="*70)

# ----------------------------------------------------------------
# PART A: METCALFE'S LAW SIMULATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART A: Metcalfe's Law Simulation")
print("-"*60)

class MetcalfeValuation:
    """
    Simulated valuation using Metcalfe's Law.
    """
    def __init__(self, initial_users: int = 1000, initial_value: float = 1000000):
        self.users = initial_users
        self.value = initial_value
        self.k = initial_value / (initial_users ** 2)
        self.history = []
    
    def add_users(self, new_users: int) -> Dict:
        """Simulate user growth and resulting value."""
        self.users += new_users
        new_value = self.k * (self.users ** 2)
        self.history.append({
            'users': self.users,
            'value': new_value,
            'price_per_user': new_value / self.users
        })
        return self.history[-1]
    
    def get_valuation(self) -> float:
        return self.k * (self.users ** 2)
    
    def get_metrics(self) -> Dict:
        return {
            'users': self.users,
            'valuation': self.get_valuation(),
            'value_per_user': self.get_valuation() / self.users,
            'user_growth': len(self.history)
        }

# Simulate network growth
network = MetcalfeValuation(initial_users=1000, initial_value=1000000)

print("Metcalfe's Law Network Growth Simulation:")
for i in range(5):
    new_users = np.random.randint(100, 500)
    network.add_users(new_users)
    
print(f"Initial Users: 1,000")
print(f"Initial Value: ${1_000_000:,.0f}")

metrics = network.get_metrics()
print(f"\nCurrent Users: {metrics['users']:,}")
print(f"Current Valuation: ${metrics['valuation']:,.0f}")
print(f"Value per User: ${metrics['value_per_user']:,.0f}")

# Visualise Metcalfe's Law
fig, ax = plt.subplots(figsize=(10, 5))
user_range = range(1000, 10000, 500)
values = [network.k * (u ** 2) for u in user_range]

ax.plot(user_range, values, color='blue', linewidth=2)
ax.set_xlabel('Users')
ax.set_ylabel('Network Value')
ax.set_title('Metcalfe\'s Law: Network Value vs Users')
ax.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('metcalfe_law.png', dpi=300, bbox_inches='tight')
plt.show()
print("Metcalfe's Law chart saved as 'metcalfe_law.png'")

# ----------------------------------------------------------------
# PART B: NVT RATIO ANALYSIS
# -----------------------------------------------------------------

print("\n" + "-"*60)
print("PART B: NVT Ratio Analysis")
print("-"*60)

class NVTAnalysis:
    """
    Simulated NVT Ratio analysis.
    """
    def __init__(self, market_cap: float, daily_volume: float):
        self.market_cap = market_cap
        self.daily_volume = daily_volume
    
    def calculate_nvt(self) -> float:
        """Calculate Network Value to Transaction Volume ratio."""
        if self.daily_volume == 0:
            return float('inf')
        return self.market_cap / self.daily_volume
    
    def get_valuation_status(self) -> str:
        """Interpret NVT ratio."""
        nvt = self.calculate_nvt()
        if nvt < 10:
            return 'Undervalued'
        elif nvt < 30:
            return 'Fairly Valued'
        elif nvt < 70:
            return 'Overvalued'
        else:
            return 'Highly Overvalued'

# Simulate NVT analysis
nvt_data = [
    {'asset': 'BTC', 'market_cap': 1_000_000_000_000, 'daily_volume': 30_000_000_000},
    {'asset': 'ETH', 'market_cap': 400_000_000_000, 'daily_volume': 15_000_000_000},
    {'asset': 'SOL', 'market_cap': 80_000_000_000, 'daily_volume': 2_000_000_000},
    {'asset': 'AAVE', 'market_cap': 5_000_000_000, 'daily_volume': 200_000_000}
]

print("NVT Ratio Analysis:")
nvt_results = []
for data in nvt_data:
    nvt = NVTAnalysis(data['market_cap'], data['daily_volume'])
    nvt_ratio = nvt.calculate_nvt()
    status = nvt.get_valuation_status()
    nvt_results.append({
        'Asset': data['asset'],
        'NVT Ratio': nvt_ratio,
        'Status': status
    })
    print(f"{data['asset']}: NVT = {nvt_ratio:.1f} ({status})")

# ----------------------------------------------------------------
# PART C: STOCK-TO-FLOW MODEL
# -----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: Stock-to-Flow (S2F) Model")
print("-"*60)

class S2FModel:
    """
    Simulated Stock-to-Flow valuation model.
    """
    def __init__(self, stock: float, annual_flow: float):
        self.stock = stock
        self.annual_flow = annual_flow
    
    def calculate_s2f(self) -> float:
        """Calculate Stock-to-Flow ratio."""
        if self.annual_flow == 0:
            return float('inf')
        return self.stock / self.annual_flow
    
    def estimate_valuation(self) -> float:
        """Estimate valuation based on S2F ratio."""
        s2f = self.calculate_s2f()
        # Simplified model: valuation = 10^s2f * constant
        # This is a simplified version of the Bitcoin S2F model
        return 10 ** (s2f * 0.5) * 1000

# Simulate S2F analysis
s2f_data = [
    {'asset': 'BTC', 'stock': 19_700_000, 'annual_flow': 164_000},
    {'asset': 'ETH', 'stock': 120_000_000, 'annual_flow': 1_500_000},
    {'asset': 'SOL', 'stock': 550_000_000, 'annual_flow': 20_000_000}
]

print("Stock-to-Flow Analysis:")
s2f_results = []
for data in s2f_data:
    s2f = S2FModel(data['stock'], data['annual_flow'])
    ratio = s2f.calculate_s2f()
    estimate = s2f.estimate_valuation()
    s2f_results.append({
        'Asset': data['asset'],
        'S2F Ratio': ratio,
        'Est. Valuation': estimate
    })
    print(f"{data['asset']}: S2F = {ratio:.1f} (Est. Valuation: ${estimate:,.0f})")

# ----------------------------------------------------------------
# PART D: VALUATION FRAMEWORK COMPARISON
# -----------------------------------------------------------------

print("\n" + "-"*60)
print("PART D: Valuation Framework Comparison")
print("-"*60)

valuation_models = {
    'Model': ['Metcalfe\'s Law', 'NVT Ratio', 'S2F', 'MV = PQ', 'DCF', 'MVRV'],
    'Type': ['Network', 'Network', 'Supply', 'Economics', 'Cash Flow', 'Market'],
    'Complexity': ['Low', 'Low', 'Medium', 'Medium', 'High', 'Medium'],
    'Data Availability': ['High', 'High', 'High', 'Medium', 'Low', 'High'],
    'Accuracy': ['Medium', 'Medium', 'Medium', 'High', 'High', 'High']
}

model_df = pd.DataFrame(valuation_models)
print(model_df.to_string(index=False))

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

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

print("""
Valuation Models for Digital Assets – Key Takeaways:

1. Valuation challenges: lack of cash flows, high volatility, limited historical data.
2. Metcalfe's Law: value proportional to users².
3. NVT Ratio: market cap / transaction volume (similar to P/E).
4. Stock-to-Flow: scarcity as a value driver.
5. Equation of Exchange: MV = PQ (velocity, supply, utility).
6. Discounted Cash Flow: applicable to revenue-generating tokens.
7. MVRV Ratio: market value vs realized value (profit/loss indicator).

Recommendations:
  - Use multiple models for triangulation.
  - Focus on network metrics for utility tokens.
  - Use DCF for security tokens with revenue.
  - Monitor S2F for supply-limited tokens.
  - Consider macro conditions and sentiment.
  - Update models as new data becomes available.
  - Understand the limitations of each model.
""")