class DHTOperatorCosts:
    """
    Operating a DHT node costs real resources
    """
    def costs_per_month(self, packets_per_sec=100_000):
        """
        Calculate monthly operating costs
        """
        return {
            'bandwidth': {
                # Liberal input: accept 98% of packets
                'ingress': packets_per_sec * 100,  # bytes/packet
                'ingress_mbps': packets_per_sec * 100 * 8 / 1_000_000,
                'ingress_monthly_gb': packets_per_sec * 100 * 2_628_000 / 1_000_000_000,
                
                # Conservative output: relay 70% to targeted subsets
                'egress': packets_per_sec * 70 * 100,  # 70% relayed
                'egress_mbps': packets_per_sec * 70 * 100 * 8 / 1_000_000,
                'egress_monthly_gb': packets_per_sec * 70 * 100 * 2_628_000 / 1_000_000_000,
                
                'cost_per_gb': 0.10,  # $0.10/GB
                'total_bandwidth_cost': 
                    (packets_per_sec * 170 * 100 * 2_628_000 / 1_000_000_000) * 0.10
            },
            
            'compute': {
                'evaluations_per_sec': packets_per_sec,  # Pidgins evaluation
                'cpu_time_per_eval': 10,  # microseconds
                'total_cpu_sec': packets_per_sec * 10 * 2_628_000 / 1_000_000,
                'cores_needed': 4,
                'cost_per_core_month': 50,
                'total_compute_cost': 200
            },
            
            'storage': {
                'routing_table_size': 10,  # GB
                'cached_packets': 50,  # GB
                'total_storage': 60,  # GB
                'cost_per_gb_month': 0.10,
                'total_storage_cost': 6
            },
            
            'total_monthly': {
                'bandwidth': 447,  # $447/month
                'compute': 200,  # $200/month
                'storage': 6,  # $6/month
                'total': 653,  # $653/month
                
                'conclusion': """
                    Operating DHT node at 100K packets/sec:
                    ~$653/month in real costs
                    
                    This is not free!
                    Operators should be compensated.
                """
            }
        }

class DHTPaymentModel:
    """
    DHT queries cost small fee
    Operators earn based on quality
    Using EVM for payments (Ethereum experience)
    """
    def __init__(self, evm_app):
        # EVM app from post 878 (~400 lines)
        self.evm = evm_app
        
        # Reputation app from post 884 (~300 lines)
        self.reputation = iR3Reputation()
        
        # Payment parameters
        self.query_fee = 0.0001  # ETH per query (~$0.20 at $2000/ETH)
        self.operator_pool = {}  # ETH held for operators
    
    def query_with_payment(self, query, payment_eth):
        """
        Query DHT with payment
        Fee goes to operator pool
        """
        if payment_eth < self.query_fee:
            return {
                'error': 'insufficient_payment',
                'required': self.query_fee,
                'provided': payment_eth
            }
        
        # Execute EVM transaction (payment)
        tx = self.evm.handle_metamask_tx({
            'from': query['requester'],
            'to': 'DHT_POOL',  # Pool contract
            'value': payment_eth,
            'data': {'query': query}
        })
        
        # Broadcast query to DHT (pure flux)
        query_id = self.dht.push_intent({
            'intent': 'paid_query',
            'query': query,
            'payment_tx': tx.hash,
            'from': query['requester']
        })
        
        return {
            'query_id': query_id,
            'payment_tx': tx.hash,
            'fee_paid': payment_eth
        }

class OperatorRewards:
    """
    Operators earn based on quality of service
    Reputation + performance metrics
    """
    def calculate_operator_rewards(self, time_period='day'):
        """
        Distribute rewards based on reputation + performance
        """
        # Get all operators
        operators = self.get_active_operators()
        
        # Total fees collected
        total_fees = self.get_fees_collected(time_period)
        
        # Calculate each operator's weight
        weights = {}
        for op in operators:
            weights[op] = self._calculate_operator_weight(op)
        
        total_weight = sum(weights.values())
        
        # Distribute proportionally
        rewards = {}
        for op in operators:
            share = weights[op] / total_weight
            rewards[op] = {
                'eth_earned': total_fees * share,
                'share_percent': share * 100,
                'reputation': weights[op]['reputation'],
                'performance': weights[op]['performance']
            }
        
        return rewards
    
    def _calculate_operator_weight(self, operator_id):
        """
        Weight = reputation × performance
        """
        # Query reputation (from post 884)
        query_id = self.reputation.query_reputation(operator_id)
        time.sleep(2.0)  # Collect responses
        rep_data = self.reputation.derive_reputation(query_id)
        
        reputation_score = rep_data['reputation']
        
        # Query performance metrics
        perf = self.get_performance_metrics(operator_id)
        
        # Performance score (0-1)
        performance_score = (
            perf['uptime'] * 0.4 +  # 40% weight on uptime
            perf['response_time'] * 0.3 +  # 30% on speed
            perf['accuracy'] * 0.3  # 30% on accuracy
        )
        
        # Combined weight
        weight = reputation_score * performance_score
        
        return {
            'weight': weight,
            'reputation': reputation_score,
            'performance': performance_score,
            'uptime': perf['uptime'],
            'response_time': perf['response_time'],
            'accuracy': perf['accuracy']
        }

