FastAPI Backend Integration

#!/usr/bin/env python3
"""
FastAPI Web App Example with MetaMask Integration

This example shows how to:
1. Create a backend API to generate payment requests
2. Frontend uses MetaMask to sign transactions (no private keys on server!)
3. Verify payments on-chain

SECURITY: Private keys NEVER leave the customer's wallet!
"""

from fastapi import FastAPI, HTTPException
from fastapi.staticfiles import StaticFiles
from fastapi.responses import FileResponse
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModel
import os
from dotenv import load_dotenv
from zynpay import ZynPayClient, Environment

load_dotenv()

app = FastAPI(title="ZynPay Payment API", version="1.0.0")

# Enable CORS
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# Initialize ZynPay client
MERCHANT_WALLET = os.getenv('MERCHANT_WALLET')
client = ZynPayClient(
    merchant_wallet=MERCHANT_WALLET,
    environment=Environment.TESTNET,
    default_chain='base'
)

# Request/Response models
class CreatePaymentRequest(BaseModel):
    amount: float
    chain: str = 'base'

class VerifyPaymentRequest(BaseModel):
    tx_hash: str
    payment_id: str

# Serve static files
app.mount("/static", StaticFiles(directory="static"), name="static")

@app.get("/")
async def index():
    """Serve the frontend"""
    return FileResponse('static/index.html')

@app.post("/api/payment/create")
async def create_payment(request: CreatePaymentRequest):
    """Create a payment request"""
    try:
        if request.amount <= 0:
            raise HTTPException(status_code=400, detail="Invalid amount")
        
        # Create payment
        payment = client.payments.create(amount=request.amount, chain=request.chain)
        
        return {
            'success': True,
            'payment': {
                'id': payment.id,
                'amount': payment.amount,
                'chain': payment.chain,
                'router_address': payment.router_address,
                'merchant_wallet': client.merchant_wallet,
                'usdc_address': payment.usdc_address,
            }
        }
    
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

@app.get("/api/balance/{address}")
async def check_balance(address: str, chain: str = 'base'):
    """Check wallet balance"""
    try:
        balance = client.web3.get_balance(address, chain=chain)
        
        return {
            'success': True,
            'balance': {
                'usdc': balance.usdc,
                'eth': balance.native,
                'has_usdc': balance.has_usdc,
                'has_gas': balance.has_gas,
            }
        }
    
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

@app.post("/api/payment/verify")
async def verify_payment(request: VerifyPaymentRequest):
    """Verify a payment transaction"""
    try:
        if not request.tx_hash:
            raise HTTPException(status_code=400, detail="Transaction hash required")
        
        # In a real app, you'd verify the transaction on-chain
        # and update your database
        
        return {
            'success': True,
            'verified': True,
            'message': 'Payment verified on blockchain'
        }
    
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

@app.get("/api/config")
async def get_config():
    """Get network configuration"""
    return {
        'merchant_wallet': client.merchant_wallet,
        'environment': client.environment,
        'supported_chains': client.get_supported_chains(),
    }

if __name__ == '__main__':
    import uvicorn
    
    print("🚀 Starting ZynPay FastAPI App...")
    print(f"📝 Merchant: {MERCHANT_WALLET}")
    print(f"🌐 Environment: {client.environment}")
    print("\n✅ Server running at: http://localhost:8080")
    print("💡 Open in browser to test with MetaMask!")
    
    uvicorn.run(app, host="0.0.0.0", port=8080)