class P2PCommerce:
    """
    Commerce via pure flux + attached pricing
    Every response can have a price
    """
    def respond_to_query(self, query, product_data):
        """
        Respond to query with price attached
        Pure flux: just send response with price
        """
        # Calculate price for this product
        price = self._calculate_price(product_data)
        
        # Respond via P2P (1-to-1)
        self._send_p2p_response(query['from'], {
            'type': 'product_response',
            'query_id': query['query_id'],
            'response': 'YES',
            'product': product_data,
            
            # ATTACH PRICE
            'price_eth': price,
            'payment_address': self.eth_address,
            
            # How to accept
            'accept_method': 'send_transfer_tx'
        })
        
        # Done! No blocking
        # If buyer wants it, they'll send tx

def accept_offer(self, offer):
    """
    Accept offer by sending transfer tx back to seller
    Pure flux: send tx, seller validates
    """
    # 1. Create transfer tx
    transfer_tx = self._create_transfer_tx(
        to=offer['payment_address'],
        amount_eth=offer['price_eth']
    )
    
    # 2. Send tx back to seller (P2P)
    self._send_p2p(offer['from'], {
        'type': 'purchase_acceptance',
        'query_id': offer['query_id'],
        'transfer_tx': transfer_tx,
        'buyer_address': self.eth_address
    })
    
    # 3. Append to series (audit trail)
    self.commerce_series.append({
        'timestamp': time.time(),
        'event_type': 'purchase_sent',
        'seller': offer['from'],
        'product': offer['product']['id'],
        'price_eth': offer['price_eth'],
        'tx_hash': transfer_tx.hash()
    })
    
    # Done! No blocking
    # Seller will validate and release product

def handle_purchase_acceptance(self, purchase):
    """
    Receive purchase tx from buyer
    Seller validates tx then releases product
    """
    transfer_tx = purchase['transfer_tx']
    buyer_address = purchase['buyer_address']
    product_id = purchase['query_id']
    
    # 1. Append purchase received to series
    self.commerce_series.append({
        'timestamp': time.time(),
        'event_type': 'purchase_received',
        'buyer': buyer_address,
        'product': product_id,
        'tx_hash': transfer_tx.hash()
    })
    
    # 2. Send tx to blockchain (seller's responsibility!)
    tx_hash = self._send_to_blockchain(transfer_tx)
    
    # 3. Wait for confirmation (seller waits, not buyer!)
    confirmed = self._wait_for_confirmation(tx_hash, timeout=60)
    
    if confirmed:
        # 4. TX confirmed - release product!
        self._release_product(buyer_address, product_id)
        
        # 5. Append to series
        self.commerce_series.append({
            'timestamp': time.time(),
            'event_type': 'product_released',
            'buyer': buyer_address,
            'product': product_id,
            'tx_hash': tx_hash
        })
    else:
        # TX failed - notify buyer
        self._send_p2p(buyer_address, {
            'type': 'purchase_failed',
            'reason': 'tx_not_confirmed',
            'tx_hash': tx_hash
        })

# ===== BUYER QUERIES =====

# Alice wants a dataset
alice = iR3Commerce('alice')
query_id = alice.query_product('forest_mapping_data')
# → Broadcasts to DHT (1-to-many)
# → Returns immediately (non-blocking!)


# ===== SELLER RESPONDS WITH PRICE =====

# Bob has the dataset, responds with price
bob = iR3Commerce('bob')
# Receives query via DHT
# Responds via P2P with price attached
bob._send_p2p_response(alice.address, {
    'type': 'product_response',
    'query_id': query_id,
    'response': 'YES',
    'product': {
        'id': 'forest_mapping_2026',
        'size': '500MB',
        'format': 'geojson'
    },
    'price_eth': 0.1,  # 0.1 ETH
    'payment_address': bob.eth_address
})


# ===== BUYER ACCEPTS =====

# Alice receives response, decides to buy
# Creates transfer tx and sends back to Bob
alice.accept_offer(bob_response)
# → Creates transfer tx (0.1 ETH to Bob)
# → Sends tx back to Bob via P2P
# → Appends to series
# → Done! (non-blocking)


# ===== SELLER VALIDATES AND RELEASES =====

# Bob receives transfer tx from Alice
# Bob sends tx to blockchain
tx_hash = bob._send_to_blockchain(alice_transfer_tx)

# Bob waits for confirmation
confirmed = bob._wait_for_confirmation(tx_hash)

if confirmed:
    # TX confirmed! Release product to Alice
    bob._release_product(alice.address, 'forest_mapping_2026')
    
    # Alice receives product via P2P
    # Commerce complete!


# ===== RESULT =====

# Alice: paid 0.1 ETH, received forest mapping data
# Bob: received 0.1 ETH, delivered product
# NO MIDDLEMAN! NO ESCROW! Just P2P + blockchain

