# Example Token Allocation (1B Total Supply)

## Community & Ecosystem (40%)
- Liquidity Mining: 20% (200M tokens)
- Community Rewards: 10% (100M tokens)
- Ecosystem Grants: 10% (100M tokens)

## Team & Advisors (20%)
- Team: 15% (150M tokens) - 4yr vest, 1yr cliff
- Advisors: 5% (50M tokens) - 2yr vest, 6mo cliff

## Investors (25%)
- Seed: 5% (50M tokens) - 3yr vest, 1yr cliff
- Private: 10% (100M tokens) - 2yr vest, 6mo cliff
- Public: 10% (100M tokens) - No lock

## Treasury & Operations (15%)
- Protocol Treasury: 10% (100M tokens)
- Operations: 5% (50M tokens)

# Token Vesting Calculator
def calculate_vesting_schedule(total_tokens, cliff_months, vesting_months):
    """
    Calculate token vesting schedule with cliff
    """
    if cliff_months >= vesting_months:
        return [(vesting_months, total_tokens)]

    cliff_amount = 0  # No tokens during cliff
    monthly_release = total_tokens / (vesting_months - cliff_months)

    schedule = []
    # Cliff period
    for month in range(1, cliff_months + 1):
        schedule.append((month, 0))

    # Vesting period
    cumulative = 0
    for month in range(cliff_months + 1, vesting_months + 1):
        cumulative += monthly_release
        schedule.append((month, min(cumulative, total_tokens)))

    return schedule

# Example: Team vesting (4 year vest, 1 year cliff)
team_schedule = calculate_vesting_schedule(150_000_000, 12, 48)

// Example: Multi-utility token contract
contract UtilityToken {
    // Governance voting power
    mapping(address => uint256) public votingPower;

    // Staking for yield
    mapping(address => StakeInfo) public stakes;

    // Fee discounts based on holdings
    function calculateFeeDiscount(address user, uint256 amount) 
        public view returns (uint256 discount) {
        uint256 balance = balanceOf(user);
        if (balance >= 10000e18) return amount * 50 / 100; // 50% discount
        if (balance >= 1000e18) return amount * 25 / 100;  // 25% discount
        if (balance >= 100e18) return amount * 10 / 100;   // 10% discount
        return 0;
    }

    // Token burn from protocol fees
    function burnFromFees(uint256 amount) external onlyProtocol {
        _burn(address(this), amount);
        emit TokensBurned(amount, totalSupply());
    }
}

# Protocol Revenue Distribution Model
class RevenueDistribution:
    def __init__(self):
        self.fee_structure = {
            'trading_fee': 0.003,  # 0.3%
            'withdrawal_fee': 0.001,  # 0.1%
            'premium_features': 0.01  # 1%
        }

    def calculate_weekly_distribution(self, weekly_volume):
        total_fees = weekly_volume * self.fee_structure['trading_fee']

        distribution = {
            'token_buyback_burn': total_fees * 0.30,  # 30% to buyback & burn
            'staker_rewards': total_fees * 0.40,      # 40% to stakers
            'liquidity_incentives': total_fees * 0.20, # 20% to LP rewards
            'treasury': total_fees * 0.10             # 10% to treasury
        }

        return distribution

# Example calculation
model = RevenueDistribution()
weekly_dist = model.calculate_weekly_distribution(1_000_000)  # $1M volume
print(f"Weekly burn: ${weekly_dist['token_buyback_burn']:,.2f}")

# Liquidity Mining Rewards Calculator
class LiquidityMining:
    def __init__(self, total_rewards_per_epoch, epoch_duration_days):
        self.total_rewards = total_rewards_per_epoch
        self.epoch_duration = epoch_duration_days

    def calculate_user_rewards(self, user_liquidity, total_liquidity, 
                              days_participated):
        user_share = user_liquidity / total_liquidity
        time_weight = days_participated / self.epoch_duration
        base_reward = self.total_rewards * user_share
        return base_reward * time_weight

    def apply_multipliers(self, base_reward, lock_duration_months):
        # Longer locks get higher multipliers
        multipliers = {
            0: 1.0,   # No lock
            3: 1.25,  # 3 month lock
            6: 1.5,   # 6 month lock
            12: 2.0   # 12 month lock
        }
        return base_reward * multipliers.get(lock_duration_months, 1.0)

# Token Launch Phases

## Phase 1: Liquidity Bootstrap (Week 1-2)
- Initial liquidity provision
- Bonding curve or LBP for price discovery
- High emission rewards for early adopters

## Phase 2: Growth Incentives (Month 1-6)
- Liquidity mining programs
- Partnership integrations
- Governance token distribution

## Phase 3: Sustainability (Month 6+)
- Reduce emission rates
- Increase fee capture mechanisms
- Focus on utility-driven demand

# Protocol Owned Liquidity (POL) Management
class POLManager:
    def __init__(self, target_liquidity_ratio=0.8):
        self.target_ratio = target_liquidity_ratio

    def should_buy_liquidity(self, current_pol, total_liquidity):
        current_ratio = current_pol / total_liquidity
        return current_ratio < self.target_ratio

    def calculate_buy_amount(self, treasury_balance, current_pol, total_liquidity):
        current_ratio = current_pol / total_liquidity
        deficit = (self.target_ratio - current_ratio) * total_liquidity
        return min(deficit, treasury_balance * 0.1)  # Max 10% of treasury per buy

# Monte Carlo simulation for tokenomics
import numpy as np

def simulate_token_economics(initial_supply, burn_rate, emission_rate, 
                           simulation_days=365):
    supply_history = [initial_supply]

    for day in range(simulation_days):
        current_supply = supply_history[-1]

        # Random daily volume (log-normal distribution)
        daily_volume = np.random.lognormal(10, 1)

        # Calculate burns and emissions
        daily_burn = daily_volume * burn_rate
        daily_emission = current_supply * emission_rate / 365

        new_supply = current_supply - daily_burn + daily_emission
        supply_history.append(max(new_supply, 0))

    return supply_history

# Run simulation
results = simulate_token_economics(1_000_000_000, 0.001, 0.05)