class Buyer:
    """
    Buyer broadcasts intent to DHT
    """
    def __init__(self, dht):
        self.dht = dht
        self.address = self.generate_address()
        self.quotes_received = []
    
    def want_weed(self, quantity, max_price):
        """
        Broadcast: I want weed
        """
        # Push intent to DHT (public broadcast)
        intent = {
            'from': self.address,  # For P2P responses
            'intent': 'want',
            'item': 'weed',
            'quantity': quantity,
            'max_price': max_price,
            'currency': 'USD'
        }
        
        # DHT broadcast (everyone sees this)
        self.dht.push_intent(intent)
        
        # Return immediately (pure flux!)
        return
    
    def on_quote_received(self, quote):
        """
        Async handler for P2P quotes
        """
        # Quotes come P2P (private, only I see them)
        self.quotes_received.append({
            't': time.time(),
            'seller': quote['from'],
            'price': quote['price'],
            'quality': quote['quality'],
            'delivery': quote['delivery_time']
        })

class Seller:
    """
    Seller monitors DHT, responds via P2P
    """
    def __init__(self, dht):
        self.dht = dht
        self.inventory = {
            'weed': {
                'quantity': 100,
                'quality': 'premium',
                'price_per_gram': 10
            }
        }
        
        # Listen to DHT broadcasts
        self.dht.on_intent_received(self.handle_intent)
    
    def handle_intent(self, intent):
        """
        DHT broadcast received
        """
        # Check if I can fulfill
        if intent['item'] == 'weed':
            if self.can_fulfill(intent):
                # Send quote DIRECTLY to buyer (P2P)
                self.send_quote(intent)
    
    def can_fulfill(self, intent):
        """
        Can I provide what they want?
        """
        item = self.inventory.get(intent['item'])
        if not item:
            return False
        
        # Check quantity
        if item['quantity'] < intent['quantity']:
            return False
        
        # Check price
        my_price = item['price_per_gram'] * intent['quantity']
        if my_price > intent['max_price']:
            return False
        
        return True
    
    def send_quote(self, intent):
        """
        Send quote directly to buyer (P2P)
        """
        buyer_address = intent['from']
        
        quote = {
            'from': self.address,
            'item': 'weed',
            'quantity': intent['quantity'],
            'price': self.calculate_price(intent),
            'quality': self.inventory['weed']['quality'],
            'delivery_time': '24 hours'
        }
        
        # Send via P2P (direct connection)
        # ONLY buyer sees this quote
        self.dht.respond_p2p(buyer_address, quote)

class Buyer:
    """
    Buyer compares quotes and chooses
    """
    def choose_best_quote(self):
        """
        Select best quote from all received
        """
        if not self.quotes_received:
            return None  # No quotes yet
        
        # Sort by price, quality, delivery time
        best = min(self.quotes_received, 
                   key=lambda q: (q['price'], -q['quality'], q['delivery']))
        
        return best
    
    def accept_quote(self, quote):
        """
        Accept quote and proceed with purchase
        """
        seller_address = quote['seller']
        
        # Send acceptance via P2P
        acceptance = {
            'from': self.address,
            'accepted': True,
            'quote_id': quote['id'],
            'payment_ready': True
        }
        
        self.dht.respond_p2p(seller_address, acceptance)
        
        # Proceed with payment
        self.pay(seller_address, quote['price'])

class PrivacyAnalysis:
    """
    What information is public vs private?
    """
    def public_information(self):
        """
        Broadcast via DHT (everyone sees)
        """
        return {
            'buyer_address': 'public',  # For P2P responses
            'intent': 'public',         # "want weed"
            'quantity': 'public',       # How much
            'max_price': 'public'       # Willing to pay up to
        }
    
    def private_information(self):
        """
        P2P only (only buyer + individual seller see)
        """
        return {
            'seller_quotes': 'private',      # Each seller's price
            'seller_inventory': 'private',   # What sellers have
            'actual_prices': 'private',      # Negotiated prices
            'accepted_quote': 'private',     # Which seller won
            'payment_details': 'private',    # How payment happens
            'delivery_info': 'private'       # Where/when delivery
        }