why_seller_validates = {
    # Seller controls product
    'has_product': 'seller holds the data/service',
    'wants_payment': 'seller wants the tx to confirm',
    'can_wait': 'seller can afford to wait for confirmation',
    
    # Buyer doesn't need to wait
    'buyer_sent_tx': 'buyer already committed',
    'buyer_continues': 'buyer can do other things',
    'async_delivery': 'product delivered when ready',
    
    # Risk management
    'seller_risk': 'if tx fails, seller keeps product',
    'buyer_risk': 'if seller malicious, buyer loses tx fee',
    'reputation': 'seller reputation handles malicious actors',
    
    # Efficiency
    'no_blocking_buyer': 'buyer fire-and-forget',
    'seller_batches': 'seller can batch validate many txs',
    'scales_better': 'buyer doesnt wait, seller optimizes'
}

def _calculate_price(self, product_data):
    """
    Calculate price for this product
    Can be dynamic based on various factors
    """
    base_price = product_data.get('base_price', 0.1)
    
    # Dynamic pricing factors
    factors = {
        # Supply/demand
        'demand': self._get_demand_multiplier(),
        
        # Buyer reputation
        'buyer_rep': self._get_buyer_reputation_discount(),
        
        # Network conditions
        'gas_price': self._get_gas_price_adjustment(),
        
        # Time of day
        'time': self._get_time_of_day_multiplier(),
        
        # Seller capacity
        'capacity': self._get_capacity_multiplier()
    }
    
    # Calculate final price
    price = base_price
    price *= factors['demand']
    price *= (1 - factors['buyer_rep'])  # Discount for good rep
    price += factors['gas_price']  # Add gas cost
    price *= factors['time']
    price *= factors['capacity']
    
    return price

def query_and_choose_best(self, product_query):
    """
    Query product, receive multiple responses with prices
    Choose best offer
    """
    # 1. Broadcast query to DHT
    query_id = self.query_product(product_query)
    
    # 2. Collect responses (each with price attached)
    time.sleep(2.0)  # Wait for responses
    responses = self.collect_product_responses(query_id)
    
    # 3. Compare offers
    offers = []
    for response in responses:
        if response['response'] == 'YES':
            offers.append({
                'seller': response['from'],
                'product': response['product'],
                'price': response['price_eth'],
                'reputation': self._get_seller_reputation(response['from'])
            })
    
    # 4. Choose best (price + reputation)
    best = self._choose_best_offer(offers)
    
    # 5. Accept best offer
    self.accept_offer(best)
    
    return best

responses = [
    {
        'seller': 'bob',
        'product': 'forest_data_v1',
        'price': 0.1,
        'reputation': 0.9  # High rep
    },
    {
        'seller': 'carol',
        'product': 'forest_data_v2',
        'price': 0.08,  # Lower price
        'reputation': 0.6  # Lower rep
    },
    {
        'seller': 'dave',
        'product': 'forest_data_premium',
        'price': 0.15,  # Higher price
        'reputation': 0.95  # Highest rep
    }
]

# Buyer chooses based on price + reputation
# Maybe Carol (cheap but risky)
# Maybe Bob (balanced)
# Maybe Dave (expensive but reliable)

def handle_tx_failure(self, tx_hash, buyer_address, product_id):
    """
    TX didn't confirm - handle failure
    Seller notifies buyer
    """
    # 1. Append failure to series
    self.commerce_series.append({
        'timestamp': time.time(),
        'event_type': 'tx_failed',
        'buyer': buyer_address,
        'product': product_id,
        'tx_hash': tx_hash
    })
    
    # 2. Notify buyer via P2P
    self._send_p2p(buyer_address, {
        'type': 'purchase_failed',
        'reason': 'tx_not_confirmed',
        'tx_hash': tx_hash,
        
        # Offer retry
        'retry_available': True,
        'same_price': True
    })
    
    # 3. Buyer can retry if they want
    # Or query other sellers

def update_seller_reputation(self, tx_result):
    """
    Update seller reputation based on tx result
    From iR³Reputation (post 884)
    """
    if tx_result == 'confirmed_and_delivered':
        # Seller succeeded - improve reputation
        self.reputation_series.append({
            'event_type': 'commerce_success',
            'seller': self.node_id,
            'timestamp': time.time()
        })
    
    elif tx_result == 'confirmed_but_not_delivered':
        # Seller took money but didn't deliver - bad!
        self.reputation_series.append({
            'event_type': 'commerce_fraud',
            'seller': self.node_id,
            'timestamp': time.time()
        })
        # Reputation tanks
    
    elif tx_result == 'not_confirmed':
        # TX failed - not seller's fault
        # Neutral reputation impact
        pass

