# Lending Intent: "I want to lend X at rate Y"
lender.declare_intent({
    'intent': 'want_to_lend',
    'asset': 'USDC',
    'amount': 10000,
    'min_rate': 0.05,  # 5% minimum
    'collateral_accepted': ['WETH', 'WBTC'],
    'ltv_max': 0.8
})
# → DHT broadcasts to all borrowers
# → Borrowers respond: YES/NO/SILENCE
# → Match emerges from responses

# Borrowing Intent: "I want to borrow X with collateral Y"
borrower.declare_intent({
    'intent': 'want_to_borrow',
    'asset': 'USDC',
    'amount': 5000,
    'collateral': 'WETH',
    'collateral_amount': 2.5,  # ETH
    'max_rate': 0.08  # 8% maximum
})
# → DHT broadcasts to all lenders
# → Lenders respond: YES/NO/SILENCE
# → Match emerges from responses

class LendingNode:
    """Lends via intent declarations"""
    
    def provide_liquidity(self, asset, amount, min_rate):
        """Declare lending intent"""
        # Append to local series
        self._append_series('declared_lending_intent',
                          asset=asset,
                          amount=amount,
                          min_rate=min_rate)
        
        # Declare intent to DHT
        dht.broadcast_intent({
            'from': self.address,
            'intent': 'want_to_lend',
            'asset': asset,
            'amount': amount,
            'min_rate': min_rate,
            'timestamp': time.time()
        })
        
        return 'intent_broadcasted'
    
    def receive_borrow_intent(self, intent):
        """Borrower wants to borrow - decide if match"""
        # Check if intent matches our terms
        asset_match = intent['asset'] == self.lending_asset
        amount_available = self._derive_available_liquidity()
        rate_acceptable = intent.get('max_rate', 0) >= self.min_rate
        
        if not asset_match or amount_available < intent['amount']:
            # SILENCE (can't provide)
            return None
        
        # Check rate limiters
        limiters = self._compute_rate_limiters()
        
        if limiters['w_tracking'] < 0.3:
            # NO (can provide but rate limited)
            return {
                'response': 'no',
                'reason': 'rate_limited',
                'available': amount_available
            }
        
        if not rate_acceptable:
            # NO (rate too low)
            return {
                'response': 'no',
                'reason': 'rate_mismatch',
                'min_rate': self.min_rate
            }
        
        # YES (match!)
        return {
            'response': 'yes',
            'amount': min(amount_available, intent['amount']),
            'rate': self.min_rate,
            'terms': self.lending_terms
        }

def process_borrow_responses(self, borrowing_intent, responses):
    """Process all responses to borrowing intent"""
    
    offers = {
        'yes': [],      # Lenders willing to lend
        'no': [],       # Lenders who refused
        'silence': []   # Lenders who didn't respond
    }
    
    # Collect YES responses (actual offers)
    for r in responses['yes']:
        offers['yes'].append({
            'lender': r['from'],
            'amount': r['amount'],
            'rate': r['rate'],
            'terms': r['terms']
        })
    
    # NO responses tell us about market
    for r in responses['no']:
        reason = r.get('reason')
        if reason == 'rate_mismatch':
            # Tells us: our rate too low
            offers['no'].append({
                'lender': r['from'],
                'min_rate': r.get('min_rate'),
                'reason': reason
            })
        elif reason == 'rate_limited':
            # Tells us: lender exists but congested
            offers['no'].append({
                'lender': r['from'],
                'available': r.get('available'),
                'reason': reason
            })
    
    # SILENCE tells us coverage
    for r in responses['silence']:
        # Lenders without this asset
        offers['silence'].append(r['from'])
    
    # Market insights
    if offers['yes']:
        best_rate = min(o['rate'] for o in offers['yes'])
        avg_rate = sum(o['rate'] for o in offers['yes']) / len(offers['yes'])
    else:
        # No offers - look at rejections
        if any(r['reason'] == 'rate_mismatch' for r in offers['no']):
            min_rates = [r['min_rate'] for r in offers['no'] 
                        if r.get('min_rate')]
            suggested_rate = min(min_rates) if min_rates else None
        else:
            suggested_rate = None
    
    return {
        'offers': offers['yes'],
        'rejections': offers['no'],
        'non_responders': len(offers['silence']),
        'best_rate': best_rate if offers['yes'] else None,
        'market_insight': {
            'liquidity_available': len(offers['yes']) > 0,
            'suggested_rate': suggested_rate,
            'lenders_congested': sum(1 for r in offers['no'] 
                                    if r['reason'] == 'rate_limited')
        }
    }