class PerformanceMetrics:
    """
    Track DHT operator performance
    """
    def track_operator_performance(self, operator_id):
        """
        Track key metrics over time
        """
        metrics = {
            'uptime': {
                'measure': 'Online time / Total time',
                'target': '>0.99',  # 99%+ uptime
                'weight': 0.4,
                'current': self._measure_uptime(operator_id)
            },
            
            'response_time': {
                'measure': 'Fast responses / Total queries',
                'target': '>0.95',  # 95%+ fast
                'threshold_ms': 100,  # <100ms = fast
                'weight': 0.3,
                'current': self._measure_response_time(operator_id)
            },
            
            'accuracy': {
                'measure': 'Correct responses / Total responses',
                'target': '>0.98',  # 98%+ accurate
                'weight': 0.3,
                'current': self._measure_accuracy(operator_id)
            },
            
            'bandwidth_contribution': {
                'measure': 'Packets relayed / Packets received',
                'target': '>0.70',  # 70%+ relay rate
                'info_only': True,  # Not in weight calculation
                'current': self._measure_relay_rate(operator_id)
            }
        }
        
        # Overall performance score
        score = (
            metrics['uptime']['current'] * metrics['uptime']['weight'] +
            metrics['response_time']['current'] * metrics['response_time']['weight'] +
            metrics['accuracy']['current'] * metrics['accuracy']['weight']
        )
        
        return {
            'metrics': metrics,
            'overall_score': score,
            'grade': self._grade_performance(score)
        }
    
    def _grade_performance(self, score):
        """Letter grade for performance"""
        if score >= 0.95: return 'A+'
        elif score >= 0.90: return 'A'
        elif score >= 0.85: return 'B+'
        elif score >= 0.80: return 'B'
        elif score >= 0.75: return 'C+'
        elif score >= 0.70: return 'C'
        else: return 'D'

class DHTReputationTracking:
    """
    Track DHT operator reputation events
    Using post 884 reputation system
    """
    def record_dht_event(self, operator_id, event_type, **details):
        """
        Record DHT operation events for reputation
        """
        # Use reputation system from post 884
        self.reputation.record_reputation_event(
            event_type=event_type,
            node_id=operator_id,
            **details
        )
    
    def track_good_service(self, operator_id, query):
        """
        Track successful query handling
        """
        self.record_dht_event(
            operator_id,
            'dht_query_success',
            query_id=query['id'],
            response_time_ms=query['response_time'],
            accuracy=True
        )
    
    def track_poor_service(self, operator_id, query, reason):
        """
        Track service failures
        """
        self.record_dht_event(
            operator_id,
            'dht_query_failed',
            query_id=query['id'],
            reason=reason,
            impact='negative'
        )
    
    def track_uptime(self, operator_id, uptime_percent):
        """
        Track uptime over period
        """
        if uptime_percent >= 0.99:
            event_type = 'dht_excellent_uptime'
        elif uptime_percent >= 0.95:
            event_type = 'dht_good_uptime'
        else:
            event_type = 'dht_poor_uptime'
        
        self.record_dht_event(
            operator_id,
            event_type,
            uptime_percent=uptime_percent
        )

class DHTFinanceViaEVM:
    """
    Use EVM for DHT payments
    Leverages Ethereum DeFi experience
    """
    def __init__(self, evm_app):
        # EVM app from post 878 (~400 lines for Metamask)
        self.evm = evm_app
        
        # Deploy payment contracts
        self._deploy_contracts()
    
    def _deploy_contracts(self):
        """
        Deploy smart contracts for DHT payments
        """
        # Query payment contract
        self.query_contract = self.evm.deploy_contract("""
            contract DHTQueryPayment {
                // Pay for DHT query
                function payForQuery(bytes32 queryId) payable {
                    require(msg.value >= MIN_QUERY_FEE);
                    queryFees[queryId] = msg.value;
                    totalFeesCollected += msg.value;
                }
                
                // Claim rewards (operators)
                function claimRewards(bytes32 operatorId, uint256 amount) {
                    require(isValidOperator(operatorId));
                    require(amount <= earned[operatorId]);
                    payable(msg.sender).transfer(amount);
                }
            }
        """)
        
        # Operator staking contract
        self.staking_contract = self.evm.deploy_contract("""
            contract DHTOperatorStaking {
                // Stake to become operator
                function stakeAsOperator(uint256 minStake) payable {
                    require(msg.value >= minStake);
                    operators[msg.sender] = Operator({
                        stake: msg.value,
                        reputation: 0.5,  # Starts neutral
                        active: true
                    });
                }
                
                // Unstake (requires good reputation)
                function unstake() {
                    require(operators[msg.sender].reputation > 0.7);
                    uint256 stake = operators[msg.sender].stake;
                    operators[msg.sender].active = false;
                    payable(msg.sender).transfer(stake);
                }
            }
        """)

