class R3Alpha:
    """
    R³ Alpha = 3 foundation components
    Everything else = applications
    """
    
    # That's it. Three components only.
    
    # Foundation Layer:
    def ir3series(self):
        """Component 1: iR³Series (local append-only)"""
        return "Every node keeps local series"
    
    def ir3dht(self):
        """Component 2: DHT (discovery + broadcast)"""
        return "Intent declarations broadcast here"
    
    def ir3bittorrent(self):
        """Component 3: BT (distributed storage)"""
        return "Chunks stored + replicated here"
    
    # Applications Layer (runs on top):
    # - EVM (Metamask compatibility)
    # - Money (Post 875)
    # - Reputation (Post 870)
    # - Territory (Post 873)
    # - Lending (Post 871)
    # - Everything else

# 1. iR³Series (~200 lines)
class iR3Series:
    """Every node appends events locally"""
    def __init__(self):
        self.series = []
    
    def append(self, event):
        self.series.append({'t': time.time(), 'event': event})
    
    def derive_state(self):
        return self._reduce(self.series)

# 2. iR³DHT (~500 lines)
class iR3DHT:
    """Kademlia for discovery + intent broadcast"""
    def broadcast_intent(self, intent):
        nodes = self.routing_table.find_closest(hash(intent))
        for node in nodes:
            node.receive(intent)

# 3. iR³BitTorrent (~1000 lines)
class iR3BitTorrent:
    """Distributed chunk storage"""
    def store_chunk(self, chunk_id, data):
        if self._rate_limiters_allow():
            self.chunks[chunk_id] = data
            dht.announce(chunk_id, self.address)

# EVM (Metamask)
class EVM:
    """ETH compatibility via intent paradigm"""
    def __init__(self, r3):
        self.series = r3.series
        self.dht = r3.dht
        self.bt = r3.bt
    
    def execute_transaction(self, tx):
        # Declare intent via DHT
        self.dht.broadcast_intent({
            'intent': 'eth_transaction',
            'tx': tx
        })
        
        # Append to series
        self.series.append({'event': 'eth_tx', 'tx': tx})
        
        # Store state in BT
        self.bt.store_chunk('evm_state', self.state)

# Money (native)
class Money:
    """Native money via intent paradigm"""
    def __init__(self, r3):
        self.series = r3.series
        self.dht = r3.dht
        self.bt = r3.bt
    
    def mint(self, currency, amount):
        # Declare intent via DHT
        self.dht.broadcast_intent({
            'intent': 'mint_money',
            'currency': currency,
            'amount': amount
        })
        
        # Append to series
        self.series.append({'event': 'money_minted', ...})
        
        # Store chunks in BT
        self.bt.store_chunk('money_series', chunks)

# Reputation (native)
class Reputation:
    """Track record via intent paradigm"""
    # Uses same three components

# Territory (native)
class Territory:
    """Mapping via intent paradigm"""
    # Uses same three components

# ALL apps use same paradigm!

class EVM:
    """
    EVM is an APPLICATION
    Not a foundation component
    Uses Series + Intent + DHT + BT
    """
    
    def __init__(self, r3_foundation):
        # Connect to foundation
        self.series = r3_foundation.series
        self.dht = r3_foundation.dht
        self.bt = r3_foundation.bt
        
        # EVM-specific state
        self.evm_state = {}
        self.evm_executor = PyEVM()
    
    def handle_metamask_transaction(self, tx):
        """Metamask sends transaction"""
        
        # 1. Declare intent via DHT (Post 874 paradigm)
        self.dht.broadcast_intent({
            'from': self.address,
            'intent': 'execute_eth_tx',
            'tx_hash': tx.hash,
            'tx_data': tx
        })
        
        # 2. Execute EVM locally
        result = self.evm_executor.execute(tx, self.evm_state)
        
        # 3. Append result to series
        self.series.append({
            't': time.time(),
            'event': 'eth_tx_executed',
            'tx_hash': tx.hash,
            'result': result
        })
        
        # 4. Store state chunks in BT
        state_chunks = self._chunk_state(self.evm_state)
        for chunk in state_chunks:
            self.bt.store_chunk(chunk.id, chunk.data)
        
        # 5. Return to Metamask
        return result.tx_hash
    
    def json_rpc_api(self):
        """Standard Ethereum JSON-RPC for Metamask"""
        return {
            'eth_sendTransaction': self.handle_metamask_transaction,
            'eth_getBalance': self._get_balance,
            'eth_call': self._call_contract,
            # ... all standard methods
        }