def discover_market_rate(asset, collateral):
    """
    Discover current market rate via intents
    No oracle needed - emergent from declarations
    """
    # Declare test borrowing intent
    test_intent = {
        'intent': 'query_rate',
        'asset': asset,
        'collateral': collateral,
        'amount': 1000  # Small test amount
    }
    
    dht.broadcast_intent(test_intent)
    
    # Collect responses
    responses = wait_for_responses(timeout=5)
    
    # Analyze offers
    offers = [r for r in responses if r['response'] == 'yes']
    
    if not offers:
        return {
            'rate': None,
            'liquidity': 0,
            'message': 'No liquidity available'
        }
    
    # Market rate = median of offers
    rates = sorted(o['rate'] for o in offers)
    market_rate = rates[len(rates) // 2]  # Median
    
    # Liquidity depth
    total_liquidity = sum(o['amount'] for o in offers)
    
    return {
        'market_rate': market_rate,
        'best_rate': min(rates),
        'worst_rate': max(rates),
        'total_liquidity': total_liquidity,
        'num_lenders': len(offers)
    }

class CollateralManagement:
    """Manage collateral via series push"""
    
    def deposit_collateral(self, asset, amount):
        """Deposit collateral"""
        # Append to series
        self._append_series('collateral_deposited',
                          asset=asset,
                          amount=amount,
                          timestamp=time.time())
        
        return self._derive_collateral_balance()
    
    def _derive_collateral_balance(self):
        """Derive collateral from series"""
        balances = {}
        
        for entry in self.series:
            if entry['event'] == 'collateral_deposited':
                asset = entry['asset']
                balances[asset] = balances.get(asset, 0) + entry['amount']
            elif entry['event'] == 'collateral_withdrawn':
                asset = entry['asset']
                balances[asset] = balances.get(asset, 0) - entry['amount']
        
        return balances
    
    def check_health_factor(self):
        """Check loan health from series"""
        collateral = self._derive_collateral_value()
        debt = self._derive_debt_value()
        
        if debt == 0:
            return float('inf')
        
        health_factor = collateral / debt
        
        # Append health check to series
        self._append_series('health_checked',
                          collateral=collateral,
                          debt=debt,
                          health_factor=health_factor)
        
        return health_factor

def broadcast_liquidation_opportunity(loan):
    """When loan unhealthy, broadcast liquidation intent"""
    
    # Check health from series
    health_factor = loan._derive_health_factor()
    
    if health_factor < 1.0:
        # Broadcast liquidation opportunity
        dht.broadcast_intent({
            'intent': 'liquidation_available',
            'loan_id': loan.loan_id,
            'collateral': loan._derive_collateral(),
            'debt': loan._derive_debt(),
            'health_factor': health_factor,
            'discount': 0.05  # 5% liquidation bonus
        })
        
        # Append to series
        loan._append_series('liquidation_broadcast',
                          health_factor=health_factor)

def receive_liquidation_intent(intent):
    """Liquidator receives opportunity"""
    
    # Check if profitable
    collateral_value = intent['collateral']['value']
    debt_value = intent['debt']['value']
    discount = intent['discount']
    
    profit = collateral_value * (1 - discount) - debt_value
    
    if profit > 0:
        # YES - execute liquidation
        return {
            'response': 'yes',
            'liquidator': self.address,
            'repay_amount': debt_value
        }
    else:
        # NO - not profitable
        return {
            'response': 'no',
            'reason': 'not_profitable'
        }

def create_market(asset, collateral):
    """
    Create market for any asset pair
    No permission needed - just declare intents
    """
    # No pool creation transaction
    # No admin approval
    # Just start declaring intents!
    
    # Lender declares
    lender.declare_intent({
        'intent': 'want_to_lend',
        'asset': asset,
        'collateral_accepted': [collateral]
    })
    
    # Borrower declares
    borrower.declare_intent({
        'intent': 'want_to_borrow',
        'asset': asset,
        'collateral': collateral
    })
    
    # Market exists!
    # No pool contract needed
    # Just intent matching

def get_multi_perspective_rate(asset, collateral, amount):
    """Get rate from multiple lenders"""
    
    # Declare borrowing intent
    dht.broadcast_intent({
        'intent': 'want_to_borrow',
        'asset': asset,
        'amount': amount,
        'collateral': collateral
    })
    
    # Collect responses
    responses = wait_for_responses()
    
    # Analyze offers
    offers = []
    for r in responses:
        if r['response'] == 'yes':
            offers.append({
                'lender': r['from'],
                'rate': r['rate'],
                'amount': r['amount'],
                'reputation': fetch_reputation(r['from'])
            })
    
    # Weight by reputation
    if offers:
        total_weight = sum(o['reputation'] for o in offers)
        weighted_rate = sum(o['rate'] * o['reputation'] 
                           for o in offers) / total_weight
        
        return {
            'weighted_rate': weighted_rate,
            'offers': offers,
            'best_rate': min(o['rate'] for o in offers),
            'confidence': 'high' if len(offers) >= 3 else 'medium'
        }
    else:
        return {
            'weighted_rate': None,
            'offers': [],
            'confidence': 'none'
        }

class EigenLending:
    """
    Universal lending via intent paradigm
    No special system - just Post 874 applied
    """
    
    def __init__(self):
        # No pool contracts
        # No admin
        # Just nodes declaring intents
        pass
    
    def lend(self, lender, asset, amount, min_rate):
        """Lend via intent"""
        lender.declare_intent({
            'intent': 'want_to_lend',
            'asset': asset,
            'amount': amount,
            'min_rate': min_rate
        })
        
        # Intent broadcast by DHT
        # Borrowers receive and respond
    
    def borrow(self, borrower, asset, amount, collateral, max_rate):
        """Borrow via intent"""
        borrower.declare_intent({
            'intent': 'want_to_borrow',
            'asset': asset,
            'amount': amount,
            'collateral': collateral,
            'max_rate': max_rate
        })
        
        # Intent broadcast by DHT
        # Lenders receive and respond
        # Borrower selects best offer
    
    def discover_rate(self, asset, collateral):
        """Discover rate via test intent"""
        test_intent = {
            'intent': 'query_rate',
            'asset': asset,
            'collateral': collateral
        }
        
        dht.broadcast_intent(test_intent)
        responses = wait_for_responses()
        
        return derive_market_rate(responses)

"I want to lend 10k USDC at 5%"
→ Broadcast via DHT
→ Borrowers respond

"I want to borrow 5k USDC with WETH collateral"
→ Broadcast via DHT
→ Lenders respond (YES/NO/SILENCE)
→ Select best offer

YES: Lending offer
NO (rate_mismatch): Market rate insight
NO (rate_limited): Lender congested
SILENCE: No liquidity
→ All inform decision

Emergent from intent declarations
Multi-perspective consensus
No oracle needed

Any asset pair
No permission
Just declare intents