def complete_economic_flow_example():
    """
    End-to-end: user pays, operators serve, rewards distribute
    """
    # STEP 1: User pays for query
    user_query = {
        'pattern': 'apple',
        'requester': 'user_alice',
        'payment_eth': 0.0001  # $0.20 at $2000/ETH
    }
    
    # Payment via EVM (Metamask)
    payment_tx = evm.handle_metamask_tx({
        'from': 'user_alice',
        'to': 'QUERY_CONTRACT',
        'value': 0.0001,
        'data': {'query': user_query}
    })
    # → Immediate return (pure flux from post 878)
    
    # STEP 2: Query broadcast to DHT
    dht.push_intent({
        'intent': 'paid_query',
        'query': user_query,
        'payment_tx': payment_tx.hash
    })
    # → Broadcast to all DHT operators (1-to-many)
    # → Immediate return (pure flux)
    
    # STEP 3: Operators evaluate via Pidgins
    for operator in dht_operators:
        # Check rate limiters (from post 901)
        if operator.should_respond(user_query):
            # Record service attempt
            reputation.record_dht_event(
                operator.id,
                'dht_query_attempted'
            )
            
            # Respond P2P (1-to-1)
            operator.respond_p2p(
                to='user_alice',
                data={'pattern': 'apple', 'results': [...]}
            )
            
            # Record successful service
            reputation.record_dht_event(
                operator.id,
                'dht_query_success',
                response_time_ms=15
            )
    
    # STEP 4: Performance tracking
    for operator in dht_operators:
        metrics = performance.track_operator_performance(operator.id)
        # Updates continuously
    
    # STEP 5: Daily reward distribution
    at_end_of_day():
        # Calculate weights (reputation × performance)
        weights = {}
        for operator in dht_operators:
            rep_score = reputation.derive_reputation(operator.id)
            perf_score = performance.get_performance_metrics(operator.id)
            weights[operator.id] = rep_score * perf_score
        
        # Distribute collected fees
        total_fees = query_contract.totalFeesCollected
        
        for operator in dht_operators:
            share = weights[operator.id] / sum(weights.values())
            reward_eth = total_fees * share
            
            # Transfer via EVM
            evm.execute_transfer(
                from_contract='QUERY_CONTRACT',
                to=operator.address,
                amount=reward_eth
            )

class OperatorSelection:
    """
    Users select which DHT operators to query
    Based on reputation + performance
    """
    def select_operators(self, query, num_operators=5):
        """
        Select best operators for query
        """
        # Get all active operators
        all_operators = self.get_active_operators()
        
        # Score each operator
        scores = {}
        for op in all_operators:
            scores[op] = self._score_operator(op, query)
        
        # Sort by score (highest first)
        ranked = sorted(
            scores.items(),
            key=lambda x: x[1]['total_score'],
            reverse=True
        )
        
        # Return top N
        return ranked[:num_operators]
    
    def _score_operator(self, operator_id, query):
        """
        Score operator for this specific query
        """
        # Reputation (from post 884)
        query_id = self.reputation.query_reputation(operator_id)
        time.sleep(2.0)
        rep_data = self.reputation.derive_reputation(query_id)
        rep_score = rep_data['reputation']
        
        # Performance (recent metrics)
        perf = self.performance.get_performance_metrics(operator_id)
        perf_score = perf['overall_score']
        
        # Query-specific factors
        specialization = self._check_specialization(operator_id, query)
        geographic_proximity = self._check_proximity(operator_id, query)
        
        # Combined score
        total_score = (
            rep_score * 0.4 +          # 40% reputation
            perf_score * 0.3 +         # 30% performance
            specialization * 0.2 +     # 20% specialization
            geographic_proximity * 0.1 # 10% proximity
        )
        
        return {
            'total_score': total_score,
            'reputation': rep_score,
            'performance': perf_score,
            'specialization': specialization,
            'proximity': geographic_proximity,
            'confidence': rep_data['confidence']
        }

