{
    "jsonrpc": "2.0",
    "method": "eth_getBalance",
    "params": ["0x742d35Cc6634C0532925a3b844Bc454e4438f44e", "latest"],
    "id": 1
}

GET /api/v2/address/0x742d35.../balance

// Web3.js example
const balance = await web3.eth.getBalance('0x742d35...');
console.log(`Balance: ${web3.utils.fromWei(balance, 'ether')} ETH`);

// Ethers.js example
const balance = await provider.getBalance('0x742d35...');
console.log(`Balance: ${ethers.formatEther(balance)} ETH`);

Application → Node API → Blockchain

Application → Provider API → Provider Infrastructure → Blockchain

Application → Provider API (primary) + Direct Node (failover) → Blockchain

Application → SDK → Provider/Node → Blockchain

┌─────────────────────────────────────────────────────────────────────────────┐
│                    BLOCKCHAIN INTEGRATION ARCHITECTURE                      │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  User Application (Frontend)                                               │
│       │                                                                     │
│       v                                                                     │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    API GATEWAY / MIDDLEWARE                          │   │
│  │  • Authentication                                                     │   │
│  │  • Rate limiting                                                      │   │
│  │  • Request routing                                                    │   │
│  │  • Caching                                                          │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                    ┌───────────────┼───────────────┐                      │
│                    v               v               v                      │
│  ┌──────────────────┐  ┌──────────────────┐  ┌──────────────────┐        │
│  │  JSON-RPC API    │  │  REST API        │  │  WebSocket API   │        │
│  │  (Blockchain     │  │  (Business       │  │  (Real-time      │        │
│  │   Operations)    │  │   Logic)         │  │   Data)          │        │
│  └────────┬─────────┘  └────────┬─────────┘  └────────┬─────────┘        │
│           │                     │                     │                   │
│           v                     v                     v                   │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    BLOCKCHAIN NODE                                   │   │
│  │  • Connect to network                                                │   │
│  │  • Broadcast transactions                                            │   │
│  │  • Sync with peers                                                  │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    BLOCKCHAIN NETWORK                                │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# ===================================================================
# MODULE 4, LESSON 4: BLOCKCHAIN APIS AND INTEGRATION
# ===================================================================

import json
import hashlib
import time
import random
from typing import Dict, List, Optional, Any
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
import warnings
warnings.filterwarnings('ignore')

print("="*70)
print("BLOCKCHAIN APIS AND INTEGRATION")
print("="*70)

# ----------------------------------------------------------------
# PART A: JSON-RPC SIMULATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART A: JSON-RPC API Simulation")
print("-"*60)

class JSONRPCNode:
    """
    Simulated JSON-RPC blockchain node.
    """
    def __init__(self):
        self.state = {
            'block_number': 1000000,
            'gas_price': 20000000000,  # 20 Gwei
            'chain_id': 1
        }
        self.accounts: Dict[str, float] = {}
        self.transactions: List[Dict] = []
        self.contracts: Dict[str, Dict] = {}
        self.request_log: List[Dict] = []
    
    def add_account(self, address: str, balance: float):
        self.accounts[address] = balance
    
    def handle_request(self, jsonrpc_request: Dict) -> Dict:
        """
        Handle a JSON-RPC request.
        """
        method = jsonrpc_request.get('method')
        params = jsonrpc_request.get('params', [])
        req_id = jsonrpc_request.get('id', 1)
        
        self.request_log.append({
            'method': method,
            'params': params,
            'timestamp': time.time()
        })
        
        if method == 'eth_blockNumber':
            result = hex(self.state['block_number'])
        
        elif method == 'eth_gasPrice':
            result = hex(self.state['gas_price'])
        
        elif method == 'eth_getBalance':
            address = params[0] if params else None
            balance = self.accounts.get(address, 0)
            result = hex(int(balance * 10**18))  # Convert to Wei
        
        elif method == 'eth_sendTransaction':
            tx = params[0] if params else {}
            tx_hash = hashlib.sha256(json.dumps(tx).encode()).hexdigest()[:16]
            self.transactions.append({
                'hash': tx_hash,
                'from': tx.get('from'),
                'to': tx.get('to'),
                'value': tx.get('value')
            })
            self.state['block_number'] += 1
            result = f"0x{tx_hash}"
        
        elif method == 'eth_call':
            result = "0x"
        
        elif method == 'eth_getLogs':
            result = []
        
        else:
            return {
                'jsonrpc': '2.0',
                'error': {'code': -32601, 'message': 'Method not found'},
                'id': req_id
            }
        
        return {
            'jsonrpc': '2.0',
            'result': result,
            'id': req_id
        }
    
    def get_metrics(self) -> Dict:
        return {
            'block_number': self.state['block_number'],
            'total_transactions': len(self.transactions),
            'total_requests': len(self.request_log)
        }

# Create node
node = JSONRPCNode()

# Add accounts
node.add_account('0xAlice', 100.5)
node.add_account('0xBob', 50.0)
node.add_account('0xCharlie', 200.0)

