The 11 guards for financial AI verification

from qwed_finance import ComplianceGuard

guard = ComplianceGuard()

# AML threshold check (BSA/FinCEN, 10,000)
result = guard.verify_aml_flag(
    amount=15000,
    country_code="US",
    llm_flagged=True
)
# result.compliant = True
# result.proof = "Z3: LLM decision matches regulatory requirement"

# Z3 proves: IF amount >= 10000 THEN flag_required
from z3 import *
amount = Real('amount')
flag = Bool('flag')
solver = Solver()
solver.add(Implies(amount >= 10000, flag == True))

from qwed_finance import CalendarGuard, DayCountConvention
from datetime import date

guard = CalendarGuard()

# Verify 30/360 day count
result = guard.verify_day_count(
    start_date=date(2026, 1, 1),
    end_date=date(2026, 7, 1),
    llm_days=180,
    convention=DayCountConvention.THIRTY_360
)
# result.verified = True

from qwed_finance import DerivativesGuard, OptionType

guard = DerivativesGuard()

# Verify Black-Scholes call price
result = guard.verify_black_scholes(
    spot_price=100,
    strike_price=105,
    time_to_expiry=0.25,
    risk_free_rate=0.05,
    volatility=0.20,
    option_type=OptionType.CALL,
    llm_price="$2.48"
)
# result.verified = True
# result.computed_price = "$2.48"
# result.greeks = {"delta": "0.3772", "gamma": "0.037988", "theta": "-0.0256", "vega": "0.1899", "rho": "0.0881"}

from qwed_finance import MessageGuard, MessageType

guard = MessageGuard()

# Verify pacs.008 payment message
result = guard.verify_iso20022_xml(
    xml_string=pacs008_xml,
    msg_type=MessageType.PACS_008
)
# result.valid = True/False
# result.errors = ["Missing required element: GrpHdr"]

from qwed_finance import SwiftMtType

# Validate MT103 fields
result = guard.verify_swift_mt(
    mt_string=mt103_message,
    mt_type=SwiftMtType.MT103
)
# Checks Field 20, 32A, 50K, 59, etc.

from qwed_finance import ISOGuard

guard = ISOGuard()

# Verify pacs.008 (JSON format)
result = guard.verify_payment_message(
    message={
        "MsgId": "1234AB",
        "CreDtTm": "2026-01-28T10:00:00",
        "NbOfTxs": 1,
        "TtlIntrBkSttlmAmt": {"amount": 100.50, "currency": "USD"}
    },
    msg_type="pacs.008"
)
# result.verified = True

from qwed_finance import QueryGuard

guard = QueryGuard(allowed_tables={"transactions", "accounts"})

# Check read-only safety
result = guard.verify_readonly_safety(
    "DELETE FROM users WHERE id=1"
)
# result.safe = False
# result.violations = ["Mutation detected: DELETE statement"]

-- A regex looking for a leading DELETE misses this:
WITH d AS (DELETE FROM users RETURNING *) SELECT * FROM d

-- The SQLGlot AST finds the mutation inside the CTE:
-- "Mutation detected in subquery: delete statement"

from qwed_finance import CrossGuard

guard = CrossGuard()

# SWIFT + Sanctions in one call
result = guard.verify_swift_with_sanctions(
    mt_string=swift_message,
    sanctions_list=["ACME Corp", "Bad Bank LLC"]
)
# Validates SWIFT format AND screens every party field
# result.passed, result.violations, result.receipts

result = guard.check_business_rules(
    pacs008_xml,
    {"max_amount": 1000000, "positive_amount": True, "allowed_currencies": ["USD", "EUR"]}
)
# result.passed = False
# result.violations = ["Amount 2500000 exceeds max 1000000"]

from qwed_finance import BondGuard

guard = BondGuard()

# Verify YTM calculation
result = guard.verify_ytm(
    face_value=1000,
    coupon_rate=0.05,
    price=950,
    years_to_maturity=10,
    llm_ytm="5.66%"
)
# result.verified = True (within the default 0.5% tolerance)
# result.computed_value = "5.6617%"

# Correct: use explicit % for percentage values
guard.verify_ytm(..., llm_ytm="5.25%")

# Correct: use decimal fraction directly
guard.verify_ytm(..., llm_ytm="0.0525")

# Breaking: "5.25" now means 525%, NOT 5.25%
# Use "5.25%" instead

from qwed_finance import FXGuard

guard = FXGuard()

# Verify Spot Conversion
result = guard.verify_currency_conversion(
    amount=1000,
    rate=0.92,
    llm_converted="920.00",
    from_currency="USD",
    to_currency="EUR",
)
# result.verified = True
# result.computed_value = "EUR 920.00"

from qwed_finance import RiskGuard

guard = RiskGuard()

# Verify Sharpe Ratio
# (Return - RiskFree) / Volatility
result = guard.verify_sharpe_ratio(
    portfolio_return=0.12,
    risk_free_rate=0.03,
    portfolio_volatility=0.15,
    llm_sharpe="0.60"
)
# result.verified = True
# result.computed_value = "0.6000"

from decimal import Decimal
from qwed_finance import TradingGuard, MarketRules

guard = TradingGuard()
guard.register_market("fed-cut-dec", MarketRules(tick_size=Decimal("0.01"), max_contracts=500))

result = guard.verify_order(
    market_id="fed-cut-dec",
    contract_type="binary",
    price="0.425",
    volume=100,
    side="buy",
)
# result.verified = False
# result.risk = "TICK_SIZE_MISMATCH"
# result.message = "Price 0.425 is not a multiple of tick size 0.01"