class NaturalQualityEmergence:
    """
    No central authority needed
    Quality emerges naturally from economics
    """
    def how_quality_emerges(self):
        """
        The natural economic cycle
        """
        return {
            'high_quality_operator': {
                'actions': [
                    'Maintains 99%+ uptime',
                    'Fast responses (<100ms)',
                    'Accurate results (>98%)',
                    'Good bandwidth (relay 70%+)'
                ],
                'reputation_events': [
                    'dht_query_success (many)',
                    'dht_excellent_uptime',
                    'ecosystem_improved'
                ],
                'reputation_score': 0.92,  # High
                'performance_score': 0.95,  # Excellent
                'weight': 0.87,  # Top tier
                'queries_selected': 'High (users choose this operator)',
                'earnings': 'High (large share of fees)',
                'outcome': 'SUCCESS - profitable operation'
            },
            
            'low_quality_operator': {
                'actions': [
                    'Maintains 85% uptime',
                    'Slow responses (>500ms)',
                    'Some errors (90% accurate)',
                    'Poor bandwidth (relay 40%)'
                ],
                'reputation_events': [
                    'dht_query_failed (many)',
                    'dht_poor_uptime',
                    'ecosystem_degraded'
                ],
                'reputation_score': 0.35,  # Low
                'performance_score': 0.45,  # Poor
                'weight': 0.16,  # Low tier
                'queries_selected': 'Low (users avoid this operator)',
                'earnings': 'Low (small share of fees)',
                'outcome': 'LOSS - unprofitable operation → exits or improves'
            },
            
            'natural_result': """
                Good operators: High reputation → Selected more → Earn more → Profitable
                Bad operators: Low reputation → Selected less → Earn less → Exit
                
                No slashing needed!
                No arbitrary punishment!
                Market naturally selects for quality.
                
                This is the power of reputation + payments.
            """
        }

comparison = {
    'traditional_pos': {
        'selection': 'Random weighted by stake',
        'quality_signal': 'Capital (stake amount)',
        'punishment': 'Slashing (lose stake)',
        'entry_barrier': 'High (32 ETH = $64K)',
        'problems': [
            'Stake ≠ quality',
            'Rich can be bad operators',
            'Slashing is arbitrary',
            'High entry barrier'
        ]
    },
    
    'reputation_plus_payments': {
        'selection': 'User choice based on reputation × performance',
        'quality_signal': 'Track record (actions over time)',
        'punishment': 'Natural (lose earnings)',
        'entry_barrier': 'Low (minimal stake)',
        'advantages': [
            'Reputation = quality',
            'Must earn good track record',
            'No arbitrary slashing',
            'Low entry barrier',
            'Market drives quality'
        ]
    },
    
    'example': {
        'pos': {
            'operator_a': 'Stake: 100 ETH, Quality: Poor → Still selected!',
            'operator_b': 'Stake: 10 ETH, Quality: Excellent → Rarely selected',
            'problem': 'Stake ≠ quality'
        },
        
        'reputation': {
            'operator_a': 'Rep: 0.3, Perf: 0.4 → Rarely selected → Low earnings',
            'operator_b': 'Rep: 0.9, Perf: 0.95 → Often selected → High earnings',
            'solution': 'Quality = earnings'
        }
    }
}

class NetworkBootstrap:
    """
    How to bootstrap DHT payment network
    """
    def bootstrap_phases(self):
        return {
            'phase_1_free': {
                'duration': '3 months',
                'query_fee': 0,  # Free
                'operators': 'Volunteers',
                'goal': 'Build initial network',
                'reputation': 'Start accumulating'
            },
            
            'phase_2_subsidized': {
                'duration': '6 months',
                'query_fee': 0.00005,  # $0.10 per query
                'subsidy': 'Foundation matches fees',
                'operators': '50-100 nodes',
                'goal': 'Prove economic model',
                'reputation': 'Differentiation emerges'
            },
            
            'phase_3_market': {
                'duration': 'Ongoing',
                'query_fee': 0.0001,  # $0.20 per query
                'subsidy': 'None (self-sustaining)',
                'operators': '200+ nodes',
                'goal': 'Full market operation',
                'reputation': 'Natural quality selection'
            },
            
            'sustainability': {
                'queries_per_day': 10_000_000,  # At scale
                'revenue_per_day': 10_000_000 * 0.0001 * 2000,  # $2M
                'operators': 500,
                'average_earning': '$4K/day per operator',
                'conclusion': 'Highly profitable for good operators'
            }
        }