# R³ Alpha = Foundation + Apps

foundation = R3Alpha()  # Series + DHT + BT

# Application suite:
apps = {
    # ETH compatibility
    'evm': EVM(foundation),
    
    # Native apps
    'money': MoneyEmission(foundation),
    'reputation': ReputationSystem(foundation),
    'territory': TerritoryMapping(foundation),
    'lending': LendingMarkets(foundation),
    
    # More apps...
    'storage': DecentralizedStorage(foundation),
    'compute': DistributedCompute(foundation),
    'messaging': SecureMessaging(foundation)
}

# All apps share:
# - Same DHT for intents
# - Same BT for chunks
# - Same series paradigm
# - Same rate limiters
# - Same multi-perspective

class DHTGarbageCollection:
    """
    Automatic network cleanup
    Part of iR³DHT component
    """
    
    def __init__(self):
        self.routing_table = {}
        self.last_seen = {}
    
    def ping_cycle(self):
        """Periodic health check"""
        for node_id in list(self.routing_table.keys()):
            try:
                response = self.routing_table[node_id].ping()
                if response:
                    # Still alive
                    self.last_seen[node_id] = time.time()
                else:
                    self._check_timeout(node_id)
            except:
                self._check_timeout(node_id)
    
    def _check_timeout(self, node_id):
        """Remove dead nodes"""
        timeout = 3600  # 1 hour
        
        if time.time() - self.last_seen.get(node_id, 0) > timeout:
            # Node offline too long
            del self.routing_table[node_id]
            del self.last_seen[node_id]
            
            print(f"Garbage collected: {node_id}")

def application_action():
    """Any app action follows same pattern"""
    
    # 1. Declare intent to DHT
    dht.broadcast_intent({
        'from': my_address,
        'intent': 'want_something',
        'parameters': {...}
    })
    
    # 2. Receive responses
    responses = {
        'yes': [],      # Nodes that provide
        'no': [],       # Nodes that refuse
        'silence': []   # Nodes that ignore
    }
    
    # 3. Append ALL to series
    for response in responses['yes']:
        series.append({'event': 'received', 'from': response})
    for response in responses['no']:
        series.append({'event': 'rejected', 'from': response})
    for response in responses['silence']:
        series.append({'event': 'silence', 'from': response})
    
    # 4. Derive state from series
    state = derive_from_series(series)
    
    # 5. Store chunks in BT
    bt.store_chunk(chunk_id, chunk_data)

# EVM transaction
dht.broadcast_intent('execute_eth_tx', tx_data)

# Money minting
dht.broadcast_intent('mint_currency', {currency: 'USD', amount: 1000})

# Reputation query
dht.broadcast_intent('want_reputation_chunks', node_id)

# Territory observation
dht.broadcast_intent('share_observations', location)

# All same pattern!

# Start node with foundation
python3 r3.py \
  --node-id my_node \
  --dht-port 7001 \
  --bt-port 6001 \
  --bootstrap node1.r3.network:7001

# Enable applications
python3 r3.py \
  --apps evm,money,reputation,territory \
  --evm-rpc-port 8545  # For Metamask

# Python client
import r3

# Connect to local node
node = r3.connect('localhost:7001')

# Use money app
node.money.mint('USD', 1000)

# Use reputation app
rep = node.reputation.query('node_xyz')

# Use territory app
node.territory.observe({'lat': 45.5, 'lon': -73.6})