Compliance

from sardis_compliance.kyc import KYCService, PersonaProvider

kyc = KYCService(provider=PersonaProvider(
    api_key=os.getenv("PERSONA_API_KEY"),
    environment="sandbox"
))

# Create inquiry for user
inquiry = await kyc.create_inquiry(
    user_id="user_abc123",
    inquiry_template_id="itmpl_...",  # Persona template
    redirect_url="https://app.example.com/onboarding"
)

print(f"KYC URL: {inquiry.url}")

# Check status
status = await kyc.check_status(inquiry_id=inquiry.inquiry_id)

if status.verified:
    print(f"✅ KYC verified: {status.name}")
    print(f"   Country: {status.country}")
    print(f"   Risk Level: {status.risk_level}")
else:
    print(f"❌ KYC failed: {status.reason}")

from sardis_compliance.risk_scoring import RiskScorer

scorer = RiskScorer()

# Calculate risk score
risk = await scorer.score_transaction(
    agent_id="agent_123",
    destination="merchant.com",
    amount=Decimal("500.00"),
    transaction_history=tx_history
)

print(f"Risk Score: {risk.score}")
print(f"Risk Level: {risk.level}")  # LOW | MEDIUM | HIGH | CRITICAL

if risk.level == "CRITICAL":
    print(f"Flags: {risk.flags}")
    # Block transaction and file SAR
    await compliance.file_sar(risk)

from sardis_compliance.sanctions import SanctionsService, EllipticProvider

sanctions = SanctionsService(provider=EllipticProvider(
    api_key=os.getenv("ELLIPTIC_API_KEY")
))

# Screen destination address
check = await sanctions.screen_address(
    address="0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb",
    chain="ethereum"
)

if check.is_sanctioned:
    print(f"❌ Address sanctioned")
    print(f"   Lists: {check.sanction_lists}")
    print(f"   Reason: {check.reason}")
    # Block payment
    raise ComplianceViolationError("Sanctioned address")
else:
    print(f"✅ Address clear")
    print(f"   Risk Score: {check.risk_score}")

from sardis_compliance.kya import KYAService, AgentManifest
from decimal import Decimal

kya = KYAService()

# Create agent manifest
manifest = AgentManifest(
    agent_id="agent_abc123",
    owner_id="org_xyz",  # Must have completed KYC
    capabilities=["saas_subscription", "api_credits"],
    max_budget_per_tx=Decimal("100.00"),
    daily_budget=Decimal("500.00"),
    allowed_domains=["openai.com", "anthropic.com", "aws.com"],
    blocked_domains=["gambling.*", "adult.*"],
    framework="langchain",
    framework_version="0.1.0",
    description="AI research assistant"
)

# Register agent
result = await kya.register_agent(manifest)

if result.success:
    print(f"✅ KYA registered")
    print(f"   Level: {result.kya_level}")
    print(f"   Manifest Hash: {manifest.manifest_hash}")

# Before payment, check KYA
check = await kya.check_agent(
    agent_id="agent_abc123",
    amount=Decimal("50.00")
)

if not check.allowed:
    print(f"❌ KYA denied: {check.reason}")
    # Possible reasons:
    # - "kya_level_insufficient"
    # - "kya_attestation_revoked"
    # - "kya_verification_expired"
    raise KYAViolationError(check.reason)

print(f"✅ KYA verified")
print(f"   Level: {check.kya_level}")
print(f"   Trust Score: {check.trust_score}")

from sardis_v2_core.kya_trust_scoring import TrustScorer, KYALevel

scorer = TrustScorer()

score = await scorer.calculate_trust(
    agent_id="agent_123",
    kya_level=KYALevel.VERIFIED,
    transaction_history=tx_history,
    compliance_record=compliance,
    reputation_record=reputation,
    behavioral_record=behavioral
)

print(f"Trust Score: {score.overall}")
print(f"Trust Tier: {score.tier}")  # UNTRUSTED | LOW | MEDIUM | HIGH | SOVEREIGN
print(f"Max Per-Tx: ${score.max_per_tx}")
print(f"Max Per-Day: ${score.max_per_day}")

# Breakdown by signal
for signal in score.signals:
    print(f"  {signal.name}: {signal.score:.2f} (weight: {signal.weight})")

from sardis_compliance.pep import PEPService

pep = PEPService()

# Screen user
check = await pep.check(
    name="John Doe",
    country="US",
    date_of_birth="1990-01-01"
)

if check.is_pep:
    print(f"⚠️ PEP detected")
    print(f"   Role: {check.pep_role}")
    print(f"   Country: {check.pep_country}")
    # Require enhanced due diligence
    await compliance.enhanced_due_diligence(check)
else:
    print(f"✅ Not a PEP")

from sardis_compliance.adverse_media import AdverseMediaService

adverse_media = AdverseMediaService()

# Screen entity
check = await adverse_media.screen(
    entity_name="Acme Corp",
    entity_type="organization"
)

if check.has_adverse_media:
    print(f"⚠️ Adverse media found")
    for article in check.articles:
        print(f"   - {article.title} ({article.source})")
        print(f"     Risk: {article.risk_category}")
    # Flag for manual review
    await compliance.manual_review(check)

from sardis_compliance.sar import SARService

sar_service = SARService()

# File SAR
sar = await sar_service.file_sar(
    agent_id="agent_123",
    transaction_id="tx_abc",
    amount=Decimal("9999.00"),
    reason="Structuring: Multiple payments just below $10k threshold",
    risk_score=0.85,
    supporting_evidence=[
        "tx_abc: $9,999",
        "tx_def: $9,998",
        "tx_ghi: $9,997"
    ]
)

print(f"SAR filed: {sar.sar_id}")
print(f"Status: {sar.status}")  # PENDING | FILED | REVIEWED

from sardis_compliance.travel_rule import TravelRuleService

travel_rule = TravelRuleService()

# Check if travel rule applies
if amount >= Decimal("1000.00"):
    # Collect beneficiary information
    beneficiary = await travel_rule.collect_beneficiary_info(
        name="Jane Smith",
        address="123 Main St, New York, NY",
        account_number="0x..."
    )
    
    # Send to counterparty VASP
    await travel_rule.send_travel_rule_message(
        beneficiary=beneficiary,
        originator=originator,
        amount=amount,
        vasp_destination="vasp.example.com"
    )

from sardis_compliance.reports import ComplianceReportService
from datetime import datetime, timedelta

reports = ComplianceReportService()

# Generate monthly compliance report
report = await reports.generate_monthly_report(
    month=datetime(2025, 3, 1),
    include_sections=[
        "transaction_summary",
        "risk_alerts",
        "sanctions_hits",
        "sar_filings",
        "kyc_verifications"
    ]
)

# Export to PDF
pdf = await reports.export_pdf(report)

# Save to S3
await s3.upload(pdf, bucket="compliance-reports")