class DistributedMarketplace:
    """
    No central server required
    """
    def __init__(self):
        # No server!
        # Just DHT nodes
        self.dht = iR3DHT()
    
    def architecture(self):
        """
        How it works
        """
        return {
            'discovery': 'DHT broadcast',     # Find sellers
            'negotiation': 'P2P direct',      # Private quotes
            'payment': 'P2P + money app',     # Direct payment
            'delivery': 'P2P coordination',   # Between parties
            
            'no_middleman': True,
            'no_central_server': True,
            'no_surveillance': True,
            'censorship_resistant': True
        }

# Buyer broadcasts intent
buyer = Buyer(dht)
buyer.want_weed(
    quantity=10,      # grams
    max_price=150     # USD
)

# DHT broadcasts to all nodes
# → Seller1 sees it
# → Seller2 sees it  
# → Seller3 sees it
# → Everyone sees it

# Seller1 checks and responds
@seller1.on_intent
def handle(intent):
    if intent['item'] == 'weed':
        # I have weed, send quote
        seller1.send_quote(
            to=buyer.address,
            price=100,
            quality='premium'
        )
        # P2P direct to buyer
        # No one else sees this quote

# Seller2 responds
@seller2.on_intent
def handle(intent):
    if intent['item'] == 'weed':
        # I have weed too, send my quote
        seller2.send_quote(
            to=buyer.address,
            price=90,
            quality='good'
        )
        # P2P direct to buyer
        # Seller1 doesn't see this quote!

# Seller3 can't fulfill
@seller3.on_intent
def handle(intent):
    if intent['item'] == 'weed':
        # I don't have weed
        pass  # Don't respond

# Buyer receives quotes async
@buyer.on_p2p_response
def handle(quote):
    buyer.quotes_received.append(quote)

# Later, buyer chooses best
best = buyer.choose_best_quote()
# → Seller2 wins ($90 vs $100)

# Buyer accepts
buyer.accept_quote(best)

# P2P payment
buyer.pay(seller2.address, 90)

# P2P delivery coordination
buyer.coordinate_delivery(seller2)

# Done! Private marketplace transaction

class InformationFlow:
    """
    Who sees what?
    """
    def dht_broadcast(self, intent):
        """
        DHT broadcast (public)
        """
        # Everyone on DHT sees:
        visible_to_all = {
            'buyer': intent['from'],
            'want': intent['item'],
            'quantity': intent['quantity'],
            'max_price': intent['max_price']
        }
        
        # This is public information
        return visible_to_all
    
    def p2p_quote(self, seller, buyer, quote):
        """
        P2P quote (private)
        """
        # Only these two see the quote:
        visible_to = [seller, buyer]
        
        # NOT visible to:
        not_visible = ['other_sellers', 'other_buyers', 'network']
        
        # Quote contains:
        private_info = {
            'price': quote['price'],
            'quality': quote['quality'],
            'delivery': quote['delivery'],
            'seller_identity': seller.address
        }
        
        return {
            'visible_to': visible_to,
            'private_info': private_info
        }

class UniversalMarketplace:
    """
    Same pattern for anything
    """
    def broadcast_want(self, item, specs):
        """
        Want anything
        """
        intent = {
            'want': item,
            'specs': specs
        }
        
        dht.push_intent(intent)
    
    def examples(self):
        """
        Use cases
        """
        return {
            # Physical goods
            'weed': {'quantity': 10, 'quality': 'premium'},
            'electronics': {'model': 'iPhone 15', 'condition': 'new'},
            'furniture': {'type': 'desk', 'size': 'large'},
            
            # Services
            'ride': {'from': 'A', 'to': 'B', 'time': 'now'},
            'delivery': {'package': 'X', 'destination': 'Y'},
            'tutoring': {'subject': 'math', 'duration': '1 hour'},
            
            # Digital goods
            'software': {'app': 'photoshop', 'license': 'permanent'},
            'data': {'type': 'customer_list', 'industry': 'tech'},
            'api_access': {'service': 'gpt4', 'calls': 1000000},
            
            # Labor
            'developer': {'skill': 'rust', 'hours': 40},
            'designer': {'style': 'minimalist', 'deliverables': 10},
            'writer': {'topic': 'crypto', 'words': 5000}
        }