# Traditional (centralized)
❌ def buy_product(product_id):
    # 1. Query central marketplace
    offers = marketplace.query(product_id)  # BLOCKS
    
    # 2. Choose offer
    offer = choose_best(offers)
    
    # 3. Pay via escrow
    marketplace.escrow_payment(offer.price)  # BLOCKS
    
    # 4. Wait for seller to deliver
    product = marketplace.wait_for_delivery()  # BLOCKS
    
    # 5. Confirm receipt
    marketplace.release_escrow()  # BLOCKS
    
    # 6. Marketplace takes fee
    fee = offer.price * 0.025  # 2.5% fee
    
    # Complex, blocking, centralized, fees

# Pure flux (iR³Commerce)
✅ def buy_product(product_id):
    # 1. Query DHT
    query_id = query_product(product_id)  # NON-BLOCKING
    
    # 2. Collect responses (multiple sellers, prices)
    responses = collect_responses(query_id)
    
    # 3. Choose best
    best = choose_best(responses)  # Price + reputation
    
    # 4. Accept (send tx to seller)
    accept_offer(best)  # NON-BLOCKING
    
    # 5. Seller validates and delivers (async)
    # Product arrives when ready
    
    # 6. NO FEES! Direct P2P
    
    # Simple, async, distributed, no fees

class BatchValidation:
    """
    Seller can batch validate multiple txs
    More efficient than one-by-one
    """
    def __init__(self):
        self.pending_txs = []
    
    def handle_purchase_acceptance(self, purchase):
        """Add to pending batch"""
        self.pending_txs.append({
            'tx': purchase['transfer_tx'],
            'buyer': purchase['buyer_address'],
            'product': purchase['query_id'],
            'timestamp': time.time()
        })
        
        # Batch validate every 5 seconds
        if time.time() - self.last_batch > 5.0:
            self._batch_validate()
    
    def _batch_validate(self):
        """
        Send all pending txs at once
        Wait for confirmations
        Release products in batch
        """
        # 1. Send all txs to blockchain
        tx_hashes = []
        for pending in self.pending_txs:
            tx_hash = self._send_to_blockchain(pending['tx'])
            tx_hashes.append((tx_hash, pending))
        
        # 2. Wait for all confirmations
        results = self._wait_for_batch_confirmation(tx_hashes)
        
        # 3. Release products for confirmed txs
        for tx_hash, pending, confirmed in results:
            if confirmed:
                self._release_product(
                    pending['buyer'],
                    pending['product']
                )
        
        # 4. Clear pending
        self.pending_txs = []
        self.last_batch = time.time()

benefits = {
    # Economic
    'no_fees': 'No marketplace fees (2-5% savings!)',
    'dynamic_pricing': 'Prices adjust to conditions',
    'competition': 'Multiple sellers compete',
    'reputation_based': 'Good sellers get more business',
    
    # Technical
    'no_blocking': 'Buyer fire-and-forget',
    'p2p_direct': 'No middleman',
    'scalable': 'Seller batches validation',
    'simple': 'Price attached to response',
    
    # Trust
    'reputation': 'Natural incentives (post 884)',
    'transparent': 'All in series (audit trail)',
    'no_escrow': 'Direct settlement',
    
    # Flexibility
    'any_product': 'Data, services, physical goods',
    'any_payment': 'ETH, stablecoins, any token',
    'instant_quotes': 'Dynamic pricing per query'
}

def sell_physical_product(self, query):
    """
    Selling physical goods via P2P
    Price attached to response
    """
    # Respond with price + shipping
    self._send_p2p_response(query['from'], {
        'type': 'product_response',
        'product': {
            'id': 'laptop_thinkpad_x1',
            'condition': 'used',
            'specs': {...}
        },
        'price_eth': 0.5,  # Product price
        'shipping_eth': 0.02,  # Shipping cost
        'payment_address': self.eth_address,
        
        # Physical shipping
        'shipping_method': 'fedex',
        'estimated_days': 3,
        'tracking': 'provided_after_payment'
    })

# Buyer accepts by sending tx
# Seller validates tx
# Seller ships product with tracking
# Buyer receives product
# Reputation updated based on outcome

# Foundation (from post 878): ~1700 lines
iR3Series        # ~500 lines
iR3DHT           # ~600 lines  
iR3BitTorrent    # ~600 lines

# Commerce app: ~200 lines

class iR3Commerce:
    __init__                        # 10 lines
    respond_to_query                # 20 lines
    _calculate_price                # 15 lines
    accept_offer                    # 25 lines
    handle_purchase_acceptance      # 40 lines
    _send_to_blockchain             # 15 lines
    _wait_for_confirmation          # 20 lines
    _release_product                # 15 lines
    query_and_choose_best           # 30 lines
    
# Helper functions                  # 10 lines

Total: ~200 lines for complete P2P commerce!