import httpx

async def check_creditworthiness(address: str, min_score: int = 700) -> dict:
    """
    Check if an address meets minimum credit requirements.
    
    Args:
        address: Ethereum address or ENS name
        min_score: Minimum required credit score
        
    Returns:
        Dict with approval status and score details
    """
    async with httpx.AsyncClient() as client:
        response = await client.get(
            f"https://api.credprotocol.com/mcp/sandbox/score/{address}",
            params={"include_factors": True}
        )
        data = response.json()
        
        return {
            "address": data["address"],
            "score": data["score"],
            "range": data["range"],
            "approved": data["score"] >= min_score,
            "factors": data.get("factors", [])
        }

# Usage
result = await check_creditworthiness("vitalik.eth", min_score=750)
if result["approved"]:
    print(f"✅ Approved! Score: {result['score']} ({result['range']})")
else:
    print(f"❌ Not approved. Score: {result['score']} (need 750+)")

import httpx
from typing import List

async def batch_risk_assessment(addresses: List[str]) -> dict:
    """
    Assess credit risk across multiple addresses.
    
    Returns summary statistics and individual scores.
    """
    async with httpx.AsyncClient() as client:
        response = await client.post(
            "https://api.credprotocol.com/mcp/sandbox/score/batch",
            json={"addresses": addresses}
        )
        data = response.json()
        
        scores = [s["score"] for s in data["scores"]]
        
        return {
            "count": data["count"],
            "average_score": sum(scores) / len(scores),
            "min_score": min(scores),
            "max_score": max(scores),
            "high_risk_count": sum(1 for s in scores if s < 640),
            "scores": data["scores"]
        }

# Usage
addresses = [
    "vitalik.eth",
    "0x742d35Cc6634C0532925a3b844Bc9e7595f32345",
    "0xAb5801a7D398351b8bE11C439e05C5B3259aeC9B"
]
risk = await batch_risk_assessment(addresses)
print(f"Portfolio avg score: {risk['average_score']:.0f}")
print(f"High risk addresses: {risk['high_risk_count']}")

import httpx

REQUIRED_ATTESTATIONS = ["ENS Name", "Gitcoin Passport"]

async def verify_identity(address: str) -> dict:
    """
    Check if address has required identity attestations.
    """
    async with httpx.AsyncClient() as client:
        response = await client.get(
            f"https://api.credprotocol.com/mcp/sandbox/identity/{address}"
        )
        data = response.json()
        
        attestations = set(data["attestations"])
        required = set(REQUIRED_ATTESTATIONS)
        
        return {
            "address": data["address"],
            "verified": required.issubset(attestations),
            "has": list(attestations),
            "missing": list(required - attestations)
        }

# Usage
result = await verify_identity("vitalik.eth")
if result["verified"]:
    print("✅ Identity verified - access granted")
else:
    print(f"❌ Missing: {result['missing']}")

import httpx
import asyncio

CHAINS = {
    1: "Ethereum",
    10: "Optimism", 
    137: "Polygon",
    8453: "Base",
    42161: "Arbitrum"
}

async def get_portfolio_breakdown(address: str) -> dict:
    """
    Get portfolio value broken down by chain.
    """
    async with httpx.AsyncClient() as client:
        # Fetch total and chain-specific values in parallel
        tasks = [
            client.get(f"https://api.credprotocol.com/mcp/sandbox/portfolio/{address}")
        ]
        for chain_id in CHAINS:
            tasks.append(
                client.get(
                    f"https://api.credprotocol.com/mcp/sandbox/portfolio/{address}/chain/{chain_id}"
                )
            )
        
        responses = await asyncio.gather(*[t for t in tasks])
        
        total_data = responses[0].json()
        chain_data = [r.json() for r in responses[1:]]
        
        return {
            "address": total_data["address"],
            "total_usd": total_data["total_asset_usd"],
            "chains": sorted(
                [
                    {
                        "chain": c["chain_name"],
                        "value_usd": c["total_asset_usd"],
                        "percentage": (c["total_asset_usd"] / total_data["total_asset_usd"]) * 100
                    }
                    for c in chain_data
                ],
                key=lambda x: x["value_usd"],
                reverse=True
            )
        }

# Usage
portfolio = await get_portfolio_breakdown("vitalik.eth")
print(f"Total: ${portfolio['total_usd']:,.2f}")
for chain in portfolio["chains"]:
    print(f"  {chain['chain']}: ${chain['value_usd']:,.2f} ({chain['percentage']:.1f}%)")

import httpx

async def discover_agents(capability: str, min_results: int = 1) -> dict:
    """
    Search the ERC-8004 Identity Registry for agents matching a capability.

    Args:
        capability: What the agent should be able to do (e.g., "lending", "risk")
        min_results: Minimum number of results expected

    Returns:
        Dict with matching agents and discovery metadata
    """
    async with httpx.AsyncClient() as client:
        response = await client.get(
            "https://api.credprotocol.com/mcp/agents/search",
            params={"q": capability, "limit": 10}
        )
        data = response.json()

        return {
            "query": capability,
            "found": data["total_results"],
            "sufficient": data["total_results"] >= min_results,
            "agents": [
                {
                    "id": agent["agent_id"],
                    "name": agent["metadata"]["name"] if agent["metadata"] else None,
                    "owner": agent["owner"],
                }
                for agent in data["agents"]
            ]
        }

# Usage
results = await discover_agents("credit scoring")
for agent in results["agents"]:
    print(f"Agent #{agent['id']}: {agent['name']} (owner: {agent['owner'][:10]}...)")