class MarketplaceWithMoney:
    """
    Integrate marketplace + money app
    """
    def __init__(self, dht, money_app):
        self.dht = dht
        self.money = money_app
    
    def complete_purchase(self, quote):
        """
        Accept quote and pay
        """
        seller = quote['seller']
        price = quote['price']
        currency = quote['currency']
        
        # 1. Accept quote (P2P)
        self.dht.respond_p2p(seller, {
            'accepted': True,
            'quote_id': quote['id']
        })
        
        # 2. Pay (using money app)
        self.money.transfer(
            to=seller,
            amount=price,
            currency=currency
        )
        
        # 3. Wait for delivery confirmation
        @self.on_p2p_response
        def handle_delivery(msg):
            if msg['type'] == 'delivered':
                # Release payment or confirm
                self.money.confirm_payment(seller)

class MarketplaceWithReputation:
    """
    Add reputation to marketplace
    """
    def __init__(self, dht, reputation_app):
        self.dht = dht
        self.reputation = reputation_app
    
    def choose_quote_with_reputation(self, quotes):
        """
        Factor in seller reputation
        """
        scored_quotes = []
        
        for quote in quotes:
            seller = quote['seller']
            
            # Get seller's reputation
            rep = self.reputation.query(seller)
            
            # Score = price + reputation weight
            score = quote['price'] * (1 - rep['trust_score'])
            
            scored_quotes.append({
                'quote': quote,
                'score': score,
                'reputation': rep
            })
        
        # Choose best score
        best = min(scored_quotes, key=lambda x: x['score'])
        return best['quote']
    
    def rate_transaction(self, seller, rating):
        """
        After transaction, rate seller
        """
        self.reputation.submit_rating(
            seller=seller,
            rating=rating,
            transaction_id=self.last_transaction
        )

# Traditional marketplace (eBay, Amazon, etc)
traditional = {
    'discovery': 'central database',
    'quotes': 'public listings',
    'payment': 'through platform',
    'fees': '10-15%',
    'privacy': 'none (platform sees everything)',
    'censorship': 'platform controls listings',
    'shutdown_risk': 'platform can be shut down'
}

# iR³ Marketplace
ir3_marketplace = {
    'discovery': 'DHT broadcast',
    'quotes': 'private P2P',
    'payment': 'direct P2P',
    'fees': '0% (optional tips)',
    'privacy': 'complete (only parties involved)',
    'censorship': 'impossible (no central control)',
    'shutdown_risk': 'none (distributed)'
}

class MarketplaceSecurity:
    """
    Security best practices
    """
    def verify_seller(self, seller):
        """
        Check seller before transacting
        """
        # 1. Check reputation
        rep = self.reputation.query(seller)
        if rep['trust_score'] < 0.7:
            return False  # Low trust
        
        # 2. Check transaction history
        history = self.get_seller_history(seller)
        if len(history) < 10:
            return False  # Too new
        
        # 3. Check for disputes
        disputes = self.get_disputes(seller)
        if len(disputes) > 2:
            return False  # Too many problems
        
        return True
    
    def escrow_payment(self, seller, amount):
        """
        Use escrow for safety
        """
        # Hold payment until delivery confirmed
        escrow = EscrowContract(
            buyer=self.address,
            seller=seller,
            amount=amount,
            timeout=7*24*3600  # 7 days
        )
        
        # Release when both parties confirm
        # Or timeout refunds buyer
        return escrow

class LegalNeutrality:
    """
    Technology is neutral
    Use cases vary
    """
    def legal_uses(self):
        """
        Perfectly legal use cases
        """
        return [
            'Buying groceries locally',
            'Hiring freelancers',
            'Selling used furniture',
            'Finding rideshares',
            'Renting equipment',
            'Trading digital goods',
            'Local services marketplace'
        ]
    
    def controversial_uses(self):
        """
        Controversial but sometimes legal
        """
        return [
            'Cannabis (legal in many jurisdictions)',
            'Alcohol (legal with age verification)',
            'Prescription drugs (legal with prescription)',
            'Adult services (legal in many places)'
        ]
    
    def responsibility(self):
        """
        User responsibility
        """
        return "Users must follow local laws. Technology doesn't determine legality."