print("JSON-RPC Node Simulation:")
print(f"Block Number: {node.state['block_number']}")
print(f"Gas Price: {node.state['gas_price']} wei")

# Simulate requests
requests = [
    {'jsonrpc': '2.0', 'method': 'eth_blockNumber', 'params': [], 'id': 1},
    {'jsonrpc': '2.0', 'method': 'eth_gasPrice', 'params': [], 'id': 2},
    {'jsonrpc': '2.0', 'method': 'eth_getBalance', 'params': ['0xAlice', 'latest'], 'id': 3},
    {'jsonrpc': '2.0', 'method': 'eth_sendTransaction', 'params': [{'from': '0xAlice', 'to': '0xBob', 'value': '0x1'}]},
    {'jsonrpc': '2.0', 'method': 'eth_getBalance', 'params': ['0xBob', 'latest'], 'id': 4}
]

print("\nProcessing JSON-RPC requests:")
for req in requests:
    response = node.handle_request(req)
    if 'error' in response:
        print(f"  Error: {response['error']['message']}")
    else:
        print(f"  {req['method']}: {response.get('result', 'N/A')}")

# Metrics
metrics = node.get_metrics()
print(f"\nNode Metrics:")
print(f"  Block Number: {metrics['block_number']}")
print(f"  Total Transactions: {metrics['total_transactions']}")
print(f"  Total API Requests: {metrics['total_requests']}")

# ----------------------------------------------------------------
# PART B: API TYPE COMPARISON
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART B: API Type Comparison")
print("-"*60)

api_data = {
    'API Type': ['JSON-RPC', 'REST', 'WebSocket', 'GraphQL'],
    'Protocol': ['HTTP/WS', 'HTTP', 'WebSocket', 'HTTP'],
    'Request Format': ['JSON', 'JSON/XML', 'JSON', 'GraphQL Query'],
    'Real-time': ['Yes (WebSocket)', 'No', 'Yes', 'Yes (Subscriptions)'],
    'Learning Curve': ['Medium', 'Low', 'Medium', 'Medium-High'],
    'Use Case': ['Core operations', 'Web integration', 'Live data', 'Flexible queries']
}

api_df = pd.DataFrame(api_data)
print(api_df.to_string(index=False))

# ----------------------------------------------------------------
# PART C: SDK COMPARISON
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: SDK Comparison")
print("-"*60)

sdk_data = {
    'SDK': ['Web3.js', 'Ethers.js', 'Web3.py', 'Viem', 'Solana Web3'],
    'Language': ['JavaScript', 'JavaScript/TS', 'Python', 'TypeScript', 'JavaScript'],
    'Ecosystem': ['Largest', 'Growing', 'Medium', 'Growing', 'Solana'],
    'Type Safety': ['Low', 'High', 'Medium', 'Very High', 'Medium'],
    'Documentation': ['Excellent', 'Excellent', 'Good', 'Good', 'Good']
}

sdk_df = pd.DataFrame(sdk_data)
print(sdk_df.to_string(index=False))

# ----------------------------------------------------------------
# PART D: INTEGRATION PATTERNS
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART D: Integration Pattern Comparison")
print("-"*60)

pattern_data = {
    'Pattern': ['Direct Node', 'Provider API', 'Hybrid', 'SDK-based'],
    'Complexity': ['High', 'Low', 'Medium', 'Low'],
    'Control': ['Full', 'Limited', 'Medium', 'Medium'],
    'Cost': ['High (infra)', 'Medium (API)', 'Medium-High', 'Low-Medium'],
    'Best For': ['Enterprises', 'DApps', 'Critical apps', 'Rapid dev']
}

pattern_df = pd.DataFrame(pattern_data)
print(pattern_df.to_string(index=False))

# ----------------------------------------------------------------
# PART E: SUMMARY AND RECOMMENDATIONS
# ----------------------------------------------------------------

print("\n" + "="*70)
print("PART E: Summary and Recommendations")
print("="*70)

print("""
Blockchain APIs and Integration – Key Takeaways:

1. APIs abstract blockchain complexity and enable application development.
2. API types: JSON-RPC (core ops), REST (web integration), WebSocket (real-time), GraphQL (flexible queries).
3. JSON-RPC is the most common protocol with standardised methods.
4. SDKs (Web3.js, Ethers.js, Web3.py) simplify development with language-native interfaces.
5. Provider services (Infura, Alchemy) offer managed infrastructure.
6. Integration patterns: direct node, provider API, hybrid, SDK-based.
7. Considerations: latency, reliability, cost, rate limits, data freshness.

API Selection Framework:
  - For core blockchain operations: JSON-RPC
  - For web applications: REST APIs
  - For real-time data: WebSocket
  - For flexible data queries: GraphQL
  - For rapid development: SDKs (Ethers.js recommended)
  - For production: Provider services with failover
  - For maximum control: Self-hosted nodes
""")