rm sixty nuts mention

display all providers

.dockerignore

@@ -8,4 +8,6 @@ compose.testing.yml
 .todo
 .github
 .vscode
-.DS_Store
+.DS_Store
+**/node_modules
+ui/.next

README.md

@@ -34,7 +34,7 @@ sequenceDiagram
 - **Model-Based Pricing** – Convert USD prices in `models.json` to sats using live BTC/USD rates
 - **Admin Dashboard** – Simple HTML interface at `/admin/` to view balances and API keys
 - **Discovery** – Fetch available providers from Nostr relays using NIP-91 protocol
-- **NIP-91 Auto-Announcement** – Automatically announce this provider to Nostr relays when NSEC is provided
+- **Auto-Listing** – Automatically announce this provider to Nostr relays when NSEC is provided
 - **Docker Support** – Provided `Dockerfile` and `compose.yml` for running with an optional Tor hidden service
 
 ## Getting Started
@@ -99,7 +99,7 @@ The most common settings are shown below. See `.env.example` for the full list.
 - `NPUB` – Nostr public key of the proxy
 - `HTTP_URL` – Public-facing URL of the proxy
 - `ONION_URL` – Tor hidden service URL of the proxy
-- `NEXT_PUBLIC_API_URL` - UI Configuration for Next.js frontend (proxy URL, default: 'http://127.0.0.1:8000' )
+- `NEXT_PUBLIC_API_URL` - UI Configuration for Next.js frontend (proxy URL, default: '<http://127.0.0.1:8000>' )
 
 ## Database Migrations
 
@@ -162,7 +162,7 @@ Once built, the UI is automatically served by the FastAPI backend:
 
 - **Dashboard**: `http://localhost:8000/`
 - **Login**: `http://localhost:8000/login`
-- **Models Management**: `http://localhost:8000/model
+- **Models Management**: `http://localhost:8000/model`
 - **Providers Management**: `http://localhost:8000/providers`
 - **Settings**: `http://localhost:8000/settings`
 

migrations/versions/5f6ac1e4fa9f_the_refactor.py

@@ -0,0 +1,60 @@
+"""the refactor
+
+Revision ID: 5f6ac1e4fa9f
+Revises: a1a1a1a1a1a1
+Create Date: 2025-11-28 13:31:49.796461
+"""
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "5f6ac1e4fa9f"
+down_revision = "a1a1a1a1a1a1"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    # Rename the table
+    op.rename_table("api_keys", "temporary_credit")
+
+    op.add_column(
+        "temporary_credit", sa.Column("created", sa.DateTime(), nullable=True)
+    )
+    op.add_column(
+        "temporary_credit",
+        sa.Column("refund_expiration_time", sa.Integer(), nullable=True),
+    )
+    op.drop_column("temporary_credit", "key_expiry_time")
+    op.drop_column("temporary_credit", "total_spent")
+    op.drop_column("temporary_credit", "total_requests")
+
+
+def downgrade() -> None:
+    op.add_column(
+        "temporary_credit",
+        sa.Column(
+            "total_requests",
+            sa.Integer(),
+            nullable=False,
+            server_default=sa.text("0"),
+        ),
+    )
+    op.add_column(
+        "temporary_credit",
+        sa.Column(
+            "total_spent",
+            sa.Integer(),
+            nullable=False,
+            server_default=sa.text("0"),
+        ),
+    )
+    op.add_column(
+        "temporary_credit", sa.Column("key_expiry_time", sa.Integer(), nullable=True)
+    )
+    op.drop_column("temporary_credit", "refund_expiration_time")
+    op.drop_column("temporary_credit", "created")
+
+    # Revert table rename
+    op.rename_table("temporary_credit", "api_keys")

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "routstr"
-version = "0.2.0c"
+version = "0.2.1"
 description = "Payment proxy for your LLM endpoint using cashu and nostr."
 readme = "README.md"
 requires-python = ">=3.11"

routstr/auth.py

@@ -1,661 +1,98 @@
 import hashlib
-import math
-from typing import Optional
+from typing import Annotated
 
-from fastapi import HTTPException
+from fastapi import Depends, Header, HTTPException
 from sqlalchemy.exc import IntegrityError
-from sqlmodel import col, update
 
 from .core import get_logger
-from .core.db import ApiKey, AsyncSession
+from .core.db import AsyncSession, TemporaryCredit, get_session
 from .core.settings import settings
-from .payment.cost_caculation import (
-    CostData,
-    CostDataError,
-    MaxCostData,
-    calculate_cost,
-)
-from .wallet import credit_balance, deserialize_token_from_string
+from .payment.wallet import credit_balance, deserialize_token_from_string
 
 logger = get_logger(__name__)
 
-# TODO: implement prepaid api key (not like it was before)
-# PREPAID_API_KEY = os.environ.get("PREPAID_API_KEY", None)
-# PREPAID_BALANCE = int(os.environ.get("PREPAID_BALANCE", "0")) * 1000  # Convert to msats
+
+async def api_key_to_credit(key: str, db_session: AsyncSession) -> TemporaryCredit:
+    key = key[3:] if key.startswith("sk-") else key
+    if existing_credit := await db_session.get(TemporaryCredit, key):
+        return existing_credit
+
+    raise HTTPException(status_code=401, detail="Invalid API-KEY")
 
 
-async def validate_bearer_key(
-    bearer_key: str,
-    session: AsyncSession,
-    refund_address: Optional[str] = None,
-    key_expiry_time: Optional[int] = None,
-) -> ApiKey:
-    """
-    Validates the provided API key using SQLModel.
-    If it's a cashu key, it redeems it and stores its hash and balance.
-    Otherwise checks if the hash of the key exists.
-    """
-    logger.debug(
-        "Starting bearer key validation",
-        extra={
-            "key_preview": bearer_key[:20] + "..."
-            if len(bearer_key) > 20
-            else bearer_key,
-            "has_refund_address": bool(refund_address),
-            "has_expiry_time": bool(key_expiry_time),
-        },
+async def cashu_token_to_credit(
+    cashu_token: str, db_session: AsyncSession
+) -> TemporaryCredit:
+    try:
+        token_hash = hashlib.sha256(cashu_token.encode()).hexdigest()
+        token_obj = deserialize_token_from_string(cashu_token)
+    except Exception:
+        raise HTTPException(status_code=400, detail="Invalid token format")
+
+    if existing_credit := await db_session.get(TemporaryCredit, token_hash):
+        return existing_credit
+
+    # create new TemporaryCredit
+    if token_obj.mint in settings.cashu_mints:
+        refund_currency = token_obj.unit
+        refund_mint_url = token_obj.mint
+    else:
+        refund_mint_url = settings.primary_mint
+        refund_currency = "sat"
+
+    new_credit = TemporaryCredit(
+        hashed_key=token_hash,
+        refund_currency=refund_currency,
+        refund_mint_url=refund_mint_url,
     )
+    db_session.add(new_credit)
 
-    if not bearer_key:
-        logger.error("Empty bearer key provided")
-        raise HTTPException(
-            status_code=401,
-            detail={
-                "error": {
-                    "message": "API key or Cashu token required",
-                    "type": "invalid_request_error",
-                    "code": "missing_api_key",
-                }
-            },
+    try:
+        await db_session.flush()
+    except IntegrityError:  # fallback to api key in case of race condition
+        await db_session.rollback()
+        return await api_key_to_credit(f"sk-{token_hash}", db_session)
+
+    try:
+        msats = await credit_balance(cashu_token, new_credit, db_session)
+    except Exception as e:
+        await db_session.rollback()
+        logger.error(
+            "Token redemption failed",
+            extra={"error": str(e)},
         )
+        raise HTTPException(status_code=400, detail="Token redemption failed")
 
-    if bearer_key.startswith("sk-"):
-        logger.debug(
-            "Processing sk- prefixed API key",
-            extra={"key_preview": bearer_key[:10] + "..."},
-        )
-
-        if existing_key := await session.get(ApiKey, bearer_key[3:]):
-            logger.info(
-                "Existing sk- API key found",
-                extra={
-                    "key_hash": existing_key.hashed_key[:8] + "...",
-                    "balance": existing_key.balance,
-                    "total_requests": existing_key.total_requests,
-                },
-            )
-
-            if key_expiry_time is not None:
-                existing_key.key_expiry_time = key_expiry_time
-                logger.debug(
-                    "Updated key expiry time",
-                    extra={
-                        "key_hash": existing_key.hashed_key[:8] + "...",
-                        "expiry_time": key_expiry_time,
-                    },
-                )
-
-            if refund_address is not None:
-                existing_key.refund_address = refund_address
-                logger.debug(
-                    "Updated refund address",
-                    extra={
-                        "key_hash": existing_key.hashed_key[:8] + "...",
-                        "refund_address_preview": refund_address[:20] + "..."
-                        if len(refund_address) > 20
-                        else refund_address,
-                    },
-                )
-
-            return existing_key
-        else:
-            logger.warning(
-                "sk- API key not found in database",
-                extra={"key_preview": bearer_key[:10] + "..."},
-            )
-
-    if bearer_key.startswith("cashu"):
-        logger.debug(
-            "Processing Cashu token",
-            extra={
-                "token_preview": bearer_key[:20] + "...",
-                "token_type": bearer_key[:6] if len(bearer_key) >= 6 else bearer_key,
-            },
-        )
-
-        try:
-            hashed_key = hashlib.sha256(bearer_key.encode()).hexdigest()
-            token_obj = deserialize_token_from_string(bearer_key)
-            logger.debug(
-                "Generated token hash", extra={"hash_preview": hashed_key[:16] + "..."}
-            )
-
-            if existing_key := await session.get(ApiKey, hashed_key):
-                logger.info(
-                    "Existing Cashu token found",
-                    extra={
-                        "key_hash": existing_key.hashed_key[:8] + "...",
-                        "balance": existing_key.balance,
-                        "total_requests": existing_key.total_requests,
-                    },
-                )
-
-                if key_expiry_time is not None:
-                    existing_key.key_expiry_time = key_expiry_time
-                    logger.debug(
-                        "Updated key expiry time for existing Cashu key",
-                        extra={
-                            "key_hash": existing_key.hashed_key[:8] + "...",
-                            "expiry_time": key_expiry_time,
-                        },
-                    )
-
-                if refund_address is not None:
-                    existing_key.refund_address = refund_address
-                    logger.debug(
-                        "Updated refund address for existing Cashu key",
-                        extra={
-                            "key_hash": existing_key.hashed_key[:8] + "...",
-                            "refund_address_preview": refund_address[:20] + "..."
-                            if len(refund_address) > 20
-                            else refund_address,
-                        },
-                    )
-
-                return existing_key
-
-            logger.info(
-                "Creating new Cashu token entry",
-                extra={
-                    "hash_preview": hashed_key[:16] + "...",
-                    "has_refund_address": bool(refund_address),
-                    "has_expiry_time": bool(key_expiry_time),
-                },
-            )
-            if token_obj.mint in settings.cashu_mints:
-                refund_currency = token_obj.unit
-                refund_mint_url = token_obj.mint
-            else:
-                refund_currency = "sat"
-                refund_mint_url = settings.primary_mint
-
-            new_key = ApiKey(
-                hashed_key=hashed_key,
-                balance=0,
-                refund_address=refund_address,
-                key_expiry_time=key_expiry_time,
-                refund_currency=refund_currency,
-                refund_mint_url=refund_mint_url,
-            )
-            session.add(new_key)
-
-            try:
-                await session.flush()
-            except IntegrityError:
-                await session.rollback()
-                logger.info(
-                    "Concurrent key creation detected, fetching existing key",
-                    extra={"key_hash": hashed_key[:8] + "..."},
-                )
-                existing_key = await session.get(ApiKey, hashed_key)
-                if not existing_key:
-                    raise Exception("Failed to fetch existing key after IntegrityError")
-
-                if key_expiry_time is not None:
-                    existing_key.key_expiry_time = key_expiry_time
-                if refund_address is not None:
-                    existing_key.refund_address = refund_address
-
-                return existing_key
-
-            logger.debug(
-                "New key created, starting token redemption",
-                extra={"key_hash": hashed_key[:8] + "..."},
-            )
-
-            logger.info(
-                "AUTH: About to call credit_balance",
-                extra={"token_preview": bearer_key[:50]},
-            )
-            try:
-                msats = await credit_balance(bearer_key, new_key, session)
-                logger.info(
-                    "AUTH: credit_balance returned successfully", extra={"msats": msats}
-                )
-            except Exception as credit_error:
-                logger.error(
-                    "AUTH: credit_balance failed",
-                    extra={
-                        "error": str(credit_error),
-                        "error_type": type(credit_error).__name__,
-                    },
-                )
-                raise credit_error
-
-            if msats <= 0:
-                logger.error(
-                    "Token redemption returned zero or negative amount",
-                    extra={"msats": msats, "key_hash": hashed_key[:8] + "..."},
-                )
-                raise Exception("Token redemption failed")
-
-            await session.refresh(new_key)
-            await session.commit()
-
-            logger.info(
-                "New Cashu token successfully redeemed and stored",
-                extra={
-                    "key_hash": hashed_key[:8] + "...",
-                    "redeemed_msats": msats,
-                    "final_balance": new_key.balance,
-                },
-            )
-
-            return new_key
-        except Exception as e:
-            logger.error(
-                "Cashu token redemption failed",
-                extra={
-                    "error": str(e),
-                    "error_type": type(e).__name__,
-                    "token_preview": bearer_key[:20] + "..."
-                    if len(bearer_key) > 20
-                    else bearer_key,
-                },
-            )
-            raise HTTPException(
-                status_code=401,
-                detail={
-                    "error": {
-                        "message": f"Invalid or expired Cashu key: {str(e)}",
-                        "type": "invalid_request_error",
-                        "code": "invalid_api_key",
-                    }
-                },
-            )
-
-    logger.error(
-        "Invalid API key format",
-        extra={
-            "key_preview": bearer_key[:10] + "..."
-            if len(bearer_key) > 10
-            else bearer_key,
-            "key_length": len(bearer_key),
-        },
-    )
-
-    raise HTTPException(
-        status_code=401,
-        detail={
-            "error": {
-                "message": "Invalid API key",
-                "type": "invalid_request_error",
-                "code": "invalid_api_key",
-            }
-        },
-    )
-
-
-async def pay_for_request(
-    key: ApiKey, cost_per_request: int, session: AsyncSession
-) -> int:
-    """Process payment for a request."""
+    await db_session.refresh(new_credit)
+    await db_session.commit()
 
     logger.info(
-        "Processing payment for request",
-        extra={
-            "key_hash": key.hashed_key[:8] + "...",
-            "current_balance": key.balance,
-            "required_cost": cost_per_request,
-            "sufficient_balance": key.balance >= cost_per_request,
-        },
+        "New TemporaryCredit created from CashuToken",
+        extra={"key_hash": token_hash[:8] + "...", "amount_msats": msats},
     )
 
-    if key.total_balance < cost_per_request:
-        logger.warning(
-            "Insufficient balance for request",
-            extra={
-                "key_hash": key.hashed_key[:8] + "...",
-                "balance": key.balance,
-                "reserved_balance": key.reserved_balance,
-                "required": cost_per_request,
-                "shortfall": cost_per_request - key.total_balance,
-            },
-        )
+    return new_credit
 
-        raise HTTPException(
-            status_code=402,
-            detail={
-                "error": {
-                    "message": f"Insufficient balance: {cost_per_request} mSats required. {key.total_balance} available. (reserved: {key.reserved_balance})",
-                    "type": "insufficient_quota",
-                    "code": "insufficient_balance",
-                }
-            },
-        )
 
-    logger.debug(
-        "Charging base cost for request",
-        extra={
-            "key_hash": key.hashed_key[:8] + "...",
-            "cost": cost_per_request,
-            "balance_before": key.balance,
-        },
+async def nwc_to_credit(
+    connection_string: str, db_session: AsyncSession
+) -> TemporaryCredit:
+    raise NotImplementedError
+
+
+async def get_credit(
+    authorization: Annotated[str, Header(...)],
+    db_session: AsyncSession = Depends(get_session),
+) -> TemporaryCredit:
+    authorization = (
+        authorization[7:] if authorization.startswith("Bearer ") else authorization
     )
 
-    # Charge the base cost for the request atomically to avoid race conditions
-    stmt = (
-        update(ApiKey)
-        .where(col(ApiKey.hashed_key) == key.hashed_key)
-        .where(col(ApiKey.balance) >= cost_per_request)
-        .values(
-            reserved_balance=col(ApiKey.reserved_balance) + cost_per_request,
-            total_requests=col(ApiKey.total_requests) + 1,
-        )
-    )
-    result = await session.exec(stmt)  # type: ignore[call-overload]
-    await session.commit()
-
-    if result.rowcount == 0:
-        logger.error(
-            "Concurrent request depleted balance",
-            extra={
-                "key_hash": key.hashed_key[:8] + "...",
-                "required_cost": cost_per_request,
-                "current_balance": key.balance,
-            },
-        )
-
-        # Another concurrent request spent the balance first
-        raise HTTPException(
-            status_code=402,
-            detail={
-                "error": {
-                    "message": f"Insufficient balance: {cost_per_request} mSats required. {key.balance} available.",
-                    "type": "insufficient_quota",
-                    "code": "insufficient_balance",
-                }
-            },
-        )
-
-    await session.refresh(key)
-
-    logger.info(
-        "Payment processed successfully",
-        extra={
-            "key_hash": key.hashed_key[:8] + "...",
-            "charged_amount": cost_per_request,
-            "new_balance": key.balance,
-            "total_spent": key.total_spent,
-            "total_requests": key.total_requests,
-        },
-    )
-
-    return cost_per_request
-
-
-async def revert_pay_for_request(
-    key: ApiKey, session: AsyncSession, cost_per_request: int
-) -> None:
-    stmt = (
-        update(ApiKey)
-        .where(col(ApiKey.hashed_key) == key.hashed_key)
-        .values(
-            reserved_balance=col(ApiKey.reserved_balance) - cost_per_request,
-            total_requests=col(ApiKey.total_requests) - 1,
-        )
-    )
-
-    result = await session.exec(stmt)  # type: ignore[call-overload]
-    await session.commit()
-    if result.rowcount == 0:
-        logger.error(
-            "Failed to revert payment - insufficient reserved balance",
-            extra={
-                "key_hash": key.hashed_key[:8] + "...",
-                "cost_to_revert": cost_per_request,
-                "current_reserved_balance": key.reserved_balance,
-            },
-        )
-        raise HTTPException(
-            status_code=402,
-            detail={
-                "error": {
-                    "message": f"failed to revert request payment: {cost_per_request} mSats required. {key.balance} available.",
-                    "type": "payment_error",
-                    "code": "payment_error",
-                }
-            },
-        )
-    await session.refresh(key)
-
-
-async def adjust_payment_for_tokens(
-    key: ApiKey, response_data: dict, session: AsyncSession, deducted_max_cost: int
-) -> dict:
-    """
-    Adjusts the payment based on token usage in the response.
-    This is called after the initial payment and the upstream request is complete.
-    Returns cost data to be included in the response.
-    """
-    model = response_data.get("model", "unknown")
-
-    logger.debug(
-        "Starting payment adjustment for tokens",
-        extra={
-            "key_hash": key.hashed_key[:8] + "...",
-            "model": model,
-            "deducted_max_cost": deducted_max_cost,
-            "current_balance": key.balance,
-            "has_usage": "usage" in response_data,
-        },
-    )
-
-    match await calculate_cost(response_data, deducted_max_cost, session):
-        case MaxCostData() as cost:
-            logger.debug(
-                "Using max cost data (no token adjustment)",
-                extra={
-                    "key_hash": key.hashed_key[:8] + "...",
-                    "model": model,
-                    "max_cost": cost.total_msats,
-                },
-            )
-            # Finalize by releasing reservation and charging max cost
-            finalize_stmt = (
-                update(ApiKey)
-                .where(col(ApiKey.hashed_key) == key.hashed_key)
-                .values(
-                    reserved_balance=col(ApiKey.reserved_balance) - deducted_max_cost,
-                    balance=col(ApiKey.balance) - cost.total_msats,
-                    total_spent=col(ApiKey.total_spent) + cost.total_msats,
-                )
-            )
-            result = await session.exec(finalize_stmt)  # type: ignore[call-overload]
-            await session.commit()
-            if result.rowcount == 0:
-                logger.error(
-                    "Failed to finalize max-cost payment - insufficient reserved balance",
-                    extra={
-                        "key_hash": key.hashed_key[:8] + "...",
-                        "deducted_max_cost": deducted_max_cost,
-                        "current_reserved_balance": key.reserved_balance,
-                        "total_cost": cost.total_msats,
-                        "model": model,
-                    },
-                )
-            else:
-                await session.refresh(key)
-                logger.info(
-                    "Max cost payment finalized",
-                    extra={
-                        "key_hash": key.hashed_key[:8] + "...",
-                        "charged_amount": cost.total_msats,
-                        "new_balance": key.balance,
-                        "model": model,
-                    },
-                )
-            return cost.dict()
-
-        case CostData() as cost:
-            # If token-based pricing is enabled and base cost is 0, use token-based cost
-            # Otherwise, token cost is additional to the base cost
-            cost_difference = cost.total_msats - deducted_max_cost
-            total_cost_msats: int = math.ceil(cost.total_msats)
-
-            logger.info(
-                "Calculated token-based cost",
-                extra={
-                    "key_hash": key.hashed_key[:8] + "...",
-                    "model": model,
-                    "token_cost": cost.total_msats,
-                    "deducted_max_cost": deducted_max_cost,
-                    "cost_difference": cost_difference,
-                    "input_msats": cost.input_msats,
-                    "output_msats": cost.output_msats,
-                },
-            )
-
-            if cost_difference == 0:
-                logger.debug(
-                    "Finalizing with exact reserved cost",
-                    extra={"key_hash": key.hashed_key[:8] + "...", "model": model},
-                )
-                finalize_stmt = (
-                    update(ApiKey)
-                    .where(col(ApiKey.hashed_key) == key.hashed_key)
-                    .values(
-                        reserved_balance=col(ApiKey.reserved_balance)
-                        - deducted_max_cost,
-                        balance=col(ApiKey.balance) - total_cost_msats,
-                        total_spent=col(ApiKey.total_spent) + total_cost_msats,
-                    )
-                )
-                await session.exec(finalize_stmt)  # type: ignore[call-overload]
-                await session.commit()
-                await session.refresh(key)
-                return cost.dict()
-
-            # this should never happen why do we handle this???
-            if cost_difference > 0:
-                # Need to charge more than reserved, finalize by releasing reservation and charging total
-                logger.info(
-                    "Additional charge required for token usage",
-                    extra={
-                        "key_hash": key.hashed_key[:8] + "...",
-                        "additional_charge": cost_difference,
-                        "current_balance": key.balance,
-                        "sufficient_balance": key.balance >= cost_difference,
-                        "model": model,
-                    },
-                )
-
-                finalize_stmt = (
-                    update(ApiKey)
-                    .where(col(ApiKey.hashed_key) == key.hashed_key)
-                    .values(
-                        reserved_balance=col(ApiKey.reserved_balance)
-                        - deducted_max_cost,
-                        balance=col(ApiKey.balance) - total_cost_msats,
-                        total_spent=col(ApiKey.total_spent) + total_cost_msats,
-                    )
-                )
-                result = await session.exec(finalize_stmt)  # type: ignore[call-overload]
-                await session.commit()
-
-                if result.rowcount:
-                    cost.total_msats = total_cost_msats
-                    await session.refresh(key)
-
-                    logger.info(
-                        "Finalized payment with additional charge",
-                        extra={
-                            "key_hash": key.hashed_key[:8] + "...",
-                            "charged_amount": total_cost_msats,
-                            "new_balance": key.balance,
-                            "model": model,
-                        },
-                    )
-                else:
-                    logger.warning(
-                        "Failed to finalize additional charge (concurrent operation)",
-                        extra={
-                            "key_hash": key.hashed_key[:8] + "...",
-                            "attempted_charge": total_cost_msats,
-                            "model": model,
-                        },
-                    )
-            else:
-                # Refund some of the base cost
-                refund = abs(cost_difference)
-                logger.info(
-                    "Refunding excess payment",
-                    extra={
-                        "key_hash": key.hashed_key[:8] + "...",
-                        "refund_amount": refund,
-                        "current_balance": key.balance,
-                        "model": model,
-                    },
-                )
-
-                refund_stmt = (
-                    update(ApiKey)
-                    .where(col(ApiKey.hashed_key) == key.hashed_key)
-                    .values(
-                        reserved_balance=col(ApiKey.reserved_balance)
-                        - deducted_max_cost,
-                        balance=col(ApiKey.balance) - total_cost_msats,
-                        total_spent=col(ApiKey.total_spent) + total_cost_msats,
-                    )
-                )
-                result = await session.exec(refund_stmt)  # type: ignore[call-overload]
-                await session.commit()
-
-                if result.rowcount == 0:
-                    logger.error(
-                        "Failed to finalize payment - insufficient reserved balance",
-                        extra={
-                            "key_hash": key.hashed_key[:8] + "...",
-                            "deducted_max_cost": deducted_max_cost,
-                            "current_reserved_balance": key.reserved_balance,
-                            "total_cost": total_cost_msats,
-                            "model": model,
-                        },
-                    )
-                    # Still return the cost data even if we couldn't properly finalize
-                    # The reservation was already made, so the user has paid
-
-                cost.total_msats = total_cost_msats
-                await session.refresh(key)
-
-                logger.info(
-                    "Refund processed successfully",
-                    extra={
-                        "key_hash": key.hashed_key[:8] + "...",
-                        "refunded_amount": refund,
-                        "new_balance": key.balance,
-                        "final_cost": cost.total_msats,
-                        "model": model,
-                    },
-                )
-
-            return cost.dict()
-
-        case CostDataError() as error:
-            logger.error(
-                "Cost calculation error during payment adjustment",
-                extra={
-                    "key_hash": key.hashed_key[:8] + "...",
-                    "model": model,
-                    "error_message": error.message,
-                    "error_code": error.code,
-                },
-            )
-
-            raise HTTPException(
-                status_code=400,
-                detail={
-                    "error": {
-                        "message": error.message,
-                        "type": "invalid_request_error",
-                        "code": error.code,
-                    }
-                },
-            )
-    # Fallback return to satisfy type checker; execution should not reach here
-    return {
-        "base_msats": deducted_max_cost,
-        "input_msats": 0,
-        "output_msats": 0,
-        "total_msats": deducted_max_cost,
-    }
+    if authorization.startswith("cashu"):
+        return await cashu_token_to_credit(authorization, db_session)
+    elif authorization.startswith("sk-"):
+        return await api_key_to_credit(authorization, db_session)
+    elif authorization.startswith("nwc"):
+        return await nwc_to_credit(authorization, db_session)
+    else:
+        raise HTTPException(status_code=401, detail="Unable to parse bearer token")

routstr/balance.py

@@ -6,11 +6,12 @@ from typing import Annotated, NoReturn
 from fastapi import APIRouter, Depends, Header, HTTPException
 from pydantic import BaseModel
 
-from .auth import validate_bearer_key
-from .core.db import ApiKey, AsyncSession, get_session
+from .auth import get_credit
+from .core.db import AsyncSession, TemporaryCredit, get_session
 from .core.logging import get_logger
 from .core.settings import settings
-from .wallet import credit_balance, recieve_token, send_to_lnurl, send_token
+from .payment.lnurl import send_to_lnurl
+from .payment.wallet import credit_balance, recieve_token, send_token
 
 router = APIRouter()
 balance_router = APIRouter(prefix="/v1/balance")
@@ -18,26 +19,15 @@ balance_router = APIRouter(prefix="/v1/balance")
 logger = get_logger(__name__)
 
 
-async def get_key_from_header(
-    authorization: Annotated[str, Header(...)],
-    session: AsyncSession = Depends(get_session),
-) -> ApiKey:
-    if authorization.startswith("Bearer "):
-        return await validate_bearer_key(authorization[7:], session)
-
-    raise HTTPException(
-        status_code=401,
-        detail="Invalid authorization. Use 'Bearer <cashu-token>' or 'Bearer <api-key>'",
-    )
-
-
 # TODO: remove this endpoint when frontend is updated
 @router.get("/", include_in_schema=False)
-async def account_info(key: ApiKey = Depends(get_key_from_header)) -> dict:
+async def account_info(
+    credit: TemporaryCredit = Depends(get_credit),
+) -> dict:
     return {
-        "api_key": "sk-" + key.hashed_key,
-        "balance": key.balance,
-        "reserved": key.reserved_balance,
+        "api_key": credit.api_key,
+        "balance": credit.balance,
+        "reserved": credit.reserved_balance,
     }
 
 
@@ -57,19 +47,18 @@ async def account_info(key: ApiKey = Depends(get_key_from_header)) -> dict:
 async def create_balance(
     initial_balance_token: str, session: AsyncSession = Depends(get_session)
 ) -> dict:
-    key = await validate_bearer_key(initial_balance_token, session)
-    return {
-        "api_key": "sk-" + key.hashed_key,
-        "balance": key.balance,
-    }
+    credit = await get_credit(initial_balance_token, session)
+    return {"api_key": credit.api_key, "balance": credit.balance}
 
 
 @router.get("/info")
-async def wallet_info(key: ApiKey = Depends(get_key_from_header)) -> dict:
+async def wallet_info(
+    credit: TemporaryCredit = Depends(get_credit),
+) -> dict:
     return {
-        "api_key": "sk-" + key.hashed_key,
-        "balance": key.balance,
-        "reserved": key.reserved_balance,
+        "api_key": credit.api_key,
+        "balance": credit.balance,
+        "reserved": credit.reserved_balance,
     }
 
 
@@ -81,7 +70,7 @@ class TopupRequest(BaseModel):
 async def topup_wallet_endpoint(
     cashu_token: str | None = None,
     topup_request: TopupRequest | None = None,
-    key: ApiKey = Depends(get_key_from_header),
+    credit: TemporaryCredit = Depends(get_credit),
     session: AsyncSession = Depends(get_session),
 ) -> dict[str, int]:
     if topup_request is not None:
@@ -93,7 +82,7 @@ async def topup_wallet_endpoint(
     if len(cashu_token) < 10 or "cashu" not in cashu_token:
         raise HTTPException(status_code=400, detail="Invalid token format")
     try:
-        amount_msats = await credit_balance(cashu_token, key, session)
+        amount_msats = await credit_balance(cashu_token, credit, session)
     except ValueError as e:
         error_msg = str(e)
         if "already spent" in error_msg.lower():
@@ -152,10 +141,11 @@ async def refund_wallet_endpoint(
     if cached := await _refund_cache_get(bearer_value):
         return cached
 
-    key: ApiKey = await validate_bearer_key(bearer_value, session)
+    key: TemporaryCredit = await get_credit(bearer_value, session)
     remaining_balance_msats: int = key.balance
+    refund_currency = key.refund_currency or "sat"
 
-    if key.refund_currency == "sat":
+    if refund_currency == "sat":
         remaining_balance = remaining_balance_msats // 1000
     else:
         remaining_balance = remaining_balance_msats
@@ -172,19 +162,18 @@ async def refund_wallet_endpoint(
 
             await send_to_lnurl(
                 remaining_balance,
-                key.refund_currency or "sat",
+                refund_currency,
                 key.refund_mint_url or global_settings.primary_mint,
                 key.refund_address,
             )
             result = {"recipient": key.refund_address}
         else:
-            refund_currency = key.refund_currency or "sat"
             token = await send_token(
                 remaining_balance, refund_currency, key.refund_mint_url
             )
             result = {"token": token}
 
-        if key.refund_currency == "sat":
+        if refund_currency == "sat":
             result["sats"] = str(remaining_balance_msats // 1000)
         else:
             result["msats"] = str(remaining_balance_msats)

routstr/core/admin.py

@@ -3,21 +3,22 @@ import secrets
 from datetime import datetime, timezone
 from pathlib import Path
 
-from fastapi import APIRouter, Depends, HTTPException, Request
+from fastapi import APIRouter, Depends, HTTPException, Query, Request
 from fastapi.responses import HTMLResponse, RedirectResponse
 from pydantic import BaseModel
 from sqlmodel import select
 
-from ..payment.models import _row_to_model, list_models
-from ..proxy import refresh_model_maps, reinitialize_upstreams
-from ..wallet import (
+from ..models.crud import row_to_model, list_models
+from ..payment.wallet import (
     fetch_all_balances,
     get_proofs_per_mint_and_unit,
     get_wallet,
     send_token,
     slow_filter_spend_proofs,
 )
-from .db import ApiKey, ModelRow, UpstreamProviderRow, create_session
+from ..proxy import refresh_model_maps, reinitialize_upstreams
+from .db import ModelRow, TemporaryCredit, UpstreamProviderRow, create_session
+from .log_manager import log_manager
 from .logging import get_logger
 from .settings import SettingsService, settings
 
@@ -106,13 +107,13 @@ async def partial_balances(request: Request) -> str:
 
 
 @admin_router.get(
-    "/partials/apikeys",
+    "/partials/TemporaryCredits",
     dependencies=[Depends(require_admin_api)],
     response_class=HTMLResponse,
 )
-async def partial_apikeys(request: Request) -> str:
+async def partial_TemporaryCredits(request: Request) -> str:
     async with create_session() as session:
-        result = await session.exec(select(ApiKey))
+        result = await session.exec(select(TemporaryCredit))
         api_keys = result.all()
 
     def fmt_time(ts: int | None) -> str:
@@ -123,7 +124,7 @@ async def partial_apikeys(request: Request) -> str:
 
     rows = "".join(
         [
-            f"<tr><td>{key.hashed_key}</td><td>{key.balance}</td><td>{key.total_spent}</td><td>{key.total_requests}</td><td>{key.refund_address}</td><td>{fmt_time(key.key_expiry_time)}</td></tr>"
+            f"<tr><td>{key.hashed_key}</td><td>{key.balance}</td><td>{key.refund_address}</td><td>{key.refund_mint_url}</td><td>{key.refund_currency}</td><td>{fmt_time(key.refund_expiration_time)}</td></tr>"
             for key in api_keys
         ]
     )
@@ -133,9 +134,9 @@ async def partial_apikeys(request: Request) -> str:
             <tr>
                 <th>Hashed Key</th>
                 <th>Balance (mSats)</th>
-                <th>Total Spent (mSats)</th>
-                <th>Total Requests</th>
                 <th>Refund Address</th>
+                <th>Refund Mint</th>
+                <th>Currency</th>
                 <th>Refund Time</th>
             </tr>
             {rows}
@@ -146,17 +147,17 @@ async def partial_apikeys(request: Request) -> str:
 @admin_router.get("/api/temporary-balances", dependencies=[Depends(require_admin_api)])
 async def get_temporary_balances_api(request: Request) -> list[dict[str, object]]:
     async with create_session() as session:
-        result = await session.exec(select(ApiKey))
+        result = await session.exec(select(TemporaryCredit))
         api_keys = result.all()
 
     return [
         {
             "hashed_key": key.hashed_key,
             "balance": key.balance,
-            "total_spent": key.total_spent,
-            "total_requests": key.total_requests,
             "refund_address": key.refund_address,
-            "key_expiry_time": key.key_expiry_time,
+            "refund_mint_url": key.refund_mint_url,
+            "refund_currency": key.refund_currency,
+            "refund_expiration_time": key.refund_expiration_time,
         }
         for key in api_keys
     ]
@@ -776,8 +777,8 @@ async def dashboard(request: Request) -> str:
                 <p><em>Save this token! It represents your withdrawn balance.</em></p>
             </div>
 
-            <div id="apikeys-table"
-                 hx-get="/admin/partials/apikeys"
+            <div id="TemporaryCredits-table"
+                 hx-get="/admin/partials/TemporaryCredits"
                  hx-trigger="load"
                  hx-swap="outerHTML">
                 <h2>Temporary Balances</h2>
@@ -1762,9 +1763,9 @@ UPSTREAM_PROVIDERS_JS: str = """<!--html-->
             provider_fee: feeValue ? parseFloat(feeValue) : defaultFee,
         };
 
-        const apiKey = document.getElementById('provider-api-key').value;
-        if (apiKey) {
-            payload.api_key = apiKey;
+        const TemporaryCredit = document.getElementById('provider-api-key').value;
+        if (TemporaryCredit) {
+            payload.api_key = TemporaryCredit;
         }
 
         const saveBtn = document.getElementById('provider-save-btn');
@@ -1782,7 +1783,7 @@ UPSTREAM_PROVIDERS_JS: str = """<!--html-->
                     body: JSON.stringify(payload)
                 });
             } else {
-                if (!apiKey) {
+                if (!TemporaryCredit) {
                     throw new Error('API Key is required for new providers');
                 }
                 resp = await fetch('/admin/api/upstream-providers', {
@@ -2455,7 +2456,7 @@ async def create_provider_model(
         await session.refresh(row)
 
     await refresh_model_maps()
-    return _row_to_model(
+    return row_to_model(
         row, apply_provider_fee=True, provider_fee=provider.provider_fee
     ).dict()  # type: ignore
 
@@ -2475,7 +2476,7 @@ async def get_provider_model(provider_id: int, model_id: str) -> dict[str, objec
             raise HTTPException(
                 status_code=404, detail="Model not found for this provider"
             )
-        return _row_to_model(
+        return row_to_model(
             row, apply_provider_fee=True, provider_fee=provider.provider_fee
         ).dict()  # type: ignore
 
@@ -2524,7 +2525,7 @@ async def update_provider_model(
         await session.refresh(row)
 
     if was_disabled and payload.enabled:
-        from ..payment.models import _cleanup_enabled_models_once
+        from ..models.models import _cleanup_enabled_models_once
 
         try:
             await _cleanup_enabled_models_once()
@@ -2535,7 +2536,7 @@ async def update_provider_model(
             )
 
     await refresh_model_maps()
-    return _row_to_model(
+    return row_to_model(
         row, apply_provider_fee=True, provider_fee=provider.provider_fee
     ).dict()  # type: ignore
 
@@ -2795,7 +2796,7 @@ async def get_provider_models(provider_id: int) -> dict[str, object]:
     dependencies=[Depends(require_admin_api)],
 )
 async def get_openrouter_presets() -> list[dict[str, object]]:
-    from ..payment.models import async_fetch_openrouter_models
+    from ..models import async_fetch_openrouter_models
 
     models_data = await async_fetch_openrouter_models()
     return models_data
@@ -2865,3 +2866,122 @@ h1 { color: #333; }
 .no-logs { text-align: center; color: #666; padding: 40px; }
 .request-id-display { background-color: #e9ecef; padding: 10px; border-radius: 4px; margin-bottom: 20px; font-family: monospace; }
 """
+
+
+@admin_router.get("/api/usage/metrics", dependencies=[Depends(require_admin_api)])
+async def get_usage_metrics(
+    request: Request,
+    interval: int = Query(
+        default=15, ge=1, le=1440, description="Time interval in minutes"
+    ),
+    hours: int = Query(
+        default=24, ge=1, le=168, description="Hours of history to analyze"
+    ),
+) -> dict:
+    """Get usage metrics aggregated by time interval."""
+    return log_manager.get_usage_metrics(interval=interval, hours=hours)
+
+
+@admin_router.get("/api/usage/summary", dependencies=[Depends(require_admin_api)])
+async def get_usage_summary(
+    request: Request,
+    hours: int = Query(
+        default=24, ge=1, le=168, description="Hours of history to analyze"
+    ),
+) -> dict:
+    """Get summary statistics for the specified time period."""
+    return log_manager.get_usage_summary(hours=hours)
+
+
+@admin_router.get("/api/usage/error-details", dependencies=[Depends(require_admin_api)])
+async def get_error_details(
+    request: Request,
+    hours: int = Query(
+        default=24, ge=1, le=168, description="Hours of history to analyze"
+    ),
+    limit: int = Query(
+        default=100, ge=1, le=1000, description="Maximum number of errors to return"
+    ),
+) -> dict:
+    """Get detailed error information."""
+    return log_manager.get_error_details(hours=hours, limit=limit)
+
+
+@admin_router.get(
+    "/api/usage/revenue-by-model", dependencies=[Depends(require_admin_api)]
+)
+async def get_revenue_by_model(
+    request: Request,
+    hours: int = Query(
+        default=24, ge=1, le=168, description="Hours of history to analyze"
+    ),
+    limit: int = Query(
+        default=20, ge=1, le=100, description="Maximum number of models to return"
+    ),
+) -> dict:
+    """
+    Get revenue breakdown by model.
+    """
+    return log_manager.get_revenue_by_model(hours=hours, limit=limit)
+
+
+@admin_router.get("/api/logs", dependencies=[Depends(require_admin_api)])
+async def get_logs_api(
+    request: Request,
+    date: str | None = None,
+    level: str | None = None,
+    request_id: str | None = None,
+    search: str | None = None,
+    limit: int = 100,
+) -> dict[str, object]:
+    """
+    Get filtered log entries.
+
+    Args:
+        date: Filter by specific date (YYYY-MM-DD)
+        level: Filter by log level
+        request_id: Filter by request ID
+        search: Search text in message and name fields (case-insensitive)
+        limit: Maximum number of entries to return
+
+    Returns:
+        Dict containing logs and filter metadata
+    """
+    log_entries = log_manager.search_logs(
+        date=date,
+        level=level,
+        request_id=request_id,
+        search_text=search,
+        limit=limit,
+    )
+
+    return {
+        "logs": log_entries,
+        "total": len(log_entries),
+        "date": date,
+        "level": level,
+        "request_id": request_id,
+        "search": search,
+        "limit": limit,
+    }
+
+
+@admin_router.get("/api/logs/dates", dependencies=[Depends(require_admin_api)])
+async def get_log_dates_api(request: Request) -> dict[str, object]:
+    logs_dir = Path("logs")
+    dates = []
+
+    if logs_dir.exists():
+        log_files = sorted(
+            logs_dir.glob("app_*.log"), key=lambda x: x.stat().st_mtime, reverse=True
+        )
+
+        for log_file in log_files[:30]:
+            try:
+                filename = log_file.name
+                date_str = filename.replace("app_", "").replace(".log", "")
+                dates.append(date_str)
+            except Exception:
+                continue
+
+    return {"dates": dates}

routstr/core/db.py

@@ -1,5 +1,6 @@
 import os
 from contextlib import asynccontextmanager
+from datetime import datetime
 from typing import AsyncGenerator
 
 from alembic import command
@@ -18,39 +19,40 @@ DATABASE_URL = os.environ.get("DATABASE_URL", "sqlite+aiosqlite:///keys.db")
 engine = create_async_engine(DATABASE_URL, echo=False)  # echo=True for debugging SQL
 
 
-class ApiKey(SQLModel, table=True):  # type: ignore
-    __tablename__ = "api_keys"
+class TemporaryCredit(SQLModel, table=True):  # type: ignore
+    __tablename__ = "temporary_credit"
 
     hashed_key: str = Field(primary_key=True)
-    balance: int = Field(default=0, description="Balance in millisatoshis (msats)")
-    reserved_balance: int = Field(
-        default=0, description="Reserved balance in millisatoshis (msats)"
-    )
+    balance: int = Field(default=0, description="Balance in msats")
+    reserved_balance: int = Field(default=0, description="Blocked balance in msats")
+    created: datetime | None = Field(None, description="Timestamp of creation")
     refund_address: str | None = Field(
-        default=None,
-        description="Lightning address to refund remaining balance after key expires",
+        None, description="Address to refund on expiration"
     )
-    key_expiry_time: int | None = Field(
-        default=None,
-        description="Unix-timestamp after which the cashu-token's balance gets refunded to the refund_address",
-    )
-    total_spent: int = Field(
-        default=0, description="Total spent in millisatoshis (msats)"
-    )
-    total_requests: int = Field(default=0)
     refund_mint_url: str | None = Field(
-        default=None,
-        description="URL of the mint used to create the cashu-token",
+        default=None, description="Mint used to issue the refund token"
     )
-    refund_currency: str | None = Field(
-        default=None,
-        description="Currency of the cashu-token",
+    refund_currency: str | None = Field(None, description="Currency of the cashu-token")
+    refund_expiration_time: int | None = Field(
+        None, description="Refund not allowed after timeout"
     )
 
     @property
-    def total_balance(self) -> int:
+    def total_balance_msat(self) -> int:
         return self.balance - self.reserved_balance
 
+    @property
+    def total_balance_sat(self) -> int:
+        return self.total_balance_msat // 1000
+
+    @property
+    def total_balance(self) -> int:
+        return self.total_balance_msat
+
+    @property
+    def api_key(self) -> str:
+        return "sk-" + self.hashed_key
+
 
 class ModelRow(SQLModel, table=True):  # type: ignore
     __tablename__ = "models"
@@ -95,8 +97,9 @@ class UpstreamProviderRow(SQLModel, table=True):  # type: ignore
 async def balances_for_mint_and_unit(
     db_session: AsyncSession, mint_url: str, unit: str
 ) -> int:
-    query = select(func.sum(ApiKey.balance)).where(
-        ApiKey.refund_mint_url == mint_url, ApiKey.refund_currency == unit
+    query = select(func.sum(TemporaryCredit.balance)).where(
+        TemporaryCredit.refund_mint_url == mint_url,
+        TemporaryCredit.refund_currency == unit,
     )
     result = await db_session.exec(query)
     return result.one() or 0

routstr/core/log_manager.py

@@ -0,0 +1,469 @@
+import json
+from collections import defaultdict
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Any, Iterator
+
+from .logging import get_logger
+
+logger = get_logger(__name__)
+
+
+class LogManager:
+    def __init__(self, logs_dir: Path = Path("logs")):
+        self.logs_dir = logs_dir
+
+    def _yield_log_entries(
+        self,
+        hours_back: int | None = None,
+        specific_date: str | None = None,
+        reverse_files: bool = False,
+        max_files: int | None = None,
+    ) -> Iterator[dict[str, Any]]:
+        """
+        Yields log entries from files.
+
+        Args:
+            hours_back: specific number of hours to look back.
+            specific_date: specific date string (YYYY-MM-DD) to look at.
+            reverse_files: if True, process files in reverse order (newest first).
+            max_files: maximum number of log files to process (most recent if reverse_files is True).
+        """
+        if not self.logs_dir.exists():
+            return
+
+        log_files = []
+        cutoff_date = None
+
+        if specific_date:
+            log_file = self.logs_dir / f"app_{specific_date}.log"
+            if log_file.exists():
+                log_files.append(log_file)
+        else:
+            log_files = sorted(self.logs_dir.glob("app_*.log"))
+            if reverse_files:
+                log_files.reverse()
+
+            # If we only care about hours back, we can optimize file selection
+            if hours_back is not None:
+                cutoff_date = datetime.now(timezone.utc) - timedelta(hours=hours_back)
+                filtered_files = []
+                for log_path in log_files:
+                    try:
+                        file_date_str = log_path.stem.split("_")[1]
+                        file_date = datetime.strptime(
+                            file_date_str, "%Y-%m-%d"
+                        ).replace(tzinfo=timezone.utc)
+                        # Include file if it's from the same day or after the cutoff day
+                        if file_date >= cutoff_date.replace(
+                            hour=0, minute=0, second=0, microsecond=0
+                        ):
+                            filtered_files.append(log_path)
+                    except Exception:
+                        continue
+                log_files = filtered_files
+
+            if max_files is not None and len(log_files) > max_files:
+                log_files = log_files[:max_files]
+
+        for log_file in log_files:
+            try:
+                with open(log_file, "r") as f:
+                    # For reverse search, we might want to read lines in reverse?
+                    # But usually logs are append-only.
+                    # If reverse_files is True, we iterate files newest to oldest.
+                    # But lines within file are still oldest to newest unless we reverse them.
+                    lines = f.readlines()
+                    if reverse_files:
+                        lines.reverse()
+
+                    for line in lines:
+                        try:
+                            entry = json.loads(line.strip())
+
+                            if cutoff_date:
+                                timestamp_str = entry.get("asctime", "")
+                                if not timestamp_str:
+                                    continue
+                                log_time = datetime.strptime(
+                                    timestamp_str, "%Y-%m-%d %H:%M:%S"
+                                )
+                                log_time = log_time.replace(tzinfo=timezone.utc)
+                                if log_time < cutoff_date:
+                                    continue
+
+                            yield entry
+                        except json.JSONDecodeError:
+                            continue
+            except Exception as e:
+                logger.error(f"Error processing log file {log_file}: {e}")
+                continue
+
+    def search_logs(
+        self,
+        date: str | None = None,
+        level: str | None = None,
+        request_id: str | None = None,
+        search_text: str | None = None,
+        limit: int = 100,
+    ) -> list[dict[str, Any]]:
+        """
+        Search through log files and return matching entries.
+        """
+        log_entries: list[dict[str, Any]] = []
+
+        # Use reverse=True to get newest logs first by default
+        # If date is specified, we only look at that file
+
+        search_text_lower = search_text.lower() if search_text else None
+
+        # We iterate efficiently
+        iterator = self._yield_log_entries(
+            specific_date=date,
+            reverse_files=True if not date else False,
+            max_files=7 if not date else None,
+        )
+
+        # If we are searching globally (no date), we might want to limit how far back we go?
+        # PR 228 did: "glob("app_*.log") sorted by mtime reverse [:7]" (last 7 files)
+        # My _yield_log_entries with reverse_files=True does all files.
+        # Let's rely on limit to stop us.
+
+        # Optimization: if we are not searching by date, maybe limit to last 7 files inside _yield?
+        # For now, let's just iterate.
+
+        for log_data in iterator:
+            if not self._matches_filters(
+                log_data, level, request_id, search_text_lower
+            ):
+                continue
+
+            log_entries.append(log_data)
+
+            if len(log_entries) >= limit:
+                break
+
+        # Sort by time descending (newest first)
+        log_entries.sort(key=lambda x: x.get("asctime", ""), reverse=True)
+        return log_entries
+
+    def _matches_filters(
+        self,
+        log_data: dict[str, Any],
+        level: str | None,
+        request_id: str | None,
+        search_text_lower: str | None,
+    ) -> bool:
+        if level and log_data.get("levelname", "").upper() != level.upper():
+            return False
+
+        if request_id and log_data.get("request_id") != request_id:
+            return False
+
+        if search_text_lower:
+            message = str(log_data.get("message", "")).lower()
+            name = str(log_data.get("name", "")).lower()
+            pathname = str(log_data.get("pathname", "")).lower()
+
+            if (
+                search_text_lower not in message
+                and search_text_lower not in name
+                and search_text_lower not in pathname
+            ):
+                return False
+
+        return True
+
+    def get_usage_summary(self, hours: int = 24) -> dict:
+        entries = list(self._yield_log_entries(hours_back=hours))
+        return self._calculate_summary_stats(entries)
+
+    def get_usage_metrics(self, interval: int = 15, hours: int = 24) -> dict:
+        entries = list(self._yield_log_entries(hours_back=hours))
+        return self._aggregate_metrics_by_time(entries, interval, hours)
+
+    def get_error_details(self, hours: int = 24, limit: int = 100) -> dict:
+        errors: list[dict] = []
+        # Iterate newest to oldest for errors?
+        # yield_log_entries sorts files by name (date) ascending by default.
+        # usage stats logic usually expects ascending time for aggregation (though dictionaries don't care).
+        # For error details "last N errors", we probably want newest first.
+
+        # Using list() loads everything into memory, which is what PR 229 did.
+        # For optimization, we could use reverse iterator.
+
+        # Let's just stick to PR 229 logic which filters 'ERROR' level.
+
+        entries = self._yield_log_entries(hours_back=hours)  # oldest to newest
+
+        for entry in entries:
+            if entry.get("levelname", "").upper() == "ERROR":
+                timestamp_str = entry.get("asctime", "")
+                errors.append(
+                    {
+                        "timestamp": timestamp_str,
+                        "message": entry.get("message", ""),
+                        "error_type": entry.get("error_type", "unknown"),
+                        "pathname": entry.get("pathname", ""),
+                        "lineno": entry.get("lineno", 0),
+                        "request_id": entry.get("request_id", ""),
+                    }
+                )
+
+        # Sort reverse time
+        errors.sort(key=lambda x: x["timestamp"], reverse=True)
+        return {"errors": errors[:limit], "total_count": len(errors)}
+
+    def get_revenue_by_model(self, hours: int = 24, limit: int = 20) -> dict:
+        entries = list(self._yield_log_entries(hours_back=hours))
+
+        model_stats: dict[str, dict[str, int | float]] = defaultdict(
+            lambda: {
+                "revenue_msats": 0,
+                "refunds_msats": 0,
+                "requests": 0,
+                "successful": 0,
+                "failed": 0,
+            }
+        )
+
+        for entry in entries:
+            try:
+                model = entry.get("model", "unknown")
+                if not isinstance(model, str):
+                    model = "unknown"
+
+                message = entry.get("message", "").lower()
+
+                if "received proxy request" in message:
+                    model_stats[model]["requests"] += 1
+
+                if (
+                    "completed for streaming" in message
+                    or "completed for non-streaming" in message
+                ):
+                    model_stats[model]["successful"] += 1
+                    cost_data = entry.get("cost_data")
+                    if isinstance(cost_data, dict):
+                        actual_cost = cost_data.get("total_msats", 0)
+                        if isinstance(actual_cost, (int, float)) and actual_cost > 0:
+                            model_stats[model]["revenue_msats"] += actual_cost
+
+                if "revert payment" in message or "upstream request failed" in message:
+                    model_stats[model]["failed"] += 1
+                    if "revert payment" in message:
+                        max_cost = entry.get("max_cost_for_model", 0)
+                        if isinstance(max_cost, (int, float)) and max_cost > 0:
+                            model_stats[model]["refunds_msats"] += max_cost
+
+            except Exception:
+                continue
+
+        models: list[dict[str, Any]] = []
+        total_revenue = 0.0
+
+        for model, stats in model_stats.items():
+            revenue_msats = float(stats["revenue_msats"])
+            refunds_msats = float(stats["refunds_msats"])
+
+            revenue_sats = revenue_msats / 1000
+            refunds_sats = refunds_msats / 1000
+            net_revenue_sats = revenue_sats - refunds_sats
+
+            total_revenue += net_revenue_sats
+
+            requests = int(stats["requests"])
+            successful = int(stats["successful"])
+
+            models.append(
+                {
+                    "model": model,
+                    "revenue_sats": revenue_sats,
+                    "refunds_sats": refunds_sats,
+                    "net_revenue_sats": net_revenue_sats,
+                    "requests": requests,
+                    "successful": successful,
+                    "failed": int(stats["failed"]),
+                    "avg_revenue_per_request": (
+                        revenue_sats / successful if successful > 0 else 0
+                    ),
+                }
+            )
+
+        models.sort(key=lambda x: float(x["net_revenue_sats"]), reverse=True)
+
+        return {
+            "models": models[:limit],
+            "total_revenue_sats": total_revenue,
+            "total_models": len(models),
+        }
+
+    def _calculate_summary_stats(self, entries: list[dict]) -> dict:
+        stats: dict[str, Any] = {
+            "total_entries": 0,
+            "total_requests": 0,
+            "successful_chat_completions": 0,
+            "failed_requests": 0,
+            "total_errors": 0,
+            "total_warnings": 0,
+            "payment_processed": 0,
+            "upstream_errors": 0,
+            "unique_models": set(),
+            "error_types": defaultdict(int),
+            "revenue_msats": 0.0,
+            "refunds_msats": 0.0,
+        }
+
+        for entry in entries:
+            try:
+                stats["total_entries"] += 1
+
+                message = entry.get("message", "").lower()
+                level = entry.get("levelname", "").upper()
+
+                if level == "ERROR":
+                    stats["total_errors"] += 1
+                    if "error_type" in entry:
+                        stats["error_types"][str(entry["error_type"])] += 1
+                elif level == "WARNING":
+                    stats["total_warnings"] += 1
+
+                if "received proxy request" in message:
+                    stats["total_requests"] += 1
+
+                if (
+                    "completed for streaming" in message
+                    or "completed for non-streaming" in message
+                ):
+                    stats["successful_chat_completions"] += 1
+
+                if "upstream request failed" in message or "revert payment" in message:
+                    stats["failed_requests"] += 1
+
+                if "payment processed successfully" in message:
+                    stats["payment_processed"] += 1
+
+                if "upstream" in message and level == "ERROR":
+                    stats["upstream_errors"] += 1
+
+                if "model" in entry:
+                    model = entry["model"]
+                    if isinstance(model, str) and model != "unknown":
+                        stats["unique_models"].add(model)
+
+                if (
+                    "completed for streaming" in message
+                    or "completed for non-streaming" in message
+                ):
+                    cost_data = entry.get("cost_data")
+                    if isinstance(cost_data, dict):
+                        actual_cost = cost_data.get("total_msats", 0)
+                        if isinstance(actual_cost, (int, float)) and actual_cost > 0:
+                            stats["revenue_msats"] += float(actual_cost)
+
+                if "revert payment" in message:
+                    max_cost = entry.get("max_cost_for_model", 0)
+                    if isinstance(max_cost, (int, float)) and max_cost > 0:
+                        stats["refunds_msats"] += float(max_cost)
+
+            except Exception:
+                continue
+
+        revenue_sats = stats["revenue_msats"] / 1000
+        refunds_sats = stats["refunds_msats"] / 1000
+        net_revenue_sats = revenue_sats - refunds_sats
+
+        total_requests = stats["total_requests"]
+        successful = stats["successful_chat_completions"]
+
+        return {
+            "total_entries": stats["total_entries"],
+            "total_requests": total_requests,
+            "successful_chat_completions": successful,
+            "failed_requests": stats["failed_requests"],
+            "total_errors": stats["total_errors"],
+            "total_warnings": stats["total_warnings"],
+            "payment_processed": stats["payment_processed"],
+            "upstream_errors": stats["upstream_errors"],
+            "unique_models_count": len(stats["unique_models"]),
+            "unique_models": sorted(list(stats["unique_models"])),
+            "error_types": dict(stats["error_types"]),
+            "success_rate": (successful / total_requests * 100)
+            if total_requests > 0
+            else 0,
+            "revenue_msats": stats["revenue_msats"],
+            "refunds_msats": stats["refunds_msats"],
+            "revenue_sats": revenue_sats,
+            "refunds_sats": refunds_sats,
+            "net_revenue_msats": stats["revenue_msats"] - stats["refunds_msats"],
+            "net_revenue_sats": net_revenue_sats,
+            "avg_revenue_per_request_msats": (
+                stats["revenue_msats"] / successful if successful > 0 else 0
+            ),
+            "refund_rate": (
+                (stats["failed_requests"] / total_requests * 100)
+                if total_requests > 0
+                else 0
+            ),
+        }
+
+    def _aggregate_metrics_by_time(
+        self, entries: list[dict], interval_minutes: int, hours_back: int
+    ) -> dict:
+        time_buckets: dict[str, dict[str, Any]] = defaultdict(
+            lambda: {"requests": 0, "errors": 0, "revenue_msats": 0.0}
+        )
+
+        for entry in entries:
+            try:
+                timestamp_str = entry.get("asctime", "")
+                if not timestamp_str:
+                    continue
+
+                log_time = datetime.strptime(timestamp_str, "%Y-%m-%d %H:%M:%S")
+                log_time = log_time.replace(tzinfo=timezone.utc)
+
+                # Round down to nearest interval
+                minutes = log_time.minute
+                rounded_minutes = (minutes // interval_minutes) * interval_minutes
+                bucket_time = log_time.replace(
+                    minute=rounded_minutes, second=0, microsecond=0
+                )
+                bucket_key = bucket_time.strftime("%Y-%m-%d %H:%M:%S")
+
+                bucket = time_buckets[bucket_key]
+
+                message = entry.get("message", "").lower()
+                level = entry.get("levelname", "").upper()
+
+                if "received proxy request" in message:
+                    bucket["requests"] += 1
+
+                if level == "ERROR":
+                    bucket["errors"] += 1
+
+                if (
+                    "completed for streaming" in message
+                    or "completed for non-streaming" in message
+                ):
+                    cost_data = entry.get("cost_data")
+                    if isinstance(cost_data, dict):
+                        actual_cost = cost_data.get("total_msats", 0)
+                        if isinstance(actual_cost, (int, float)) and actual_cost > 0:
+                            bucket["revenue_msats"] += float(actual_cost)
+            except Exception:
+                continue
+
+        result = []
+        for bucket_key in sorted(time_buckets.keys()):
+            result.append({"timestamp": bucket_key, **time_buckets[bucket_key]})
+
+        return {
+            "metrics": result,
+            "interval_minutes": interval_minutes,
+            "hours_back": hours_back,
+            "total_buckets": len(result),
+        }
+
+
+log_manager = LogManager()

routstr/core/logging.py

@@ -1,3 +1,40 @@
+"""
+Logging configuration for Routstr.
+
+CRITICAL LOG MESSAGES FOR USAGE STATISTICS:
+===========================================
+The following log messages are parsed by the usage tracking system (routstr/core/admin.py).
+DO NOT modify or remove these messages without updating the usage tracking logic:
+
+1. "Received proxy request" (INFO) - routstr/proxy.py
+   - Used to count total incoming requests
+   - Includes model information in context
+
+    2. "Payment adjustment completed for streaming" (INFO) - routstr/upstream/base.py
+       "Payment adjustment completed for non-streaming" (INFO) - routstr/upstream/base.py
+   - Used to track successful completions and revenue
+   - The 'cost_data.total_msats' field is extracted for revenue calculation
+   - Must include 'cost_data' in extra dict
+
+3. "Payment processed successfully" (INFO) - routstr/auth.py
+   - Used to count successful payment processing events
+   - Tracks payment-related metrics
+
+4. "Upstream request failed, revert payment" (WARNING) - routstr/proxy.py
+   - Used to track failed requests and refunds
+   - The 'max_cost_for_model' field is extracted for refund calculation
+   - Must include 'max_cost_for_model' in extra dict
+
+5. Any ERROR level logs with "upstream" in the message
+   - Used to count upstream provider errors
+   - Helps identify service reliability issues
+
+If you need to modify these messages, ensure you also update the parsing logic in:
+- routstr/core/admin.py:_aggregate_metrics_by_time()
+- routstr/core/admin.py:_get_summary_stats()
+- routstr/core/admin.py:get_revenue_by_model()
+"""
+
 import logging.config
 import logging.handlers
 import os

routstr/core/main.py

@@ -1,155 +1,30 @@
-import asyncio
 import os
-from contextlib import asynccontextmanager
-from pathlib import Path
-from typing import AsyncGenerator
 
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import FileResponse, RedirectResponse
-from fastapi.staticfiles import StaticFiles
+from fastapi.responses import RedirectResponse
 from starlette.exceptions import HTTPException
 
 from ..balance import balance_router, deprecated_wallet_router
-from ..discovery import providers_cache_refresher, providers_router
-from ..nip91 import announce_provider
-from ..payment.models import (
-    cleanup_enabled_models_periodically,
-    models_router,
-    update_sats_pricing,
-)
-from ..payment.price import update_prices_periodically
-from ..proxy import initialize_upstreams, proxy_router, refresh_model_maps_periodically
-from ..wallet import periodic_payout
+from ..models.models import models_router
+from ..nostr.discovery import providers_router
+from ..proxy import proxy_router
 from .admin import admin_router
-from .db import create_session, init_db, run_migrations
 from .exceptions import general_exception_handler, http_exception_handler
 from .logging import get_logger, setup_logging
 from .middleware import LoggingMiddleware
-from .settings import SettingsService
 from .settings import settings as global_settings
+from .tasks import lifespan
+from .ui import setup_ui_routes
 
 # Initialize logging first
 setup_logging()
 logger = get_logger(__name__)
 
 if os.getenv("VERSION_SUFFIX") is not None:
-    __version__ = f"0.2.0c-{os.getenv('VERSION_SUFFIX')}"
+    __version__ = f"0.2.1-{os.getenv('VERSION_SUFFIX')}"
 else:
-    __version__ = "0.2.0c"
-
-
-@asynccontextmanager
-async def lifespan(_: FastAPI) -> AsyncGenerator[None, None]:
-    logger.info("Application startup initiated", extra={"version": __version__})
-
-    btc_price_task = None
-    pricing_task = None
-    payout_task = None
-    nip91_task = None
-    providers_task = None
-    models_refresh_task = None
-    models_cleanup_task = None
-    model_maps_refresh_task = None
-
-    try:
-        # Run database migrations on startup
-        # This ensures the database schema is always up-to-date in production
-        # Migrations are idempotent - running them multiple times is safe
-        logger.info("Running database migrations")
-        run_migrations()
-
-        # Initialize database connection pools
-        # This creates any tables that might not be tracked by migrations yet
-        await init_db()
-
-        # Initialize application settings (env -> computed -> DB precedence)
-        async with create_session() as session:
-            s = await SettingsService.initialize(session)
-
-        # Apply app metadata from settings
-        try:
-            app.title = s.name
-            app.description = s.description
-        except Exception:
-            pass
-
-        # await ensure_models_bootstrapped()
-
-        from ..payment.price import _update_prices
-        from ..proxy import get_upstreams
-        from ..upstream.helpers import refresh_upstreams_models_periodically
-
-        await _update_prices()
-        await initialize_upstreams()
-
-        btc_price_task = asyncio.create_task(update_prices_periodically())
-        pricing_task = asyncio.create_task(update_sats_pricing())
-        if global_settings.models_refresh_interval_seconds > 0:
-            models_refresh_task = asyncio.create_task(
-                refresh_upstreams_models_periodically(get_upstreams())
-            )
-        models_cleanup_task = asyncio.create_task(cleanup_enabled_models_periodically())
-        model_maps_refresh_task = asyncio.create_task(refresh_model_maps_periodically())
-        payout_task = asyncio.create_task(periodic_payout())
-        nip91_task = asyncio.create_task(announce_provider())
-        providers_task = asyncio.create_task(providers_cache_refresher())
-
-        yield
-
-    except Exception as e:
-        logger.error(
-            "Application startup failed",
-            extra={"error": str(e), "error_type": type(e).__name__},
-        )
-        raise
-    finally:
-        logger.info("Application shutdown initiated")
-
-        if btc_price_task is not None:
-            btc_price_task.cancel()
-        if pricing_task is not None:
-            pricing_task.cancel()
-        if payout_task is not None:
-            payout_task.cancel()
-        if nip91_task is not None:
-            nip91_task.cancel()
-        if providers_task is not None:
-            providers_task.cancel()
-        if models_refresh_task is not None:
-            models_refresh_task.cancel()
-        if models_cleanup_task is not None:
-            models_cleanup_task.cancel()
-        if model_maps_refresh_task is not None:
-            model_maps_refresh_task.cancel()
-
-        try:
-            tasks_to_wait = []
-            if btc_price_task is not None:
-                tasks_to_wait.append(btc_price_task)
-            if pricing_task is not None:
-                tasks_to_wait.append(pricing_task)
-            if payout_task is not None:
-                tasks_to_wait.append(payout_task)
-            if nip91_task is not None:
-                tasks_to_wait.append(nip91_task)
-            if providers_task is not None:
-                tasks_to_wait.append(providers_task)
-            if models_refresh_task is not None:
-                tasks_to_wait.append(models_refresh_task)
-            if models_cleanup_task is not None:
-                tasks_to_wait.append(models_cleanup_task)
-            if model_maps_refresh_task is not None:
-                tasks_to_wait.append(model_maps_refresh_task)
-
-            if tasks_to_wait:
-                await asyncio.gather(*tasks_to_wait, return_exceptions=True)
-            logger.info("Background tasks stopped successfully")
-        except Exception as e:
-            logger.error(
-                "Error stopping background tasks",
-                extra={"error": str(e), "error_type": type(e).__name__},
-            )
+    __version__ = "0.2.1"
 
 
 app = FastAPI(version=__version__, lifespan=lifespan)
@@ -182,7 +57,6 @@ async def info() -> dict:
         "mints": global_settings.cashu_mints,
         "http_url": global_settings.http_url,
         "onion_url": global_settings.onion_url,
-        "models": [],  # kept for back-compat; prefer /v1/models
     }
 
 
@@ -191,117 +65,7 @@ async def providers() -> RedirectResponse:
     return RedirectResponse("/v1/providers/")
 
 
-UI_DIST_PATH = Path(__file__).parent.parent.parent / "ui_out"
-
-if UI_DIST_PATH.exists() and UI_DIST_PATH.is_dir():
-    logger.info(f"Serving static UI from {UI_DIST_PATH}")
-
-    app.mount(
-        "/_next",
-        StaticFiles(directory=UI_DIST_PATH / "_next", check_dir=True),
-        name="next-static",
-    )
-
-    @app.get("/", include_in_schema=False)
-    async def serve_root_ui() -> FileResponse:
-        return FileResponse(UI_DIST_PATH / "index.html")
-
-    # Add explicit route for /index.txt to redirect to /
-    @app.get("/index.txt", include_in_schema=False)
-    async def redirect_index_txt() -> RedirectResponse:
-        return RedirectResponse("/")
-
-    @app.get("/admin")
-    async def admin_redirect() -> FileResponse:
-        return FileResponse(UI_DIST_PATH / "index.html")
-
-    @app.get("/dashboard", include_in_schema=False)
-    async def serve_dashboard_ui() -> FileResponse:
-        return FileResponse(UI_DIST_PATH / "index.html")
-
-    @app.get("/login", include_in_schema=False)
-    async def serve_login_ui() -> FileResponse:
-        return FileResponse(UI_DIST_PATH / "login" / "index.html")
-
-    # Add explicit route for /login/index.txt to redirect to /login
-    @app.get("/login/index.txt", include_in_schema=False)
-    async def redirect_login_index_txt() -> RedirectResponse:
-        return RedirectResponse("/login")
-
-    @app.get("/model", include_in_schema=False)
-    async def serve_models_ui() -> FileResponse:
-        return FileResponse(UI_DIST_PATH / "model" / "index.html")
-
-    # Add explicit route for /model/index.txt to redirect to /model
-    @app.get("/model/index.txt", include_in_schema=False)
-    async def redirect_model_index_txt() -> RedirectResponse:
-        return RedirectResponse("/model")
-
-    @app.get("/providers", include_in_schema=False)
-    async def serve_providers_ui() -> FileResponse:
-        return FileResponse(UI_DIST_PATH / "providers" / "index.html")
-
-    # Add explicit route for /providers/index.txt to redirect to /providers
-    @app.get("/providers/index.txt", include_in_schema=False)
-    async def redirect_providers_index_txt() -> RedirectResponse:
-        return RedirectResponse("/providers")
-
-    @app.get("/settings", include_in_schema=False)
-    async def serve_settings_ui() -> FileResponse:
-        return FileResponse(UI_DIST_PATH / "settings" / "index.html")
-
-    # Add explicit route for /settings/index.txt to redirect to /settings
-    @app.get("/settings/index.txt", include_in_schema=False)
-    async def redirect_settings_index_txt() -> RedirectResponse:
-        return RedirectResponse("/settings")
-
-    @app.get("/transactions", include_in_schema=False)
-    async def serve_transactions_ui() -> FileResponse:
-        return FileResponse(UI_DIST_PATH / "transactions" / "index.html")
-
-    # Add explicit route for /transactions/index.txt to redirect to /transactions
-    @app.get("/transactions/index.txt", include_in_schema=False)
-    async def redirect_transactions_index_txt() -> RedirectResponse:
-        return RedirectResponse("/transactions")
-
-    @app.get("/unauthorized", include_in_schema=False)
-    async def serve_unauthorized_ui() -> FileResponse:
-        return FileResponse(UI_DIST_PATH / "unauthorized" / "index.html")
-
-    # Add explicit route for /unauthorized/index.txt to redirect to /unauthorized
-    @app.get("/unauthorized/index.txt", include_in_schema=False)
-    async def redirect_unauthorized_index_txt() -> RedirectResponse:
-        return RedirectResponse("/unauthorized")
-
-    @app.get("/favicon.ico", include_in_schema=False)
-    async def serve_favicon() -> FileResponse:
-        icon_path = UI_DIST_PATH / "icon.ico"
-        if icon_path.exists():
-            return FileResponse(icon_path)
-        return FileResponse(UI_DIST_PATH / "favicon.ico")
-
-    @app.get("/icon.ico", include_in_schema=False)
-    async def serve_icon() -> FileResponse:
-        return FileResponse(UI_DIST_PATH / "icon.ico")
-
-    app.mount(
-        "/static", StaticFiles(directory=UI_DIST_PATH, check_dir=True), name="ui-static"
-    )
-else:
-    logger.warning(
-        f"UI dist directory not found at {UI_DIST_PATH}, skipping static file serving"
-    )
-
-    @app.get("/", include_in_schema=False)
-    async def root_fallback() -> dict:
-        return {
-            "name": global_settings.name,
-            "description": global_settings.description,
-            "version": __version__,
-            "status": "running",
-            "ui": "not available",
-        }
-
+setup_ui_routes(app)
 
 app.include_router(models_router)
 app.include_router(admin_router)

routstr/core/settings.py

@@ -114,7 +114,7 @@ def resolve_bootstrap() -> Settings:
                 )
             except Exception:
                 pass
-        # Map COST_PER_1K_* -> CUSTOM_PER_1K_*
+        # Map COST_PER_1K_* -> FIXED_PER_1K_*
         if (
             "COST_PER_1K_INPUT_TOKENS" in os.environ
             and "FIXED_PER_1K_INPUT_TOKENS" not in os.environ
@@ -139,7 +139,7 @@ def resolve_bootstrap() -> Settings:
         pass
     if not base.onion_url:
         try:
-            from ..nip91 import discover_onion_url_from_tor  # type: ignore
+            from ..nostr.listing import discover_onion_url_from_tor
 
             discovered = discover_onion_url_from_tor()
             if discovered:

routstr/core/tasks.py

@@ -0,0 +1,132 @@
+import asyncio
+from contextlib import asynccontextmanager
+from typing import AsyncGenerator
+
+from fastapi import FastAPI
+
+from ..models.models import (
+    cleanup_enabled_models_periodically,
+    update_sats_pricing,
+)
+from ..nostr import announce_provider, providers_cache_refresher
+from ..payment.price import update_prices_periodically
+from ..payment.wallet import periodic_payout
+from ..proxy import get_upstreams, initialize_upstreams, refresh_model_maps_periodically
+from ..upstream.helpers import refresh_upstreams_models_periodically
+from .db import create_session, init_db, run_migrations
+from .logging import get_logger
+from .settings import SettingsService
+from .settings import settings as global_settings
+
+logger = get_logger(__name__)
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
+    # Extract version from app if available, or use default/log without it
+    version = getattr(app, "version", "unknown")
+
+    logger.info("Application startup initiated", extra={"version": version})
+
+    btc_price_task = None
+    pricing_task = None
+    payout_task = None
+    listing_task = None
+    providers_task = None
+    models_refresh_task = None
+    models_cleanup_task = None
+    model_maps_refresh_task = None
+
+    try:
+        # Run database migrations on startup
+        # This ensures the database schema is always up-to-date in production
+        # Migrations are idempotent - running them multiple times is safe
+        logger.info("Running database migrations")
+        run_migrations()
+
+        # Initialize database connection pools
+        # This creates any tables that might not be tracked by migrations yet
+        await init_db()
+
+        # Initialize application settings (env -> computed -> DB precedence)
+        async with create_session() as session:
+            s = await SettingsService.initialize(session)
+
+        # Apply app metadata from settings
+        try:
+            app.title = s.name
+            app.description = s.description
+        except Exception:
+            pass
+
+        _initialize_upstreams_task = asyncio.create_task(initialize_upstreams())
+
+        btc_price_task = asyncio.create_task(update_prices_periodically())
+        pricing_task = asyncio.create_task(update_sats_pricing())
+        if global_settings.models_refresh_interval_seconds > 0:
+            models_refresh_task = asyncio.create_task(
+                refresh_upstreams_models_periodically(get_upstreams())
+            )
+        models_cleanup_task = asyncio.create_task(cleanup_enabled_models_periodically())
+        model_maps_refresh_task = asyncio.create_task(refresh_model_maps_periodically())
+        payout_task = asyncio.create_task(periodic_payout())
+        listing_task = asyncio.create_task(announce_provider())
+        providers_task = asyncio.create_task(providers_cache_refresher())
+
+        await _initialize_upstreams_task
+
+        yield
+
+    except Exception as e:
+        logger.error(
+            "Application startup failed",
+            extra={"error": str(e), "error_type": type(e).__name__},
+        )
+        raise
+    finally:
+        logger.info("Application shutdown initiated")
+
+        if btc_price_task is not None:
+            btc_price_task.cancel()
+        if pricing_task is not None:
+            pricing_task.cancel()
+        if payout_task is not None:
+            payout_task.cancel()
+        if listing_task is not None:
+            listing_task.cancel()
+        if providers_task is not None:
+            providers_task.cancel()
+        if models_refresh_task is not None:
+            models_refresh_task.cancel()
+        if models_cleanup_task is not None:
+            models_cleanup_task.cancel()
+        if model_maps_refresh_task is not None:
+            model_maps_refresh_task.cancel()
+
+        try:
+            tasks_to_wait = []
+            if btc_price_task is not None:
+                tasks_to_wait.append(btc_price_task)
+            if pricing_task is not None:
+                tasks_to_wait.append(pricing_task)
+            if payout_task is not None:
+                tasks_to_wait.append(payout_task)
+            if listing_task is not None:
+                tasks_to_wait.append(listing_task)
+            if providers_task is not None:
+                tasks_to_wait.append(providers_task)
+            if models_refresh_task is not None:
+                tasks_to_wait.append(models_refresh_task)
+            if models_cleanup_task is not None:
+                tasks_to_wait.append(models_cleanup_task)
+            if model_maps_refresh_task is not None:
+                tasks_to_wait.append(model_maps_refresh_task)
+
+            if tasks_to_wait:
+                await asyncio.gather(*tasks_to_wait, return_exceptions=True)
+            logger.info("Background tasks stopped successfully")
+        except Exception as e:
+            logger.error(
+                "Error stopping background tasks",
+                extra={"error": str(e), "error_type": type(e).__name__},
+            )

routstr/core/ui.py

@@ -0,0 +1,160 @@
+from pathlib import Path
+
+from fastapi import APIRouter, FastAPI
+from fastapi.responses import FileResponse, RedirectResponse
+from fastapi.staticfiles import StaticFiles
+
+from .logging import get_logger
+from .settings import settings as global_settings
+
+logger = get_logger(__name__)
+
+
+def setup_ui_routes(app: FastAPI) -> None:
+    UI_DIST_PATH = Path(__file__).parent.parent.parent / "ui_out"
+
+    if UI_DIST_PATH.exists() and UI_DIST_PATH.is_dir():
+        logger.info(f"Serving static UI from {UI_DIST_PATH}")
+
+        app.mount(
+            "/_next",
+            StaticFiles(directory=UI_DIST_PATH / "_next", check_dir=True),
+            name="next-static",
+        )
+
+        router = APIRouter()
+
+        @router.get("/", include_in_schema=False)
+        async def serve_root_ui() -> FileResponse:
+            return FileResponse(UI_DIST_PATH / "index.html")
+
+        # Add explicit route for /index.txt to redirect to /
+        @router.get("/index.txt", include_in_schema=False)
+        async def redirect_index_txt() -> RedirectResponse:
+            return RedirectResponse("/")
+
+        @router.get("/admin")
+        async def admin_redirect() -> FileResponse:
+            return FileResponse(UI_DIST_PATH / "index.html")
+
+        @router.get("/dashboard", include_in_schema=False)
+        async def serve_dashboard_ui() -> FileResponse:
+            return FileResponse(UI_DIST_PATH / "index.html")
+
+        @router.get("/login", include_in_schema=False)
+        async def serve_login_ui() -> FileResponse:
+            return FileResponse(UI_DIST_PATH / "login" / "index.html")
+
+        # Add explicit route for /login/index.txt to redirect to /login
+        @router.get("/login/index.txt", include_in_schema=False)
+        async def redirect_login_index_txt() -> RedirectResponse:
+            return RedirectResponse("/login")
+
+        @router.get("/model", include_in_schema=False)
+        async def serve_models_ui() -> FileResponse:
+            return FileResponse(UI_DIST_PATH / "model" / "index.html")
+
+        # Add explicit route for /model/index.txt to redirect to /model
+        @router.get("/model/index.txt", include_in_schema=False)
+        async def redirect_model_index_txt() -> RedirectResponse:
+            return RedirectResponse("/model")
+
+        @router.get("/providers", include_in_schema=False)
+        async def serve_providers_ui() -> FileResponse:
+            return FileResponse(UI_DIST_PATH / "providers" / "index.html")
+
+        # Add explicit route for /providers/index.txt to redirect to /providers
+        @router.get("/providers/index.txt", include_in_schema=False)
+        async def redirect_providers_index_txt() -> RedirectResponse:
+            return RedirectResponse("/providers")
+
+        @router.get("/settings", include_in_schema=False)
+        async def serve_settings_ui() -> FileResponse:
+            return FileResponse(UI_DIST_PATH / "settings" / "index.html")
+
+        # Add explicit route for /settings/index.txt to redirect to /settings
+        @router.get("/settings/index.txt", include_in_schema=False)
+        async def redirect_settings_index_txt() -> RedirectResponse:
+            return RedirectResponse("/settings")
+
+        @router.get("/transactions", include_in_schema=False)
+        async def serve_transactions_ui() -> FileResponse:
+            return FileResponse(UI_DIST_PATH / "transactions" / "index.html")
+
+        # Add explicit route for /transactions/index.txt to redirect to /transactions
+        @router.get("/transactions/index.txt", include_in_schema=False)
+        async def redirect_transactions_index_txt() -> RedirectResponse:
+            return RedirectResponse("/transactions")
+
+        @router.get("/balances", include_in_schema=False)
+        async def serve_balances_ui() -> FileResponse:
+            return FileResponse(UI_DIST_PATH / "balances" / "index.html")
+
+        # Add explicit route for /balances/index.txt to redirect to /balances
+        @router.get("/balances/index.txt", include_in_schema=False)
+        async def redirect_balances_index_txt() -> RedirectResponse:
+            return RedirectResponse("/balances")
+
+        @router.get("/logs", include_in_schema=False)
+        async def serve_logs_ui() -> FileResponse:
+            return FileResponse(UI_DIST_PATH / "logs" / "index.html")
+
+        # Add explicit route for /logs/index.txt to redirect to /logs
+        @router.get("/logs/index.txt", include_in_schema=False)
+        async def redirect_logs_index_txt() -> RedirectResponse:
+            return RedirectResponse("/logs")
+
+        @router.get("/usage", include_in_schema=False)
+        async def serve_usage_ui() -> FileResponse:
+            return FileResponse(UI_DIST_PATH / "usage" / "index.html")
+
+        # Add explicit route for /usage/index.txt to redirect to /usage
+        @router.get("/usage/index.txt", include_in_schema=False)
+        async def redirect_usage_index_txt() -> RedirectResponse:
+            return RedirectResponse("/usage")
+
+        @router.get("/unauthorized", include_in_schema=False)
+        async def serve_unauthorized_ui() -> FileResponse:
+            return FileResponse(UI_DIST_PATH / "unauthorized" / "index.html")
+
+        # Add explicit route for /unauthorized/index.txt to redirect to /unauthorized
+        @router.get("/unauthorized/index.txt", include_in_schema=False)
+        async def redirect_unauthorized_index_txt() -> RedirectResponse:
+            return RedirectResponse("/unauthorized")
+
+        @router.get("/favicon.ico", include_in_schema=False)
+        async def serve_favicon() -> FileResponse:
+            icon_path = UI_DIST_PATH / "icon.ico"
+            if icon_path.exists():
+                return FileResponse(icon_path)
+            return FileResponse(UI_DIST_PATH / "favicon.ico")
+
+        @router.get("/icon.ico", include_in_schema=False)
+        async def serve_icon() -> FileResponse:
+            return FileResponse(UI_DIST_PATH / "icon.ico")
+
+        app.include_router(router)
+
+        app.mount(
+            "/static",
+            StaticFiles(directory=UI_DIST_PATH, check_dir=True),
+            name="ui-static",
+        )
+    else:
+        logger.warning(
+            f"UI dist directory not found at {UI_DIST_PATH}, skipping static file serving"
+        )
+
+        router = APIRouter()
+
+        @router.get("/", include_in_schema=False)
+        async def root_fallback() -> dict:
+            return {
+                "name": global_settings.name,
+                "description": global_settings.description,
+                "version": app.version,
+                "status": "running",
+                "ui": "not available",
+            }
+
+        app.include_router(router)

routstr/models/__init__.py

@@ -0,0 +1,9 @@
+from .metadata import async_fetch_openrouter_models
+from .models import Model
+
+__all__ = [
+    "Model",
+    "async_fetch_openrouter_models",
+]
+
+# specifically ai models that the node sells and not meaning database models

routstr/models/algorithm.py

@@ -2,11 +2,13 @@
 
 from typing import TYPE_CHECKING
 
-from .core.logging import get_logger
+from ..core import get_logger
+from ..models.crud import row_to_model
+from ..upstream.helpers import resolve_model_alias
 
 if TYPE_CHECKING:
-    from .payment.models import Model
-    from .upstream import BaseUpstreamProvider
+    from ..upstream import BaseUpstreamProvider
+    from .models import Model
 
 logger = get_logger(__name__)
 
@@ -192,8 +194,6 @@ def create_model_mappings(
     Returns:
         Tuple of (model_instances, provider_map, unique_models)
     """
-    from .payment.models import _row_to_model
-    from .upstream.helpers import resolve_model_alias
 
     model_instances: dict[str, "Model"] = {}
     provider_map: dict[str, "BaseUpstreamProvider"] = {}
@@ -245,7 +245,7 @@ def create_model_mappings(
             # Apply overrides if present
             if model.id in overrides_by_id:
                 override_row, provider_fee = overrides_by_id[model.id]
-                model_to_use = _row_to_model(
+                model_to_use = row_to_model(
                     override_row, apply_provider_fee=True, provider_fee=provider_fee
                 )
             else:

routstr/models/crud.py

@@ -0,0 +1,105 @@
+import json
+
+from ..core import get_logger
+from ..core.db import AsyncSession, ModelRow, UpstreamProviderRow
+from ..payment.price import sats_usd_price
+from .models import (
+    Architecture,
+    Model,
+    Pricing,
+    TopProvider,
+    _update_model_sats_pricing,
+    calculate_usd_max_costs,
+)
+
+logger = get_logger(__name__)
+
+
+def row_to_model(
+    row: ModelRow, apply_provider_fee: bool = False, provider_fee: float = 1.01
+) -> Model:
+    architecture = json.loads(row.architecture)
+    pricing = json.loads(row.pricing)
+    per_request_limits = (
+        json.loads(row.per_request_limits) if row.per_request_limits else None
+    )
+    top_provider_dict = json.loads(row.top_provider) if row.top_provider else None
+
+    if apply_provider_fee and isinstance(pricing, dict):
+        pricing = {k: float(v) * provider_fee for k, v in pricing.items()}
+
+    if isinstance(pricing, dict) and float(pricing.get("request", 0.0)) <= 0.0:
+        pricing["request"] = max(pricing.get("request", 0.0), 0.0)
+
+    parsed_pricing = Pricing.parse_obj(pricing)
+    model = Model(
+        id=row.id,
+        name=row.name,
+        created=row.created,
+        description=row.description,
+        context_length=row.context_length,
+        architecture=Architecture.parse_obj(architecture),
+        pricing=parsed_pricing,
+        sats_pricing=None,
+        per_request_limits=per_request_limits,
+        top_provider=TopProvider.parse_obj(top_provider_dict)
+        if top_provider_dict
+        else None,
+        enabled=row.enabled,
+        upstream_provider_id=row.upstream_provider_id,
+        canonical_slug=getattr(row, "canonical_slug", None),
+    )
+
+    if apply_provider_fee:
+        (
+            parsed_pricing.max_prompt_cost,
+            parsed_pricing.max_completion_cost,
+            parsed_pricing.max_cost,
+        ) = calculate_usd_max_costs(model)
+
+    try:
+        sats_to_usd = sats_usd_price()
+        model = _update_model_sats_pricing(model, sats_to_usd)
+    except Exception as e:
+        logger.warning(f"Could not calculate sats pricing: {e}")
+
+    return model
+
+
+async def list_models(
+    session: AsyncSession,
+    upstream_id: int,
+    include_disabled: bool = False,
+) -> list[Model]:
+    from sqlmodel import select
+
+    query = select(ModelRow)
+    if upstream_id is not None:
+        query = query.where(ModelRow.upstream_provider_id == upstream_id)
+    if not include_disabled:
+        query = query.where(ModelRow.enabled)
+
+    rows = (await session.exec(query)).all()  # type: ignore
+    provider_result = await session.exec(select(UpstreamProviderRow))
+    providers_by_id = {p.id: p for p in provider_result.all()}
+    return [
+        row_to_model(
+            r,
+            apply_provider_fee=True,
+            provider_fee=providers_by_id[r.upstream_provider_id].provider_fee
+            if r.upstream_provider_id in providers_by_id
+            else 1.01,
+        )
+        for r in rows
+    ]
+
+
+async def get_model_by_id(
+    model_id: str, provider_id: int, session: AsyncSession
+) -> Model | None:
+    row = await session.get(ModelRow, (model_id, provider_id))
+    if not row or not row.enabled:
+        return None
+    provider = await session.get(UpstreamProviderRow, provider_id)
+    provider_fee = provider.provider_fee if provider else 1.01
+    return row_to_model(row, apply_provider_fee=True, provider_fee=provider_fee)

routstr/models/metadata.py

@@ -0,0 +1,52 @@
+from typing import Final
+
+import httpx
+
+from ..core import get_logger
+
+logger = get_logger(__name__)
+
+DEFAULT_EXCLUDED_MODEL_IDS: Final[set[str]] = {
+    "openrouter/auto",
+    "google/gemini-2.5-pro-exp-03-25",
+    "opengvlab/internvl3-78b",
+    "openrouter/sonoma-dusk-alpha",
+    "openrouter/sonoma-sky-alpha",
+}
+
+
+async def async_fetch_openrouter_models(source_filter: str | None = None) -> list[dict]:
+    """Asynchronously fetch model information from OpenRouter API."""
+    base_url = "https://openrouter.ai/api/v1"
+
+    try:
+        async with httpx.AsyncClient() as client:
+            response = await client.get(f"{base_url}/models", timeout=30)
+            response.raise_for_status()
+            data = response.json()
+
+            models_data: list[dict] = []
+            for model in data.get("data", []):
+                model_id = model.get("id", "")
+
+                if source_filter:
+                    source_prefix = f"{source_filter}/"
+                    if not model_id.startswith(source_prefix):
+                        continue
+
+                    model = dict(model)
+                    model["id"] = model_id[len(source_prefix) :]
+                    model_id = model["id"]
+
+                if (
+                    "(free)" in model.get("name", "")
+                    or model_id in DEFAULT_EXCLUDED_MODEL_IDS
+                ):
+                    continue
+
+                models_data.append(model)
+
+            return models_data
+    except Exception as e:
+        logger.error(f"Error (async) fetching models from OpenRouter API: {e}")
+        return []

routstr/models/models.py

@@ -0,0 +1,376 @@
+import asyncio
+import json
+import random
+
+from fastapi import APIRouter, Depends
+from pydantic.v1 import BaseModel
+from sqlmodel import select
+from sqlmodel.ext.asyncio.session import AsyncSession
+
+from ..core.db import ModelRow, create_session, get_session
+from ..core.logging import get_logger
+from ..core.settings import settings
+from ..payment.price import sats_usd_price
+
+logger = get_logger(__name__)
+
+models_router = APIRouter()
+
+
+class Architecture(BaseModel):
+    modality: str
+    input_modalities: list[str]
+    output_modalities: list[str]
+    tokenizer: str
+    instruct_type: str | None
+
+
+class Pricing(BaseModel):
+    prompt: float
+    completion: float
+    request: float
+    image: float
+    web_search: float
+    internal_reasoning: float
+    max_prompt_cost: float = 0.0  # in sats not msats
+    max_completion_cost: float = 0.0  # in sats not msats
+    max_cost: float = 0.0  # in sats not msats
+
+
+class TopProvider(BaseModel):
+    context_length: int | None = None
+    max_completion_tokens: int | None = None
+    is_moderated: bool | None = None
+
+
+class Model(BaseModel):
+    id: str
+    name: str
+    created: int
+    description: str
+    context_length: int
+    architecture: Architecture
+    pricing: Pricing
+    sats_pricing: Pricing | None = None
+    per_request_limits: dict | None = None
+    top_provider: TopProvider | None = None
+    enabled: bool = True
+    upstream_provider_id: int | None = None
+    canonical_slug: str | None = None
+    alias_ids: list[str] | None = None
+
+    def __hash__(self) -> int:
+        return hash(self.id)
+
+
+def is_openrouter_upstream() -> bool:
+    try:
+        base = (settings.upstream_base_url or "").strip().rstrip("/")
+    except Exception:
+        return False
+    return base.lower() == "https://openrouter.ai/api/v1"
+
+
+def calculate_usd_max_costs(model: Model) -> tuple[float, float, float]:
+    """Calculate max costs in USD based on model context/token limits.
+
+    Args:
+        model: Model object
+
+    Returns:
+        Tuple of (max_prompt_cost, max_completion_cost, max_cost) in USD
+    """
+    min_req_msat = max(1, int(getattr(settings, "min_request_msat", 1)))
+    min_req_usd = float(min_req_msat) / 1_000_000.0
+
+    prompt_price = model.pricing.prompt
+    completion_price = model.pricing.completion
+
+    if model.top_provider and (
+        model.top_provider.context_length or model.top_provider.max_completion_tokens
+    ):
+        if (cl := model.top_provider.context_length) and (
+            mct := model.top_provider.max_completion_tokens
+        ):
+            if cl <= mct:
+                return (
+                    cl * prompt_price,
+                    cl * completion_price,
+                    cl * max(completion_price, prompt_price),
+                )
+            return (
+                cl * prompt_price,
+                mct * completion_price,
+                (cl - mct) * prompt_price + mct * completion_price,
+            )
+        elif cl := model.top_provider.context_length:
+            return (
+                cl * prompt_price,
+                cl * completion_price,
+                cl * max(completion_price, prompt_price),
+            )
+        elif mct := model.top_provider.max_completion_tokens:
+            return (
+                mct * prompt_price,
+                mct * completion_price,
+                mct * completion_price,
+            )
+    elif model.context_length:
+        return (
+            model.context_length * prompt_price,
+            model.context_length * completion_price,
+            model.context_length * max(completion_price, prompt_price),
+        )
+
+    p = prompt_price * 1_000_000
+    c = completion_price * 32_000
+    r = model.pricing.request * 100_000
+    i = model.pricing.image * 100
+    w = model.pricing.web_search * 1000
+    ir = model.pricing.internal_reasoning * 100
+    return (p, c, max(p + c + r + i + w + ir, min_req_usd))
+
+
+def _update_model_sats_pricing(model: Model, sats_to_usd: float) -> Model:
+    """Update a model's sats_pricing based on USD pricing and exchange rate.
+
+    Args:
+        model: Model object to update
+        sats_to_usd: Current sats to USD exchange rate
+
+    Returns:
+        Updated Model object with new sats_pricing
+    """
+    try:
+        min_req_msat = max(1, int(getattr(settings, "min_request_msat", 1)))
+        min_req_sats = float(min_req_msat) / 1000.0
+
+        sats = Pricing.parse_obj(
+            {k: v / sats_to_usd for k, v in model.pricing.dict().items()}
+        )
+
+        if sats.request <= 0.0:
+            sats.request = min_req_sats
+        if (sats.max_cost or 0.0) < min_req_sats:
+            sats.max_cost = min_req_sats
+
+        return Model(
+            id=model.id,
+            name=model.name,
+            created=model.created,
+            description=model.description,
+            context_length=model.context_length,
+            architecture=model.architecture,
+            pricing=model.pricing,
+            sats_pricing=sats,
+            per_request_limits=model.per_request_limits,
+            top_provider=model.top_provider,
+            enabled=model.enabled,
+            upstream_provider_id=model.upstream_provider_id,
+            canonical_slug=model.canonical_slug,
+            alias_ids=model.alias_ids,
+        )
+    except Exception as e:
+        logger.error(
+            "Failed to update sats pricing for model",
+            extra={
+                "model_id": model.id,
+                "error": str(e),
+                "error_type": type(e).__name__,
+            },
+        )
+        return model
+
+
+async def _update_sats_pricing_once() -> None:
+    """Update sats pricing once for all provider models (in-memory only)."""
+    from ..proxy import get_upstreams
+
+    upstreams = get_upstreams()
+    sats_to_usd = sats_usd_price()
+
+    updated_count = 0
+    for upstream in upstreams:
+        updated_models = [
+            _update_model_sats_pricing(m, sats_to_usd)
+            for m in upstream.get_cached_models()
+        ]
+        upstream._models_cache = updated_models
+        upstream._models_by_id = {m.id: m for m in updated_models}
+        updated_count += len(updated_models)
+
+    if updated_count > 0:
+        logger.info("Updated sats pricing", extra={"models_updated": updated_count})
+
+
+async def update_sats_pricing() -> None:
+    """Periodically update sats pricing for all provider models and database overrides."""
+    try:
+        if not settings.enable_pricing_refresh:
+            return
+    except Exception:
+        pass
+
+    await _update_sats_pricing_once()
+
+    while True:
+        try:
+            interval = getattr(settings, "pricing_refresh_interval_seconds", 120)
+            jitter = max(0.0, float(interval) * 0.1)
+            await asyncio.sleep(interval + random.uniform(0, jitter))
+        except asyncio.CancelledError:
+            break
+
+        try:
+            try:
+                if not settings.enable_pricing_refresh:
+                    return
+            except Exception:
+                pass
+
+            await _update_sats_pricing_once()
+        except asyncio.CancelledError:
+            break
+        except Exception as e:
+            logger.error(f"Error updating sats pricing: {e}")
+
+
+async def cleanup_enabled_models_periodically() -> None:
+    """Background task to clean up enabled models that match upstream pricing.
+
+    When model is enabled (enabled=True), remove it from DB if it matches upstream pricing.
+    Keep it in DB only if pricing differs from upstream or if it's disabled.
+    """
+    interval = getattr(
+        settings, "models_cleanup_interval_seconds", 300
+    )  # 5 minutes default
+    if not interval or interval <= 0:
+        return
+
+    while True:
+        try:
+            await _cleanup_enabled_models_once()
+        except asyncio.CancelledError:
+            break
+        except Exception as e:
+            logger.error(
+                "Error during enabled models cleanup",
+                extra={"error": str(e), "error_type": type(e).__name__},
+            )
+
+        try:
+            jitter = max(0.0, float(interval) * 0.1)
+            await asyncio.sleep(interval + random.uniform(0, jitter))
+        except asyncio.CancelledError:
+            break
+
+
+async def _cleanup_enabled_models_once() -> None:
+    """Clean up enabled models that match upstream pricing."""
+    from ..proxy import get_upstreams
+
+    async with create_session() as session:
+        # Get all enabled models from DB
+        result = await session.exec(
+            select(ModelRow).where(
+                ModelRow.enabled,  # Only enabled models
+            )
+        )
+        db_models = result.all()
+
+        if not db_models:
+            return
+
+        upstreams = get_upstreams()
+        models_to_remove = []
+
+        for db_model in db_models:
+            # Find corresponding upstream model
+            upstream_model = None
+            for upstream in upstreams:
+                upstream_model = upstream.get_cached_model_by_id(db_model.id)
+                if upstream_model:
+                    break
+
+            if not upstream_model:
+                continue
+
+            # Compare pricing to see if they match
+            db_pricing = json.loads(db_model.pricing)
+            upstream_pricing = upstream_model.pricing.dict()
+
+            # Check if pricing matches (with small tolerance for float comparison)
+            pricing_matches = _pricing_matches(db_pricing, upstream_pricing)
+
+            if pricing_matches:
+                models_to_remove.append(db_model)
+                logger.info(
+                    f"Removing enabled model {db_model.id} - matches upstream pricing",
+                    extra={"model_id": db_model.id},
+                )
+
+        # Remove models that match upstream pricing
+        for model in models_to_remove:
+            await session.delete(model)
+
+        if models_to_remove:
+            await session.commit()
+            logger.info(
+                f"Cleaned up {len(models_to_remove)} enabled models that match upstream pricing"
+            )
+
+
+def _pricing_matches(
+    db_pricing: dict, upstream_pricing: dict, tolerance: float = 0.0
+) -> bool:
+    """Check if pricing dictionaries match within tolerance."""
+    keys_to_compare = [
+        "prompt",
+        "completion",
+        "request",
+        "image",
+        "web_search",
+        "internal_reasoning",
+    ]
+
+    for key in keys_to_compare:
+        db_val = int(float(db_pricing.get(key, 0.0)) * 1000000)
+        upstream_val = int(float(upstream_pricing.get(key, 0.0)) * 1000000)
+
+        if abs(db_val - upstream_val) > tolerance:
+            return False
+
+    return True
+
+
+def _model_to_row_payload(model: Model) -> dict[str, str | int | bool | None]:
+    return {
+        "id": model.id,
+        "name": model.name,
+        "created": model.created,
+        "description": model.description,
+        "context_length": model.context_length,
+        "architecture": json.dumps(model.architecture.dict()),
+        "pricing": json.dumps(model.pricing.dict()),
+        "sats_pricing": json.dumps(model.sats_pricing.dict())
+        if model.sats_pricing
+        else None,
+        "per_request_limits": json.dumps(model.per_request_limits)
+        if model.per_request_limits is not None
+        else None,
+        "top_provider": json.dumps(model.top_provider.dict())
+        if model.top_provider is not None
+        else None,
+        "enabled": model.enabled,
+        "upstream_provider_id": model.upstream_provider_id,
+    }
+
+
+@models_router.get("/v1/models")
+@models_router.get("/models", include_in_schema=False)
+async def models(session: AsyncSession = Depends(get_session)) -> dict:
+    """Get all available models from all providers with database overrides applied."""
+    from ..proxy import get_unique_models
+
+    items = get_unique_models()
+    return {"data": items}

routstr/nostr/__init__.py

@@ -0,0 +1,7 @@
+from .discovery import providers_cache_refresher
+from .listing import announce_provider
+
+__all__ = [
+    "providers_cache_refresher",
+    "announce_provider",
+]

routstr/nostr/discovery.py

@@ -8,8 +8,8 @@ import httpx
 import websockets
 from fastapi import APIRouter
 
-from .core.logging import get_logger
-from .core.settings import settings
+from ..core.logging import get_logger
+from ..core.settings import settings
 
 logger = get_logger(__name__)
 

routstr/nostr/listing.py

@@ -18,15 +18,15 @@ from nostr.key import PrivateKey
 from nostr.message_type import ClientMessageType
 from nostr.relay_manager import RelayManager
 
-from .core import get_logger
-from .core.settings import settings
+from ..core import get_logger
+from ..core.settings import settings
 
 logger = get_logger(__name__)
 
 
 def get_app_version() -> str | None:
     try:
-        from .core.main import __version__ as imported_version
+        from ..core.main import __version__ as imported_version
 
         return imported_version
     except Exception:
@@ -71,7 +71,7 @@ def nsec_to_keypair(nsec: str) -> tuple[str, str] | None:
         return None
 
 
-def create_nip91_event(
+def create_listing_event(
     private_key_hex: str,
     provider_id: str,
     endpoint_urls: list[str],
@@ -164,7 +164,7 @@ def events_semantically_equal(a: dict[str, Any], b: dict[str, Any]) -> bool:
     return True
 
 
-async def query_nip91_events(
+async def query_listing_events(
     relay_url: str,
     pubkey: str,
     provider_id: str | None = None,
@@ -188,7 +188,7 @@ async def query_nip91_events(
 
             flt = Filter(kinds=[38421], authors=[pubkey], limit=10)
             filters = Filters([flt])
-            sub_id = f"nip91_{int(time.time())}"
+            sub_id = f"routstr_listing_{int(time.time())}"
             rm.add_subscription(sub_id, filters)
             req: list[Any] = [ClientMessageType.REQUEST, sub_id]
             req.extend(filters.to_json_array())
@@ -294,7 +294,7 @@ async def _determine_provider_id(public_key_hex: str, relay_urls: list[str]) ->
 
     async def query_single_relay(relay_url: str) -> list[dict[str, Any]]:
         try:
-            events, _ok = await query_nip91_events(relay_url, public_key_hex, None)
+            events, _ok = await query_listing_events(relay_url, public_key_hex, None)
             return events
         except Exception:
             return []
@@ -434,7 +434,7 @@ async def announce_provider() -> None:
 
     # Create the candidate event that we would publish
     version_str = get_app_version()
-    candidate_event = create_nip91_event(
+    candidate_event = create_listing_event(
         private_key_hex=private_key_hex,
         provider_id=provider_id,
         endpoint_urls=endpoint_urls,
@@ -474,7 +474,7 @@ async def announce_provider() -> None:
         if _should_skip(relay_url):
             logger.debug(f"Skipping {relay_url} due to backoff")
             continue
-        events, ok = await query_nip91_events(relay_url, public_key_hex, provider_id)
+        events, ok = await query_listing_events(relay_url, public_key_hex, provider_id)
         if ok:
             _register_success(relay_url)
             existing_events.extend(events)
@@ -518,7 +518,7 @@ async def announce_provider() -> None:
 
             # Build fresh candidate event for comparison
             version_str = get_app_version()
-            candidate_event = create_nip91_event(
+            candidate_event = create_listing_event(
                 private_key_hex=private_key_hex,
                 provider_id=provider_id,
                 endpoint_urls=endpoint_urls,
@@ -533,7 +533,7 @@ async def announce_provider() -> None:
                 if _should_skip(relay_url):
                     logger.debug(f"Skipping {relay_url} due to backoff")
                     continue
-                events, ok = await query_nip91_events(
+                events, ok = await query_listing_events(
                     relay_url, public_key_hex, provider_id
                 )
                 if ok:

routstr/payment/__init__.py

@@ -1,4 +1,4 @@
-from .cost_caculation import CostData, CostDataError, MaxCostData, calculate_cost
+from .cost import CostData, CostDataError, MaxCostData, calculate_cost
 
 __all__ = [
     "CostData",

routstr/payment/cashu.py

@@ -0,0 +1,48 @@
+from cashu.wallet.helpers import deserialize_token_from_string
+from fastapi import HTTPException
+
+from ..core import get_logger
+
+logger = get_logger(__name__)
+
+
+def get_token_balance_msat(cashu_token: str) -> int:
+    try:
+        token = deserialize_token_from_string(cashu_token)
+    except Exception:
+        raise HTTPException(401, "Invalid authentication token format")
+
+    if token.unit == "sat":
+        return token.amount * 1000
+    if token.unit == "msat":
+        return token.amount
+
+    raise HTTPException(401, f"Unit {token.unit} not supported yet")
+
+
+def pre_check_header_token_balance(
+    headers: dict, body: dict, max_cost_for_model: int
+) -> None:
+    if x_cashu := headers.get("x-cashu", None):
+        cashu_token = x_cashu
+    elif auth := headers.get("authorization", None):
+        cashu_token = auth.split(" ")[1] if len(auth.split(" ")) > 1 else ""
+    else:
+        raise HTTPException(status_code=401, detail="Unauthorized")
+
+    # Handle regular API keys (sk-*)
+    if cashu_token.startswith("sk-"):
+        return
+
+    amount_msat = get_token_balance_msat(cashu_token)
+
+    if max_cost_for_model > amount_msat:
+        raise HTTPException(
+            status_code=413,
+            detail={
+                "reason": "Insufficient balance",
+                "amount_required_msat": max_cost_for_model,
+                "model": body.get("model", "unknown"),
+                "type": "minimum_balance_required",
+            },
+        )

routstr/payment/cost.py

@@ -0,0 +1,425 @@
+import base64
+import math
+from io import BytesIO
+from typing import Any
+
+import httpx
+from PIL import Image
+from pydantic.v1 import BaseModel
+
+from ..core import get_logger
+from ..core.settings import settings
+from ..models.models import Model
+
+logger = get_logger(__name__)
+
+
+class CostData(BaseModel):
+    base_msats: int
+    input_msats: int
+    output_msats: int
+    total_msats: int
+
+
+class MaxCostData(CostData):
+    pass
+
+
+class CostDataError(BaseModel):
+    message: str
+    code: str
+
+
+def calculate_cost(
+    response_data: dict, max_cost: int
+) -> CostData | MaxCostData | CostDataError:
+    """
+    Calculate the cost of an API request based on token usage.
+
+    Args:
+        response_data: Response data containing usage information
+        max_cost: Maximum cost in millisats
+
+    Returns:
+        Cost data or error information
+    """
+    logger.debug(
+        "Starting cost calculation",
+        extra={
+            "max_cost_msats": max_cost,
+            "has_usage_data": "usage" in response_data,
+            "response_model": response_data.get("model", "unknown"),
+        },
+    )
+
+    cost_data = MaxCostData(
+        base_msats=max_cost,
+        input_msats=0,
+        output_msats=0,
+        total_msats=max_cost,
+    )
+
+    if "usage" not in response_data or response_data["usage"] is None:
+        logger.warning(
+            "No usage data in response, using base cost only",
+            extra={
+                "max_cost_msats": max_cost,
+                "model": response_data.get("model", "unknown"),
+            },
+        )
+        return cost_data
+
+    MSATS_PER_1K_INPUT_TOKENS: float = (
+        float(settings.fixed_per_1k_input_tokens) * 1000.0
+    )
+    MSATS_PER_1K_OUTPUT_TOKENS: float = (
+        float(settings.fixed_per_1k_output_tokens) * 1000.0
+    )
+
+    if not settings.fixed_pricing:
+        response_model = response_data.get("model", "")
+        logger.debug(
+            "Using model-based pricing",
+            extra={"model": response_model},
+        )
+
+        from ..proxy import get_model_instance
+
+        model_obj = get_model_instance(response_model)
+
+        if not model_obj:
+            logger.error(
+                "Invalid model in response",
+                extra={"response_model": response_model},
+            )
+            return CostDataError(
+                message=f"Invalid model in response: {response_model}",
+                code="model_not_found",
+            )
+
+        if not model_obj.sats_pricing:
+            logger.error(
+                "Model pricing not defined",
+                extra={"model": response_model, "model_id": response_model},
+            )
+            return CostDataError(
+                message="Model pricing not defined", code="pricing_not_found"
+            )
+
+        try:
+            mspp = float(model_obj.sats_pricing.prompt)
+            mspc = float(model_obj.sats_pricing.completion)
+        except Exception:
+            return CostDataError(message="Invalid pricing data", code="pricing_invalid")
+
+        MSATS_PER_1K_INPUT_TOKENS = mspp * 1_000_000.0
+        MSATS_PER_1K_OUTPUT_TOKENS = mspc * 1_000_000.0
+
+        logger.info(
+            "Applied model-specific pricing",
+            extra={
+                "model": response_model,
+                "input_price_msats_per_1k": MSATS_PER_1K_INPUT_TOKENS,
+                "output_price_msats_per_1k": MSATS_PER_1K_OUTPUT_TOKENS,
+            },
+        )
+
+    if not (MSATS_PER_1K_OUTPUT_TOKENS and MSATS_PER_1K_INPUT_TOKENS):
+        logger.warning(
+            "No token pricing configured, using base cost",
+            extra={
+                "base_cost_msats": max_cost,
+                "model": response_data.get("model", "unknown"),
+            },
+        )
+        return cost_data
+
+    input_tokens = response_data.get("usage", {}).get("prompt_tokens", 0)
+    output_tokens = response_data.get("usage", {}).get("completion_tokens", 0)
+
+    input_msats = round(input_tokens / 1000 * MSATS_PER_1K_INPUT_TOKENS, 3)
+    output_msats = round(output_tokens / 1000 * MSATS_PER_1K_OUTPUT_TOKENS, 3)
+    token_based_cost = math.ceil(input_msats + output_msats)
+
+    logger.info(
+        "Calculated token-based cost",
+        extra={
+            "input_tokens": input_tokens,
+            "output_tokens": output_tokens,
+            "input_cost_msats": input_msats,
+            "output_cost_msats": output_msats,
+            "total_cost_msats": token_based_cost,
+            "model": response_data.get("model", "unknown"),
+        },
+    )
+
+    return CostData(
+        base_msats=0,
+        input_msats=int(input_msats),
+        output_msats=int(output_msats),
+        total_msats=token_based_cost,
+    )
+
+
+def get_max_cost_for_model(model_obj: Model) -> int:
+    """Get the maximum cost for a specific model from providers with overrides."""
+    if settings.fixed_pricing:
+        default_cost_msats = settings.fixed_cost_per_request * 1000
+        return max(settings.min_request_msat, default_cost_msats)
+
+    if model_obj.sats_pricing:
+        max_cost = (
+            model_obj.sats_pricing.max_cost
+            * 1000
+            * (1 - settings.tolerance_percentage / 100)
+        )
+        calculated_msats = int(max_cost)
+        return max(settings.min_request_msat, calculated_msats)
+
+    logger.warning(
+        "Model pricing not found, using fixed cost",
+        extra={
+            "model": model_obj.id,
+            "default_cost_msats": settings.fixed_cost_per_request * 1000,
+        },
+    )
+    return max(settings.min_request_msat, settings.fixed_cost_per_request * 1000)
+
+
+async def calculate_discounted_max_cost(
+    max_cost_for_model: int,
+    body: dict,
+    model_obj: Any | None = None,
+) -> int:
+    """Calculate the discounted max cost for a request using model pricing when available."""
+    if settings.fixed_pricing:
+        return max_cost_for_model
+
+    model = body.get("model", "unknown")
+
+    model_pricing = model_obj.sats_pricing if model_obj else None
+    if not model_pricing:
+        return max_cost_for_model
+
+    tol = settings.tolerance_percentage
+    tol_factor = max(0.0, 1 - float(tol) / 100.0)
+    max_prompt_allowed_sats = model_pricing.max_prompt_cost * tol_factor
+    max_completion_allowed_sats = model_pricing.max_completion_cost * tol_factor
+
+    adjusted = max_cost_for_model
+
+    if messages := body.get("messages"):
+        prompt_tokens = _estimate_tokens(messages)
+
+        image_tokens = await _estimate_image_tokens_in_messages(messages)
+        if image_tokens > 0:
+            logger.debug(
+                "Found images in request",
+                extra={
+                    "model": model,
+                    "image_tokens": image_tokens,
+                },
+            )
+            prompt_tokens += image_tokens
+
+        estimated_prompt_delta_sats = (
+            max_prompt_allowed_sats - prompt_tokens * model_pricing.prompt
+        )
+        if estimated_prompt_delta_sats > 0:
+            adjusted = adjusted - math.floor(estimated_prompt_delta_sats * 1000)
+
+    max_tokens_raw = body.get("max_tokens", None)
+    if max_tokens_raw is not None:
+        try:
+            max_tokens_int = int(max_tokens_raw)
+        except (TypeError, ValueError):
+            logger.warning(
+                "Invalid max_tokens; ignoring in cost adjustment",
+                extra={"max_tokens": str(max_tokens_raw)[:64], "model": model},
+            )
+        else:
+            estimated_completion_delta_sats = (
+                max_completion_allowed_sats - max_tokens_int * model_pricing.completion
+            )
+            if estimated_completion_delta_sats > 0:
+                adjusted = adjusted - math.floor(estimated_completion_delta_sats * 1000)
+
+    logger.debug(
+        "Discounted max cost computed",
+        extra={
+            "model": model,
+            "original_msats": max_cost_for_model,
+            "adjusted_msats": adjusted,
+            "tolerance_pct": tol,
+        },
+    )
+
+    return max(0, adjusted)
+
+
+def _estimate_tokens(messages: list) -> int:
+    """Estimate tokens for text content, excluding image_url fields."""
+    total = 0
+    for msg in messages:
+        if isinstance(msg, dict):
+            content = msg.get("content")
+            if isinstance(content, str):
+                total += len(content)
+            elif isinstance(content, list):
+                total += sum(
+                    len(item.get("text", ""))
+                    for item in content
+                    if isinstance(item, dict) and item.get("type") == "text"
+                )
+    return total // 3
+
+
+def _get_image_dimensions(image_data: bytes) -> tuple[int, int]:
+    """Extract image dimensions from image bytes."""
+    try:
+        img = Image.open(BytesIO(image_data))
+        return img.size
+    except Exception as e:
+        logger.warning(
+            "Failed to get image dimensions, using default",
+            extra={"error": str(e)},
+        )
+        return (512, 512)
+
+
+async def _fetch_image_from_url(url: str) -> bytes | None:
+    """Fetch image from URL."""
+    try:
+        async with httpx.AsyncClient(timeout=10.0) as client:
+            response = await client.get(url)
+            response.raise_for_status()
+            return response.content
+    except Exception as e:
+        logger.warning(
+            "Failed to fetch image from URL",
+            extra={"error": str(e), "url": url[:100]},
+        )
+        return None
+
+
+def _calculate_image_tokens(width: int, height: int, detail: str = "auto") -> int:
+    """Calculate image tokens based on OpenAI's vision pricing.
+
+    For low detail: 85 tokens
+    For high detail/auto: 85 base tokens + 170 tokens per 512px tile
+    """
+    if detail == "low":
+        return 85
+
+    if width > 2048 or height > 2048:
+        aspect_ratio = width / height
+        if width > height:
+            width = 2048
+            height = int(width / aspect_ratio)
+        else:
+            height = 2048
+            width = int(height * aspect_ratio)
+
+    if width > 768 or height > 768:
+        aspect_ratio = width / height
+        if width > height:
+            width = 768
+            height = int(width / aspect_ratio)
+        else:
+            height = 768
+            width = int(height * aspect_ratio)
+
+    tiles_width = (width + 511) // 512
+    tiles_height = (height + 511) // 512
+    num_tiles = tiles_width * tiles_height
+
+    return 85 + (170 * num_tiles)
+
+
+async def _estimate_image_tokens_in_messages(messages: list) -> int:
+    """Estimate total tokens for all images in messages.
+
+    Supports both base64 encoded images and image URLs.
+    """
+    total_image_tokens = 0
+
+    for message in messages:
+        if not isinstance(message, dict):
+            continue
+
+        content = message.get("content")
+        if not content:
+            continue
+
+        if isinstance(content, str):
+            continue
+
+        if not isinstance(content, list):
+            continue
+
+        for content_item in content:
+            if not isinstance(content_item, dict):
+                continue
+
+            content_type = content_item.get("type")
+            if content_type not in ("image_url", "input_image"):
+                continue
+
+            image_url_data = content_item.get("image_url")
+            if not image_url_data:
+                continue
+
+            if isinstance(image_url_data, str):
+                url = image_url_data
+                detail = "auto"
+            elif isinstance(image_url_data, dict):
+                url = image_url_data.get("url", "")
+                detail = image_url_data.get("detail", "auto")
+            else:
+                continue
+
+            if not url:
+                continue
+
+            if url.startswith("data:image/"):
+                try:
+                    header, base64_data = url.split(",", 1)
+                    image_bytes = base64.b64decode(base64_data)
+                    width, height = _get_image_dimensions(image_bytes)
+                    tokens = _calculate_image_tokens(width, height, detail)
+                    total_image_tokens += tokens
+                    logger.debug(
+                        "Calculated tokens for base64 image",
+                        extra={
+                            "width": width,
+                            "height": height,
+                            "detail": detail,
+                            "tokens": tokens,
+                        },
+                    )
+                except Exception as e:
+                    logger.warning(
+                        "Failed to process base64 image",
+                        extra={"error": str(e)},
+                    )
+                    total_image_tokens += 85
+            else:
+                image_bytes_or_none = await _fetch_image_from_url(url)
+                if image_bytes_or_none:
+                    width, height = _get_image_dimensions(image_bytes_or_none)
+                    tokens = _calculate_image_tokens(width, height, detail)
+                    total_image_tokens += tokens
+                    logger.debug(
+                        "Calculated tokens for URL image",
+                        extra={
+                            "url": url[:100],
+                            "width": width,
+                            "height": height,
+                            "detail": detail,
+                            "tokens": tokens,
+                        },
+                    )
+                else:
+                    total_image_tokens += 85
+
+    return total_image_tokens

routstr/payment/cost_caculation.py

@@ -1,156 +0,0 @@
-import math
-
-from pydantic.v1 import BaseModel
-
-from ..core import get_logger
-from ..core.db import AsyncSession
-from ..core.settings import settings
-
-logger = get_logger(__name__)
-
-
-class CostData(BaseModel):
-    base_msats: int
-    input_msats: int
-    output_msats: int
-    total_msats: int
-
-
-class MaxCostData(CostData):
-    pass
-
-
-class CostDataError(BaseModel):
-    message: str
-    code: str
-
-
-async def calculate_cost(  # todo: can be sync
-    response_data: dict, max_cost: int, session: AsyncSession
-) -> CostData | MaxCostData | CostDataError:
-    """
-    Calculate the cost of an API request based on token usage.
-
-    Args:
-        response_data: Response data containing usage information
-        max_cost: Maximum cost in millisats
-
-    Returns:
-        Cost data or error information
-    """
-    logger.debug(
-        "Starting cost calculation",
-        extra={
-            "max_cost_msats": max_cost,
-            "has_usage_data": "usage" in response_data,
-            "response_model": response_data.get("model", "unknown"),
-        },
-    )
-
-    cost_data = MaxCostData(
-        base_msats=max_cost,
-        input_msats=0,
-        output_msats=0,
-        total_msats=max_cost,
-    )
-
-    if "usage" not in response_data or response_data["usage"] is None:
-        logger.warning(
-            "No usage data in response, using base cost only",
-            extra={
-                "max_cost_msats": max_cost,
-                "model": response_data.get("model", "unknown"),
-            },
-        )
-        return cost_data
-
-    MSATS_PER_1K_INPUT_TOKENS: float = (
-        float(settings.fixed_per_1k_input_tokens) * 1000.0
-    )
-    MSATS_PER_1K_OUTPUT_TOKENS: float = (
-        float(settings.fixed_per_1k_output_tokens) * 1000.0
-    )
-
-    if not settings.fixed_pricing:
-        response_model = response_data.get("model", "")
-        logger.debug(
-            "Using model-based pricing",
-            extra={"model": response_model},
-        )
-
-        from ..proxy import get_model_instance
-
-        model_obj = get_model_instance(response_model)
-
-        if not model_obj:
-            logger.error(
-                "Invalid model in response",
-                extra={"response_model": response_model},
-            )
-            return CostDataError(
-                message=f"Invalid model in response: {response_model}",
-                code="model_not_found",
-            )
-
-        if not model_obj.sats_pricing:
-            logger.error(
-                "Model pricing not defined",
-                extra={"model": response_model, "model_id": response_model},
-            )
-            return CostDataError(
-                message="Model pricing not defined", code="pricing_not_found"
-            )
-
-        try:
-            mspp = float(model_obj.sats_pricing.prompt)
-            mspc = float(model_obj.sats_pricing.completion)
-        except Exception:
-            return CostDataError(message="Invalid pricing data", code="pricing_invalid")
-
-        MSATS_PER_1K_INPUT_TOKENS = mspp * 1_000_000.0
-        MSATS_PER_1K_OUTPUT_TOKENS = mspc * 1_000_000.0
-
-        logger.info(
-            "Applied model-specific pricing",
-            extra={
-                "model": response_model,
-                "input_price_msats_per_1k": MSATS_PER_1K_INPUT_TOKENS,
-                "output_price_msats_per_1k": MSATS_PER_1K_OUTPUT_TOKENS,
-            },
-        )
-
-    if not (MSATS_PER_1K_OUTPUT_TOKENS and MSATS_PER_1K_INPUT_TOKENS):
-        logger.warning(
-            "No token pricing configured, using base cost",
-            extra={
-                "base_cost_msats": max_cost,
-                "model": response_data.get("model", "unknown"),
-            },
-        )
-        return cost_data
-
-    input_tokens = response_data.get("usage", {}).get("prompt_tokens", 0)
-    output_tokens = response_data.get("usage", {}).get("completion_tokens", 0)
-
-    input_msats = round(input_tokens / 1000 * MSATS_PER_1K_INPUT_TOKENS, 3)
-    output_msats = round(output_tokens / 1000 * MSATS_PER_1K_OUTPUT_TOKENS, 3)
-    token_based_cost = math.ceil(input_msats + output_msats)
-
-    logger.info(
-        "Calculated token-based cost",
-        extra={
-            "input_tokens": input_tokens,
-            "output_tokens": output_tokens,
-            "input_cost_msats": input_msats,
-            "output_cost_msats": output_msats,
-            "total_cost_msats": token_based_cost,
-            "model": response_data.get("model", "unknown"),
-        },
-    )
-
-    return CostData(
-        base_msats=0,
-        input_msats=int(input_msats),
-        output_msats=int(output_msats),
-        total_msats=token_based_cost,
-    )

routstr/payment/helpers.py

@@ -1,396 +1,18 @@
-import base64
 import json
 import math
-from io import BytesIO
-from typing import Any
 
-import httpx
 from fastapi import HTTPException, Response
 from fastapi.requests import Request
-from PIL import Image
-from sqlmodel.ext.asyncio.session import AsyncSession
+from sqlmodel import col, update
 
 from ..core import get_logger
-from ..core.settings import settings
-from ..wallet import deserialize_token_from_string
+from ..core.db import AsyncSession, TemporaryCredit
+from ..payment.cost import CostData, CostDataError, MaxCostData, calculate_cost
 
 logger = get_logger(__name__)
 
 
-def check_token_balance(headers: dict, body: dict, max_cost_for_model: int) -> None:
-    if x_cashu := headers.get("x-cashu", None):
-        cashu_token = x_cashu
-        logger.debug(
-            "Using X-Cashu token",
-            extra={
-                "token_preview": cashu_token[:20] + "..."
-                if len(cashu_token) > 20
-                else cashu_token
-            },
-        )
-    elif auth := headers.get("authorization", None):
-        cashu_token = auth.split(" ")[1] if len(auth.split(" ")) > 1 else ""
-        logger.debug(
-            "Using Authorization header token",
-            extra={
-                "token_preview": cashu_token[:20] + "..."
-                if len(cashu_token) > 20
-                else cashu_token
-            },
-        )
-    else:
-        logger.error("No authentication token provided")
-        raise HTTPException(status_code=401, detail="Unauthorized")
-
-    # Handle empty token
-    if not cashu_token:
-        logger.error("Empty token provided")
-        raise HTTPException(
-            status_code=401,
-            detail={
-                "error": {
-                    "message": "API key or Cashu token required",
-                    "type": "invalid_request_error",
-                    "code": "missing_api_key",
-                }
-            },
-        )
-
-    # Handle regular API keys (sk-*)
-    if cashu_token.startswith("sk-"):
-        return
-
-    try:
-        token_obj = deserialize_token_from_string(cashu_token)
-    except Exception:
-        # Invalid token format - let the auth system handle it
-        raise HTTPException(
-            status_code=401,
-            detail="Invalid authentication token format",
-        )
-
-    amount_msat = (
-        token_obj.amount if token_obj.unit == "msat" else token_obj.amount * 1000
-    )
-
-    if max_cost_for_model > amount_msat:
-        raise HTTPException(
-            status_code=413,
-            detail={
-                "reason": "Insufficient balance",
-                "amount_required_msat": max_cost_for_model,
-                "model": body.get("model", "unknown"),
-                "type": "minimum_balance_required",
-            },
-        )
-
-
-async def get_max_cost_for_model(
-    model: str,
-    session: AsyncSession,
-    model_obj: Any | None = None,
-) -> int:
-    """Get the maximum cost for a specific model from providers with overrides."""
-    logger.debug(
-        "Getting max cost for model",
-        extra={
-            "model": model,
-            "fixed_pricing": settings.fixed_pricing,
-        },
-    )
-
-    if settings.fixed_pricing:
-        default_cost_msats = settings.fixed_cost_per_request * 1000
-        logger.debug(
-            "Using fixed cost pricing",
-            extra={"cost_msats": default_cost_msats, "model": model},
-        )
-        return max(settings.min_request_msat, default_cost_msats)
-
-    if not model_obj:
-        from ..proxy import get_model_instance
-
-        model_obj = get_model_instance(model)
-
-    if not model_obj:
-        fallback_msats = settings.fixed_cost_per_request * 1000
-        logger.warning(
-            "Model not found in providers or overrides",
-            extra={
-                "requested_model": model,
-                "using_default_cost": fallback_msats,
-            },
-        )
-        return max(settings.min_request_msat, fallback_msats)
-
-    if model_obj.sats_pricing:
-        try:
-            max_cost = (
-                model_obj.sats_pricing.max_cost
-                * 1000
-                * (1 - settings.tolerance_percentage / 100)
-            )
-            logger.debug(
-                "Found model-specific max cost",
-                extra={"model": model, "max_cost_msats": max_cost},
-            )
-            calculated_msats = int(max_cost)
-            return max(settings.min_request_msat, calculated_msats)
-        except Exception as e:
-            logger.error(
-                "Error calculating max cost from model pricing",
-                extra={"model": model, "error": str(e)},
-            )
-
-    logger.warning(
-        "Model pricing not found, using fixed cost",
-        extra={
-            "model": model,
-            "default_cost_msats": settings.fixed_cost_per_request * 1000,
-        },
-    )
-    return max(settings.min_request_msat, settings.fixed_cost_per_request * 1000)
-
-
-async def calculate_discounted_max_cost(
-    max_cost_for_model: int,
-    body: dict,
-    model_obj: Any | None = None,
-) -> int:
-    """Calculate the discounted max cost for a request using model pricing when available."""
-    if settings.fixed_pricing:
-        return max_cost_for_model
-
-    model = body.get("model", "unknown")
-
-    model_pricing = model_obj.sats_pricing if model_obj else None
-    if not model_pricing:
-        return max_cost_for_model
-
-    tol = settings.tolerance_percentage
-    tol_factor = max(0.0, 1 - float(tol) / 100.0)
-    max_prompt_allowed_sats = model_pricing.max_prompt_cost * tol_factor
-    max_completion_allowed_sats = model_pricing.max_completion_cost * tol_factor
-
-    adjusted = max_cost_for_model
-
-    if messages := body.get("messages"):
-        prompt_tokens = estimate_tokens(messages)
-
-        image_tokens = await estimate_image_tokens_in_messages(messages)
-        if image_tokens > 0:
-            logger.debug(
-                "Found images in request",
-                extra={
-                    "model": model,
-                    "image_tokens": image_tokens,
-                },
-            )
-            prompt_tokens += image_tokens
-
-        estimated_prompt_delta_sats = (
-            max_prompt_allowed_sats - prompt_tokens * model_pricing.prompt
-        )
-        if estimated_prompt_delta_sats > 0:
-            adjusted = adjusted - math.floor(estimated_prompt_delta_sats * 1000)
-
-    max_tokens_raw = body.get("max_tokens", None)
-    if max_tokens_raw is not None:
-        try:
-            max_tokens_int = int(max_tokens_raw)
-        except (TypeError, ValueError):
-            logger.warning(
-                "Invalid max_tokens; ignoring in cost adjustment",
-                extra={"max_tokens": str(max_tokens_raw)[:64], "model": model},
-            )
-        else:
-            estimated_completion_delta_sats = (
-                max_completion_allowed_sats - max_tokens_int * model_pricing.completion
-            )
-            if estimated_completion_delta_sats > 0:
-                adjusted = adjusted - math.floor(estimated_completion_delta_sats * 1000)
-
-    logger.debug(
-        "Discounted max cost computed",
-        extra={
-            "model": model,
-            "original_msats": max_cost_for_model,
-            "adjusted_msats": adjusted,
-            "tolerance_pct": tol,
-        },
-    )
-
-    return max(0, adjusted)
-
-
-def estimate_tokens(messages: list) -> int:
-    """Estimate tokens for text content, excluding image_url fields."""
-    total = 0
-    for msg in messages:
-        if isinstance(msg, dict):
-            content = msg.get("content")
-            if isinstance(content, str):
-                total += len(content)
-            elif isinstance(content, list):
-                total += sum(
-                    len(item.get("text", ""))
-                    for item in content
-                    if isinstance(item, dict) and item.get("type") == "text"
-                )
-    return total // 3
-
-
-def _get_image_dimensions(image_data: bytes) -> tuple[int, int]:
-    """Extract image dimensions from image bytes."""
-    try:
-        img = Image.open(BytesIO(image_data))
-        return img.size
-    except Exception as e:
-        logger.warning(
-            "Failed to get image dimensions, using default",
-            extra={"error": str(e)},
-        )
-        return (512, 512)
-
-
-async def _fetch_image_from_url(url: str) -> bytes | None:
-    """Fetch image from URL."""
-    try:
-        async with httpx.AsyncClient(timeout=10.0) as client:
-            response = await client.get(url)
-            response.raise_for_status()
-            return response.content
-    except Exception as e:
-        logger.warning(
-            "Failed to fetch image from URL",
-            extra={"error": str(e), "url": url[:100]},
-        )
-        return None
-
-
-def _calculate_image_tokens(width: int, height: int, detail: str = "auto") -> int:
-    """Calculate image tokens based on OpenAI's vision pricing.
-
-    For low detail: 85 tokens
-    For high detail/auto: 85 base tokens + 170 tokens per 512px tile
-    """
-    if detail == "low":
-        return 85
-
-    if width > 2048 or height > 2048:
-        aspect_ratio = width / height
-        if width > height:
-            width = 2048
-            height = int(width / aspect_ratio)
-        else:
-            height = 2048
-            width = int(height * aspect_ratio)
-
-    if width > 768 or height > 768:
-        aspect_ratio = width / height
-        if width > height:
-            width = 768
-            height = int(width / aspect_ratio)
-        else:
-            height = 768
-            width = int(height * aspect_ratio)
-
-    tiles_width = (width + 511) // 512
-    tiles_height = (height + 511) // 512
-    num_tiles = tiles_width * tiles_height
-
-    return 85 + (170 * num_tiles)
-
-
-async def estimate_image_tokens_in_messages(messages: list) -> int:
-    """Estimate total tokens for all images in messages.
-
-    Supports both base64 encoded images and image URLs.
-    """
-    total_image_tokens = 0
-
-    for message in messages:
-        if not isinstance(message, dict):
-            continue
-
-        content = message.get("content")
-        if not content:
-            continue
-
-        if isinstance(content, str):
-            continue
-
-        if not isinstance(content, list):
-            continue
-
-        for content_item in content:
-            if not isinstance(content_item, dict):
-                continue
-
-            content_type = content_item.get("type")
-            if content_type not in ("image_url", "input_image"):
-                continue
-
-            image_url_data = content_item.get("image_url")
-            if not image_url_data:
-                continue
-
-            if isinstance(image_url_data, str):
-                url = image_url_data
-                detail = "auto"
-            elif isinstance(image_url_data, dict):
-                url = image_url_data.get("url", "")
-                detail = image_url_data.get("detail", "auto")
-            else:
-                continue
-
-            if not url:
-                continue
-
-            if url.startswith("data:image/"):
-                try:
-                    header, base64_data = url.split(",", 1)
-                    image_bytes = base64.b64decode(base64_data)
-                    width, height = _get_image_dimensions(image_bytes)
-                    tokens = _calculate_image_tokens(width, height, detail)
-                    total_image_tokens += tokens
-                    logger.debug(
-                        "Calculated tokens for base64 image",
-                        extra={
-                            "width": width,
-                            "height": height,
-                            "detail": detail,
-                            "tokens": tokens,
-                        },
-                    )
-                except Exception as e:
-                    logger.warning(
-                        "Failed to process base64 image",
-                        extra={"error": str(e)},
-                    )
-                    total_image_tokens += 85
-            else:
-                image_bytes_or_none = await _fetch_image_from_url(url)
-                if image_bytes_or_none:
-                    width, height = _get_image_dimensions(image_bytes_or_none)
-                    tokens = _calculate_image_tokens(width, height, detail)
-                    total_image_tokens += tokens
-                    logger.debug(
-                        "Calculated tokens for URL image",
-                        extra={
-                            "url": url[:100],
-                            "width": width,
-                            "height": height,
-                            "detail": detail,
-                            "tokens": tokens,
-                        },
-                    )
-                else:
-                    total_image_tokens += 85
-
-    return total_image_tokens
-
-
+# TODO: remove and replace with custom HTTPException
 def create_error_response(
     error_type: str,
     message: str,
@@ -414,3 +36,380 @@ def create_error_response(
         media_type="application/json",
         headers={"X-Cashu": token} if token else {},
     )
+
+
+# Request payment handlers, todo: maybe mode somewhere else...
+
+
+async def pay_for_request(
+    key: TemporaryCredit, cost_per_request: int, session: AsyncSession
+) -> int:
+    """Process payment for a request."""
+
+    logger.info(
+        "Processing payment for request",
+        extra={
+            "key_hash": key.hashed_key[:8] + "...",
+            "current_balance": key.balance,
+            "required_cost": cost_per_request,
+            "sufficient_balance": key.balance >= cost_per_request,
+        },
+    )
+
+    if key.total_balance_msat < cost_per_request:
+        logger.warning(
+            "Insufficient balance for request",
+            extra={
+                "key_hash": key.hashed_key[:8] + "...",
+                "balance": key.balance,
+                "reserved_balance": key.reserved_balance,
+                "required": cost_per_request,
+                "shortfall": cost_per_request - key.total_balance_msat,
+            },
+        )
+
+        raise HTTPException(
+            status_code=402,
+            detail={
+                "error": {
+                    "message": f"Insufficient balance: {cost_per_request} mSats required. {key.total_balance} available. (reserved: {key.reserved_balance})",
+                    "type": "insufficient_quota",
+                    "code": "insufficient_balance",
+                }
+            },
+        )
+
+    logger.debug(
+        "Charging base cost for request",
+        extra={
+            "key_hash": key.hashed_key[:8] + "...",
+            "cost": cost_per_request,
+            "balance_before": key.balance,
+        },
+    )
+
+    # Charge the base cost for the request atomically to avoid race conditions
+    stmt = (
+        update(TemporaryCredit)
+        .where(col(TemporaryCredit.hashed_key) == key.hashed_key)
+        .where(
+            col(TemporaryCredit.balance) - col(TemporaryCredit.reserved_balance)
+            >= cost_per_request
+        )
+        .values(
+            reserved_balance=col(TemporaryCredit.reserved_balance) + cost_per_request
+        )
+    )
+    result = await session.exec(stmt)  # type: ignore[call-overload]
+    await session.commit()
+
+    if result.rowcount == 0:
+        logger.error(
+            "Concurrent request depleted balance",
+            extra={
+                "key_hash": key.hashed_key[:8] + "...",
+                "required_cost": cost_per_request,
+                "current_balance": key.balance,
+            },
+        )
+
+        # Another concurrent request spent the balance first
+        raise HTTPException(
+            status_code=402,
+            detail={
+                "error": {
+                    "message": f"Insufficient balance: {cost_per_request} mSats required. {key.balance} available.",
+                    "type": "insufficient_quota",
+                    "code": "insufficient_balance",
+                }
+            },
+        )
+
+    await session.refresh(key)
+
+    logger.info(
+        "Payment processed successfully",
+        extra={
+            "key_hash": key.hashed_key[:8] + "...",
+            "charged_amount": cost_per_request,
+            "new_balance": key.balance,
+        },
+    )
+
+    return cost_per_request
+
+
+async def revert_pay_for_request(
+    key: TemporaryCredit, session: AsyncSession, cost_per_request: int
+) -> None:
+    stmt = (
+        update(TemporaryCredit)
+        .where(col(TemporaryCredit.hashed_key) == key.hashed_key)
+        .values(
+            reserved_balance=col(TemporaryCredit.reserved_balance) - cost_per_request
+        )
+    )
+
+    result = await session.exec(stmt)  # type: ignore[call-overload]
+    await session.commit()
+    if result.rowcount == 0:
+        logger.error(
+            "Failed to revert payment - insufficient reserved balance",
+            extra={
+                "key_hash": key.hashed_key[:8] + "...",
+                "cost_to_revert": cost_per_request,
+                "current_reserved_balance": key.reserved_balance,
+            },
+        )
+        raise HTTPException(
+            status_code=402,
+            detail={
+                "error": {
+                    "message": f"failed to revert request payment: {cost_per_request} mSats required. {key.balance} available.",
+                    "type": "payment_error",
+                    "code": "payment_error",
+                }
+            },
+        )
+    await session.refresh(key)
+
+
+async def adjust_payment_for_tokens(
+    key: TemporaryCredit,
+    response_data: dict,
+    session: AsyncSession,
+    deducted_max_cost: int,
+) -> dict:
+    """
+    Adjusts the payment based on token usage in the response.
+    This is called after the initial payment and the upstream request is complete.
+    Returns cost data to be included in the response.
+    """
+    model = response_data.get("model", "unknown")
+
+    logger.debug(
+        "Starting payment adjustment for tokens",
+        extra={
+            "key_hash": key.hashed_key[:8] + "...",
+            "model": model,
+            "deducted_max_cost": deducted_max_cost,
+            "current_balance": key.balance,
+            "has_usage": "usage" in response_data,
+        },
+    )
+
+    match calculate_cost(response_data, deducted_max_cost):
+        case MaxCostData() as cost:
+            logger.debug(
+                "Using max cost data (no token adjustment)",
+                extra={
+                    "key_hash": key.hashed_key[:8] + "...",
+                    "model": model,
+                    "max_cost": cost.total_msats,
+                },
+            )
+            # Finalize by releasing reservation and charging max cost
+            finalize_stmt = (
+                update(TemporaryCredit)
+                .where(col(TemporaryCredit.hashed_key) == key.hashed_key)
+                .values(
+                    reserved_balance=col(TemporaryCredit.reserved_balance)
+                    - deducted_max_cost,
+                    balance=col(TemporaryCredit.balance) - cost.total_msats,
+                )
+            )
+            result = await session.exec(finalize_stmt)  # type: ignore[call-overload]
+            await session.commit()
+            if result.rowcount == 0:
+                logger.error(
+                    "Failed to finalize max-cost payment - insufficient reserved balance",
+                    extra={
+                        "key_hash": key.hashed_key[:8] + "...",
+                        "deducted_max_cost": deducted_max_cost,
+                        "current_reserved_balance": key.reserved_balance,
+                        "total_cost": cost.total_msats,
+                        "model": model,
+                    },
+                )
+            else:
+                await session.refresh(key)
+                logger.info(
+                    "Max cost payment finalized",
+                    extra={
+                        "key_hash": key.hashed_key[:8] + "...",
+                        "charged_amount": cost.total_msats,
+                        "new_balance": key.balance,
+                        "model": model,
+                    },
+                )
+            return cost.dict()
+
+        case CostData() as cost:
+            # If token-based pricing is enabled and base cost is 0, use token-based cost
+            # Otherwise, token cost is additional to the base cost
+            cost_difference = cost.total_msats - deducted_max_cost
+            total_cost_msats: int = math.ceil(cost.total_msats)
+
+            logger.info(
+                "Calculated token-based cost",
+                extra={
+                    "key_hash": key.hashed_key[:8] + "...",
+                    "model": model,
+                    "token_cost": cost.total_msats,
+                    "deducted_max_cost": deducted_max_cost,
+                    "cost_difference": cost_difference,
+                    "input_msats": cost.input_msats,
+                    "output_msats": cost.output_msats,
+                },
+            )
+
+            if cost_difference == 0:
+                logger.debug(
+                    "Finalizing with exact reserved cost",
+                    extra={"key_hash": key.hashed_key[:8] + "...", "model": model},
+                )
+                finalize_stmt = (
+                    update(TemporaryCredit)
+                    .where(col(TemporaryCredit.hashed_key) == key.hashed_key)
+                    .values(
+                        reserved_balance=col(TemporaryCredit.reserved_balance)
+                        - deducted_max_cost,
+                        balance=col(TemporaryCredit.balance) - total_cost_msats,
+                    )
+                )
+                await session.exec(finalize_stmt)  # type: ignore[call-overload]
+                await session.commit()
+                await session.refresh(key)
+                return cost.dict()
+
+            # this should never happen why do we handle this???
+            if cost_difference > 0:
+                # Need to charge more than reserved, finalize by releasing reservation and charging total
+                logger.info(
+                    "Additional charge required for token usage",
+                    extra={
+                        "key_hash": key.hashed_key[:8] + "...",
+                        "additional_charge": cost_difference,
+                        "current_balance": key.balance,
+                        "sufficient_balance": key.balance >= cost_difference,
+                        "model": model,
+                    },
+                )
+
+                finalize_stmt = (
+                    update(TemporaryCredit)
+                    .where(col(TemporaryCredit.hashed_key) == key.hashed_key)
+                    .values(
+                        reserved_balance=col(TemporaryCredit.reserved_balance)
+                        - deducted_max_cost,
+                        balance=col(TemporaryCredit.balance) - total_cost_msats,
+                    )
+                )
+                result = await session.exec(finalize_stmt)  # type: ignore[call-overload]
+                await session.commit()
+
+                if result.rowcount:
+                    cost.total_msats = total_cost_msats
+                    await session.refresh(key)
+
+                    logger.info(
+                        "Finalized payment with additional charge",
+                        extra={
+                            "key_hash": key.hashed_key[:8] + "...",
+                            "charged_amount": total_cost_msats,
+                            "new_balance": key.balance,
+                            "model": model,
+                        },
+                    )
+                else:
+                    logger.warning(
+                        "Failed to finalize additional charge (concurrent operation)",
+                        extra={
+                            "key_hash": key.hashed_key[:8] + "...",
+                            "attempted_charge": total_cost_msats,
+                            "model": model,
+                        },
+                    )
+            else:
+                # Refund some of the base cost
+                refund = abs(cost_difference)
+                logger.info(
+                    "Refunding excess payment",
+                    extra={
+                        "key_hash": key.hashed_key[:8] + "...",
+                        "refund_amount": refund,
+                        "current_balance": key.balance,
+                        "model": model,
+                    },
+                )
+
+                refund_stmt = (
+                    update(TemporaryCredit)
+                    .where(col(TemporaryCredit.hashed_key) == key.hashed_key)
+                    .values(
+                        reserved_balance=col(TemporaryCredit.reserved_balance)
+                        - deducted_max_cost,
+                        balance=col(TemporaryCredit.balance) - total_cost_msats,
+                    )
+                )
+                result = await session.exec(refund_stmt)  # type: ignore[call-overload]
+                await session.commit()
+
+                if result.rowcount == 0:
+                    logger.error(
+                        "Failed to finalize payment - insufficient reserved balance",
+                        extra={
+                            "key_hash": key.hashed_key[:8] + "...",
+                            "deducted_max_cost": deducted_max_cost,
+                            "current_reserved_balance": key.reserved_balance,
+                            "total_cost": total_cost_msats,
+                            "model": model,
+                        },
+                    )
+                    # Still return the cost data even if we couldn't properly finalize
+                    # The reservation was already made, so the user has paid
+
+                cost.total_msats = total_cost_msats
+                await session.refresh(key)
+
+                logger.info(
+                    "Refund processed successfully",
+                    extra={
+                        "key_hash": key.hashed_key[:8] + "...",
+                        "refunded_amount": refund,
+                        "new_balance": key.balance,
+                        "final_cost": cost.total_msats,
+                        "model": model,
+                    },
+                )
+
+            return cost.dict()
+
+        case CostDataError() as error:
+            logger.error(
+                "Cost calculation error during payment adjustment",
+                extra={
+                    "key_hash": key.hashed_key[:8] + "...",
+                    "model": model,
+                    "error_message": error.message,
+                    "error_code": error.code,
+                },
+            )
+
+            raise HTTPException(
+                status_code=400,
+                detail={
+                    "error": {
+                        "message": error.message,
+                        "type": "invalid_request_error",
+                        "code": error.code,
+                    }
+                },
+            )
+    # Fallback return to satisfy type checker; execution should not reach here
+    return {
+        "base_msats": deducted_max_cost,
+        "input_msats": 0,
+        "output_msats": 0,
+        "total_msats": deducted_max_cost,
+    }

routstr/payment/lnurl.py

@@ -305,3 +305,12 @@ async def raw_send_to_lnurl(
         quote_id=melt_quote_resp.quote,
     )
     return final_amount
+
+
+async def send_to_lnurl(amount: int, unit: str, mint: str, address: str) -> int:
+    from .wallet import get_wallet
+
+    wallet = await get_wallet(mint, unit)
+    proofs = wallet._get_proofs_per_keyset(wallet.proofs)[wallet.keyset_id]
+    proofs, _ = await wallet.select_to_send(proofs, amount, set_reserved=True)
+    return await raw_send_to_lnurl(wallet, proofs, address, unit)

routstr/payment/models.py

@@ -1,722 +0,0 @@
-import asyncio
-import json
-import random
-from pathlib import Path
-from urllib.request import urlopen
-
-import httpx
-from fastapi import APIRouter, Depends
-from pydantic.v1 import BaseModel
-from sqlmodel import select
-from sqlmodel.ext.asyncio.session import AsyncSession
-
-from ..core.db import ModelRow, create_session, get_session
-from ..core.logging import get_logger
-from ..core.settings import settings
-from .price import sats_usd_price
-
-logger = get_logger(__name__)
-
-models_router = APIRouter()
-
-
-class Architecture(BaseModel):
-    modality: str
-    input_modalities: list[str]
-    output_modalities: list[str]
-    tokenizer: str
-    instruct_type: str | None
-
-
-class Pricing(BaseModel):
-    prompt: float
-    completion: float
-    request: float
-    image: float
-    web_search: float
-    internal_reasoning: float
-    max_prompt_cost: float = 0.0  # in sats not msats
-    max_completion_cost: float = 0.0  # in sats not msats
-    max_cost: float = 0.0  # in sats not msats
-
-
-class TopProvider(BaseModel):
-    context_length: int | None = None
-    max_completion_tokens: int | None = None
-    is_moderated: bool | None = None
-
-
-class Model(BaseModel):
-    id: str
-    name: str
-    created: int
-    description: str
-    context_length: int
-    architecture: Architecture
-    pricing: Pricing
-    sats_pricing: Pricing | None = None
-    per_request_limits: dict | None = None
-    top_provider: TopProvider | None = None
-    enabled: bool = True
-    upstream_provider_id: int | None = None
-    canonical_slug: str | None = None
-    alias_ids: list[str] | None = None
-
-    def __hash__(self) -> int:
-        return hash(self.id)
-
-
-def fetch_openrouter_models(source_filter: str | None = None) -> list[dict]:
-    """Fetches model information from OpenRouter API."""
-    base_url = "https://openrouter.ai/api/v1"
-
-    try:
-        with urlopen(f"{base_url}/models") as response:
-            data = json.loads(response.read().decode("utf-8"))
-
-            models_data: list[dict] = []
-            for model in data.get("data", []):
-                model_id = model.get("id", "")
-
-                if source_filter:
-                    source_prefix = f"{source_filter}/"
-                    if not model_id.startswith(source_prefix):
-                        continue
-
-                    model = dict(model)
-                    model["id"] = model_id[len(source_prefix) :]
-                    model_id = model["id"]
-
-                if (
-                    "(free)" in model.get("name", "")
-                    or model_id == "openrouter/auto"
-                    or model_id == "google/gemini-2.5-pro-exp-03-25"
-                    or model_id == "opengvlab/internvl3-78b"
-                    or model_id == "openrouter/sonoma-dusk-alpha"
-                    or model_id == "openrouter/sonoma-sky-alpha"
-                ):
-                    continue
-
-                models_data.append(model)
-
-            return models_data
-    except Exception as e:
-        logger.error(f"Error fetching models from OpenRouter API: {e}")
-        return []
-
-
-async def async_fetch_openrouter_models(source_filter: str | None = None) -> list[dict]:
-    """Asynchronously fetch model information from OpenRouter API."""
-    base_url = "https://openrouter.ai/api/v1"
-
-    try:
-        async with httpx.AsyncClient() as client:
-            response = await client.get(f"{base_url}/models", timeout=30)
-            response.raise_for_status()
-            data = response.json()
-
-            models_data: list[dict] = []
-            for model in data.get("data", []):
-                model_id = model.get("id", "")
-
-                if source_filter:
-                    source_prefix = f"{source_filter}/"
-                    if not model_id.startswith(source_prefix):
-                        continue
-
-                    model = dict(model)
-                    model["id"] = model_id[len(source_prefix) :]
-                    model_id = model["id"]
-
-                if (
-                    "(free)" in model.get("name", "")
-                    or model_id == "openrouter/auto"
-                    or model_id == "google/gemini-2.5-pro-exp-03-25"
-                    or model_id == "opengvlab/internvl3-78b"
-                    or model_id == "openrouter/sonoma-dusk-alpha"
-                    or model_id == "openrouter/sonoma-sky-alpha"
-                ):
-                    continue
-
-                models_data.append(model)
-
-            return models_data
-    except Exception as e:
-        logger.error(f"Error (async) fetching models from OpenRouter API: {e}")
-        return []
-
-
-def is_openrouter_upstream() -> bool:
-    try:
-        base = (settings.upstream_base_url or "").strip().rstrip("/")
-    except Exception:
-        return False
-    return base.lower() == "https://openrouter.ai/api/v1"
-
-
-def load_models() -> list[Model]:
-    """Load model definitions from a JSON file or auto-generate from OpenRouter API.
-
-    The file path can be specified via the ``MODELS_PATH`` environment variable.
-    If a user-provided models.json exists, it will be used. Otherwise, models are
-    automatically fetched from OpenRouter API in memory. If the example file exists
-    and no user file is provided, it will be used as a fallback.
-    """
-
-    try:
-        models_path = Path(settings.models_path)
-    except Exception:
-        models_path = Path("models.json")
-
-    # Check if user has actively provided a models.json file
-    if models_path.exists():
-        logger.info(f"Loading models from user-provided file: {models_path}")
-        try:
-            with models_path.open("r") as f:
-                data = json.load(f)
-            return [Model(**model) for model in data.get("models", [])]  # type: ignore
-        except Exception as e:
-            logger.error(f"Error loading models from {models_path}: {e}")
-            # Fall through to auto-generation
-
-    # Only auto-generate from OpenRouter when upstream is OpenRouter
-    if not is_openrouter_upstream():
-        logger.info(
-            "Skipping auto-generation from OpenRouter because upstream_base_url is not https://openrouter.ai/api/v1"
-        )
-        return []
-
-    logger.info("Auto-generating models from OpenRouter API")
-    try:
-        source_filter = settings.source or None
-    except Exception:
-        source_filter = None
-    source_filter = source_filter if source_filter and source_filter.strip() else None
-
-    models_data = fetch_openrouter_models(source_filter=source_filter)
-    if not models_data:
-        logger.error("Failed to fetch models from OpenRouter API")
-        return []
-
-    logger.info(f"Successfully fetched {len(models_data)} models from OpenRouter API")
-    return [Model(**model) for model in models_data]  # type: ignore
-
-
-def _row_to_model(
-    row: ModelRow, apply_provider_fee: bool = False, provider_fee: float = 1.01
-) -> Model:
-    architecture = json.loads(row.architecture)
-    pricing = json.loads(row.pricing)
-    per_request_limits = (
-        json.loads(row.per_request_limits) if row.per_request_limits else None
-    )
-    top_provider_dict = json.loads(row.top_provider) if row.top_provider else None
-
-    if apply_provider_fee and isinstance(pricing, dict):
-        pricing = {k: float(v) * provider_fee for k, v in pricing.items()}
-
-    if isinstance(pricing, dict) and float(pricing.get("request", 0.0)) <= 0.0:
-        pricing["request"] = max(pricing.get("request", 0.0), 0.0)
-
-    parsed_pricing = Pricing.parse_obj(pricing)
-    model = Model(
-        id=row.id,
-        name=row.name,
-        created=row.created,
-        description=row.description,
-        context_length=row.context_length,
-        architecture=Architecture.parse_obj(architecture),
-        pricing=parsed_pricing,
-        sats_pricing=None,
-        per_request_limits=per_request_limits,
-        top_provider=TopProvider.parse_obj(top_provider_dict)
-        if top_provider_dict
-        else None,
-        enabled=row.enabled,
-        upstream_provider_id=row.upstream_provider_id,
-        canonical_slug=getattr(row, "canonical_slug", None),
-    )
-
-    if apply_provider_fee:
-        (
-            parsed_pricing.max_prompt_cost,
-            parsed_pricing.max_completion_cost,
-            parsed_pricing.max_cost,
-        ) = _calculate_usd_max_costs(model)
-
-    try:
-        sats_to_usd = sats_usd_price()
-        model = _update_model_sats_pricing(model, sats_to_usd)
-    except Exception as e:
-        logger.warning(f"Could not calculate sats pricing: {e}")
-
-    return model
-
-
-def _model_to_row_payload(model: Model) -> dict[str, str | int | bool | None]:
-    return {
-        "id": model.id,
-        "name": model.name,
-        "created": model.created,
-        "description": model.description,
-        "context_length": model.context_length,
-        "architecture": json.dumps(model.architecture.dict()),
-        "pricing": json.dumps(model.pricing.dict()),
-        "sats_pricing": json.dumps(model.sats_pricing.dict())
-        if model.sats_pricing
-        else None,
-        "per_request_limits": json.dumps(model.per_request_limits)
-        if model.per_request_limits is not None
-        else None,
-        "top_provider": json.dumps(model.top_provider.dict())
-        if model.top_provider is not None
-        else None,
-        "enabled": model.enabled,
-        "upstream_provider_id": model.upstream_provider_id,
-    }
-
-
-async def list_models(
-    session: AsyncSession,
-    upstream_id: int,
-    include_disabled: bool = False,
-) -> list[Model]:
-    from sqlmodel import select
-
-    from ..core.db import UpstreamProviderRow
-
-    query = select(ModelRow)
-    if upstream_id is not None:
-        query = query.where(ModelRow.upstream_provider_id == upstream_id)
-    if not include_disabled:
-        query = query.where(ModelRow.enabled)
-
-    rows = (await session.exec(query)).all()  # type: ignore
-    provider_result = await session.exec(select(UpstreamProviderRow))
-    providers_by_id = {p.id: p for p in provider_result.all()}
-    return [
-        _row_to_model(
-            r,
-            apply_provider_fee=True,
-            provider_fee=providers_by_id[r.upstream_provider_id].provider_fee
-            if r.upstream_provider_id in providers_by_id
-            else 1.01,
-        )
-        for r in rows
-    ]
-
-
-async def get_model_by_id(
-    model_id: str, provider_id: int, session: AsyncSession
-) -> Model | None:
-    from ..core.db import UpstreamProviderRow
-
-    row = await session.get(ModelRow, (model_id, provider_id))
-    if not row or not row.enabled:
-        return None
-    provider = await session.get(UpstreamProviderRow, provider_id)
-    provider_fee = provider.provider_fee if provider else 1.01
-    return _row_to_model(row, apply_provider_fee=True, provider_fee=provider_fee)
-
-
-def _calculate_usd_max_costs(model: Model) -> tuple[float, float, float]:
-    """Calculate max costs in USD based on model context/token limits.
-
-    Args:
-        model: Model object
-
-    Returns:
-        Tuple of (max_prompt_cost, max_completion_cost, max_cost) in USD
-    """
-    min_req_msat = max(1, int(getattr(settings, "min_request_msat", 1)))
-    min_req_usd = float(min_req_msat) / 1_000_000.0
-
-    prompt_price = model.pricing.prompt
-    completion_price = model.pricing.completion
-
-    if model.top_provider and (
-        model.top_provider.context_length or model.top_provider.max_completion_tokens
-    ):
-        if (cl := model.top_provider.context_length) and (
-            mct := model.top_provider.max_completion_tokens
-        ):
-            if cl <= mct:
-                return (
-                    cl * prompt_price,
-                    cl * completion_price,
-                    cl * max(completion_price, prompt_price),
-                )
-            return (
-                cl * prompt_price,
-                mct * completion_price,
-                (cl - mct) * prompt_price + mct * completion_price,
-            )
-        elif cl := model.top_provider.context_length:
-            return (
-                cl * prompt_price,
-                cl * completion_price,
-                cl * max(completion_price, prompt_price),
-            )
-        elif mct := model.top_provider.max_completion_tokens:
-            return (
-                mct * prompt_price,
-                mct * completion_price,
-                mct * completion_price,
-            )
-    elif model.context_length:
-        return (
-            model.context_length * prompt_price,
-            model.context_length * completion_price,
-            model.context_length * max(completion_price, prompt_price),
-        )
-
-    p = prompt_price * 1_000_000
-    c = completion_price * 32_000
-    r = model.pricing.request * 100_000
-    i = model.pricing.image * 100
-    w = model.pricing.web_search * 1000
-    ir = model.pricing.internal_reasoning * 100
-    return (p, c, max(p + c + r + i + w + ir, min_req_usd))
-
-
-def _update_model_sats_pricing(model: Model, sats_to_usd: float) -> Model:
-    """Update a model's sats_pricing based on USD pricing and exchange rate.
-
-    Args:
-        model: Model object to update
-        sats_to_usd: Current sats to USD exchange rate
-
-    Returns:
-        Updated Model object with new sats_pricing
-    """
-    try:
-        min_req_msat = max(1, int(getattr(settings, "min_request_msat", 1)))
-        min_req_sats = float(min_req_msat) / 1000.0
-
-        sats = Pricing.parse_obj(
-            {k: v / sats_to_usd for k, v in model.pricing.dict().items()}
-        )
-
-        if sats.request <= 0.0:
-            sats.request = min_req_sats
-        if (sats.max_cost or 0.0) < min_req_sats:
-            sats.max_cost = min_req_sats
-
-        return Model(
-            id=model.id,
-            name=model.name,
-            created=model.created,
-            description=model.description,
-            context_length=model.context_length,
-            architecture=model.architecture,
-            pricing=model.pricing,
-            sats_pricing=sats,
-            per_request_limits=model.per_request_limits,
-            top_provider=model.top_provider,
-            enabled=model.enabled,
-            upstream_provider_id=model.upstream_provider_id,
-            canonical_slug=model.canonical_slug,
-            alias_ids=model.alias_ids,
-        )
-    except Exception as e:
-        logger.error(
-            "Failed to update sats pricing for model",
-            extra={
-                "model_id": model.id,
-                "error": str(e),
-                "error_type": type(e).__name__,
-            },
-        )
-        return model
-
-
-async def ensure_models_bootstrapped() -> None:
-    async with create_session() as s:
-        existing = (await s.exec(select(ModelRow.id).limit(1))).all()  # type: ignore
-        if existing:
-            return
-
-        try:
-            models_path = Path(settings.models_path)
-        except Exception:
-            models_path = Path("models.json")
-
-        models_to_insert: list[dict] = []
-        if models_path.exists():
-            try:
-                with models_path.open("r") as f:
-                    data = json.load(f)
-                models_to_insert = data.get("models", [])
-                logger.info(
-                    f"Bootstrapping {len(models_to_insert)} models from {models_path}"
-                )
-            except Exception as e:
-                logger.error(f"Error loading models from {models_path}: {e}")
-
-        if not models_to_insert and is_openrouter_upstream():
-            logger.info("Bootstrapping models from OpenRouter API")
-            source_filter = None
-            try:
-                src = settings.source or None
-                source_filter = src if src and src.strip() else None
-            except Exception:
-                pass
-            models_to_insert = fetch_openrouter_models(source_filter=source_filter)
-        elif not models_to_insert:
-            logger.info(
-                "No models.json found and upstream is not OpenRouter; skipping bootstrap"
-            )
-
-        for m in models_to_insert:
-            try:
-                model = Model(**m)  # type: ignore
-            except Exception:
-                # Some OpenRouter models include extra fields; only map required ones
-                continue
-            exists = await s.get(ModelRow, model.id)
-            if exists:
-                continue
-            payload = _model_to_row_payload(model)
-            s.add(ModelRow(**payload))  # type: ignore
-        await s.commit()
-
-
-async def _update_sats_pricing_once() -> None:
-    """Update sats pricing once for all provider models (in-memory only)."""
-    from ..proxy import get_upstreams
-
-    upstreams = get_upstreams()
-    sats_to_usd = sats_usd_price()
-
-    updated_count = 0
-    for upstream in upstreams:
-        updated_models = [
-            _update_model_sats_pricing(m, sats_to_usd)
-            for m in upstream.get_cached_models()
-        ]
-        upstream._models_cache = updated_models
-        upstream._models_by_id = {m.id: m for m in updated_models}
-        updated_count += len(updated_models)
-
-    if updated_count > 0:
-        logger.info("Updated sats pricing", extra={"models_updated": updated_count})
-
-
-async def update_sats_pricing() -> None:
-    """Periodically update sats pricing for all provider models and database overrides."""
-    try:
-        if not settings.enable_pricing_refresh:
-            return
-    except Exception:
-        pass
-
-    await _update_sats_pricing_once()
-
-    while True:
-        try:
-            interval = getattr(settings, "pricing_refresh_interval_seconds", 120)
-            jitter = max(0.0, float(interval) * 0.1)
-            await asyncio.sleep(interval + random.uniform(0, jitter))
-        except asyncio.CancelledError:
-            break
-
-        try:
-            try:
-                if not settings.enable_pricing_refresh:
-                    return
-            except Exception:
-                pass
-
-            await _update_sats_pricing_once()
-        except asyncio.CancelledError:
-            break
-        except Exception as e:
-            logger.error(f"Error updating sats pricing: {e}")
-
-
-async def cleanup_enabled_models_periodically() -> None:
-    """Background task to clean up enabled models that match upstream pricing.
-
-    When model is enabled (enabled=True), remove it from DB if it matches upstream pricing.
-    Keep it in DB only if pricing differs from upstream or if it's disabled.
-    """
-    interval = getattr(
-        settings, "models_cleanup_interval_seconds", 300
-    )  # 5 minutes default
-    if not interval or interval <= 0:
-        return
-
-    while True:
-        try:
-            await _cleanup_enabled_models_once()
-        except asyncio.CancelledError:
-            break
-        except Exception as e:
-            logger.error(
-                "Error during enabled models cleanup",
-                extra={"error": str(e), "error_type": type(e).__name__},
-            )
-
-        try:
-            jitter = max(0.0, float(interval) * 0.1)
-            await asyncio.sleep(interval + random.uniform(0, jitter))
-        except asyncio.CancelledError:
-            break
-
-
-async def _cleanup_enabled_models_once() -> None:
-    """Clean up enabled models that match upstream pricing."""
-    from ..proxy import get_upstreams
-
-    async with create_session() as session:
-        # Get all enabled models from DB
-        result = await session.exec(
-            select(ModelRow).where(
-                ModelRow.enabled,  # Only enabled models
-            )
-        )
-        db_models = result.all()
-
-        if not db_models:
-            return
-
-        upstreams = get_upstreams()
-        models_to_remove = []
-
-        for db_model in db_models:
-            # Find corresponding upstream model
-            upstream_model = None
-            for upstream in upstreams:
-                upstream_model = upstream.get_cached_model_by_id(db_model.id)
-                if upstream_model:
-                    break
-
-            if not upstream_model:
-                continue
-
-            # Compare pricing to see if they match
-            db_pricing = json.loads(db_model.pricing)
-            upstream_pricing = upstream_model.pricing.dict()
-
-            # Check if pricing matches (with small tolerance for float comparison)
-            pricing_matches = _pricing_matches(db_pricing, upstream_pricing)
-
-            if pricing_matches:
-                models_to_remove.append(db_model)
-                logger.info(
-                    f"Removing enabled model {db_model.id} - matches upstream pricing",
-                    extra={"model_id": db_model.id},
-                )
-
-        # Remove models that match upstream pricing
-        for model in models_to_remove:
-            await session.delete(model)
-
-        if models_to_remove:
-            await session.commit()
-            logger.info(
-                f"Cleaned up {len(models_to_remove)} enabled models that match upstream pricing"
-            )
-
-
-def _pricing_matches(
-    db_pricing: dict, upstream_pricing: dict, tolerance: float = 0.0
-) -> bool:
-    """Check if pricing dictionaries match within tolerance."""
-    keys_to_compare = [
-        "prompt",
-        "completion",
-        "request",
-        "image",
-        "web_search",
-        "internal_reasoning",
-    ]
-
-    for key in keys_to_compare:
-        db_val = int(float(db_pricing.get(key, 0.0)) * 1000000)
-        upstream_val = int(float(upstream_pricing.get(key, 0.0)) * 1000000)
-
-        if abs(db_val - upstream_val) > tolerance:
-            return False
-
-    return True
-
-
-async def refresh_models_periodically() -> None:
-    """Background task: periodically fetch OpenRouter models and insert new ones.
-
-    - Respects optional SOURCE filter from settings
-    - Does not overwrite existing rows
-    - Sleeps according to settings.models_refresh_interval_seconds; disabled when 0
-    """
-    interval = getattr(settings, "models_refresh_interval_seconds", 0)
-    if not interval or interval <= 0:
-        return
-
-    # Only refresh from OpenRouter when upstream is OpenRouter
-    if not is_openrouter_upstream():
-        logger.info("Skipping models refresh: upstream_base_url is not OpenRouter")
-        return
-
-    while True:
-        try:
-            try:
-                if not settings.enable_models_refresh:
-                    return
-            except Exception:
-                pass
-            try:
-                src = settings.source or None
-                source_filter = src if src and src.strip() else None
-            except Exception:
-                source_filter = None
-
-            models = fetch_openrouter_models(source_filter=source_filter)
-            if not models:
-                await asyncio.sleep(interval)
-                continue
-
-            async with create_session() as s:
-                result = await s.exec(select(ModelRow.id))  # type: ignore
-                existing_ids = {
-                    row[0] if isinstance(row, tuple) else row for row in result.all()
-                }
-                inserted = 0
-                for m in models:
-                    try:
-                        model = Model(**m)  # type: ignore
-                    except Exception:
-                        continue
-                    if model.id in existing_ids:
-                        continue
-                    payload = _model_to_row_payload(model)
-                    try:
-                        s.add(ModelRow(**payload))  # type: ignore
-                    except Exception:
-                        pass
-                    inserted += 1
-                if inserted:
-                    await s.commit()
-                    logger.info(f"Inserted {inserted} new models from OpenRouter")
-        except asyncio.CancelledError:
-            break
-        except Exception as e:
-            logger.error(
-                "Error during models refresh",
-                extra={"error": str(e), "error_type": type(e).__name__},
-            )
-        try:
-            jitter = max(0.0, float(interval) * 0.1)
-            await asyncio.sleep(interval + random.uniform(0, jitter))
-        except asyncio.CancelledError:
-            break
-
-
-@models_router.get("/v1/models")
-@models_router.get("/models", include_in_schema=False)
-async def models(session: AsyncSession = Depends(get_session)) -> dict:
-    """Get all available models from all providers with database overrides applied."""
-    from ..proxy import get_unique_models
-
-    items = get_unique_models()
-    return {"data": items}

routstr/payment/wallet.py

@@ -7,9 +7,9 @@ from cashu.wallet.helpers import deserialize_token_from_string
 from cashu.wallet.wallet import Wallet
 from sqlmodel import col, update
 
-from .core import db, get_logger
-from .core.settings import settings
-from .payment.lnurl import raw_send_to_lnurl
+from ..core import db, get_logger
+from ..core.settings import settings
+from ..payment.lnurl import raw_send_to_lnurl
 
 logger = get_logger(__name__)
 
@@ -19,9 +19,7 @@ async def get_balance(unit: str) -> int:
     return wallet.available_balance.amount
 
 
-async def recieve_token(
-    token: str,
-) -> tuple[int, str, str]:  # amount, unit, mint_url
+async def recieve_token(token: str) -> tuple[int, str, str]:  # amount, unit, mint_url
     token_obj = deserialize_token_from_string(token)
     if len(token_obj.keysets) > 1:
         raise ValueError("Multiple keysets per token currently not supported")
@@ -104,7 +102,7 @@ async def swap_to_primary_mint(
 
 
 async def credit_balance(
-    cashu_token: str, key: db.ApiKey, session: db.AsyncSession
+    cashu_token: str, credit: db.TemporaryCredit, session: db.AsyncSession
 ) -> int:
     logger.info(
         "credit_balance: Starting token redemption",
@@ -126,22 +124,22 @@ async def credit_balance(
 
         logger.info(
             "credit_balance: Updating balance",
-            extra={"old_balance": key.balance, "credit_amount": amount},
+            extra={"old_balance": credit.balance, "credit_amount": amount},
         )
 
         # Use atomic SQL UPDATE to prevent race conditions during concurrent topups
         stmt = (
-            update(db.ApiKey)
-            .where(col(db.ApiKey.hashed_key) == key.hashed_key)
-            .values(balance=(db.ApiKey.balance) + amount)
+            update(db.TemporaryCredit)
+            .where(col(db.TemporaryCredit.hashed_key) == credit.hashed_key)
+            .values(balance=(db.TemporaryCredit.balance) + amount)
         )
         await session.exec(stmt)  # type: ignore[call-overload]
         await session.commit()
-        await session.refresh(key)
+        await session.refresh(credit)
 
         logger.info(
             "credit_balance: Balance updated successfully",
-            extra={"new_balance": key.balance},
+            extra={"new_balance": credit.balance},
         )
 
         logger.info(
@@ -351,34 +349,3 @@ async def periodic_payout() -> None:
                 f"Error sending payout: {type(e).__name__}",
                 extra={"error": str(e)},
             )
-
-
-async def send_to_lnurl(amount: int, unit: str, mint: str, address: str) -> int:
-    wallet = await get_wallet(mint, unit)
-    proofs = wallet._get_proofs_per_keyset(wallet.proofs)[wallet.keyset_id]
-    proofs, _ = await wallet.select_to_send(proofs, amount, set_reserved=True)
-    return await raw_send_to_lnurl(wallet, proofs, address, unit)
-
-
-# class Payment:
-#     """
-#     Stores all cashu payment related data
-#     """
-
-#     def __init__(self, token: str) -> None:
-#         self.initial_token = token
-#         amount, unit, mint_url = self.parse_token(token)
-#         self.amount = amount
-#         self.unit = unit
-#         self.mint_url = mint_url
-
-#         self.claimed_proofs = redeem_to_proofs(token)
-
-#     def parse_token(self, token: str) -> tuple[int, CurrencyUnit, str]:
-#         raise NotImplementedError
-
-#     def refund_full(self) -> None:
-#         raise NotImplementedError
-
-#     def refund_partial(self, amount: int) -> None:
-#         raise NotImplementedError

routstr/proxy.py

@@ -5,24 +5,20 @@ from fastapi import APIRouter, Depends, HTTPException, Request
 from fastapi.responses import Response, StreamingResponse
 from sqlmodel import select
 
-from .algorithm import create_model_mappings
-from .auth import pay_for_request, revert_pay_for_request, validate_bearer_key
+from .auth import get_credit
 from .core import get_logger
 from .core.db import (
-    ApiKey,
     AsyncSession,
     ModelRow,
     UpstreamProviderRow,
     create_session,
     get_session,
 )
-from .payment.helpers import (
-    calculate_discounted_max_cost,
-    check_token_balance,
-    create_error_response,
-    get_max_cost_for_model,
-)
-from .payment.models import Model
+from .models.algorithm import create_model_mappings
+from .models.models import Model
+from .payment.cashu import pre_check_header_token_balance
+from .payment.cost import calculate_discounted_max_cost, get_max_cost_for_model
+from .payment.helpers import pay_for_request, revert_pay_for_request
 from .upstream import BaseUpstreamProvider
 from .upstream.helpers import init_upstreams
 
@@ -130,18 +126,21 @@ async def refresh_model_maps_periodically() -> None:
             )
 
 
-@proxy_router.api_route("/{path:path}", methods=["GET", "POST"], response_model=None)
-async def proxy(
-    request: Request, path: str, session: AsyncSession = Depends(get_session)
-) -> Response | StreamingResponse:
+async def parse_request(request: Request) -> tuple[dict, dict, bytes]:
     headers = dict(request.headers)
+    body_bytes = await request.body()
+    body_dict = parse_request_body_json(body_bytes)
+    return headers, body_dict, body_bytes
 
+
+def ensure_authorization(headers: dict) -> None:
     if "x-cashu" not in headers and "authorization" not in headers.keys():
-        return create_error_response(
-            "unauthorized", "Unauthorized", 401, request=request
-        )
+        # return create_error_response("unauthorized", "Unauthorized", 401, request=request)
+        raise HTTPException(status_code=401, detail="Unauthorized")
 
-    logger.info(  # TODO: move to middleware, async
+
+def log_request(request: Request, path: str) -> None:
+    logger.info(
         "Received proxy request",
         extra={
             "method": request.method,
@@ -151,58 +150,49 @@ async def proxy(
         },
     )
 
-    request_body = await request.body()
-    request_body_dict = parse_request_body_json(request_body, path)
 
-    model_id = request_body_dict.get("model", "unknown")
+def get_model_and_upstream(request_body: dict) -> tuple[Model, BaseUpstreamProvider]:
+    model_id = request_body.get("model", "unknown")
 
-    model_obj = get_model_instance(model_id)
-    if not model_obj:
-        return create_error_response(
-            "invalid_model", f"Model '{model_id}' not found", 400, request=request
-        )
+    if not (model := get_model_instance(model_id)):
+        raise HTTPException(status_code=400, detail=f"Model '{model_id}' not found")
 
-    upstream = get_provider_for_model(model_id)
-    if not upstream:
-        return create_error_response(
-            "invalid_model",
-            f"No provider found for model '{model_id}'",
-            400,
-            request=request,
-        )
+    if not (upstream := get_provider_for_model(model_id)):
+        raise HTTPException(status_code=400, detail=f"No provider with '{model_id}'")
 
-    _max_cost_for_model = await get_max_cost_for_model(
-        model=model_id, session=session, model_obj=model_obj
-    )
+    return model, upstream
+
+
+@proxy_router.api_route("/{path:path}", methods=["GET", "POST"], response_model=None)
+async def proxy(
+    request: Request,
+    path: str,
+    session: AsyncSession = Depends(get_session),
+) -> Response | StreamingResponse:
+    headers, body_dict, body_bytes = await parse_request(request)
+
+    ensure_authorization(headers)
+
+    log_request(request, path)
+
+    model, upstream = get_model_and_upstream(body_dict)
+
+    _max_cost_for_model = get_max_cost_for_model(model_obj=model)
     max_cost_for_model = await calculate_discounted_max_cost(
-        _max_cost_for_model, request_body_dict, model_obj=model_obj
+        _max_cost_for_model, body_dict, model_obj=model
     )
-    check_token_balance(headers, request_body_dict, max_cost_for_model)
+    pre_check_header_token_balance(headers, body_dict, max_cost_for_model)
 
     if x_cashu := headers.get("x-cashu", None):
         return await upstream.handle_x_cashu(
-            request, x_cashu, path, max_cost_for_model, model_obj
+            request, x_cashu, path, max_cost_for_model, model
         )
 
     elif auth := headers.get("authorization", None):
-        key = await get_bearer_token_key(headers, path, session, auth)
-
-    else:
-        if request.method not in ["GET"]:
-            raise HTTPException(
-                status_code=401,
-                detail={
-                    "error": {"type": "invalid_request_error", "code": "unauthorized"}
-                },
-            )
-
-        logger.debug("Processing unauthenticated GET request", extra={"path": path})
-        # TODO: why is this needed? can we remove it?
-        headers = upstream.prepare_headers(dict(request.headers))
-        return await upstream.forward_get_request(request, path, headers)
+        key = await get_credit(auth, session)
 
     # Only pay for request if we have request body data (for completions endpoints)
-    if request_body_dict:
+    if body_dict:
         await pay_for_request(key, max_cost_for_model, session)
 
     # Prepare headers for upstream
@@ -213,11 +203,11 @@ async def proxy(
         request,
         path,
         headers,
-        request_body,
+        body_bytes,
         key,
         max_cost_for_model,
         session,
-        model_obj,
+        model,
     )
 
     if response.status_code != 200:
@@ -241,87 +231,7 @@ async def proxy(
     return response
 
 
-async def get_bearer_token_key(
-    headers: dict, path: str, session: AsyncSession, auth: str
-) -> ApiKey:
-    """Handle bearer token authentication proxy requests."""
-    bearer_key = auth.replace("Bearer ", "") if auth.startswith("Bearer ") else ""
-    refund_address = headers.get("Refund-LNURL", None)
-    key_expiry_time = headers.get("Key-Expiry-Time", None)
-
-    logger.debug(
-        "Processing bearer token",
-        extra={
-            "path": path,
-            "has_refund_address": bool(refund_address),
-            "has_expiry_time": bool(key_expiry_time),
-            "bearer_key_preview": bearer_key[:20] + "..."
-            if len(bearer_key) > 20
-            else bearer_key,
-        },
-    )
-
-    # Validate key_expiry_time header
-    if key_expiry_time:
-        try:
-            key_expiry_time = int(key_expiry_time)  # type: ignore
-            logger.debug(
-                "Key expiry time validated",
-                extra={"expiry_time": key_expiry_time, "path": path},
-            )
-        except ValueError:
-            logger.error(
-                "Invalid Key-Expiry-Time header",
-                extra={"key_expiry_time": key_expiry_time, "path": path},
-            )
-            raise HTTPException(
-                status_code=400,
-                detail="Invalid Key-Expiry-Time: must be a valid Unix timestamp",
-            )
-        if not refund_address:
-            logger.error(
-                "Missing Refund-LNURL header with Key-Expiry-Time",
-                extra={"path": path, "expiry_time": key_expiry_time},
-            )
-            raise HTTPException(
-                status_code=400,
-                detail="Error: Refund-LNURL header required when using Key-Expiry-Time",
-            )
-    else:
-        key_expiry_time = None
-
-    try:
-        key = await validate_bearer_key(
-            bearer_key,
-            session,
-            refund_address,
-            key_expiry_time,  # type: ignore
-        )
-        logger.info(
-            "Bearer token validated successfully",
-            extra={
-                "path": path,
-                "key_hash": key.hashed_key[:8] + "...",
-                "key_balance": key.balance,
-            },
-        )
-        return key
-    except Exception as e:
-        logger.error(
-            "Bearer token validation failed",
-            extra={
-                "error": str(e),
-                "error_type": type(e).__name__,
-                "path": path,
-                "bearer_key_preview": bearer_key[:20] + "..."
-                if len(bearer_key) > 20
-                else bearer_key,
-            },
-        )
-        raise
-
-
-def parse_request_body_json(request_body: bytes, path: str) -> dict[str, Any]:
+def parse_request_body_json(request_body: bytes) -> dict[str, Any]:
     request_body_dict = {}
     if request_body:
         try:
@@ -341,7 +251,6 @@ def parse_request_body_json(request_body: bytes, path: str) -> dict[str, Any]:
             logger.debug(
                 "Request body parsed",
                 extra={
-                    "path": path,
                     "body_keys": list(request_body_dict.keys()),
                     "model": request_body_dict.get("model", "not_specified"),
                 },
@@ -351,7 +260,6 @@ def parse_request_body_json(request_body: bytes, path: str) -> dict[str, Any]:
                 "Invalid JSON in request body",
                 extra={
                     "error": str(e),
-                    "path": path,
                     "body_preview": request_body[:200].decode(errors="ignore")
                     if request_body
                     else "empty",

routstr/upstream/anthropic.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING
 
-from ..payment.models import Model, async_fetch_openrouter_models
+from ..models import Model, async_fetch_openrouter_models
 from .base import BaseUpstreamProvider
 
 if TYPE_CHECKING:

routstr/upstream/base.py

@@ -11,28 +11,23 @@ import httpx
 from fastapi import BackgroundTasks, HTTPException, Request
 from fastapi.responses import Response, StreamingResponse
 
-from ..auth import adjust_payment_for_tokens
 from ..core import get_logger
-from ..core.db import ApiKey, AsyncSession, create_session
+from ..core.db import AsyncSession, TemporaryCredit, create_session
+from ..payment.helpers import adjust_payment_for_tokens
 
 if TYPE_CHECKING:
     from ..core.db import UpstreamProviderRow
 
-from ..payment.cost_caculation import (
-    CostData,
-    CostDataError,
-    MaxCostData,
-    calculate_cost,
-)
-from ..payment.helpers import create_error_response
-from ..payment.models import (
+from ..models.models import (
     Model,
     Pricing,
-    _calculate_usd_max_costs,
     _update_model_sats_pricing,
+    calculate_usd_max_costs,
 )
+from ..payment.cost import CostData, CostDataError, MaxCostData, calculate_cost
+from ..payment.helpers import create_error_response
 from ..payment.price import sats_usd_price
-from ..wallet import recieve_token, send_token
+from ..payment.wallet import recieve_token, send_token
 
 logger = get_logger(__name__)
 
@@ -136,6 +131,13 @@ class BaseUpstreamProvider:
                 if headers.pop(auth_header, None) is not None:
                     removed_headers.append(auth_header)
 
+        for header in ["authorization", "accept-encoding"]:
+            if headers.pop(header, None) is not None:
+                removed_headers.append(f"{header} (replaced with routstr-safe version)")
+
+        # Explicitly define the list of supported compression encodings
+        headers["accept-encoding"] = "gzip, deflate, br, identity"
+
         logger.debug(
             "Headers prepared for upstream",
             extra={
@@ -330,7 +332,7 @@ class BaseUpstreamProvider:
         )
 
     async def handle_streaming_chat_completion(
-        self, response: httpx.Response, key: ApiKey, max_cost_for_model: int
+        self, response: httpx.Response, key: TemporaryCredit, max_cost_for_model: int
     ) -> StreamingResponse:
         """Handle streaming chat completion responses with token usage tracking and cost adjustment.
 
@@ -453,11 +455,12 @@ class BaseUpstreamProvider:
                                                 )
                                                 usage_finalized = True
                                                 logger.info(
-                                                    "Token adjustment completed for streaming",
+                                                    "Payment adjustment completed for streaming",
                                                     extra={
                                                         "key_hash": key.hashed_key[:8]
                                                         + "...",
                                                         "cost_data": cost_data,
+                                                        "model": last_model_seen,
                                                         "balance_after_adjustment": fresh_key.balance,
                                                     },
                                                 )
@@ -504,16 +507,21 @@ class BaseUpstreamProvider:
                 await finalize_without_usage()
                 raise
 
+        # Remove inaccurate encoding headers from upstream response
+        response_headers = dict(response.headers)
+        response_headers.pop("content-encoding", None)
+        response_headers.pop("content-length", None)
+
         return StreamingResponse(
             stream_with_cost(max_cost_for_model),
             status_code=response.status_code,
-            headers=dict(response.headers),
+            headers=response_headers,
         )
 
     async def handle_non_streaming_chat_completion(
         self,
         response: httpx.Response,
-        key: ApiKey,
+        key: TemporaryCredit,
         session: AsyncSession,
         deducted_max_cost: int,
     ) -> Response:
@@ -556,7 +564,7 @@ class BaseUpstreamProvider:
             response_json["cost"] = cost_data
 
             logger.info(
-                "Token adjustment completed for non-streaming",
+                "Payment adjustment completed for non-streaming",
                 extra={
                     "key_hash": key.hashed_key[:8] + "...",
                     "cost_data": cost_data,
@@ -619,7 +627,7 @@ class BaseUpstreamProvider:
         path: str,
         headers: dict,
         request_body: bytes | None,
-        key: ApiKey,
+        key: TemporaryCredit,
         max_cost_for_model: int,
         session: AsyncSession,
         model_obj: Model,
@@ -933,45 +941,43 @@ class BaseUpstreamProvider:
             extra={"model": model, "has_usage": "usage" in response_data},
         )
 
-        async with create_session() as session:
-            match await calculate_cost(response_data, max_cost_for_model, session):
-                case MaxCostData() as cost:
-                    logger.debug(
-                        "Using max cost pricing",
-                        extra={"model": model, "max_cost_msats": cost.total_msats},
-                    )
-                    return cost
-                case CostData() as cost:
-                    logger.debug(
-                        "Using token-based pricing",
-                        extra={
-                            "model": model,
-                            "total_cost_msats": cost.total_msats,
-                            "input_msats": cost.input_msats,
-                            "output_msats": cost.output_msats,
-                        },
-                    )
-                    return cost
-                case CostDataError() as error:
-                    logger.error(
-                        "Cost calculation error",
-                        extra={
-                            "model": model,
-                            "error_message": error.message,
-                            "error_code": error.code,
-                        },
-                    )
-                    raise HTTPException(
-                        status_code=400,
-                        detail={
-                            "error": {
-                                "message": error.message,
-                                "type": "invalid_request_error",
-                                "code": error.code,
-                            }
-                        },
-                    )
-        return None
+        match calculate_cost(response_data, max_cost_for_model):
+            case MaxCostData() as cost:
+                logger.debug(
+                    "Using max cost pricing",
+                    extra={"model": model, "max_cost_msats": cost.total_msats},
+                )
+                return cost
+            case CostData() as cost:
+                logger.debug(
+                    "Using token-based pricing",
+                    extra={
+                        "model": model,
+                        "total_cost_msats": cost.total_msats,
+                        "input_msats": cost.input_msats,
+                        "output_msats": cost.output_msats,
+                    },
+                )
+                return cost
+            case CostDataError() as error:
+                logger.error(
+                    "Cost calculation error",
+                    extra={
+                        "model": model,
+                        "error_message": error.message,
+                        "error_code": error.code,
+                    },
+                )
+                raise HTTPException(
+                    status_code=400,
+                    detail={
+                        "error": {
+                            "message": error.message,
+                            "type": "invalid_request_error",
+                            "code": error.code,
+                        }
+                    },
+                )
 
     async def send_refund(self, amount: int, unit: str, mint: str | None = None) -> str:
         """Create and send a refund token to the user.
@@ -1673,7 +1679,7 @@ class BaseUpstreamProvider:
             adjusted_pricing.max_prompt_cost,
             adjusted_pricing.max_completion_cost,
             adjusted_pricing.max_cost,
-        ) = _calculate_usd_max_costs(temp_model)
+        ) = calculate_usd_max_costs(temp_model)
 
         return Model(
             id=model.id,

routstr/upstream/helpers.py

@@ -10,7 +10,7 @@ if TYPE_CHECKING:
 
 from ..core import get_logger
 from ..core.db import AsyncSession, ModelRow, UpstreamProviderRow, create_session
-from ..payment.models import Model
+from ..models import Model
 from .base import BaseUpstreamProvider
 
 logger = get_logger(__name__)
@@ -82,7 +82,7 @@ async def get_all_models_with_overrides(
     """
     from sqlmodel import select
 
-    from ..payment.models import _row_to_model
+    from ..models.crud import row_to_model
 
     async with create_session() as session:
         result = await session.exec(select(ModelRow).where(ModelRow.enabled))
@@ -108,7 +108,7 @@ async def get_all_models_with_overrides(
         for model in upstream.get_cached_models():
             if model.id in overrides_by_id:
                 override_row, provider_fee = overrides_by_id[model.id]
-                all_models[model.id] = _row_to_model(
+                all_models[model.id] = row_to_model(
                     override_row, apply_provider_fee=True, provider_fee=provider_fee
                 )
             elif model.enabled:

routstr/upstream/ollama.py

@@ -9,8 +9,8 @@ from fastapi.responses import Response, StreamingResponse
 from .base import BaseUpstreamProvider
 
 if TYPE_CHECKING:
-    from ..core.db import ApiKey, AsyncSession, UpstreamProviderRow
-    from ..payment.models import Model
+    from ..core.db import AsyncSession, TemporaryCredit, UpstreamProviderRow
+    from ..models import Model
 
 from ..core.logging import get_logger
 
@@ -73,7 +73,7 @@ class OllamaUpstreamProvider(BaseUpstreamProvider):
         path: str,
         headers: dict,
         request_body: bytes | None,
-        key: ApiKey,
+        key: TemporaryCredit,
         max_cost_for_model: int,
         session: AsyncSession,
         model_obj: Model,
@@ -102,7 +102,7 @@ class OllamaUpstreamProvider(BaseUpstreamProvider):
 
     async def fetch_models(self) -> list[Model]:
         """Fetch models from Ollama API using /api/tags endpoint."""
-        from ..payment.models import Architecture, Model, Pricing, TopProvider
+        from ..models.models import Architecture, Model, Pricing, TopProvider
 
         try:
             async with httpx.AsyncClient(timeout=30.0) as client:
@@ -199,7 +199,7 @@ class OllamaUpstreamProvider(BaseUpstreamProvider):
     async def refresh_models_cache(self) -> None:
         """Refresh the in-memory models cache from upstream API."""
         try:
-            from ..payment.models import _update_model_sats_pricing
+            from ..models.models import _update_model_sats_pricing
             from ..payment.price import sats_usd_price
 
             models = await self.fetch_models()
@@ -252,7 +252,7 @@ class OllamaUpstreamProvider(BaseUpstreamProvider):
         Returns:
             Model with provider fee applied to pricing and max costs calculated
         """
-        from ..payment.models import Model, Pricing, _calculate_usd_max_costs
+        from ..models.models import Model, Pricing, calculate_usd_max_costs
 
         adjusted_pricing = Pricing.parse_obj(
             {k: v * self.provider_fee for k, v in model.pricing.dict().items()}
@@ -278,7 +278,7 @@ class OllamaUpstreamProvider(BaseUpstreamProvider):
             adjusted_pricing.max_prompt_cost,
             adjusted_pricing.max_completion_cost,
             adjusted_pricing.max_cost,
-        ) = _calculate_usd_max_costs(temp_model)
+        ) = calculate_usd_max_costs(temp_model)
 
         return Model(
             id=model.id,

routstr/upstream/openai.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING
 
-from ..payment.models import Model, async_fetch_openrouter_models
+from ..models import Model, async_fetch_openrouter_models
 from .base import BaseUpstreamProvider
 
 if TYPE_CHECKING:

routstr/upstream/openrouter.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING
 
-from ..payment.models import Model, async_fetch_openrouter_models
+from ..models import Model, async_fetch_openrouter_models
 from .base import BaseUpstreamProvider
 
 if TYPE_CHECKING:

routstr/upstream/perplexity.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING
 
-from ..payment.models import Model, async_fetch_openrouter_models
+from ..models import Model, async_fetch_openrouter_models
 from .base import BaseUpstreamProvider
 
 if TYPE_CHECKING:

routstr/upstream/xai.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING
 
-from ..payment.models import Model, async_fetch_openrouter_models
+from ..models import Model, async_fetch_openrouter_models
 from .base import BaseUpstreamProvider
 
 if TYPE_CHECKING:

scripts/crontab.example

@@ -1,5 +0,0 @@
-# Example crontab entries for Routstr tasks
-
-# Update models.json daily at 03:15 (optional)
-# OUTPUT_FILE=/app/models.json SOURCE=openrouter
-15 3 * * * /usr/local/bin/python /app/scripts/models_meta.py >> /var/log/cron.log 2>&1

scripts/models_meta.py

@@ -1,90 +0,0 @@
-#!/usr/bin/env python3
-
-import json
-import os
-from typing import TypedDict
-from urllib.request import urlopen
-
-
-class ModelArchitecture(TypedDict):
-    modality: str
-    input_modalities: list[str]
-    output_modalities: list[str]
-    tokenizer: str
-    instruct_type: str | None
-
-
-class ModelPricing(TypedDict):
-    prompt: str
-    completion: str
-    request: str
-    image: str
-    web_search: str
-    internal_reasoning: str
-
-
-class ModelProvider(TypedDict):
-    context_length: int
-    max_completion_tokens: int | None
-    is_moderated: bool
-
-
-class Model(TypedDict):
-    id: str
-    name: str
-    created: int
-    description: str
-    context_length: int
-    architecture: ModelArchitecture
-    pricing: ModelPricing
-    top_provider: ModelProvider
-    per_request_limits: dict | None
-
-
-OUTPUT_FILE = os.getenv("OUTPUT_FILE", "models.json")
-SOURCE = os.getenv("SOURCE")
-
-
-def fetch_openrouter_models(source_filter: str | None = None) -> list[Model]:
-    """Fetches model information from OpenRouter API."""
-    base_url = "https://openrouter.ai/api/v1"
-    with urlopen(f"{base_url}/models") as response:
-        data = json.loads(response.read().decode("utf-8"))
-
-        models_data: list[Model] = []
-        for model in data.get("data", []):
-            model_id = model.get("id", "")
-
-            if source_filter:
-                source_prefix = f"{source_filter}/"
-                if not model_id.startswith(source_prefix):
-                    continue
-
-                model = dict(model)
-                model["id"] = model_id[len(source_prefix) :]
-                model_id = model["id"]
-
-            if (
-                "(free)" in model.get("name", "")
-                or model_id == "openrouter/auto"
-                or model_id == "google/gemini-2.5-pro-exp-03-25"
-            ):
-                continue
-
-            models_data.append(model)
-
-        return models_data
-
-
-def main() -> None:
-    source_filter = SOURCE if SOURCE and SOURCE.strip() else None
-    models = fetch_openrouter_models(source_filter=source_filter)
-
-    print(f"Writing {len(models)} models to {OUTPUT_FILE}")
-
-    with open(OUTPUT_FILE, "w") as f:
-        json.dump({"models": models}, f, indent=4)
-
-
-if __name__ == "__main__":
-    main()

tests/integration/conftest.py

@@ -66,7 +66,7 @@ os.environ.update(test_env)
 os.environ.pop("ADMIN_PASSWORD", None)
 
 
-from routstr.core.db import ApiKey, get_session  # noqa: E402
+from routstr.core.db import TemporaryCredit, get_session  # noqa: E402
 from routstr.core.main import app, lifespan  # noqa: E402
 
 
@@ -113,7 +113,7 @@ class TestmintWallet:
         self.refund_history: List[Dict[str, Any]] = []
 
     async def init(self) -> None:
-        """Initialize the sixty_nuts wallet"""
+        """Initialize the cashu wallet"""
         # In mock mode, we don't actually create a real wallet
         # This is just a placeholder for the mock implementation
         self.wallet = None
@@ -280,7 +280,7 @@ class TestmintWallet:
         return 100000  # 100k sats
 
     async def credit_balance(
-        self, cashu_token: str, key: ApiKey, session: AsyncSession
+        self, cashu_token: str, key: TemporaryCredit, session: AsyncSession
     ) -> int:
         """Credit balance to API key - test implementation"""
         try:
@@ -301,9 +301,9 @@ class TestmintWallet:
 
             # Use atomic update to avoid lost update problem in concurrent scenarios
             stmt = (
-                update(ApiKey)
-                .where(col(ApiKey.hashed_key) == key.hashed_key)
-                .values(balance=ApiKey.balance + amount_msat)
+                update(TemporaryCredit)
+                .where(col(TemporaryCredit.hashed_key) == key.hashed_key)
+                .values(balance=TemporaryCredit.balance + amount_msat)
             )
             await session.execute(stmt)
             await session.commit()
@@ -390,7 +390,7 @@ class DatabaseSnapshot:
     async def capture(self) -> Dict[str, List[Dict]]:
         """Capture current database state"""
         # Get all API keys with their data
-        result = await self.session.execute(select(ApiKey))
+        result = await self.session.execute(select(TemporaryCredit))
         api_keys = result.scalars().all()
 
         snapshot = {
@@ -398,10 +398,8 @@ class DatabaseSnapshot:
                 {
                     "hashed_key": key.hashed_key,
                     "balance": key.balance,
-                    "total_spent": key.total_spent,
-                    "total_requests": key.total_requests,
                     "refund_address": key.refund_address,
-                    "key_expiry_time": key.key_expiry_time,
+                    "refund_expiration_time": key.refund_expiration_time,
                 }
                 for key in api_keys
             ]
@@ -447,10 +445,8 @@ class DatabaseSnapshot:
 
                 for field in [
                     "balance",
-                    "total_spent",
-                    "total_requests",
                     "refund_address",
-                    "key_expiry_time",
+                    "refund_expiration_time",
                 ]:
                     if old[field] != new[field]:
                         changes[field] = {
@@ -522,18 +518,19 @@ async def integration_app(
         with (
             patch("routstr.core.db.engine", integration_engine),
             patch.object(_settings, "cashu_mints", [mint_url]),
-            patch("routstr.wallet.credit_balance", testmint_wallet.credit_balance),
-            patch("routstr.wallet.send_token", testmint_wallet.send_token),
-            patch("routstr.wallet.send_to_lnurl", testmint_wallet.send_to_lnurl),
-            patch("routstr.wallet.recieve_token", testmint_wallet.redeem_token),
-            patch("routstr.wallet.get_balance", testmint_wallet.get_balance),
+            patch(
+                "routstr.payment.wallet.credit_balance", testmint_wallet.credit_balance
+            ),
+            patch("routstr.payment.wallet.send_token", testmint_wallet.send_token),
+            patch("routstr.payment.wallet.recieve_token", testmint_wallet.redeem_token),
+            patch("routstr.payment.wallet.get_balance", testmint_wallet.get_balance),
             patch("routstr.balance.send_token", testmint_wallet.send_token),
             patch("routstr.balance.send_to_lnurl", testmint_wallet.send_to_lnurl),
             patch("websockets.connect") as mock_websockets,
             patch("routstr.payment.price.btc_usd_price", return_value=50000.0),
             patch("routstr.payment.price.sats_usd_price", return_value=0.0005),
             patch(
-                "routstr.payment.helpers.calculate_discounted_max_cost",
+                "routstr.payment.cost.calculate_discounted_max_cost",
                 side_effect=_passthrough_discount,
             ),
         ):
@@ -705,8 +702,8 @@ async def background_tasks_controller() -> AsyncGenerator[Any, None]:
     original_periodic_payout: Optional[Callable] = None
 
     try:
-        from routstr.payment.models import update_sats_pricing
-        from routstr.wallet import periodic_payout
+        from routstr.models.models import update_sats_pricing
+        from routstr.payment.wallet import periodic_payout
 
         async def controlled_update_pricing() -> None:
             while not controller.cancelled:

tests/integration/real_testmint.py

@@ -1,18 +1,18 @@
 """
 Real Cashu mint integration for integration tests.
 
-This module provides a real sixty_nuts Wallet implementation that can be used
+This module provides a real cashu Wallet implementation that can be used
 with an actual Cashu mint instance for more thorough integration testing.
 """
 
 import os
 from typing import Optional, Tuple
 
-from sixty_nuts import Wallet
+from cashu.wallet.wallet import Wallet
 
 
 class RealMintWallet:
-    """Real Cashu mint wallet using sixty_nuts library"""
+    """Real Cashu mint wallet using cashu library"""
 
     def __init__(self, mint_url: str, nsec: str):
         self.mint_url = mint_url
@@ -22,7 +22,12 @@ class RealMintWallet:
     async def init(self) -> None:
         """Initialize the wallet connection"""
         if not self._wallet:
-            self._wallet = await Wallet.create(nsec=self.nsec)
+            self._wallet = await Wallet.with_db(
+                self.mint_url,
+                db="sqlite+aiosqlite:///:memory:",
+                load_all_keysets=True,
+                unit="sat",
+            )
 
     @property
     def wallet(self) -> Wallet:

tests/integration/test_background_tasks.py

@@ -9,9 +9,9 @@ from unittest.mock import AsyncMock, patch
 
 import pytest
 
-from routstr.core.db import ApiKey
-from routstr.payment.models import Model, Pricing, update_sats_pricing
-from routstr.wallet import periodic_payout
+from routstr.core.db import TemporaryCredit
+from routstr.models.models import Model, Pricing, update_sats_pricing
+from routstr.payment.wallet import periodic_payout
 
 
 @pytest.mark.asyncio
@@ -201,12 +201,12 @@ class TestRefundCheckTask:
     ) -> None:
         """Test that expired keys with balance and refund address are refunded"""
         # Create an expired API key with balance
-        expired_key = ApiKey(
+        expired_key = TemporaryCredit(
             hashed_key="expired_test_key",
             balance=5000,  # 5 sats in msats
             refund_address="lnurl1test",
-            key_expiry_time=int(time.time()) - 3600,  # Expired 1 hour ago
-            created_at=datetime.utcnow() - timedelta(days=1),
+            refund_expiration_time=int(time.time()) - 3600,  # Expired 1 hour ago
+            created=datetime.utcnow() - timedelta(days=1),
         )
         integration_session.add(expired_key)
         await integration_session.commit()
@@ -214,7 +214,7 @@ class TestRefundCheckTask:
         # Mock the wallet send_to_lnurl method and get_session
         with (
             patch(
-                "routstr.wallet.send_to_lnurl", AsyncMock(return_value=5)
+                "routstr.payment.lnurl.send_to_lnurl", AsyncMock(return_value=5)
             ) as mock_send_to_lnurl,
             patch("routstr.core.db.get_session") as mock_get_session,
         ):
@@ -233,8 +233,8 @@ class TestRefundCheckTask:
             if (
                 expired_key.balance > 0
                 and expired_key.refund_address
-                and expired_key.key_expiry_time
-                and expired_key.key_expiry_time < current_time
+                and expired_key.refund_expiration_time
+                and expired_key.refund_expiration_time < current_time
             ):
                 # Call wallet send_to_lnurl to trigger the refund
                 amount_sats = expired_key.balance // 1000
@@ -258,12 +258,12 @@ class TestRefundCheckTask:
         """Test that refund check continues after mint errors"""
         # Create multiple expired keys
         for i in range(3):
-            key = ApiKey(
+            key = TemporaryCredit(
                 hashed_key=f"expired_key_{i}",
                 balance=1000 * (i + 1),
                 refund_address=f"lnurl{i}",
-                key_expiry_time=int(time.time()) - 3600,
-                created_at=datetime.utcnow(),
+                refund_expiration_time=int(time.time()) - 3600,
+                created=datetime.utcnow(),
             )
             integration_session.add(key)
         await integration_session.commit()
@@ -279,7 +279,7 @@ class TestRefundCheckTask:
 
         with (
             patch(
-                "routstr.wallet.send_to_lnurl", mock_send_to_lnurl
+                "routstr.payment.lnurl.send_to_lnurl", mock_send_to_lnurl
             ) as mock_send_to_lnurl_patch,
             patch("routstr.core.db.get_session") as mock_get_session,
         ):
@@ -293,15 +293,15 @@ class TestRefundCheckTask:
             current_time = int(time.time())
             from sqlalchemy import select as sa_select
 
-            result = await integration_session.execute(sa_select(ApiKey))
+            result = await integration_session.execute(sa_select(TemporaryCredit))
             keys = result.scalars().all()
 
             for key in keys:
                 if (
                     key.balance > 0
                     and key.refund_address
-                    and key.key_expiry_time
-                    and key.key_expiry_time < current_time
+                    and key.refund_expiration_time
+                    and key.refund_expiration_time < current_time
                 ):
                     amount_sats = key.balance // 1000
                     try:
@@ -352,21 +352,21 @@ class TestRefundCheckTask:
 
         current_time = int(time.time())
         for data in keys_data:
-            key = ApiKey(
+            key = TemporaryCredit(
                 hashed_key=data["hashed_key"],
                 balance=data["balance"],
                 refund_address=data["refund_address"],
-                key_expiry_time=current_time - 3600
+                refund_expiration_time=current_time - 3600
                 if data["expired"]
                 else current_time + 3600,
-                created_at=datetime.utcnow(),
+                created=datetime.utcnow(),
             )
             integration_session.add(key)
         await integration_session.commit()
 
         with (
             patch(
-                "routstr.wallet.send_to_lnurl", AsyncMock(return_value=1)
+                "routstr.payment.lnurl.send_to_lnurl", AsyncMock(return_value=1)
             ) as mock_send_to_lnurl,
             patch("routstr.core.db.get_session") as mock_get_session,
         ):
@@ -382,15 +382,15 @@ class TestRefundCheckTask:
             current_time = int(time.time())
             from sqlalchemy import select as sa_select
 
-            result = await integration_session.execute(sa_select(ApiKey))
+            result = await integration_session.execute(sa_select(TemporaryCredit))
             keys = result.scalars().all()
 
             for key in keys:
                 if (
                     key.balance > 0
                     and key.refund_address
-                    and key.key_expiry_time
-                    and key.key_expiry_time < current_time
+                    and key.refund_expiration_time
+                    and key.refund_expiration_time < current_time
                 ):
                     amount_sats = key.balance // 1000
                     await mock_send_to_lnurl(key.refund_address, amount=amount_sats)
@@ -410,7 +410,7 @@ class TestRefundCheckTask:
             # Check final state
             from sqlalchemy import select as sa_select
 
-            result = await integration_session.execute(sa_select(ApiKey))
+            result = await integration_session.execute(sa_select(TemporaryCredit))
             remaining_keys_list = result.scalars().all()
             remaining_ids = [k.hashed_key for k in remaining_keys_list]
 
@@ -454,10 +454,10 @@ class TestPeriodicPayoutTask:
         for i in range(5):
             balance = 10000 * (i + 1)  # 10, 20, 30, 40, 50 sats
             total_user_balance += balance
-            key = ApiKey(
+            key = TemporaryCredit(
                 hashed_key=f"user_key_{i}",
                 balance=balance,
-                created_at=datetime.utcnow(),
+                created=datetime.utcnow(),
             )
             integration_session.add(key)
         await integration_session.commit()
@@ -466,9 +466,12 @@ class TestPeriodicPayoutTask:
         wallet_balance = 200000  # 200 sats total
 
         with (
-            patch("routstr.wallet.get_balance", AsyncMock(return_value=wallet_balance)),
             patch(
-                "routstr.wallet.send_to_lnurl", AsyncMock(return_value=None)
+                "routstr.payment.wallet.get_balance",
+                AsyncMock(return_value=wallet_balance),
+            ),
+            patch(
+                "routstr.payment.lnurl.send_to_lnurl", AsyncMock(return_value=None)
             ) as mock_send_to_lnurl,
         ):
             # Mock environment variables
@@ -481,7 +484,7 @@ class TestPeriodicPayoutTask:
                 },
             ):
                 # Call periodic_payout directly (pay_out was renamed/refactored)
-                from routstr.wallet import periodic_payout
+                from routstr.payment.wallet import periodic_payout
 
                 await periodic_payout()
 
@@ -501,7 +504,7 @@ class TestPeriodicPayoutTask:
     #     key = ApiKey(
     #         hashed_key="single_user",
     #         balance=50000,  # 50 sats
-    #         created_at=datetime.utcnow(),
+    #         created=datetime.utcnow(),
     #     )
     #     integration_session.add(key)
     #     await integration_session.commit()
@@ -538,7 +541,7 @@ class TestPeriodicPayoutTask:
     #     key = ApiKey(
     #         hashed_key="low_revenue_user",
     #         balance=95000,  # 95 sats
-    #         created_at=datetime.utcnow(),
+    #         created=datetime.utcnow(),
     #     )
     #     integration_session.add(key)
     #     await integration_session.commit()
@@ -648,14 +651,14 @@ class TestTaskInteractions:
         """Test that database operations don't deadlock during concurrent task execution"""
         # Create test data
         for i in range(10):
-            key = ApiKey(
+            key = TemporaryCredit(
                 hashed_key=f"concurrent_key_{i}",
                 balance=1000 * i,
                 refund_address=f"lnurl{i}" if i % 2 == 0 else None,
-                key_expiry_time=int(time.time()) - 3600
+                refund_expiration_time=int(time.time()) - 3600
                 if i % 3 == 0
                 else int(time.time()) + 3600,
-                created_at=datetime.utcnow(),
+                created=datetime.utcnow(),
             )
             integration_session.add(key)
         await integration_session.commit()
@@ -664,14 +667,14 @@ class TestTaskInteractions:
         async def read_operation() -> int:
             from sqlalchemy import select as sa_select
 
-            result = await integration_session.execute(sa_select(ApiKey))
+            result = await integration_session.execute(sa_select(TemporaryCredit))
             return len(result.scalars().all())
 
         async def write_operation(key_id: int) -> None:
             from sqlalchemy import select as sa_select
 
-            stmt = sa_select(ApiKey).where(
-                ApiKey.hashed_key == f"concurrent_key_{key_id}"  # type: ignore[arg-type]
+            stmt = sa_select(TemporaryCredit).where(
+                TemporaryCredit.hashed_key == f"concurrent_key_{key_id}"  # type: ignore[arg-type]
             )
             result = await integration_session.execute(stmt)
             key = result.scalar_one_or_none()
@@ -708,14 +711,16 @@ class TestTaskInteractions:
         # Patch the actual task functions
         with (
             patch(
-                "routstr.payment.models.update_sats_pricing",
+                "routstr.models.models.update_sats_pricing",
                 lambda: task_with_cleanup("pricing"),
             ),
             patch(
-                "routstr.wallet.periodic_payout", lambda: task_with_cleanup("refund")
+                "routstr.payment.wallet.periodic_payout",
+                lambda: task_with_cleanup("refund"),
             ),
             patch(
-                "routstr.wallet.periodic_payout", lambda: task_with_cleanup("payout")
+                "routstr.payment.wallet.periodic_payout",
+                lambda: task_with_cleanup("payout"),
             ),
         ):
             # Start all tasks

tests/integration/test_database_consistency.py

@@ -11,7 +11,7 @@ from sqlalchemy.exc import IntegrityError
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlmodel import select
 
-from routstr.core.db import ApiKey
+from routstr.core.db import TemporaryCredit
 
 
 class TestTransactionAtomicity:
@@ -34,7 +34,7 @@ class TestTransactionAtomicity:
             api_key_header[3:] if api_key_header.startswith("sk-") else api_key_header
         )
 
-        stmt = select(ApiKey).where(ApiKey.hashed_key == api_key_hash)  # type: ignore[arg-type]
+        stmt = select(TemporaryCredit).where(TemporaryCredit.hashed_key == api_key_hash)  # type: ignore[arg-type]
         result = await integration_session.execute(stmt)
         api_key = result.scalar_one()
         initial_balance = api_key.balance
@@ -47,7 +47,9 @@ class TestTransactionAtomicity:
             try:
                 # Get api key in new session
                 result = await test_session.execute(
-                    select(ApiKey).where(ApiKey.hashed_key == api_key_hash)  # type: ignore[arg-type]
+                    select(TemporaryCredit).where(
+                        TemporaryCredit.hashed_key == api_key_hash
+                    )  # type: ignore[arg-type]
                 )
                 test_api_key = result.scalar_one()
 
@@ -72,14 +74,14 @@ class TestTransactionAtomicity:
 
         try:
             await integration_session.execute(
-                update(ApiKey)
-                .where(ApiKey.hashed_key == api_key_hash)  # type: ignore[arg-type]
-                .values(balance=ApiKey.balance - 1000)
+                update(TemporaryCredit)
+                .where(TemporaryCredit.hashed_key == api_key_hash)  # type: ignore[arg-type]
+                .values(balance=TemporaryCredit.balance - 1000)
             )
             # Force a constraint violation or error
             await integration_session.execute(
-                update(ApiKey)
-                .where(ApiKey.hashed_key == "non_existent_key")  # type: ignore[arg-type]
+                update(TemporaryCredit)
+                .where(TemporaryCredit.hashed_key == "non_existent_key")  # type: ignore[arg-type]
                 .values(balance=-1)  # This should fail
             )
             await integration_session.commit()
@@ -108,13 +110,13 @@ class TestTransactionAtomicity:
             api_key_header[3:] if api_key_header.startswith("sk-") else api_key_header
         )
 
-        stmt = select(ApiKey).where(ApiKey.hashed_key == api_key_hash)  # type: ignore[arg-type]
+        stmt = select(TemporaryCredit).where(TemporaryCredit.hashed_key == api_key_hash)  # type: ignore[arg-type]
         result = await integration_session.execute(stmt)
         api_key = result.scalar_one()
         initial_balance = api_key.balance
 
         # Mock wallet to fail after token validation
-        with patch("routstr.wallet.send_token") as mock_wallet_func:
+        with patch("routstr.payment.wallet.send_token") as mock_wallet_func:
             mock_proof = MagicMock()
             mock_proof.amount = 1000
             mock_wallet = AsyncMock()
@@ -158,7 +160,7 @@ class TestTransactionAtomicity:
         )
 
         # Set a known balance
-        stmt = select(ApiKey).where(ApiKey.hashed_key == api_key_hash)  # type: ignore[arg-type]
+        stmt = select(TemporaryCredit).where(TemporaryCredit.hashed_key == api_key_hash)  # type: ignore[arg-type]
         result = await integration_session.execute(stmt)
         api_key = result.scalar_one()
         api_key.balance = 10000
@@ -166,12 +168,12 @@ class TestTransactionAtomicity:
 
         # Simulate concurrent balance updates through direct database operations
         async def update_balance(session: AsyncSession, amount: int) -> bool:
-            stmt = select(ApiKey).where(ApiKey.hashed_key == api_key_hash)  # type: ignore[arg-type]
+            stmt = select(TemporaryCredit).where(
+                TemporaryCredit.hashed_key == api_key_hash
+            )  # type: ignore[arg-type]
             result = await session.execute(stmt)
             key = result.scalar_one()
             key.balance -= amount
-            key.total_spent += amount
-            key.total_requests += 1
             try:
                 await session.commit()
                 return True
@@ -248,7 +250,7 @@ class TestConcurrentOperations:
         )
 
         # Set initial balance
-        stmt = select(ApiKey).where(ApiKey.hashed_key == api_key_hash)  # type: ignore[arg-type]
+        stmt = select(TemporaryCredit).where(TemporaryCredit.hashed_key == api_key_hash)  # type: ignore[arg-type]
         result = await integration_session.execute(stmt)
         api_key = result.scalar_one()
         initial_balance = 5000
@@ -256,7 +258,7 @@ class TestConcurrentOperations:
         await integration_session.commit()
 
         # Mock wallet for topup
-        with patch("routstr.wallet.send_token") as mock_wallet_func:
+        with patch("routstr.payment.wallet.send_token") as mock_wallet_func:
             mock_proof = MagicMock()
             mock_proof.amount = 2000
             mock_wallet = AsyncMock()
@@ -323,12 +325,10 @@ class TestConcurrentOperations:
         )
 
         # Set a specific balance
-        stmt = select(ApiKey).where(ApiKey.hashed_key == api_key_hash)  # type: ignore[arg-type]
+        stmt = select(TemporaryCredit).where(TemporaryCredit.hashed_key == api_key_hash)  # type: ignore[arg-type]
         result = await integration_session.execute(stmt)
         api_key = result.scalar_one()
         api_key.balance = 1000
-        api_key.total_spent = 0
-        api_key.total_requests = 0
         await integration_session.commit()
 
         # Create a controlled race condition scenario
@@ -336,7 +336,9 @@ class TestConcurrentOperations:
 
         async def check_and_update_balance() -> bool:
             # Read current balance
-            stmt = select(ApiKey).where(ApiKey.hashed_key == api_key_hash)  # type: ignore[arg-type]
+            stmt = select(TemporaryCredit).where(
+                TemporaryCredit.hashed_key == api_key_hash
+            )  # type: ignore[arg-type]
             result = await integration_session.execute(stmt)
             current_api_key = result.scalar_one()
             current_balance = current_api_key.balance
@@ -347,8 +349,6 @@ class TestConcurrentOperations:
 
             # Try to update based on read value
             current_api_key.balance = current_balance - 100
-            current_api_key.total_spent += 100
-            current_api_key.total_requests += 1
 
             try:
                 await integration_session.commit()
@@ -371,8 +371,6 @@ class TestConcurrentOperations:
         # Final balance should reflect successful updates
         expected_balance = 1000 - (successful_updates * 100)
         assert api_key.balance == expected_balance
-        assert api_key.total_spent == successful_updates * 100
-        assert api_key.total_requests == successful_updates
 
 
 class TestDataIntegrity:
@@ -396,7 +394,7 @@ class TestDataIntegrity:
         )
 
         # Set low balance
-        stmt = select(ApiKey).where(ApiKey.hashed_key == api_key_hash)  # type: ignore[arg-type]
+        stmt = select(TemporaryCredit).where(TemporaryCredit.hashed_key == api_key_hash)  # type: ignore[arg-type]
         result = await integration_session.execute(stmt)
         api_key = result.scalar_one()
         api_key.balance = 0
@@ -431,9 +429,7 @@ class TestDataIntegrity:
         )
 
         # Try to manually insert duplicate key with same hash
-        duplicate_key = ApiKey(
-            hashed_key=api_key_hash, balance=5000, total_spent=0, total_requests=0
-        )
+        duplicate_key = TemporaryCredit(hashed_key=api_key_hash, balance=5000)
 
         integration_session.add(duplicate_key)
 
@@ -481,20 +477,13 @@ class TestDataIntegrity:
             api_key_header[3:] if api_key_header.startswith("sk-") else api_key_header
         )
 
-        stmt = select(ApiKey).where(ApiKey.hashed_key == api_key_hash)  # type: ignore[arg-type]
+        stmt = select(TemporaryCredit).where(TemporaryCredit.hashed_key == api_key_hash)  # type: ignore[arg-type]
         result = await integration_session.execute(stmt)
         api_key = result.scalar_one()
 
         # Test setting invalid values directly
         # These should maintain integrity
         assert api_key.balance >= 0
-        assert api_key.total_spent >= 0
-        assert api_key.total_requests >= 0
-
-        # Verify calculations are consistent
-        if api_key.total_requests > 0:
-            average_cost = api_key.total_spent / api_key.total_requests
-            assert average_cost >= 0
 
 
 class TestPerformance:
@@ -522,7 +511,7 @@ class TestPerformance:
             operation_times["select"].append((end - start) * 1000)  # Convert to ms
 
         # Test UPDATE performance (via topup)
-        with patch("routstr.wallet.send_token") as mock_wallet_func:
+        with patch("routstr.payment.wallet.send_token") as mock_wallet_func:
             mock_proof = MagicMock()
             mock_proof.amount = 100
             mock_wallet = AsyncMock()
@@ -607,7 +596,7 @@ class TestPerformance:
 
         # Primary key lookup should be fast
         start = time.time()
-        stmt = select(ApiKey).where(ApiKey.hashed_key == api_key_hash)  # type: ignore[arg-type]
+        stmt = select(TemporaryCredit).where(TemporaryCredit.hashed_key == api_key_hash)  # type: ignore[arg-type]
         result = await integration_session.execute(stmt)
         api_key = result.scalar_one()
         end = time.time()

tests/integration/test_error_handling_edge_cases.py

@@ -11,7 +11,7 @@ from httpx import ASGITransport, AsyncClient, ConnectError
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlmodel import select
 
-from routstr.core.db import ApiKey
+from routstr.core.db import TemporaryCredit
 
 
 class TestNetworkFailureScenarios:
@@ -27,7 +27,7 @@ class TestNetworkFailureScenarios:
         # Patch the wallet send function to simulate failure across all modules
         with (
             patch(
-                "routstr.wallet.send_token",
+                "routstr.payment.wallet.send_token",
                 AsyncMock(side_effect=ConnectError("Mint service unavailable")),
             ),
             patch(
@@ -422,7 +422,7 @@ class TestRecoveryScenarios:
             api_key_header[3:] if api_key_header.startswith("sk-") else api_key_header
         )
 
-        stmt = select(ApiKey).where(ApiKey.hashed_key == api_key_hash)  # type: ignore[arg-type]
+        stmt = select(TemporaryCredit).where(TemporaryCredit.hashed_key == api_key_hash)  # type: ignore[arg-type]
         result = await integration_session.execute(stmt)
         initial_key = result.scalar_one()
         initial_balance = initial_key.balance
@@ -458,17 +458,15 @@ class TestRecoveryScenarios:
             api_key_header[3:] if api_key_header.startswith("sk-") else api_key_header
         )
 
-        stmt = select(ApiKey).where(ApiKey.hashed_key == api_key_hash)  # type: ignore[arg-type]
+        stmt = select(TemporaryCredit).where(TemporaryCredit.hashed_key == api_key_hash)  # type: ignore[arg-type]
         result = await integration_session.execute(stmt)
         api_key = result.scalar_one()
         initial_balance = api_key.balance
-        initial_requests = api_key.total_requests
 
         # Simulate operations that might be interrupted
         try:
             # Start a transaction
             api_key.reserved_balance += 1000
-            api_key.total_requests += 1
             # Don't commit - simulate crash
             raise Exception("Simulated database crash")
         except Exception:
@@ -478,7 +476,6 @@ class TestRecoveryScenarios:
         # Verify state is consistent after "recovery"
         await integration_session.refresh(api_key)
         assert api_key.balance == initial_balance
-        assert api_key.total_requests == initial_requests
 
     @pytest.mark.asyncio
     async def test_state_consistency_after_failures(
@@ -527,10 +524,7 @@ class TestRecoveryScenarios:
             for mod in diff["api_keys"]["modified"]:
                 # Only acceptable changes are request counts
                 for field, change in mod["changes"].items():
-                    if field == "total_requests":
-                        # Request count might increase
-                        assert change["delta"] >= 0
-                    elif field == "balance":
+                    if field == "balance":
                         # Balance should not decrease from failed operations
                         assert change["delta"] >= 0
                     else:
@@ -641,12 +635,10 @@ class TestEdgeCaseCombinations:
         api_key_hash = test_key[3:]  # Remove sk- prefix
 
         # Create the API key with only 500 msats (less than one request cost)
-        new_key = ApiKey(
+        new_key = TemporaryCredit(
             hashed_key=api_key_hash,
             balance=500,  # Less than fixed cost per request (1000 msats)
             reserved_balance=0,
-            total_spent=0,
-            total_requests=0,
         )
         integration_session.add(new_key)
         await integration_session.commit()
@@ -687,7 +679,7 @@ class TestEdgeCaseCombinations:
         assert insufficient_funds_count > 0
 
         # Balance should never go negative
-        stmt = select(ApiKey).where(ApiKey.hashed_key == api_key_hash)  # type: ignore[arg-type]
+        stmt = select(TemporaryCredit).where(TemporaryCredit.hashed_key == api_key_hash)  # type: ignore[arg-type]
         result = await integration_session.execute(stmt)
         final_key = result.scalar_one()
         assert final_key.balance >= 0

tests/integration/test_general_info_endpoints.py

@@ -62,7 +62,6 @@ async def test_root_endpoint_structure_and_performance(
         "mints",
         "http_url",
         "onion_url",
-        "models",
     ]
     for field in required_fields:
         assert field in data, f"Missing required field: {field}"
@@ -75,15 +74,9 @@ async def test_root_endpoint_structure_and_performance(
     assert isinstance(data["mints"], list)
     assert isinstance(data["http_url"], str)
     assert isinstance(data["onion_url"], str)
-    assert isinstance(data["models"], list)
 
-    # Validate models structure if any exist
-    for model in data["models"]:
-        assert isinstance(model, dict)
-        # Models should have at least basic fields
-        model_required_fields = ["id", "name"]
-        for field in model_required_fields:
-            assert field in model, f"Model missing required field: {field}"
+    # Ensure models field is not present (removed as per issue #184)
+    assert "models" not in data, "Models field should not be present in base URL output"
 
     # Verify no database state changes
     diff = await db_snapshot.diff()

tests/integration/test_performance_load.py

@@ -149,15 +149,13 @@ class TestPerformanceBaseline:
         """Test database operation performance"""
         from sqlmodel import select
 
-        from routstr.core.db import ApiKey
+        from routstr.core.db import TemporaryCredit
 
         # Create test data
         for i in range(100):
-            key = ApiKey(
+            key = TemporaryCredit(
                 hashed_key=f"test_key_{i}",
                 balance=1000000,
-                total_spent=0,
-                total_requests=0,
             )
             integration_session.add(key)
         await integration_session.commit()
@@ -168,7 +166,7 @@ class TestPerformanceBaseline:
         for _ in range(100):
             start = time.time()
             result = await integration_session.execute(
-                select(ApiKey).where(ApiKey.balance > 0)  # type: ignore[arg-type]
+                select(TemporaryCredit).where(TemporaryCredit.balance > 0)  # type: ignore[arg-type]
             )
             _ = result.all()
             duration = (time.time() - start) * 1000

tests/integration/test_provider_management.py

@@ -9,7 +9,7 @@ from unittest.mock import patch
 import pytest
 from httpx import AsyncClient
 
-from routstr.discovery import _PROVIDERS_CACHE
+from routstr.nostr.discovery import _PROVIDERS_CACHE
 
 from .utils import PerformanceValidator, ResponseValidator
 
@@ -62,9 +62,9 @@ async def test_providers_endpoint_default_response(
     }
 
     with patch(
-        "routstr.discovery.query_nostr_relay_for_providers", return_value=mock_events
+        "routstr.nostr.discovery.query_nostr_relay_for_providers", return_value=mock_events
     ):
-        with patch("routstr.discovery.fetch_provider_health") as mock_fetch:
+        with patch("routstr.nostr.discovery.fetch_provider_health") as mock_fetch:
             # Configure mock to return appropriate responses
             mock_fetch.side_effect = lambda url: mock_fetch_responses.get(
                 url, {"status_code": 500, "json": {"error": "Unknown provider"}}
@@ -126,9 +126,9 @@ async def test_providers_endpoint_with_include_json(
     }
 
     with patch(
-        "routstr.discovery.query_nostr_relay_for_providers", return_value=mock_events
+        "routstr.nostr.discovery.query_nostr_relay_for_providers", return_value=mock_events
     ):
-        with patch("routstr.discovery.fetch_provider_health") as mock_fetch:
+        with patch("routstr.nostr.discovery.fetch_provider_health") as mock_fetch:
             mock_fetch.return_value = {
                 "status_code": 200,
                 "json": mock_provider_response,
@@ -200,9 +200,9 @@ async def test_providers_data_structure_validation(
     }
 
     with patch(
-        "routstr.discovery.query_nostr_relay_for_providers", return_value=mock_events
+        "routstr.nostr.discovery.query_nostr_relay_for_providers", return_value=mock_events
     ):
-        with patch("routstr.discovery.fetch_provider_health") as mock_fetch:
+        with patch("routstr.nostr.discovery.fetch_provider_health") as mock_fetch:
             mock_fetch.return_value = mock_health_response
 
             response = await integration_client.get("/v1/providers/?include_json=true")
@@ -247,7 +247,7 @@ async def test_providers_endpoint_no_providers_found(
     ]
 
     with patch(
-        "routstr.discovery.query_nostr_relay_for_providers", return_value=mock_events
+        "routstr.nostr.discovery.query_nostr_relay_for_providers", return_value=mock_events
     ):
         response = await integration_client.get("/v1/providers/")
 
@@ -308,10 +308,10 @@ async def test_providers_endpoint_offline_providers(
             }
 
     with patch(
-        "routstr.discovery.query_nostr_relay_for_providers", return_value=mock_events
+        "routstr.nostr.discovery.query_nostr_relay_for_providers", return_value=mock_events
     ):
         with patch(
-            "routstr.discovery.fetch_provider_health",
+            "routstr.nostr.discovery.fetch_provider_health",
             side_effect=mock_fetch_provider_health,
         ):
             response = await integration_client.get("/v1/providers/?include_json=true")
@@ -377,9 +377,9 @@ async def test_providers_endpoint_duplicate_urls(
     ]
 
     with patch(
-        "routstr.discovery.query_nostr_relay_for_providers", return_value=mock_events
+        "routstr.nostr.discovery.query_nostr_relay_for_providers", return_value=mock_events
     ):
-        with patch("routstr.discovery.fetch_provider_health") as mock_fetch:
+        with patch("routstr.nostr.discovery.fetch_provider_health") as mock_fetch:
             mock_fetch.return_value = {
                 "status_code": 200,
                 "endpoint": "root",
@@ -416,7 +416,7 @@ async def test_providers_endpoint_nostr_relay_failures(
         raise Exception("Connection to relay failed")
 
     with patch(
-        "routstr.discovery.query_nostr_relay_for_providers", side_effect=failing_query
+        "routstr.nostr.discovery.query_nostr_relay_for_providers", side_effect=failing_query
     ):
         response = await integration_client.get("/v1/providers/")
 
@@ -454,9 +454,9 @@ async def test_providers_endpoint_malformed_urls(
     ]
 
     with patch(
-        "routstr.discovery.query_nostr_relay_for_providers", return_value=mock_events
+        "routstr.nostr.discovery.query_nostr_relay_for_providers", return_value=mock_events
     ):
-        with patch("routstr.discovery.fetch_provider_health") as mock_fetch:
+        with patch("routstr.nostr.discovery.fetch_provider_health") as mock_fetch:
             mock_fetch.return_value = {"status_code": 200, "json": {"status": "online"}}
 
             response = await integration_client.get("/v1/providers/")
@@ -486,9 +486,9 @@ async def test_providers_endpoint_response_format(
     ]
 
     with patch(
-        "routstr.discovery.query_nostr_relay_for_providers", return_value=mock_events
+        "routstr.nostr.discovery.query_nostr_relay_for_providers", return_value=mock_events
     ):
-        with patch("routstr.discovery.fetch_provider_health") as mock_fetch:
+        with patch("routstr.nostr.discovery.fetch_provider_health") as mock_fetch:
             mock_fetch.return_value = {"status_code": 200, "json": {"status": "online"}}
 
             # Test default format
@@ -536,9 +536,9 @@ async def test_providers_endpoint_performance(integration_client: AsyncClient) -
     validator = PerformanceValidator()
 
     with patch(
-        "routstr.discovery.query_nostr_relay_for_providers", return_value=mock_events
+        "routstr.nostr.discovery.query_nostr_relay_for_providers", return_value=mock_events
     ):
-        with patch("routstr.discovery.fetch_provider_health") as mock_fetch:
+        with patch("routstr.nostr.discovery.fetch_provider_health") as mock_fetch:
             mock_fetch.return_value = {"status_code": 200, "json": {"status": "online"}}
 
             # Test multiple requests
@@ -576,9 +576,9 @@ async def test_providers_endpoint_concurrent_requests(
     ]
 
     with patch(
-        "routstr.discovery.query_nostr_relay_for_providers", return_value=mock_events
+        "routstr.nostr.discovery.query_nostr_relay_for_providers", return_value=mock_events
     ):
-        with patch("routstr.discovery.fetch_provider_health") as mock_fetch:
+        with patch("routstr.nostr.discovery.fetch_provider_health") as mock_fetch:
             mock_fetch.return_value = {"status_code": 200, "json": {"status": "online"}}
 
             # Create concurrent requests
@@ -618,9 +618,9 @@ async def test_providers_endpoint_parameter_validation(
     ]
 
     with patch(
-        "routstr.discovery.query_nostr_relay_for_providers", return_value=mock_events
+        "routstr.nostr.discovery.query_nostr_relay_for_providers", return_value=mock_events
     ):
-        with patch("routstr.discovery.fetch_provider_health") as mock_fetch:
+        with patch("routstr.nostr.discovery.fetch_provider_health") as mock_fetch:
             mock_fetch.return_value = {"status_code": 200, "json": {"status": "online"}}
 
             # Test various parameter values
@@ -670,9 +670,9 @@ async def test_no_database_changes_during_provider_operations(
     ]
 
     with patch(
-        "routstr.discovery.query_nostr_relay_for_providers", return_value=mock_events
+        "routstr.nostr.discovery.query_nostr_relay_for_providers", return_value=mock_events
     ):
-        with patch("routstr.discovery.fetch_provider_health") as mock_fetch:
+        with patch("routstr.nostr.discovery.fetch_provider_health") as mock_fetch:
             mock_fetch.return_value = {"status_code": 200, "json": {"status": "online"}}
 
             # Make multiple requests with different parameters

tests/integration/test_proxy_get_endpoints.py

@@ -14,7 +14,7 @@ import pytest
 from httpx import AsyncClient
 from sqlmodel import select
 
-from routstr.core.db import ApiKey
+from routstr.core.db import TemporaryCredit
 
 from .utils import (
     ConcurrencyTester,
@@ -297,8 +297,8 @@ async def test_proxy_get_insufficient_balance(
     from sqlmodel import update
 
     await integration_session.execute(
-        update(ApiKey)
-        .where(ApiKey.hashed_key == hashed_key)  # type: ignore[arg-type]
+        update(TemporaryCredit)
+        .where(TemporaryCredit.hashed_key == hashed_key)  # type: ignore[arg-type]
         .values(balance=100)  # Only 0.1 sats
     )
     await integration_session.commit()
@@ -382,7 +382,7 @@ async def test_proxy_get_database_state_verification(
 
     # Get initial key state
     result = await integration_session.execute(
-        select(ApiKey).where(ApiKey.hashed_key == hashed_key)  # type: ignore[arg-type]
+        select(TemporaryCredit).where(TemporaryCredit.hashed_key == hashed_key)  # type: ignore[arg-type]
     )
     initial_key = result.scalar_one()
     initial_balance = initial_key.balance

tests/integration/test_real_mint.py

@@ -9,7 +9,7 @@ import os
 try:
     from .real_testmint import create_real_mint_wallet
 except ImportError:
-    # sixty_nuts not available, tests will be skipped
+    # cashu not available, tests will be skipped
     create_real_mint_wallet = None  # type: ignore
 
 
@@ -17,9 +17,9 @@ async def test_real_wallet() -> None:
     """Test basic operations with a real Cashu mint wallet"""
     print("Testing real Cashu mint wallet...")
 
-    # Check if sixty_nuts dependency is available
+    # Check if cashu dependency is available
     if create_real_mint_wallet is None:
-        print("sixty_nuts not available. Skipping real mint tests.")
+        print("cashu not available. Skipping real mint tests.")
         return
 
     # Check if real mint is enabled

tests/integration/test_reserved_balance_negative.py

@@ -7,7 +7,7 @@ import pytest
 from httpx import AsyncClient
 from sqlmodel.ext.asyncio.session import AsyncSession
 
-from routstr.core.db import ApiKey, create_session
+from routstr.core.db import TemporaryCredit, create_session
 
 
 @pytest.mark.asyncio
@@ -16,7 +16,7 @@ async def test_reserved_balance_never_negative(integration_client: AsyncClient)
 
     # Create a test API key with limited balance
     async with create_session() as session:
-        test_key = ApiKey(
+        test_key = TemporaryCredit(
             hashed_key="test_reserved_balance_key",
             balance=1000,  # 1 sat
             reserved_balance=0,
@@ -40,7 +40,7 @@ async def test_reserved_balance_never_negative(integration_client: AsyncClient)
 
     # Check reserved balance after failed request
     async with create_session() as session:
-        key = await session.get(ApiKey, "test_reserved_balance_key")
+        key = await session.get(TemporaryCredit, "test_reserved_balance_key")
         assert key is not None
         assert key.reserved_balance >= 0, (
             f"Reserved balance went negative: {key.reserved_balance}"
@@ -69,7 +69,7 @@ async def test_reserved_balance_never_negative(integration_client: AsyncClient)
 
     # Check final state
     async with create_session() as session:
-        key = await session.get(ApiKey, "test_reserved_balance_key")
+        key = await session.get(TemporaryCredit, "test_reserved_balance_key")
         assert key is not None
         assert key.reserved_balance >= 0, (
             f"Reserved balance went negative after concurrent requests: {key.reserved_balance}"
@@ -86,7 +86,7 @@ async def test_reserved_balance_with_successful_requests(
     # Create a test API key with more balance
     async with create_session() as session:
         unique_key = f"test_successful_key_{uuid.uuid4().hex[:8]}"
-        test_key = ApiKey(
+        test_key = TemporaryCredit(
             hashed_key=unique_key,
             balance=100000,  # 100 sats
             reserved_balance=0,
@@ -111,24 +111,23 @@ async def test_reserved_balance_with_successful_requests(
 
     # Check that reserved balance was properly adjusted
     async with create_session() as session:
-        key = await session.get(ApiKey, unique_key)
+        key = await session.get(TemporaryCredit, unique_key)
         assert key is not None
         assert key.reserved_balance >= 0, (
             f"Reserved balance went negative: {key.reserved_balance}"
         )
         # Check if the request was processed (might fail due to model pricing in test env)
         # The important part is that reserved_balance doesn't go negative
-        if key.total_spent > 0:
-            assert key.balance < 100000, (
-                "Balance should decrease after successful request"
-            )
+        if key.balance < 100000:
+            # Balance decreased
+            pass
         else:
             # Request failed, but reserved balance should still be non-negative
             assert key.balance == 100000, (
                 "Balance should remain unchanged if request failed"
             )
         print(
-            f"After successful request - Balance: {key.balance}, Reserved: {key.reserved_balance}, Spent: {key.total_spent}"
+            f"After successful request - Balance: {key.balance}, Reserved: {key.reserved_balance}"
         )
 
 
@@ -137,11 +136,11 @@ async def test_insufficient_reserved_balance_for_revert(
     integration_session: AsyncSession,
 ) -> None:
     """Test revert_pay_for_request behavior with insufficient reserved balance."""
-    from routstr.auth import revert_pay_for_request
+    from routstr.payment.helpers import revert_pay_for_request
 
     # Create key with zero reserved balance
     unique_key = f"test_revert_key_{uuid.uuid4().hex[:8]}"
-    test_key = ApiKey(
+    test_key = TemporaryCredit(
         hashed_key=unique_key,
         balance=1000,
         reserved_balance=0,
@@ -160,6 +159,3 @@ async def test_insufficient_reserved_balance_for_revert(
     assert test_key.reserved_balance == -100, (
         f"Expected reserved_balance to be -100, got: {test_key.reserved_balance}"
     )
-    assert test_key.total_requests == -1, (
-        f"Expected total_requests to be -1, got: {test_key.total_requests}"
-    )

tests/integration/test_wallet_authentication.py

@@ -11,7 +11,7 @@ import pytest
 from httpx import AsyncClient
 from sqlmodel import select
 
-from routstr.core.db import ApiKey
+from routstr.core.db import TemporaryCredit
 
 from .utils import (
     CashuTokenGenerator,
@@ -55,13 +55,11 @@ async def test_api_key_generation_valid_token(
     # Verify database state directly
     hashed_key = api_key[3:]  # Remove "sk-" prefix
     result = await integration_session.execute(
-        select(ApiKey).where(ApiKey.hashed_key == hashed_key)  # type: ignore[arg-type]
+        select(TemporaryCredit).where(TemporaryCredit.hashed_key == hashed_key)  # type: ignore[arg-type]
     )
     db_key = result.scalar_one()
 
     assert db_key.balance == amount * 1000
-    assert db_key.total_spent == 0
-    assert db_key.total_requests == 0
 
     # Verify the API key can be used for authentication
     integration_client.headers["Authorization"] = f"Bearer {api_key}"
@@ -93,15 +91,15 @@ async def test_api_key_generation_invalid_token(
         integration_client.headers["Authorization"] = f"Bearer {invalid_token}"
         response = await integration_client.get("/v1/wallet/info")
 
-        # Should fail with 401
-        assert response.status_code == 401, (
-            f"Token {invalid_token[:20]}... should be invalid"
+        # Should fail with 401 or 400
+        assert response.status_code in [400, 401], (
+            f"Token {invalid_token[:20]}... should be invalid (400 or 401)"
         )
 
         # Validate error response
         validator = ResponseValidator()
         error_validation = validator.validate_error_response(
-            response, expected_status=401, expected_error_key="detail"
+            response, expected_status=response.status_code, expected_error_key="detail"
         )
         assert error_validation["valid"]
 
@@ -169,7 +167,7 @@ async def test_authorization_header_validation(
     valid_api_key = response.json()["api_key"]
 
     # Test scenarios
-    test_cases = [
+    test_cases: list[tuple[dict[str, str], int, str]] = [
         # (headers, expected_status, description)
         (
             {},
@@ -193,7 +191,7 @@ async def test_authorization_header_validation(
         integration_client.headers.pop("authorization", None)
 
         # Set test headers
-        integration_client.headers.update(headers)
+        integration_client.headers.update(headers)  # type: ignore[arg-type]
 
         # Make request to protected endpoint
         response = await integration_client.get("/v1/wallet/")
@@ -256,16 +254,14 @@ async def test_database_state_api_key_creation(
         # Verify database record
         hashed_key = api_key[3:]  # Remove "sk-" prefix
         result = await integration_session.execute(
-            select(ApiKey).where(ApiKey.hashed_key == hashed_key)  # type: ignore[arg-type]
+            select(TemporaryCredit).where(TemporaryCredit.hashed_key == hashed_key)  # type: ignore[arg-type]
         )
         db_key = result.scalar_one()
 
         # Validate stored data
         assert db_key.balance == amount * 1000  # msats
-        assert db_key.total_spent == 0
-        assert db_key.total_requests == 0
         assert db_key.refund_address is None
-        assert db_key.key_expiry_time is None
+        assert db_key.refund_expiration_time is None
 
         # Creation timestamp should be recent (within last minute)
         # Note: The model doesn't have a creation timestamp field,
@@ -446,7 +442,7 @@ async def test_concurrent_token_submissions(
     for api_key in api_keys:
         hashed_key = api_key[3:]  # Remove "sk-" prefix
         result = await integration_session.execute(
-            select(ApiKey).where(ApiKey.hashed_key == hashed_key)  # type: ignore[arg-type]
+            select(TemporaryCredit).where(TemporaryCredit.hashed_key == hashed_key)  # type: ignore[arg-type]
         )
         db_key = result.scalar_one()
         assert db_key.balance == expected_balances[hashed_key]
@@ -568,7 +564,7 @@ async def test_database_timestamp_accuracy(
     # Verify key exists in database
     hashed_key = api_key[3:]  # Remove "sk-" prefix
     result = await integration_session.execute(
-        select(ApiKey).where(ApiKey.hashed_key == hashed_key)  # type: ignore[arg-type]
+        select(TemporaryCredit).where(TemporaryCredit.hashed_key == hashed_key)  # type: ignore[arg-type]
     )
     db_key = result.scalar_one()
 

tests/integration/test_wallet_information.py

@@ -11,7 +11,7 @@ import pytest
 from httpx import AsyncClient
 from sqlmodel import select, update
 
-from routstr.core.db import ApiKey
+from routstr.core.db import TemporaryCredit
 
 from .utils import ConcurrencyTester, ResponseValidator
 
@@ -49,7 +49,7 @@ async def test_wallet_endpoint_with_valid_api_key(
     hashed_key = api_key[3:]  # Remove "sk-" prefix
 
     result = await integration_session.execute(
-        select(ApiKey).where(ApiKey.hashed_key == hashed_key)  # type: ignore[arg-type]
+        select(TemporaryCredit).where(TemporaryCredit.hashed_key == hashed_key)  # type: ignore[arg-type]
     )
     db_key = result.scalar_one()
 
@@ -138,7 +138,9 @@ async def test_wallet_with_zero_balance(
     # Manually set balance to zero in database
     hashed_key = api_key[3:]  # Remove "sk-" prefix
     await integration_session.execute(
-        update(ApiKey).where(ApiKey.hashed_key == hashed_key).values(balance=0)  # type: ignore[arg-type]
+        update(TemporaryCredit)
+        .where(TemporaryCredit.hashed_key == hashed_key)
+        .values(balance=0)  # type: ignore[arg-type]
     )
     await integration_session.commit()
 
@@ -181,9 +183,11 @@ async def test_expired_api_key_behavior(
     from sqlmodel import update
 
     await integration_session.execute(
-        update(ApiKey)
-        .where(ApiKey.hashed_key == hashed_key)  # type: ignore[arg-type]
-        .values(key_expiry_time=past_expiry, refund_address="test@lightning.address")
+        update(TemporaryCredit)
+        .where(TemporaryCredit.hashed_key == hashed_key)  # type: ignore[arg-type]
+        .values(
+            refund_expiration_time=past_expiry, refund_address="test@lightning.address"
+        )
     )
     await integration_session.commit()
 
@@ -197,10 +201,10 @@ async def test_expired_api_key_behavior(
     # Verify expiry time was stored
     hashed_key = api_key[3:]  # Remove "sk-" prefix
     result = await integration_session.execute(
-        select(ApiKey).where(ApiKey.hashed_key == hashed_key)  # type: ignore[arg-type]
+        select(TemporaryCredit).where(TemporaryCredit.hashed_key == hashed_key)  # type: ignore[arg-type]
     )
     db_key = result.scalar_one()
-    assert db_key.key_expiry_time == past_expiry
+    assert db_key.refund_expiration_time == past_expiry
     assert db_key.refund_address == "test@lightning.address"
 
 
@@ -270,7 +274,7 @@ async def test_wallet_info_data_consistency(
     # Verify against database
     hashed_key = api_key[3:]  # Remove "sk-" prefix
     result = await integration_session.execute(
-        select(ApiKey).where(ApiKey.hashed_key == hashed_key)  # type: ignore[arg-type]
+        select(TemporaryCredit).where(TemporaryCredit.hashed_key == hashed_key)  # type: ignore[arg-type]
     )
     db_key = result.scalar_one()
 
@@ -360,12 +364,10 @@ async def test_wallet_after_partial_spending(
     hashed_key = api_key[3:]  # Remove "sk-" prefix
 
     await integration_session.execute(
-        update(ApiKey)
-        .where(ApiKey.hashed_key == hashed_key)  # type: ignore[arg-type]
+        update(TemporaryCredit)
+        .where(TemporaryCredit.hashed_key == hashed_key)  # type: ignore[arg-type]
         .values(
             balance=initial_balance - spent_amount,
-            total_spent=spent_amount,
-            total_requests=5,  # Simulate 5 requests
         )
     )
     await integration_session.commit()

tests/integration/test_wallet_refund.py

@@ -13,7 +13,7 @@ import pytest
 from httpx import AsyncClient
 from sqlmodel import select
 
-from routstr.core.db import ApiKey
+from routstr.core.db import TemporaryCredit
 
 
 @pytest.mark.integration
@@ -123,7 +123,9 @@ async def test_zero_balance_refund_handling(
     from sqlmodel import update
 
     await integration_session.execute(
-        update(ApiKey).where(ApiKey.hashed_key == hashed_key).values(balance=0)  # type: ignore[arg-type]
+        update(TemporaryCredit)
+        .where(TemporaryCredit.hashed_key == hashed_key)
+        .values(balance=0)  # type: ignore[arg-type]
     )
     await integration_session.commit()
 
@@ -136,7 +138,7 @@ async def test_zero_balance_refund_handling(
 
     # Key should still exist
     result = await integration_session.execute(
-        select(ApiKey).where(ApiKey.hashed_key == hashed_key)  # type: ignore[arg-type]
+        select(TemporaryCredit).where(TemporaryCredit.hashed_key == hashed_key)  # type: ignore[arg-type]
     )
     assert result.scalar_one_or_none() is not None
 
@@ -159,7 +161,7 @@ async def test_refund_amount_validation(
 
     # Verify the key has no refund address (needed for the "too small" check)
     result = await integration_session.execute(
-        select(ApiKey).where(ApiKey.hashed_key == hashed_key)  # type: ignore[arg-type]
+        select(TemporaryCredit).where(TemporaryCredit.hashed_key == hashed_key)  # type: ignore[arg-type]
     )
     key = result.scalar_one()
     assert key.refund_address is None
@@ -192,8 +194,8 @@ async def test_refund_with_lightning_address(
     from sqlmodel import update
 
     await integration_session.execute(
-        update(ApiKey)
-        .where(ApiKey.hashed_key == hashed_key)  # type: ignore[arg-type]
+        update(TemporaryCredit)
+        .where(TemporaryCredit.hashed_key == hashed_key)  # type: ignore[arg-type]
         .values(refund_address=refund_address)
     )
     await integration_session.commit()
@@ -252,7 +254,7 @@ async def test_database_state_after_refund(
 
     # Verify key exists before refund
     result = await integration_session.execute(
-        select(ApiKey).where(ApiKey.hashed_key == hashed_key)  # type: ignore[arg-type]
+        select(TemporaryCredit).where(TemporaryCredit.hashed_key == hashed_key)  # type: ignore[arg-type]
     )
     key_before = result.scalar_one()
     assert key_before.balance == 10_000_000
@@ -263,12 +265,12 @@ async def test_database_state_after_refund(
 
     # Verify key is deleted after refund
     result = await integration_session.execute(
-        select(ApiKey).where(ApiKey.hashed_key == hashed_key)  # type: ignore[arg-type]
+        select(TemporaryCredit).where(TemporaryCredit.hashed_key == hashed_key)  # type: ignore[arg-type]
     )
     assert result.scalar_one_or_none() is None
 
     # Count total keys to ensure only the specific one was deleted
-    result = await integration_session.execute(select(ApiKey))
+    result = await integration_session.execute(select(TemporaryCredit))
     remaining_keys = result.scalars().all()
     # Should have no keys left (assuming clean test environment)
     assert len(remaining_keys) == 0
@@ -480,8 +482,8 @@ async def test_refund_error_handling(
     from sqlmodel import update
 
     await integration_session.execute(
-        update(ApiKey)
-        .where(ApiKey.hashed_key == hashed_key)  # type: ignore[arg-type]
+        update(TemporaryCredit)
+        .where(TemporaryCredit.hashed_key == hashed_key)  # type: ignore[arg-type]
         .values(balance=-1000)  # Invalid negative balance
     )
     await integration_session.commit()
@@ -517,9 +519,9 @@ async def test_refund_with_expired_key(
     from sqlmodel import update
 
     await integration_session.execute(
-        update(ApiKey)
-        .where(ApiKey.hashed_key == hashed_key)  # type: ignore[arg-type]
-        .values(key_expiry_time=past_expiry, refund_address="expired@ln.address")
+        update(TemporaryCredit)
+        .where(TemporaryCredit.hashed_key == hashed_key)  # type: ignore[arg-type]
+        .values(refund_expiration_time=past_expiry, refund_address="expired@ln.address")
     )
     await integration_session.commit()
 

tests/integration/test_wallet_topup.py

@@ -11,7 +11,7 @@ import pytest
 from httpx import AsyncClient
 from sqlmodel import select
 
-from routstr.core.db import ApiKey
+from routstr.core.db import TemporaryCredit
 
 from .utils import (
     CashuTokenGenerator,
@@ -64,7 +64,7 @@ async def test_topup_with_valid_token(  # type: ignore[no-untyped-def]
     # Get the hashed key from the API key
     hashed_key = api_key[3:]  # Remove "sk-" prefix
     result = await integration_session.execute(
-        select(ApiKey).where(ApiKey.hashed_key == hashed_key)  # type: ignore[arg-type]
+        select(TemporaryCredit).where(TemporaryCredit.hashed_key == hashed_key)  # type: ignore[arg-type]
     )
     db_key = result.scalar_one()
 

tests/integration/utils.py

@@ -9,7 +9,7 @@ import httpx
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlmodel import select
 
-from routstr.core.db import ApiKey
+from routstr.core.db import TemporaryCredit
 
 
 class CashuTokenGenerator:
@@ -97,11 +97,11 @@ class DatabaseStateValidator:
     def __init__(self, session: AsyncSession) -> None:
         self.session = session
 
-    async def get_api_key(self, api_key: str) -> Optional[ApiKey]:
+    async def get_api_key(self, api_key: str) -> Optional[TemporaryCredit]:
         """Get API key from database"""
         hashed_key = hashlib.sha256(api_key.encode()).hexdigest()
         result = await self.session.execute(
-            select(ApiKey).where(ApiKey.hashed_key == hashed_key)  # type: ignore[arg-type]
+            select(TemporaryCredit).where(TemporaryCredit.hashed_key == hashed_key)  # type: ignore[arg-type]
         )
         return result.scalar_one_or_none()
 
@@ -125,20 +125,6 @@ class DatabaseStateValidator:
             "current_balance": key_obj.balance,
         }
 
-    async def validate_request_count(
-        self, api_key: str, expected_count: int
-    ) -> Dict[str, Any]:
-        """Validate request count for an API key"""
-        key_obj = await self.get_api_key(api_key)
-        if not key_obj:
-            return {"valid": False, "error": "API key not found"}
-
-        return {
-            "valid": key_obj.total_requests == expected_count,
-            "expected": expected_count,
-            "actual": key_obj.total_requests,
-        }
-
     async def validate_atomic_update(
         self, api_key: str, field: str, expected_value: Any
     ) -> bool:
@@ -315,7 +301,7 @@ class ConcurrencyTester:
                 )
 
         tasks = [make_request(req) for req in requests]
-        return await asyncio.gather(*tasks, return_exceptions=False)
+        return await asyncio.gather(*tasks, return_exceptions=False)  # type: ignore
 
     @staticmethod
     async def test_race_condition(
@@ -463,8 +449,6 @@ class TestDataBuilder:
         """Create test API key data"""
         data: Dict[str, Any] = {
             "balance": balance,
-            "total_spent": 0,
-            "total_requests": 0,
         }
 
         if refund_address:

tests/integration/verify_setup.py

@@ -44,9 +44,9 @@ def check_imports() -> bool:
         print("Conftest fixtures imported successfully")
 
         # Check routstr modules - imports are for verification only
-        from routstr.core.db import ApiKey
+        from routstr.core.db import TemporaryCredit
 
-        del ApiKey
+        del TemporaryCredit
 
         print("Router modules imported successfully")
 

tests/unit/test_algorithm.py

@@ -7,12 +7,12 @@ from unittest.mock import Mock
 os.environ["UPSTREAM_BASE_URL"] = "http://test"
 os.environ["UPSTREAM_API_KEY"] = "test"
 
-from routstr.algorithm import (  # noqa: E402
+from routstr.models.algorithm import (  # noqa: E402
     calculate_model_cost_score,
     get_provider_penalty,
     should_prefer_model,
 )
-from routstr.payment.models import Architecture, Model, Pricing  # noqa: E402
+from routstr.models.models import Architecture, Model, Pricing  # noqa: E402
 
 
 def create_test_model(

tests/unit/test_fee_consistency.py

@@ -21,11 +21,11 @@ import pytest
 os.environ["UPSTREAM_BASE_URL"] = "http://test"
 os.environ["UPSTREAM_API_KEY"] = "test"
 
-from routstr.payment.models import (  # noqa: E402
+from routstr.models.crud import _model_to_row_payload
+from routstr.models.models import (  # noqa: E402
     Architecture,
     Model,
     Pricing,
-    _model_to_row_payload,
 )
 
 

tests/unit/test_image_tokens.py

@@ -4,10 +4,10 @@ from io import BytesIO
 import pytest
 from PIL import Image
 
-from routstr.payment.helpers import (
+from routstr.payment.cost import (
     _calculate_image_tokens,
+    _estimate_image_tokens_in_messages,
     _get_image_dimensions,
-    estimate_image_tokens_in_messages,
 )
 
 
@@ -81,7 +81,7 @@ async def test_estimate_image_tokens_base64() -> None:
         }
     ]
 
-    tokens = await estimate_image_tokens_in_messages(messages)
+    tokens = await _estimate_image_tokens_in_messages(messages)
     assert tokens > 0
 
 
@@ -108,7 +108,7 @@ async def test_estimate_image_tokens_multiple_images() -> None:
         }
     ]
 
-    tokens = await estimate_image_tokens_in_messages(messages)
+    tokens = await _estimate_image_tokens_in_messages(messages)
     assert tokens > 0
 
 
@@ -148,8 +148,8 @@ async def test_estimate_image_tokens_with_detail() -> None:
         }
     ]
 
-    tokens_low = await estimate_image_tokens_in_messages(messages_low)
-    tokens_high = await estimate_image_tokens_in_messages(messages_high)
+    tokens_low = await _estimate_image_tokens_in_messages(messages_low)
+    tokens_high = await _estimate_image_tokens_in_messages(messages_high)
 
     assert tokens_low == 85
     assert tokens_high > tokens_low
@@ -163,7 +163,7 @@ async def test_estimate_image_tokens_no_images() -> None:
         {"role": "assistant", "content": "I'm doing well, thank you!"},
     ]
 
-    tokens = await estimate_image_tokens_in_messages(messages)
+    tokens = await _estimate_image_tokens_in_messages(messages)
     assert tokens == 0
 
 
@@ -185,5 +185,5 @@ async def test_estimate_image_tokens_input_image_type() -> None:
         }
     ]
 
-    tokens = await estimate_image_tokens_in_messages(messages)
+    tokens = await _estimate_image_tokens_in_messages(messages)
     assert tokens > 0

tests/unit/test_payment_helpers.py

@@ -7,11 +7,11 @@ os.environ["UPSTREAM_BASE_URL"] = "http://test"
 os.environ["UPSTREAM_API_KEY"] = "test"
 
 from routstr.core.settings import settings  # noqa: E402
-from routstr.payment.helpers import get_max_cost_for_model  # noqa: E402
+from routstr.payment.cost import get_max_cost_for_model  # noqa: E402
 
 
 async def test_get_max_cost_for_model_known() -> None:
-    from routstr.payment.models import Pricing
+    from routstr.models.models import Pricing
 
     # Mock DB session behavior
     mock_session = AsyncMock()
@@ -63,48 +63,32 @@ async def test_get_max_cost_for_model_known() -> None:
 
     with patch.object(settings, "fixed_pricing", False):
         with patch.object(settings, "tolerance_percentage", 0):
-            cost = await get_max_cost_for_model(
-                "gpt-4", session=mock_session, model_obj=mock_model
-            )
+            cost = get_max_cost_for_model(model_obj=mock_model)
             assert cost == 500000  # 500 sats * 1000 = msats
 
 
 async def test_get_max_cost_for_model_unknown() -> None:
-    mock_session = AsyncMock()
+    mock_model = Mock()
+    mock_model.sats_pricing = None
+    mock_model.id = "unknown-model"
 
-    # Mock the exec results to return no model override
-    async def async_mock_exec(query: Any) -> Any:
-        result = Mock()
-        result.first = Mock(return_value=None)
-        result.all = Mock(return_value=[])
-        return result
-
-    mock_session.exec = AsyncMock(side_effect=async_mock_exec)
-    mock_session.get = AsyncMock(return_value=None)
-
-    # Mock get_upstreams to return empty list
-    with patch("routstr.proxy.get_upstreams", return_value=[]):
-        with patch.object(settings, "fixed_cost_per_request", 100):
-            with patch.object(settings, "tolerance_percentage", 0):
-                cost = await get_max_cost_for_model(
-                    "unknown-model", session=mock_session, model_obj=None
-                )
-                assert cost == 100000
+    with patch.object(settings, "fixed_cost_per_request", 100):
+        with patch.object(settings, "tolerance_percentage", 0):
+            cost = get_max_cost_for_model(model_obj=mock_model)
+            assert cost == 100000
 
 
 async def test_get_max_cost_for_model_disabled() -> None:
-    mock_session = AsyncMock()
+    mock_model = Mock()
     with patch.object(settings, "fixed_pricing", True):
         with patch.object(settings, "fixed_cost_per_request", 200):
             with patch.object(settings, "tolerance_percentage", 0):
-                cost = await get_max_cost_for_model("any-model", session=mock_session)
+                cost = get_max_cost_for_model(model_obj=mock_model)
                 assert cost == 200000
 
 
 async def test_get_max_cost_for_model_tolerance() -> None:
-    from routstr.payment.models import Pricing
-
-    mock_session = AsyncMock()
+    from routstr.models.models import Pricing
 
     # Mock the model with sats_pricing
     mock_pricing = Pricing(
@@ -121,7 +105,5 @@ async def test_get_max_cost_for_model_tolerance() -> None:
 
     with patch.object(settings, "fixed_pricing", False):
         with patch.object(settings, "tolerance_percentage", 10):
-            cost = await get_max_cost_for_model(
-                "gpt-4", session=mock_session, model_obj=mock_model
-            )
+            cost = get_max_cost_for_model(model_obj=mock_model)
             assert cost == 450000  # 500 sats * 1000 * 0.9 = 450000

tests/unit/test_wallet.py

@@ -4,8 +4,13 @@ from unittest.mock import AsyncMock, Mock, patch
 
 import pytest
 
-from routstr.core.db import ApiKey
-from routstr.wallet import credit_balance, get_balance, recieve_token, send_token
+from routstr.core.db import TemporaryCredit
+from routstr.payment.wallet import (
+    credit_balance,
+    get_balance,
+    recieve_token,
+    send_token,
+)
 
 
 @pytest.mark.asyncio
@@ -15,7 +20,7 @@ async def test_get_balance() -> None:
     mock_wallet.load_mint = AsyncMock()
     mock_wallet.load_proofs = AsyncMock()
 
-    with patch("routstr.wallet.Wallet.with_db", return_value=mock_wallet):
+    with patch("routstr.payment.wallet.Wallet.with_db", return_value=mock_wallet):
         balance = await get_balance("sat")
         assert balance == 50000
 
@@ -43,7 +48,9 @@ async def test_recieve_token_valid() -> None:
     from routstr.core.settings import settings
 
     with patch.object(settings, "cashu_mints", ["http://mint:3338"]):
-        with patch("routstr.wallet.deserialize_token_from_string") as mock_deserialize:
+        with patch(
+            "routstr.payment.wallet.deserialize_token_from_string"
+        ) as mock_deserialize:
             mock_token = Mock()
             mock_token.keysets = ["keyset1"]
             mock_token.mint = "http://mint:3338"
@@ -54,7 +61,9 @@ async def test_recieve_token_valid() -> None:
 
             mock_wallet.load_mint = AsyncMock()
             mock_wallet.load_proofs = AsyncMock()
-            with patch("routstr.wallet.Wallet.with_db", return_value=mock_wallet):
+            with patch(
+                "routstr.payment.wallet.Wallet.with_db", return_value=mock_wallet
+            ):
                 amount, unit, mint = await recieve_token(token_str)
                 assert amount == 1000
                 assert unit == "sat"
@@ -65,8 +74,8 @@ async def test_recieve_token_valid() -> None:
 async def test_send_token() -> None:
     mock_wallet = Mock()
 
-    with patch("routstr.wallet.Wallet.with_db", return_value=mock_wallet):
-        with patch("routstr.wallet.send", return_value=(1000, "test_token")):
+    with patch("routstr.payment.wallet.Wallet.with_db", return_value=mock_wallet):
+        with patch("routstr.payment.wallet.send", return_value=(1000, "test_token")):
             token = await send_token(1000, "sat", "http://mint:3338")
             assert token == "test_token"
 
@@ -87,7 +96,7 @@ async def test_credit_balance() -> None:
     mock_session = AsyncMock()
 
     # Mock session.refresh to update the balance (simulates DB reload)
-    async def mock_refresh(key: ApiKey) -> None:
+    async def mock_refresh(key: TemporaryCredit) -> None:
         key.balance = 6000000
 
     mock_session.refresh.side_effect = mock_refresh
@@ -96,7 +105,7 @@ async def test_credit_balance() -> None:
 
     with patch.object(settings, "cashu_mints", ["http://mint:3338"]):
         with patch(
-            "routstr.wallet.recieve_token",
+            "routstr.payment.wallet.recieve_token",
             return_value=(1000, "sat", "http://mint:3338"),
         ):
             amount = await credit_balance(token_str, mock_key, mock_session)
@@ -112,7 +121,9 @@ async def test_credit_balance() -> None:
 async def test_recieve_token_untrusted_mint() -> None:
     mock_wallet = Mock()
 
-    with patch("routstr.wallet.deserialize_token_from_string") as mock_deserialize:
+    with patch(
+        "routstr.payment.wallet.deserialize_token_from_string"
+    ) as mock_deserialize:
         mock_token = Mock()
         mock_token.keysets = ["keyset1"]
         mock_token.mint = "http://untrusted:3338"
@@ -122,9 +133,9 @@ async def test_recieve_token_untrusted_mint() -> None:
 
         mock_wallet.load_mint = AsyncMock()
         mock_wallet.load_proofs = AsyncMock()
-        with patch("routstr.wallet.Wallet.with_db", return_value=mock_wallet):
+        with patch("routstr.payment.wallet.Wallet.with_db", return_value=mock_wallet):
             with patch(
-                "routstr.wallet.swap_to_primary_mint",
+                "routstr.payment.wallet.swap_to_primary_mint",
                 return_value=(900, "sat", "http://mint:3338"),
             ):
                 amount, unit, mint = await recieve_token("test_token")

ui/app/_register/page.tsx

@@ -1,172 +0,0 @@
-'use client';
-
-import { useAuth } from '@/lib/auth/AuthContext';
-import { Button } from '@/components/ui/button';
-import { Input } from '@/components/ui/input';
-import { Label } from '@/components/ui/label';
-import { useRouter } from 'next/navigation';
-import { useState } from 'react';
-import { toast } from 'sonner';
-import Link from 'next/link';
-import { ArrowUpCircleIcon } from 'lucide-react';
-import { registerUser, SchemaRegisterProps } from '@/lib/api/services/auth';
-
-export default function NostrRegisterPage() {
-  const router = useRouter();
-  const { connectNostr } = useAuth();
-  const [isLoading, setIsLoading] = useState(false);
-  const [formData, setFormData] = useState<SchemaRegisterProps>({
-    npub: '',
-    name: '',
-  });
-
-  const handleInputChange = (e: React.ChangeEvent<HTMLInputElement>) => {
-    const { name, value } = e.target;
-    setFormData((prev) => ({ ...prev, [name]: value }));
-  };
-
-  const handleNostrConnect = async () => {
-    setIsLoading(true);
-    try {
-      const publicKey = await connectNostr();
-      if (publicKey) {
-        setFormData((prev) => ({ ...prev, npub: publicKey }));
-        toast.success(
-          'Nostr connected. Please enter your name to complete registration.'
-        );
-      } else {
-        toast.error(
-          'Failed to connect. Please make sure your Nostr extension is installed and enabled.'
-        );
-      }
-    } catch (error) {
-      console.error('Nostr connection error:', error);
-      toast.error('Failed to connect to Nostr. Please try again.');
-    } finally {
-      setIsLoading(false);
-    }
-  };
-
-  const handleRegister = async (e: React.FormEvent) => {
-    e.preventDefault();
-
-    if (!formData.npub || formData.npub.length < 10) {
-      toast.error('Please enter a valid Nostr public key');
-      return;
-    }
-
-    if (!formData.name) {
-      toast.error('Please enter your name');
-      return;
-    }
-
-    setIsLoading(true);
-    try {
-      // Register the user
-      const result = await registerUser(formData);
-      console.log('Registration successful:', result);
-      toast.success('Account created successfully');
-      router.push('/login');
-    } catch (error) {
-      console.error('Registration error:', error);
-      toast.error('Registration failed. Please try again.');
-    } finally {
-      setIsLoading(false);
-    }
-  };
-
-  return (
-    <div className='flex min-h-screen items-center justify-center p-4'>
-      <div className='w-full max-w-md'>
-        <div className='flex flex-col gap-6'>
-          <form onSubmit={handleRegister}>
-            <div className='flex flex-col gap-6'>
-              <div className='flex flex-col items-center gap-2'>
-                <Link
-                  href='/'
-                  className='flex flex-col items-center gap-2 font-medium'
-                >
-                  <div className='flex h-8 w-8 items-center justify-center rounded-md'>
-                    <ArrowUpCircleIcon className='size-6' />
-                  </div>
-                  <span className='sr-only'>Routstr</span>
-                </Link>
-                <h1 className='text-xl font-bold'>Create an Account</h1>
-                <div className='text-center text-sm'>
-                  Already have an account?{' '}
-                  <Link href='/login' className='underline underline-offset-4'>
-                    Sign in
-                  </Link>
-                </div>
-              </div>
-              <div className='flex flex-col gap-6'>
-                <div className='grid gap-2'>
-                  <Label htmlFor='npub'>Nostr Public Key (npub)</Label>
-                  <Input
-                    id='npub'
-                    name='npub'
-                    type='text'
-                    placeholder='npub1...'
-                    value={formData.npub}
-                    onChange={handleInputChange}
-                    required
-                  />
-                </div>
-                <div className='grid gap-2'>
-                  <Label htmlFor='name'>Name</Label>
-                  <Input
-                    id='name'
-                    name='name'
-                    type='text'
-                    placeholder='John Doe'
-                    value={formData.name}
-                    onChange={handleInputChange}
-                    required
-                  />
-                </div>
-                <Button type='submit' className='w-full' disabled={isLoading}>
-                  {isLoading ? 'Creating account...' : 'Create Account'}
-                </Button>
-              </div>
-              <div className='after:border-border relative text-center text-sm after:absolute after:inset-0 after:top-1/2 after:z-0 after:flex after:items-center after:border-t'>
-                <span className='bg-background text-muted-foreground relative z-10 px-2'>
-                  Or
-                </span>
-              </div>
-              <div className='grid gap-4'>
-                <Button
-                  variant='outline'
-                  className='w-full'
-                  onClick={handleNostrConnect}
-                  disabled={isLoading}
-                  type='button'
-                >
-                  <svg
-                    className='mr-2 h-4 w-4'
-                    viewBox='0 0 256 256'
-                    xmlns='http://www.w3.org/2000/svg'
-                  >
-                    <path
-                      d='M158.4 28.4c-31.8-31.8-83.1-31.8-114.9 0s-31.8 83.1 0 114.9l57.4 57.4 57.4-57.4c31.8-31.8 31.8-83.1 0-114.9z'
-                      fill='currentColor'
-                    />
-                    <path
-                      d='M215.8 199.3c-31.8-31.8-83.1-31.8-114.9 0L43.6 256l57.4-57.4c31.8-31.8 31.8-83.1 0-114.9L158.4 28.4 101 85.8c-31.8 31.8-31.8 83.1 0 114.9l114.8-1.4z'
-                      fill='currentColor'
-                    />
-                  </svg>
-                  Connect with Nostr Extension
-                </Button>
-              </div>
-            </div>
-          </form>
-          <div className='text-muted-foreground hover:[&_a]:text-primary text-center text-xs text-balance [&_a]:underline [&_a]:underline-offset-4'>
-            By clicking create account, you agree to our{' '}
-            <Link href='#'>Terms of Service</Link> and{' '}
-            <Link href='#'>Privacy Policy</Link>.
-          </div>
-        </div>
-      </div>
-    </div>
-  );
-}

ui/app/balances/page.tsx

@@ -0,0 +1,62 @@
+'use client';
+
+import { useCurrencyStore } from '@/lib/stores/currency';
+import { useQuery } from '@tanstack/react-query';
+import { AppSidebar } from '@/components/app-sidebar';
+import { SiteHeader } from '@/components/site-header';
+import { SidebarInset, SidebarProvider } from '@/components/ui/sidebar';
+import { DetailedWalletBalance } from '@/components/detailed-wallet-balance';
+import { TemporaryBalances } from '@/components/temporary-balances';
+import { fetchBtcUsdPrice, btcToSatsRate } from '@/lib/exchange-rate';
+
+export default function BalancesPage() {
+  const { displayUnit } = useCurrencyStore();
+
+  const { data: btcUsdPrice } = useQuery({
+    queryKey: ['btc-usd-price'],
+    queryFn: fetchBtcUsdPrice,
+    refetchInterval: 120_000,
+    staleTime: 60_000,
+  });
+
+  const usdPerSat = btcUsdPrice ? btcToSatsRate(btcUsdPrice) : null;
+
+  return (
+    <SidebarProvider>
+      <AppSidebar variant='inset' />
+      <SidebarInset className='p-0'>
+        <SiteHeader />
+        <div className='container max-w-6xl px-4 py-8 md:px-6 lg:px-8'>
+          <div className='mb-8 flex flex-col gap-4 lg:flex-row lg:items-start lg:justify-between'>
+            <div>
+              <h1 className='text-3xl font-bold tracking-tight'>
+                Balances
+              </h1>
+              <p className='text-muted-foreground mt-2'>
+                Monitor and manage wallet balances
+              </p>
+            </div>
+            {/* Global currency toggle is now in SiteHeader */}
+          </div>
+
+          <div className='grid gap-6'>
+            <div className='col-span-full'>
+              <DetailedWalletBalance
+                refreshInterval={30000}
+                displayUnit={displayUnit}
+                usdPerSat={usdPerSat}
+              />
+            </div>
+            <div className='col-span-full'>
+              <TemporaryBalances
+                refreshInterval={60000}
+                displayUnit={displayUnit}
+                usdPerSat={usdPerSat}
+              />
+            </div>
+          </div>
+        </div>
+      </SidebarInset>
+    </SidebarProvider>
+  );
+}

ui/app/globals.css

@@ -6,8 +6,8 @@
 @theme inline {
   --color-background: var(--background);
   --color-foreground: var(--foreground);
-  --font-sans: var(--font-geist-sans);
-  --font-mono: var(--font-geist-mono);
+  --font-sans: Geist, sans-serif;
+  --font-mono: Geist Mono, monospace;
   --color-sidebar-ring: var(--sidebar-ring);
   --color-sidebar-border: var(--sidebar-border);
   --color-sidebar-accent-foreground: var(--sidebar-accent-foreground);
@@ -41,75 +41,152 @@
   --radius-md: calc(var(--radius) - 2px);
   --radius-lg: var(--radius);
   --radius-xl: calc(var(--radius) + 4px);
+  --font-serif: Georgia, serif;
+  --radius: 0.5rem;
+  --tracking-tighter: calc(var(--tracking-normal) - 0.05em);
+  --tracking-tight: calc(var(--tracking-normal) - 0.025em);
+  --tracking-wide: calc(var(--tracking-normal) + 0.025em);
+  --tracking-wider: calc(var(--tracking-normal) + 0.05em);
+  --tracking-widest: calc(var(--tracking-normal) + 0.1em);
+  --tracking-normal: var(--tracking-normal);
+  --shadow-2xl: var(--shadow-2xl);
+  --shadow-xl: var(--shadow-xl);
+  --shadow-lg: var(--shadow-lg);
+  --shadow-md: var(--shadow-md);
+  --shadow: var(--shadow);
+  --shadow-sm: var(--shadow-sm);
+  --shadow-xs: var(--shadow-xs);
+  --shadow-2xs: var(--shadow-2xs);
+  --spacing: var(--spacing);
+  --letter-spacing: var(--letter-spacing);
+  --shadow-offset-y: var(--shadow-offset-y);
+  --shadow-offset-x: var(--shadow-offset-x);
+  --shadow-spread: var(--shadow-spread);
+  --shadow-blur: var(--shadow-blur);
+  --shadow-opacity: var(--shadow-opacity);
+  --color-shadow-color: var(--shadow-color);
+  --color-destructive-foreground: var(--destructive-foreground);
 }
 
 :root {
-  --radius: 0.625rem;
-  --background: oklch(1 0 0);
-  --foreground: oklch(0.147 0.004 49.25);
+  --radius: 0.5rem;
+  --background: oklch(0.99 0 0);
+  --foreground: oklch(0 0 0);
   --card: oklch(1 0 0);
-  --card-foreground: oklch(0.147 0.004 49.25);
-  --popover: oklch(1 0 0);
-  --popover-foreground: oklch(0.147 0.004 49.25);
-  --primary: oklch(0.216 0.006 56.043);
-  --primary-foreground: oklch(0.985 0.001 106.423);
-  --secondary: oklch(0.97 0.001 106.424);
-  --secondary-foreground: oklch(0.216 0.006 56.043);
-  --muted: oklch(0.97 0.001 106.424);
-  --muted-foreground: oklch(0.553 0.013 58.071);
-  --accent: oklch(0.97 0.001 106.424);
-  --accent-foreground: oklch(0.216 0.006 56.043);
-  --destructive: oklch(0.577 0.245 27.325);
-  --border: oklch(0.923 0.003 48.717);
-  --input: oklch(0.923 0.003 48.717);
-  --ring: oklch(0.709 0.01 56.259);
-  --chart-1: oklch(0.646 0.222 41.116);
-  --chart-2: oklch(0.6 0.118 184.704);
-  --chart-3: oklch(0.398 0.07 227.392);
-  --chart-4: oklch(0.828 0.189 84.429);
-  --chart-5: oklch(0.769 0.188 70.08);
-  --sidebar: oklch(0.985 0.001 106.423);
-  --sidebar-foreground: oklch(0.147 0.004 49.25);
-  --sidebar-primary: oklch(0.216 0.006 56.043);
-  --sidebar-primary-foreground: oklch(0.985 0.001 106.423);
-  --sidebar-accent: oklch(0.97 0.001 106.424);
-  --sidebar-accent-foreground: oklch(0.216 0.006 56.043);
-  --sidebar-border: oklch(0.923 0.003 48.717);
-  --sidebar-ring: oklch(0.709 0.01 56.259);
+  --card-foreground: oklch(0 0 0);
+  --popover: oklch(0.99 0 0);
+  --popover-foreground: oklch(0 0 0);
+  --primary: oklch(0 0 0);
+  --primary-foreground: oklch(1 0 0);
+  --secondary: oklch(0.94 0 0);
+  --secondary-foreground: oklch(0 0 0);
+  --muted: oklch(0.97 0 0);
+  --muted-foreground: oklch(0.44 0 0);
+  --accent: oklch(0.94 0 0);
+  --accent-foreground: oklch(0 0 0);
+  --destructive: oklch(0.63 0.19 23.03);
+  --border: oklch(0.92 0 0);
+  --input: oklch(0.94 0 0);
+  --ring: oklch(0 0 0);
+  --chart-1: oklch(0.81 0.17 75.35);
+  --chart-2: oklch(0.55 0.22 264.53);
+  --chart-3: oklch(0.72 0 0);
+  --chart-4: oklch(0.92 0 0);
+  --chart-5: oklch(0.56 0 0);
+  --sidebar: oklch(0.99 0 0);
+  --sidebar-foreground: oklch(0 0 0);
+  --sidebar-primary: oklch(0 0 0);
+  --sidebar-primary-foreground: oklch(1 0 0);
+  --sidebar-accent: oklch(0.94 0 0);
+  --sidebar-accent-foreground: oklch(0 0 0);
+  --sidebar-border: oklch(0.94 0 0);
+  --sidebar-ring: oklch(0 0 0);
+  --destructive-foreground: oklch(1 0 0);
+  --font-sans: Geist, sans-serif;
+  --font-serif: Georgia, serif;
+  --font-mono: Geist Mono, monospace;
+  --shadow-color: hsl(0 0% 0%);
+  --shadow-opacity: 0.18;
+  --shadow-blur: 2px;
+  --shadow-spread: 0px;
+  --shadow-offset-x: 0px;
+  --shadow-offset-y: 1px;
+  --letter-spacing: 0em;
+  --spacing: 0.25rem;
+  --shadow-2xs: 0px 1px 2px 0px hsl(0 0% 0% / 0.09);
+  --shadow-xs: 0px 1px 2px 0px hsl(0 0% 0% / 0.09);
+  --shadow-sm:
+    0px 1px 2px 0px hsl(0 0% 0% / 0.18), 0px 1px 2px -1px hsl(0 0% 0% / 0.18);
+  --shadow:
+    0px 1px 2px 0px hsl(0 0% 0% / 0.18), 0px 1px 2px -1px hsl(0 0% 0% / 0.18);
+  --shadow-md:
+    0px 1px 2px 0px hsl(0 0% 0% / 0.18), 0px 2px 4px -1px hsl(0 0% 0% / 0.18);
+  --shadow-lg:
+    0px 1px 2px 0px hsl(0 0% 0% / 0.18), 0px 4px 6px -1px hsl(0 0% 0% / 0.18);
+  --shadow-xl:
+    0px 1px 2px 0px hsl(0 0% 0% / 0.18), 0px 8px 10px -1px hsl(0 0% 0% / 0.18);
+  --shadow-2xl: 0px 1px 2px 0px hsl(0 0% 0% / 0.45);
+  --tracking-normal: 0em;
 }
 
 .dark {
-  --background: oklch(0.147 0.004 49.25);
-  --foreground: oklch(0.985 0.001 106.423);
-  --card: oklch(0.216 0.006 56.043);
-  --card-foreground: oklch(0.985 0.001 106.423);
-  --popover: oklch(0.216 0.006 56.043);
-  --popover-foreground: oklch(0.985 0.001 106.423);
-  --primary: oklch(0.923 0.003 48.717);
-  --primary-foreground: oklch(0.216 0.006 56.043);
-  --secondary: oklch(0.268 0.007 34.298);
-  --secondary-foreground: oklch(0.985 0.001 106.423);
-  --muted: oklch(0.268 0.007 34.298);
-  --muted-foreground: oklch(0.709 0.01 56.259);
-  --accent: oklch(0.268 0.007 34.298);
-  --accent-foreground: oklch(0.985 0.001 106.423);
-  --destructive: oklch(0.704 0.191 22.216);
-  --border: oklch(1 0 0 / 10%);
-  --input: oklch(1 0 0 / 15%);
-  --ring: oklch(0.553 0.013 58.071);
-  --chart-1: oklch(0.488 0.243 264.376);
-  --chart-2: oklch(0.696 0.17 162.48);
-  --chart-3: oklch(0.769 0.188 70.08);
-  --chart-4: oklch(0.627 0.265 303.9);
-  --chart-5: oklch(0.645 0.246 16.439);
-  --sidebar: oklch(0.216 0.006 56.043);
-  --sidebar-foreground: oklch(0.985 0.001 106.423);
-  --sidebar-primary: oklch(0.488 0.243 264.376);
-  --sidebar-primary-foreground: oklch(0.985 0.001 106.423);
-  --sidebar-accent: oklch(0.268 0.007 34.298);
-  --sidebar-accent-foreground: oklch(0.985 0.001 106.423);
-  --sidebar-border: oklch(1 0 0 / 10%);
-  --sidebar-ring: oklch(0.553 0.013 58.071);
+  --background: oklch(0 0 0);
+  --foreground: oklch(1 0 0);
+  --card: oklch(0.14 0 0);
+  --card-foreground: oklch(1 0 0);
+  --popover: oklch(0.18 0 0);
+  --popover-foreground: oklch(1 0 0);
+  --primary: oklch(1 0 0);
+  --primary-foreground: oklch(0 0 0);
+  --secondary: oklch(0.25 0 0);
+  --secondary-foreground: oklch(1 0 0);
+  --muted: oklch(0.23 0 0);
+  --muted-foreground: oklch(0.72 0 0);
+  --accent: oklch(0.32 0 0);
+  --accent-foreground: oklch(1 0 0);
+  --destructive: oklch(0.69 0.2 23.91);
+  --border: oklch(0.26 0 0);
+  --input: oklch(0.32 0 0);
+  --ring: oklch(0.72 0 0);
+  --chart-1: oklch(0.81 0.17 75.35);
+  --chart-2: oklch(0.58 0.21 260.84);
+  --chart-3: oklch(0.56 0 0);
+  --chart-4: oklch(0.44 0 0);
+  --chart-5: oklch(0.92 0 0);
+  --sidebar: oklch(0.18 0 0);
+  --sidebar-foreground: oklch(1 0 0);
+  --sidebar-primary: oklch(1 0 0);
+  --sidebar-primary-foreground: oklch(0 0 0);
+  --sidebar-accent: oklch(0.32 0 0);
+  --sidebar-accent-foreground: oklch(1 0 0);
+  --sidebar-border: oklch(0.32 0 0);
+  --sidebar-ring: oklch(0.72 0 0);
+  --destructive-foreground: oklch(0 0 0);
+  --radius: 0.5rem;
+  --font-sans: Geist, sans-serif;
+  --font-serif: Georgia, serif;
+  --font-mono: Geist Mono, monospace;
+  --shadow-color: hsl(0 0% 0%);
+  --shadow-opacity: 0.18;
+  --shadow-blur: 2px;
+  --shadow-spread: 0px;
+  --shadow-offset-x: 0px;
+  --shadow-offset-y: 1px;
+  --letter-spacing: 0em;
+  --spacing: 0.25rem;
+  --shadow-2xs: 0px 1px 2px 0px hsl(0 0% 0% / 0.09);
+  --shadow-xs: 0px 1px 2px 0px hsl(0 0% 0% / 0.09);
+  --shadow-sm:
+    0px 1px 2px 0px hsl(0 0% 0% / 0.18), 0px 1px 2px -1px hsl(0 0% 0% / 0.18);
+  --shadow:
+    0px 1px 2px 0px hsl(0 0% 0% / 0.18), 0px 1px 2px -1px hsl(0 0% 0% / 0.18);
+  --shadow-md:
+    0px 1px 2px 0px hsl(0 0% 0% / 0.18), 0px 2px 4px -1px hsl(0 0% 0% / 0.18);
+  --shadow-lg:
+    0px 1px 2px 0px hsl(0 0% 0% / 0.18), 0px 4px 6px -1px hsl(0 0% 0% / 0.18);
+  --shadow-xl:
+    0px 1px 2px 0px hsl(0 0% 0% / 0.18), 0px 8px 10px -1px hsl(0 0% 0% / 0.18);
+  --shadow-2xl: 0px 1px 2px 0px hsl(0 0% 0% / 0.45);
 }
 
 @layer base {
@@ -118,6 +195,7 @@
   }
   body {
     @apply bg-background text-foreground;
+    letter-spacing: var(--tracking-normal);
   }
 }
 

ui/app/login/page.tsx

@@ -78,8 +78,8 @@ export default function AdminLoginPage(): ReactElement {
   };
 
   return (
-    <div className='flex min-h-screen items-center justify-center bg-gray-50 p-4'>
-      <Card className='w-full max-w-md'>
+    <div className='flex min-h-screen items-center justify-center bg-background px-4 py-12 text-foreground'>
+      <Card className='w-full max-w-md border border-border/60 bg-card/90 shadow-2xl shadow-black/30 backdrop-blur'>
         <CardHeader className='space-y-1'>
           <CardTitle className='text-center text-2xl font-bold'>
             Admin Login

ui/app/logs/log-details-dialog.tsx

@@ -0,0 +1,205 @@
+import { Button } from '@/components/ui/button';
+import { Badge } from '@/components/ui/badge';
+import { ScrollArea } from '@/components/ui/scroll-area';
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogHeader,
+  DialogTitle,
+} from '@/components/ui/dialog';
+import { Copy, Check } from 'lucide-react';
+import { useState } from 'react';
+
+interface LogEntry {
+  asctime: string;
+  name: string;
+  levelname: string;
+  message: string;
+  pathname: string;
+  lineno: number;
+  version: string;
+  request_id: string;
+  [key: string]: string | number | object | undefined;
+}
+
+interface LogDetailsDialogProps {
+  log: LogEntry | null;
+  isOpen: boolean;
+  onClose: () => void;
+}
+
+const getLevelColor = (level: string): string => {
+  switch (level.toUpperCase()) {
+    case 'TRACE':
+    case 'DEBUG':
+      return 'bg-gray-100 text-gray-800 border-gray-200';
+    case 'INFO':
+      return 'bg-blue-100 text-blue-800 border-blue-200';
+    case 'WARNING':
+      return 'bg-yellow-100 text-yellow-800 border-yellow-200';
+    case 'ERROR':
+      return 'bg-red-100 text-red-800 border-red-200';
+    case 'CRITICAL':
+      return 'bg-purple-100 text-purple-800 border-purple-200';
+    default:
+      return 'bg-gray-100 text-gray-800 border-gray-200';
+  }
+};
+
+export function LogDetailsDialog({
+  log,
+  isOpen,
+  onClose,
+}: LogDetailsDialogProps) {
+  const [copiedField, setCopiedField] = useState<string | null>(null);
+
+  if (!log) return null;
+
+  const copyToClipboard = (text: string, fieldName?: string) => {
+    navigator.clipboard.writeText(text);
+    if (fieldName) {
+      setCopiedField(fieldName);
+      setTimeout(() => setCopiedField(null), 2000);
+    }
+  };
+
+  const allFields = Object.keys(log).filter((key) => key !== 'key');
+  const standardFields = [
+    'asctime',
+    'name',
+    'levelname',
+    'message',
+    'pathname',
+    'lineno',
+    'version',
+    'request_id',
+  ];
+  const extraFields = allFields.filter((key) => !standardFields.includes(key));
+
+  return (
+    <Dialog open={isOpen} onOpenChange={onClose}>
+      <DialogContent className='max-h-[90vh] w-[95vw] max-w-[95vw] overflow-hidden'>
+        <DialogHeader>
+          <DialogTitle className='flex items-center gap-2'>
+            <Badge variant='outline' className={getLevelColor(log.levelname)}>
+              {log.levelname}
+            </Badge>
+            <span>Log Entry Details</span>
+          </DialogTitle>
+          <DialogDescription>
+            {log.asctime} • {log.name} • {log.pathname}:{log.lineno}
+          </DialogDescription>
+        </DialogHeader>
+
+        <ScrollArea className='h-[75vh] w-full overflow-x-auto'>
+          <div className='space-y-6'>
+            <div>
+              <h4 className='mb-2 text-sm font-medium'>Message</h4>
+              <div className='bg-muted max-h-48 overflow-auto rounded-md p-3'>
+                <pre className='font-mono text-sm whitespace-pre break-all'>
+                  {log.message}
+                </pre>
+              </div>
+            </div>
+
+            <div>
+              <h4 className='mb-3 text-sm font-medium'>Standard Fields</h4>
+              <div className='grid grid-cols-1 gap-3'>
+                {standardFields.map((field) => (
+                  <div key={field} className='flex flex-col space-y-1'>
+                    <div className='flex items-center justify-between gap-2'>
+                      <span className='text-muted-foreground text-xs font-medium uppercase'>
+                        {field}
+                      </span>
+                      {field === 'request_id' && (
+                        <Button
+                          variant='outline'
+                          size='sm'
+                          onClick={() => copyToClipboard(String(log[field as keyof LogEntry] || ''), field)}
+                          className='h-6 flex-shrink-0 px-2'
+                        >
+                          {copiedField === field ? (
+                            <>
+                              <Check className='mr-1 h-3 w-3' />
+                              Copied
+                            </>
+                          ) : (
+                            <>
+                              <Copy className='mr-1 h-3 w-3' />
+                              Copy
+                            </>
+                          )}
+                        </Button>
+                      )}
+                    </div>
+                    <div className='bg-muted max-h-32 overflow-auto rounded p-2'>
+                      <pre className='font-mono text-sm break-all whitespace-pre-wrap'>
+                        {String(log[field as keyof LogEntry] || 'N/A')}
+                      </pre>
+                    </div>
+                  </div>
+                ))}
+              </div>
+            </div>
+
+            {extraFields.length > 0 && (
+              <div>
+                <h4 className='mb-3 text-sm font-medium'>Additional Fields</h4>
+                <div className='grid grid-cols-1 gap-3'>
+                  {extraFields.map((field) => (
+                    <div key={field} className='flex flex-col space-y-1'>
+                      <span className='text-muted-foreground truncate text-xs font-medium uppercase'>
+                        {field}
+                      </span>
+                      <div className='bg-muted max-h-48 overflow-auto rounded p-2'>
+                        {typeof log[field] === 'object' ? (
+                          <pre className='font-mono text-xs break-all whitespace-pre-wrap'>
+                            {JSON.stringify(log[field], null, 2)}
+                          </pre>
+                        ) : (
+                          <pre className='font-mono text-sm break-all whitespace-pre-wrap'>
+                            {String(log[field] || 'N/A')}
+                          </pre>
+                        )}
+                      </div>
+                    </div>
+                  ))}
+                </div>
+              </div>
+            )}
+
+            <div>
+              <div className='mb-3 flex items-center justify-between'>
+                <h4 className='text-sm font-medium'>Raw JSON</h4>
+                <Button
+                  variant='outline'
+                  size='sm'
+                  onClick={() => copyToClipboard(JSON.stringify(log, null, 2), 'json')}
+                  className='h-6 px-2'
+                >
+                  {copiedField === 'json' ? (
+                    <>
+                      <Check className='mr-1 h-3 w-3' />
+                      Copied
+                    </>
+                  ) : (
+                    <>
+                      <Copy className='mr-1 h-3 w-3' />
+                      Copy
+                    </>
+                  )}
+                </Button>
+              </div>
+              <div className='bg-muted max-h-64 overflow-auto rounded-md p-4'>
+                <pre className='text-xs break-all whitespace-pre-wrap'>
+                  {JSON.stringify(log, null, 2)}
+                </pre>
+              </div>
+            </div>
+          </div>
+        </ScrollArea>
+      </DialogContent>
+    </Dialog>
+  );
+}

ui/app/logs/log-entry-card.tsx

@@ -0,0 +1,122 @@
+import { Badge } from '@/components/ui/badge';
+import { Eye } from 'lucide-react';
+
+interface LogEntry {
+  asctime: string;
+  name: string;
+  levelname: string;
+  message: string;
+  pathname: string;
+  lineno: number;
+  version: string;
+  request_id: string;
+  [key: string]: string | number | object | undefined;
+}
+
+interface LogEntryCardProps {
+  entry: LogEntry;
+  onClick: (entry: LogEntry) => void;
+}
+
+const getLevelColor = (level: string): string => {
+  switch (level.toUpperCase()) {
+    case 'TRACE':
+    case 'DEBUG':
+      return 'bg-gray-100 text-gray-800 border-gray-200';
+    case 'INFO':
+      return 'bg-blue-100 text-blue-800 border-blue-200';
+    case 'WARNING':
+      return 'bg-yellow-100 text-yellow-800 border-yellow-200';
+    case 'ERROR':
+      return 'bg-red-100 text-red-800 border-red-200';
+    case 'CRITICAL':
+      return 'bg-purple-100 text-purple-800 border-purple-200';
+    default:
+      return 'bg-gray-100 text-gray-800 border-gray-200';
+  }
+};
+
+export function LogEntryCard({ entry, onClick }: LogEntryCardProps) {
+  const extraFields = Object.keys(entry).filter(
+    (key) =>
+      ![
+        'asctime',
+        'name',
+        'levelname',
+        'message',
+        'pathname',
+        'lineno',
+        'version',
+        'request_id',
+      ].includes(key)
+  );
+
+  return (
+    <div
+      className='bg-card hover:bg-accent/50 group mb-4 cursor-pointer overflow-hidden rounded-lg border p-3 transition-colors duration-200 sm:p-4'
+      onClick={() => onClick(entry)}
+    >
+      <div className='mb-3 flex min-w-0 flex-col gap-2 sm:flex-row sm:items-center sm:justify-between'>
+        <div className='flex min-w-0 flex-wrap items-center gap-2'>
+          <Badge variant='outline' className={getLevelColor(entry.levelname)}>
+            {entry.levelname}
+          </Badge>
+          <span className='text-muted-foreground truncate text-xs sm:text-sm'>
+            {entry.asctime}
+          </span>
+          <Badge variant='secondary' className='truncate text-xs'>
+            {entry.name}
+          </Badge>
+        </div>
+        <div className='flex min-w-0 items-center gap-2'>
+          <div className='text-muted-foreground truncate text-xs'>
+            {entry.pathname}:{entry.lineno}
+          </div>
+          <Eye className='text-muted-foreground h-4 w-4 flex-shrink-0 opacity-0 transition-opacity group-hover:opacity-100' />
+        </div>
+      </div>
+
+      <div className='mb-2 line-clamp-3 overflow-hidden font-mono text-xs break-words sm:text-sm'>
+        {entry.message}
+      </div>
+
+      {entry.request_id && entry.request_id !== 'no-request-id' && (
+        <div className='mb-2 min-w-0'>
+          <div className='inline-block max-w-full'>
+            <Badge variant='outline' className='text-xs'>
+              <span className='inline-block max-w-[250px] truncate sm:max-w-[400px]'>
+                Request ID: {entry.request_id}
+              </span>
+            </Badge>
+          </div>
+        </div>
+      )}
+
+      {extraFields.length > 0 && (
+        <div className='mt-3 min-w-0 border-t pt-3'>
+          <div className='mb-2 text-xs font-medium'>Additional Fields:</div>
+          <div className='grid grid-cols-1 gap-2'>
+            {extraFields.slice(0, 4).map((key) => (
+              <div
+                key={key}
+                className='min-w-0 overflow-hidden text-xs break-words'
+              >
+                <span className='font-medium break-all'>{key}:</span>{' '}
+                <span className='text-muted-foreground break-all'>
+                  {typeof entry[key] === 'object'
+                    ? JSON.stringify(entry[key])
+                    : String(entry[key])}
+                </span>
+              </div>
+            ))}
+            {extraFields.length > 4 && (
+              <div className='text-muted-foreground text-xs'>
+                ...and {extraFields.length - 4} more fields
+              </div>
+            )}
+          </div>
+        </div>
+      )}
+    </div>
+  );
+}

ui/app/logs/log-filters.tsx

@@ -0,0 +1,296 @@
+import { Button } from '@/components/ui/button';
+import {
+  Card,
+  CardContent,
+  CardDescription,
+  CardHeader,
+  CardTitle,
+} from '@/components/ui/card';
+import { Input } from '@/components/ui/input';
+import { Label } from '@/components/ui/label';
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from '@/components/ui/select';
+import {
+  Popover,
+  PopoverContent,
+  PopoverTrigger,
+} from '@/components/ui/popover';
+import { Calendar } from '@/components/ui/calendar';
+import { CalendarIcon, Filter, X } from 'lucide-react';
+import { useState, useEffect } from 'react';
+import { format } from 'date-fns';
+import { cn } from '@/lib/utils';
+
+interface LogFiltersProps {
+  selectedDate: string;
+  selectedLevel: string;
+  requestId: string;
+  searchText: string;
+  limit: number;
+  onDateChange: (date: string) => void;
+  onLevelChange: (level: string) => void;
+  onRequestIdChange: (requestId: string) => void;
+  onSearchTextChange: (searchText: string) => void;
+  onLimitChange: (limit: number) => void;
+  onClearFilters: () => void;
+}
+
+const LOG_LEVELS = ['TRACE', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'];
+const PRESET_LIMITS = ['25', '50', '100', '200', '500', '1000'];
+
+export function LogFilters({
+  selectedDate,
+  selectedLevel,
+  requestId,
+  searchText,
+  limit,
+  onDateChange,
+  onLevelChange,
+  onRequestIdChange,
+  onSearchTextChange,
+  onLimitChange,
+  onClearFilters,
+}: LogFiltersProps) {
+  const isPreset = PRESET_LIMITS.includes(limit.toString());
+
+  const [customLimit, setCustomLimit] = useState<string>(
+    isPreset ? '' : limit.toString()
+  );
+  const [isCustom, setIsCustom] = useState<boolean>(!isPreset);
+  const [date, setDate] = useState<Date | undefined>(
+    selectedDate && selectedDate !== 'all'
+      ? new Date(selectedDate + 'T00:00:00')
+      : undefined
+  );
+
+  useEffect(() => {
+    const currentIsPreset = PRESET_LIMITS.includes(limit.toString());
+    setIsCustom(!currentIsPreset);
+    if (!currentIsPreset) {
+      setCustomLimit(limit.toString());
+    }
+  }, [limit]);
+
+  useEffect(() => {
+    if (selectedDate === 'all' || !selectedDate) {
+      setDate(undefined);
+    } else {
+      const d = new Date(selectedDate + 'T00:00:00');
+      setDate(isNaN(d.getTime()) ? undefined : d);
+    }
+  }, [selectedDate]);
+
+  const handleLimitChange = (value: string) => {
+    if (value === 'custom') {
+      setIsCustom(true);
+      setCustomLimit(limit.toString());
+    } else {
+      setIsCustom(false);
+      setCustomLimit('');
+      onLimitChange(Number(value));
+    }
+  };
+
+  const handleCustomLimitChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+    const value = e.target.value;
+    setCustomLimit(value);
+  };
+
+  const handleCustomLimitApply = () => {
+    const numValue = parseInt(customLimit);
+    if (!isNaN(numValue) && numValue > 0) {
+      onLimitChange(numValue);
+    } else {
+      setIsCustom(false);
+      setCustomLimit('');
+      onLimitChange(100);
+    }
+  };
+
+  const handleCustomLimitKeyDown = (
+    e: React.KeyboardEvent<HTMLInputElement>
+  ) => {
+    if (e.key === 'Enter') {
+      handleCustomLimitApply();
+    }
+  };
+
+  const handleDateSelect = (selectedDate: Date | undefined) => {
+    setDate(selectedDate);
+    if (selectedDate) {
+      onDateChange(format(selectedDate, 'yyyy-MM-dd'));
+    } else {
+      onDateChange('all');
+    }
+  };
+
+  return (
+    <Card className='mb-6'>
+      <CardHeader>
+        <CardTitle className='flex items-center gap-2'>
+          <Filter className='h-5 w-5' />
+          Filters
+        </CardTitle>
+        <CardDescription>
+          Filter logs by date, level, request ID, text search, and limit
+        </CardDescription>
+      </CardHeader>
+      <CardContent>
+        <div className='grid grid-cols-1 gap-4 md:grid-cols-2 lg:grid-cols-3'>
+          <div className='space-y-2'>
+            <Label htmlFor='date'>Date</Label>
+            <Popover>
+              <PopoverTrigger asChild>
+                <Button
+                  variant='outline'
+                  className={cn(
+                    'w-full justify-start text-left font-normal',
+                    !date && 'text-muted-foreground'
+                  )}
+                >
+                  <CalendarIcon className='mr-2 h-4 w-4' />
+                  {date ? format(date, 'PPP') : <span>Pick a date</span>}
+                </Button>
+              </PopoverTrigger>
+              <PopoverContent className='w-auto p-0' align='start'>
+                <Calendar
+                  mode='single'
+                  selected={date}
+                  onSelect={handleDateSelect}
+                  initialFocus
+                />
+              </PopoverContent>
+            </Popover>
+            {date && (
+              <Button
+                type='button'
+                variant='ghost'
+                size='sm'
+                onClick={() => handleDateSelect(undefined)}
+                className='w-full'
+              >
+                <X className='mr-2 h-4 w-4' />
+                Clear date
+              </Button>
+            )}
+          </div>
+
+          <div className='space-y-2'>
+            <Label htmlFor='level'>Log Level</Label>
+            <Select value={selectedLevel} onValueChange={onLevelChange}>
+              <SelectTrigger>
+                <SelectValue placeholder='Select level' />
+              </SelectTrigger>
+              <SelectContent>
+                <SelectItem value='all'>All levels</SelectItem>
+                {LOG_LEVELS.map((level) => (
+                  <SelectItem key={level} value={level}>
+                    {level}
+                  </SelectItem>
+                ))}
+              </SelectContent>
+            </Select>
+          </div>
+
+          <div className='space-y-2'>
+            <Label htmlFor='request-id'>Request ID</Label>
+            <Input
+              id='request-id'
+              type='text'
+              placeholder='Search by request ID'
+              value={requestId}
+              onChange={(e) => onRequestIdChange(e.target.value)}
+            />
+          </div>
+
+          <div className='space-y-2'>
+            <Label htmlFor='search-text' className='flex items-center gap-1'>
+              <span>Text Search</span>
+              <span className='text-muted-foreground text-xs font-normal'>
+                (can be slow)
+              </span>
+            </Label>
+            <Input
+              id='search-text'
+              type='text'
+              placeholder='Search in message and name'
+              value={searchText}
+              onChange={(e) => onSearchTextChange(e.target.value)}
+            />
+          </div>
+
+          <div className='space-y-2'>
+            <Label htmlFor='limit'>Limit</Label>
+            {isCustom ? (
+              <div className='flex gap-2'>
+                <Input
+                  id='limit'
+                  type='number'
+                  min='1'
+                  placeholder='Enter custom limit'
+                  value={customLimit}
+                  onChange={handleCustomLimitChange}
+                  onKeyDown={handleCustomLimitKeyDown}
+                  onBlur={handleCustomLimitApply}
+                  autoFocus
+                  className='flex-1'
+                />
+                <Button
+                  type='button'
+                  variant='secondary'
+                  size='sm'
+                  onClick={() => {
+                    setIsCustom(false);
+                    setCustomLimit('');
+                    if (!isPreset) {
+                      onLimitChange(100);
+                    }
+                  }}
+                >
+                  Cancel
+                </Button>
+              </div>
+            ) : (
+              <Select
+                value={isPreset ? limit.toString() : 'custom'}
+                onValueChange={handleLimitChange}
+              >
+                <SelectTrigger>
+                  <SelectValue placeholder='Select limit' />
+                </SelectTrigger>
+                <SelectContent>
+                  <SelectItem value='25'>25</SelectItem>
+                  <SelectItem value='50'>50</SelectItem>
+                  <SelectItem value='100'>100</SelectItem>
+                  <SelectItem value='200'>200</SelectItem>
+                  <SelectItem value='500'>500</SelectItem>
+                  <SelectItem value='1000'>1000</SelectItem>
+                  <SelectItem value='custom'>Custom...</SelectItem>
+                </SelectContent>
+              </Select>
+            )}
+            {!isCustom && !isPreset && (
+              <p className='text-muted-foreground text-xs'>Custom: {limit}</p>
+            )}
+          </div>
+
+          <div className='space-y-2'>
+            <Label>&nbsp;</Label>
+            <Button
+              onClick={onClearFilters}
+              variant='outline'
+              className='w-full'
+            >
+              Clear Filters
+            </Button>
+          </div>
+        </div>
+      </CardContent>
+    </Card>
+  );
+}

ui/app/logs/page.tsx

@@ -0,0 +1,178 @@
+'use client';
+
+import { useState } from 'react';
+import { useQuery } from '@tanstack/react-query';
+import { AppSidebar } from '@/components/app-sidebar';
+import { SiteHeader } from '@/components/site-header';
+import { Button } from '@/components/ui/button';
+import {
+  Card,
+  CardContent,
+  CardDescription,
+  CardHeader,
+  CardTitle,
+} from '@/components/ui/card';
+import { Badge } from '@/components/ui/badge';
+import { ScrollArea } from '@/components/ui/scroll-area';
+import { FileText, RefreshCw } from 'lucide-react';
+import { apiClient } from '@/lib/api/client';
+import { SidebarInset, SidebarProvider } from '@/components/ui/sidebar';
+import { LogEntry, LogsResponse } from './types';
+import { LogFilters } from './log-filters';
+import { LogEntryCard } from './log-entry-card';
+import { LogDetailsDialog } from './log-details-dialog';
+
+export default function LogsPage() {
+  const [selectedDate, setSelectedDate] = useState<string>('all');
+  const [selectedLevel, setSelectedLevel] = useState<string>('all');
+  const [requestId, setRequestId] = useState<string>('');
+  const [searchText, setSearchText] = useState<string>('');
+  const [limit, setLimit] = useState<number>(100);
+  const [selectedLog, setSelectedLog] = useState<LogEntry | null>(null);
+  const [isDialogOpen, setIsDialogOpen] = useState<boolean>(false);
+
+  const {
+    data: logsData,
+    refetch: refetchLogs,
+    isLoading,
+  } = useQuery({
+    queryKey: [
+      'logs',
+      selectedDate,
+      selectedLevel,
+      requestId,
+      searchText,
+      limit,
+    ],
+    queryFn: () =>
+      apiClient.get<LogsResponse>('/admin/api/logs', {
+        date: selectedDate === 'all' ? undefined : selectedDate,
+        level: selectedLevel === 'all' ? undefined : selectedLevel,
+        request_id: requestId || undefined,
+        search: searchText || undefined,
+        limit: limit,
+      }),
+    refetchInterval: 30000,
+  });
+
+  const handleClearFilters = () => {
+    setSelectedDate('all');
+    setSelectedLevel('all');
+    setRequestId('');
+    setSearchText('');
+    setLimit(100);
+  };
+
+  const handleLogClick = (entry: LogEntry) => {
+    setSelectedLog(entry);
+    setIsDialogOpen(true);
+  };
+
+  return (
+    <SidebarProvider>
+      <AppSidebar variant='inset' />
+      <SidebarInset className='overflow-x-hidden p-0'>
+        <SiteHeader />
+        <div className='container max-w-6xl overflow-x-hidden px-3 py-4 sm:px-4 sm:py-8 md:px-6 lg:px-8'>
+          <div className='mb-6 flex flex-col gap-3 sm:mb-8 sm:gap-4 lg:flex-row lg:items-start lg:justify-between'>
+            <div>
+              <h1 className='flex items-center gap-2 text-2xl font-bold tracking-tight sm:text-3xl'>
+                <FileText className='h-6 w-6 sm:h-8 sm:w-8' />
+                System Logs
+              </h1>
+              <p className='text-muted-foreground mt-1 text-sm sm:mt-2 sm:text-base'>
+                View and filter application logs
+              </p>
+            </div>
+            <Button
+              onClick={() => refetchLogs()}
+              variant='outline'
+              size='sm'
+              className='self-start'
+            >
+              <RefreshCw className='mr-2 h-4 w-4' />
+              Refresh
+            </Button>
+          </div>
+
+          <LogFilters
+            selectedDate={selectedDate}
+            selectedLevel={selectedLevel}
+            requestId={requestId}
+            searchText={searchText}
+            limit={limit}
+            onDateChange={setSelectedDate}
+            onLevelChange={setSelectedLevel}
+            onRequestIdChange={setRequestId}
+            onSearchTextChange={setSearchText}
+            onLimitChange={setLimit}
+            onClearFilters={handleClearFilters}
+          />
+
+          <Card>
+            <CardHeader>
+              <CardTitle className='flex flex-col items-start gap-2 sm:flex-row sm:items-center sm:justify-between'>
+                <span className='text-lg sm:text-xl'>Log Entries</span>
+                {logsData && (
+                  <Badge variant='secondary' className='text-xs sm:text-sm'>
+                    {logsData.logs.length} entries
+                  </Badge>
+                )}
+              </CardTitle>
+              {(selectedDate !== 'all' ||
+                selectedLevel !== 'all' ||
+                requestId ||
+                searchText) && (
+                <CardDescription className='text-xs sm:text-sm'>
+                  Showing logs
+                  {selectedDate !== 'all' && ` for ${selectedDate}`}
+                  {selectedLevel !== 'all' && ` with level ${selectedLevel}`}
+                  {requestId && ` with request ID ${requestId}`}
+                  {searchText && ` matching "${searchText}"`}
+                </CardDescription>
+              )}
+            </CardHeader>
+            <CardContent className='overflow-hidden p-3 sm:p-6'>
+              {isLoading ? (
+                <div className='flex items-center justify-center py-8'>
+                  <RefreshCw className='h-6 w-6 animate-spin' />
+                  <span className='ml-2 text-sm sm:text-base'>
+                    Loading logs...
+                  </span>
+                </div>
+              ) : logsData?.logs && logsData.logs.length > 0 ? (
+                <>
+                  <ScrollArea className='h-[500px] w-full sm:h-[600px]'>
+                    <div className='space-y-2 pr-3'>
+                      {logsData.logs.map((entry, index) => (
+                        <LogEntryCard
+                          key={`${entry.request_id}-${entry.asctime}-${entry.lineno}-${index}`}
+                          entry={entry}
+                          onClick={handleLogClick}
+                        />
+                      ))}
+                    </div>
+                  </ScrollArea>
+                </>
+              ) : (
+                <div className='text-muted-foreground py-8 text-center'>
+                  <FileText className='mx-auto mb-4 h-10 w-10 opacity-50 sm:h-12 sm:w-12' />
+                  <p className='text-sm sm:text-base'>No log entries found</p>
+                  <p className='text-xs sm:text-sm'>
+                    Try adjusting your filters or check back later
+                  </p>
+                </div>
+              )}
+            </CardContent>
+          </Card>
+
+          <LogDetailsDialog
+            log={selectedLog}
+            isOpen={isDialogOpen}
+            onClose={() => setIsDialogOpen(false)}
+          />
+        </div>
+      </SidebarInset>
+    </SidebarProvider>
+  );
+}

ui/app/logs/types.ts

@@ -0,0 +1,25 @@
+export interface LogEntry {
+  asctime: string;
+  name: string;
+  levelname: string;
+  message: string;
+  pathname: string;
+  lineno: number;
+  version: string;
+  request_id: string;
+  [key: string]: string | number | object | undefined;
+}
+
+export interface LogsResponse {
+  logs: LogEntry[];
+  total: number;
+  date: string | null;
+  level: string | null;
+  request_id: string | null;
+  search: string | null;
+  limit: number;
+}
+
+export interface DatesResponse {
+  dates: string[];
+}

ui/app/model/page.tsx

@@ -34,7 +34,6 @@ export default function ModelsPage() {
   const { models = [], groups = [] } = modelsData || {};
 
   const groupedModels = useMemo(() => {
-    if (!models) return {};
     return groupAndSortModelsByProvider(models);
   }, [models]);
 
@@ -43,7 +42,14 @@ export default function ModelsPage() {
   }, [groups]);
 
   const providerInfo = useMemo(() => {
-    return Object.entries(groupedModels).map(([provider, providerModels]) => {
+    const allProviders = new Set([
+      ...Object.keys(groupedModels),
+      ...groups.map((g) => g.provider),
+    ]);
+    console.log(allProviders);
+
+    return Array.from(allProviders).map((provider) => {
+      const providerModels = groupedModels[provider] || [];
       const groupData = groupDataMap.get(provider);
       const activeModels = providerModels.filter(
         (m) => m.isEnabled && !m.soft_deleted
@@ -59,7 +65,7 @@ export default function ModelsPage() {
         hasGroupApiKey: !!groupData?.group_api_key,
       };
     });
-  }, [groupedModels, groupDataMap]);
+  }, [groupedModels, groupDataMap, groups]);
 
   return (
     <SidebarProvider>
@@ -158,9 +164,9 @@ export default function ModelsPage() {
                         </div>
                       </TabsContent>
 
-                      {Object.entries(groupedModels).map(
-                        ([provider, providerModels]) => {
-                          const groupData = groupDataMap.get(provider);
+                      {providerInfo.map(
+                        ({ provider, totalModels, groupData }) => {
+                          const providerModels = groupedModels[provider] || [];
 
                           return (
                             <TabsContent key={provider} value={provider}>
@@ -190,15 +196,55 @@ export default function ModelsPage() {
                                           {groupData.group_url}
                                         </span>
                                       )}
+                                      {totalModels === 0 && (
+                                        <span className='text-muted-foreground'>
+                                          No models configured
+                                        </span>
+                                      )}
                                     </div>
                                   </div>
                                 </div>
-                                <ModelSelector
-                                  filterProvider={provider}
-                                  groupData={groupData}
-                                  showProviderActions={true}
-                                  showDeleteAllButton={false}
-                                />
+                                {totalModels === 0 ? (
+                                  <Alert>
+                                    <AlertCircle className='h-4 w-4' />
+                                    <AlertDescription>
+                                      <div className='space-y-2'>
+                                        <p className='font-medium'>
+                                          No models found for this provider
+                                        </p>
+                                        <div className='text-sm space-y-1'>
+                                          <p className='font-medium'>Common issues:</p>
+                                          <ul className='list-disc list-inside space-y-1 ml-2'>
+                                            <li>
+                                              <strong>API credentials:</strong> Check if the API key is correct and has the right permissions
+                                            </li>
+                                            <li>
+                                              <strong>Base URL:</strong> Verify the base URL is correct for your provider
+                                            </li>
+                                            <li>
+                                              <strong>Network access:</strong> Ensure the server can reach the provider&apos;s API endpoint
+                                            </li>
+                                            <li>
+                                              <strong>Provider status:</strong> The upstream provider might be temporarily unavailable
+                                            </li>
+                                          </ul>
+                                          {groupData?.group_url && (
+                                            <p className='mt-2 text-xs text-muted-foreground'>
+                                              Current endpoint: <code className='bg-muted px-1 rounded'>{groupData.group_url}</code>
+                                            </p>
+                                          )}
+                                        </div>
+                                      </div>
+                                    </AlertDescription>
+                                  </Alert>
+                                ) : (
+                                  <ModelSelector
+                                    filterProvider={provider}
+                                    groupData={groupData}
+                                    showProviderActions={true}
+                                    showDeleteAllButton={false}
+                                  />
+                                )}
                               </div>
                             </TabsContent>
                           );

ui/app/page.tsx

@@ -5,81 +5,349 @@ import { useQuery } from '@tanstack/react-query';
 import { AppSidebar } from '@/components/app-sidebar';
 import { SiteHeader } from '@/components/site-header';
 import { SidebarInset, SidebarProvider } from '@/components/ui/sidebar';
-import { DetailedWalletBalance } from '@/components/detailed-wallet-balance';
-import { TemporaryBalances } from '@/components/temporary-balances';
-import { ToggleGroup, ToggleGroupItem } from '@/components/ui/toggle-group';
-import type { DisplayUnit } from '@/lib/types/units';
+import { UsageMetricsChart } from '@/components/usage-metrics-chart';
+import { UsageSummaryCards } from '@/components/usage-summary-cards';
+import { ErrorDetailsTable } from '@/components/error-details-table';
+import { RevenueByModelTable } from '@/components/revenue-by-model-table';
+import { DashboardBalanceSummary } from '@/components/dashboard-balance-summary';
+import { AdminService } from '@/lib/api/services/admin';
+import { Button } from '@/components/ui/button';
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from '@/components/ui/select';
+import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
+import { RefreshCw } from 'lucide-react';
+import { useCurrencyStore } from '@/lib/stores/currency';
 import { fetchBtcUsdPrice, btcToSatsRate } from '@/lib/exchange-rate';
+import { CheatSheet } from '@/components/landing/cheat-sheet';
+import { ConfigurationService } from '@/lib/api/services/configuration';
 
-export default function Page() {
-  const [displayUnit, setDisplayUnit] = useState<DisplayUnit>('sat');
+export default function DashboardPage() {
+  const [timeRange, setTimeRange] = useState('24');
+  const [interval, setInterval] = useState('15');
+  const { displayUnit } = useCurrencyStore();
+  const [isAuthenticated, setIsAuthenticated] = useState(() => {
+    if (typeof window === 'undefined') {
+      return false;
+    }
+    return ConfigurationService.isTokenValid();
+  });
 
+  useEffect(() => {
+    if (typeof window === 'undefined') {
+      return;
+    }
+
+    const syncAuthState = (): void => {
+      setIsAuthenticated(ConfigurationService.isTokenValid());
+    };
+
+    syncAuthState();
+    window.addEventListener('storage', syncAuthState);
+
+    return () => {
+      window.removeEventListener('storage', syncAuthState);
+    };
+  }, []);
+  
   const { data: btcUsdPrice } = useQuery({
     queryKey: ['btc-usd-price'],
     queryFn: fetchBtcUsdPrice,
+    enabled: isAuthenticated,
     refetchInterval: 120_000,
     staleTime: 60_000,
   });
 
   const usdPerSat = btcUsdPrice ? btcToSatsRate(btcUsdPrice) : null;
 
-  useEffect(() => {
-    if (displayUnit === 'usd' && usdPerSat === null) {
-      setDisplayUnit('sat');
-    }
-  }, [displayUnit, usdPerSat]);
+  const {
+    data: metricsData,
+    isLoading: metricsLoading,
+    refetch: refetchMetrics,
+  } = useQuery({
+    queryKey: ['usage-metrics', interval, timeRange],
+    queryFn: () =>
+      AdminService.getUsageMetrics(parseInt(interval), parseInt(timeRange)),
+    enabled: isAuthenticated,
+    refetchInterval: 60_000,
+    staleTime: 30_000,
+  });
+
+  const {
+    data: summaryData,
+    isLoading: summaryLoading,
+    refetch: refetchSummary,
+  } = useQuery({
+    queryKey: ['usage-summary', timeRange],
+    queryFn: () => AdminService.getUsageSummary(parseInt(timeRange)),
+    enabled: isAuthenticated,
+    refetchInterval: 60_000,
+    staleTime: 30_000,
+  });
+
+  const {
+    data: errorData,
+    isLoading: errorLoading,
+    refetch: refetchErrors,
+  } = useQuery({
+    queryKey: ['usage-errors', timeRange],
+    queryFn: () => AdminService.getErrorDetails(parseInt(timeRange), 100),
+    enabled: isAuthenticated,
+    refetchInterval: 60_000,
+    staleTime: 30_000,
+  });
+
+  const {
+    data: revenueByModelData,
+    isLoading: revenueByModelLoading,
+    refetch: refetchRevenueByModel,
+  } = useQuery({
+    queryKey: ['revenue-by-model', timeRange],
+    queryFn: () => AdminService.getRevenueByModel(parseInt(timeRange), 20),
+    enabled: isAuthenticated,
+    refetchInterval: 60_000,
+    staleTime: 30_000,
+  });
+
+  if (!isAuthenticated) {
+    return <CheatSheet />;
+  }
+
+  const handleRefresh = () => {
+    refetchMetrics();
+    refetchSummary();
+    refetchErrors();
+    refetchRevenueByModel();
+  };
 
   return (
     <SidebarProvider>
       <AppSidebar variant='inset' />
       <SidebarInset className='p-0'>
         <SiteHeader />
-        <div className='container max-w-6xl px-4 py-8 md:px-6 lg:px-8'>
-          <div className='mb-8 flex flex-col gap-4 lg:flex-row lg:items-start lg:justify-between'>
+        <div className='container max-w-7xl px-4 py-8 md:px-6 lg:px-8'>
+          <div className='mb-8'>
+            <h1 className='text-3xl font-bold tracking-tight mb-6'>Dashboard</h1>
+            <DashboardBalanceSummary displayUnit={displayUnit} usdPerSat={usdPerSat} />
+          </div>
+
+          <div className='mb-6 flex flex-col gap-4 lg:flex-row lg:items-end lg:justify-between'>
             <div>
-              <h1 className='text-3xl font-bold tracking-tight'>
-                Admin Dashboard
-              </h1>
-              <p className='text-muted-foreground mt-2'>
-                Monitor and manage wallet balances
+              <h2 className='text-xl font-semibold tracking-tight'>
+                Usage Analytics
+              </h2>
+              <p className='text-muted-foreground text-sm mt-1'>
+                Monitor requests, errors, and revenue over the last {timeRange} hours
               </p>
             </div>
-            <div className='flex items-center'>
-              <ToggleGroup
-                type='single'
-                value={displayUnit}
-                onValueChange={(value) => {
-                  if (value) {
-                    setDisplayUnit(value as DisplayUnit);
-                  }
-                }}
-                variant='outline'
-                size='sm'
-              >
-                <ToggleGroupItem value='msat'>mSAT</ToggleGroupItem>
-                <ToggleGroupItem value='sat'>sat</ToggleGroupItem>
-                <ToggleGroupItem value='usd' disabled={!usdPerSat}>
-                  USD
-                </ToggleGroupItem>
-              </ToggleGroup>
+            <div className='flex items-center gap-4'>
+              <Select value={timeRange} onValueChange={setTimeRange}>
+                <SelectTrigger className='w-[180px]'>
+                  <SelectValue placeholder='Select time range' />
+                </SelectTrigger>
+                <SelectContent>
+                  <SelectItem value='1'>Last Hour</SelectItem>
+                  <SelectItem value='6'>Last 6 Hours</SelectItem>
+                  <SelectItem value='24'>Last 24 Hours</SelectItem>
+                  <SelectItem value='72'>Last 3 Days</SelectItem>
+                  <SelectItem value='168'>Last Week</SelectItem>
+                </SelectContent>
+              </Select>
+              <Select value={interval} onValueChange={setInterval}>
+                <SelectTrigger className='w-[180px]'>
+                  <SelectValue placeholder='Select interval' />
+                </SelectTrigger>
+                <SelectContent>
+                  <SelectItem value='5'>5 Minutes</SelectItem>
+                  <SelectItem value='15'>15 Minutes</SelectItem>
+                  <SelectItem value='30'>30 Minutes</SelectItem>
+                  <SelectItem value='60'>1 Hour</SelectItem>
+                </SelectContent>
+              </Select>
+              <Button onClick={handleRefresh} variant='outline' size='icon'>
+                <RefreshCw className='h-4 w-4' />
+              </Button>
             </div>
           </div>
 
-          <div className='grid gap-6'>
-            <div className='col-span-full'>
-              <DetailedWalletBalance
-                refreshInterval={30000}
-                displayUnit={displayUnit}
-                usdPerSat={usdPerSat}
-              />
+          <div className='space-y-6'>
+            {summaryLoading ? (
+              <div className='text-center py-8'>Loading summary...</div>
+            ) : summaryData ? (
+              <UsageSummaryCards summary={summaryData} />
+            ) : null}
+
+            <div className='grid gap-6 lg:grid-cols-2'>
+              {metricsLoading ? (
+                <div className='text-center py-8 col-span-2'>
+                  Loading metrics...
+                </div>
+              ) : metricsData && metricsData.metrics.length > 0 ? (
+                <>
+                  <div className="col-span-full">
+                    <UsageMetricsChart
+                      data={metricsData.metrics.map((m) => ({
+                        ...m,
+                        revenue_sats: m.revenue_msats / 1000,
+                        refunds_sats: m.refunds_msats / 1000,
+                        net_revenue_sats:
+                          (m.revenue_msats - m.refunds_msats) / 1000,
+                      })) as Array<Record<string, unknown> & { timestamp: string }>}
+                      title='Revenue Over Time (sats)'
+                      dataKeys={[
+                        {
+                          key: 'revenue_sats',
+                          name: 'Revenue',
+                          color: '#10b981',
+                        },
+                        {
+                          key: 'net_revenue_sats',
+                          name: 'Net Revenue',
+                          color: '#059669',
+                        },
+                        {
+                          key: 'refunds_sats',
+                          name: 'Refunds',
+                          color: '#ef4444',
+                        },
+                      ]}
+                    />
+                  </div>
+                  <UsageMetricsChart
+                    data={metricsData.metrics as Array<Record<string, unknown> & { timestamp: string }>}
+                    title='Request Volume'
+                    dataKeys={[
+                      {
+                        key: 'total_requests',
+                        name: 'Total Requests',
+                        color: '#3b82f6',
+                      },
+                      {
+                        key: 'successful_chat_completions',
+                        name: 'Successful',
+                        color: '#22c55e',
+                      },
+                      {
+                        key: 'failed_requests',
+                        name: 'Failed',
+                        color: '#f43f5e',
+                      },
+                    ]}
+                  />
+                  <UsageMetricsChart
+                    data={metricsData.metrics as Array<Record<string, unknown> & { timestamp: string }>}
+                    title='Error Tracking'
+                    dataKeys={[
+                      {
+                        key: 'errors',
+                        name: 'Errors',
+                        color: '#f97316',
+                      },
+                      {
+                        key: 'warnings',
+                        name: 'Warnings',
+                        color: '#eab308',
+                      },
+                      {
+                        key: 'upstream_errors',
+                        name: 'Upstream Errors',
+                        color: '#dc2626',
+                      },
+                    ]}
+                  />
+                  <UsageMetricsChart
+                    data={metricsData.metrics as Array<Record<string, unknown> & { timestamp: string }>}
+                    title='Payment Activity'
+                    dataKeys={[
+                      {
+                        key: 'payment_processed',
+                        name: 'Payments Processed',
+                        color: '#8b5cf6',
+                      },
+                    ]}
+                  />
+                  <div className="space-y-6">
+                    {summaryData && summaryData.unique_models.length > 0 && (
+                      <Card>
+                        <CardHeader>
+                          <CardTitle>Active Models</CardTitle>
+                        </CardHeader>
+                        <CardContent>
+                          <div className='flex flex-wrap gap-2'>
+                            {summaryData.unique_models.map((model) => (
+                              <span
+                                key={model}
+                                className='bg-secondary text-secondary-foreground inline-flex items-center rounded-md px-2.5 py-0.5 text-xs font-semibold'
+                              >
+                                {model}
+                              </span>
+                            ))}
+                          </div>
+                        </CardContent>
+                      </Card>
+                    )}
+                    {summaryData &&
+                      summaryData.error_types &&
+                      Object.keys(summaryData.error_types).length > 0 && (
+                        <Card>
+                          <CardHeader>
+                            <CardTitle>Error Types Distribution</CardTitle>
+                          </CardHeader>
+                          <CardContent>
+                            <div className='space-y-2'>
+                              {Object.entries(summaryData.error_types)
+                                .sort(([, a], [, b]) => b - a)
+                                .map(([type, count]) => (
+                                  <div
+                                    key={type}
+                                    className='flex items-center justify-between'
+                                  >
+                                    <span className='text-sm font-medium'>{type}</span>
+                                    <span className='text-muted-foreground text-sm'>
+                                      {count}
+                                    </span>
+                                  </div>
+                                ))}
+                            </div>
+                          </CardContent>
+                        </Card>
+                      )}
+                  </div>
+                </>
+              ) : (
+                <Card className='col-span-2'>
+                  <CardHeader>
+                    <CardTitle>No Data Available</CardTitle>
+                  </CardHeader>
+                  <CardContent>
+                    <p className='text-muted-foreground'>
+                      No metrics data found for the selected time range. This
+                      could be because no requests have been logged yet or the
+                      log files are not available.
+                    </p>
+                  </CardContent>
+                </Card>
+              )}
             </div>
-            <div className='col-span-full'>
-              <TemporaryBalances
-                refreshInterval={60000}
-                displayUnit={displayUnit}
-                usdPerSat={usdPerSat}
+
+            {revenueByModelLoading ? (
+              <div className='text-center py-8'>Loading revenue by model...</div>
+            ) : revenueByModelData && revenueByModelData.models.length > 0 ? (
+              <RevenueByModelTable 
+                models={revenueByModelData.models}
+                totalRevenue={revenueByModelData.total_revenue_sats}
               />
-            </div>
+            ) : null}
+
+            {errorLoading ? (
+              <div className='text-center py-8'>Loading errors...</div>
+            ) : errorData ? (
+              <ErrorDetailsTable errors={errorData.errors} />
+            ) : null}
           </div>
         </div>
       </SidebarInset>

ui/components/app-sidebar.tsx

@@ -2,10 +2,12 @@
 
 import * as React from 'react';
 import {
+  FileTextIcon,
   DatabaseIcon,
   LayoutDashboardIcon,
   ServerIcon,
   SettingsIcon,
+  WalletIcon,
 } from 'lucide-react';
 import Image from 'next/image';
 
@@ -34,6 +36,16 @@ const data = {
       url: '/',
       icon: LayoutDashboardIcon,
     },
+    {
+      title: 'Balances',
+      url: '/balances',
+      icon: WalletIcon,
+    },
+    {
+      title: 'Logs',
+      url: '/logs',
+      icon: FileTextIcon,
+    },
     {
       title: 'Models',
       url: '/model',
@@ -49,26 +61,6 @@ const data = {
       url: '/settings',
       icon: SettingsIcon,
     },
-    // {
-    //   title: 'Transactions',
-    //   url: '/transactions',
-    //   icon: ReceiptIcon,
-    // },
-    // {
-    //   title: 'Credit',
-    //   url: '/credits',
-    //   icon: FolderIcon,
-    // },
-    // {
-    //   title: 'Users',
-    //   url: '/users',
-    //   icon: UsersIcon,
-    // },
-    // {
-    //   title: 'Organizations',
-    //   url: '/organizations',
-    //   icon: FolderIcon,
-    // },
   ],
   documents: [],
 };

ui/components/currency-toggle.tsx

@@ -0,0 +1,74 @@
+'use client';
+
+import { useCurrencyStore } from '@/lib/stores/currency';
+import { useQuery } from '@tanstack/react-query';
+import { fetchBtcUsdPrice, btcToSatsRate } from '@/lib/exchange-rate';
+import { useEffect } from 'react';
+import type { DisplayUnit } from '@/lib/types/units';
+import {
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuTrigger,
+} from '@/components/ui/dropdown-menu';
+import { Button } from '@/components/ui/button';
+import { Coins } from 'lucide-react';
+
+export function CurrencyToggle() {
+  const { displayUnit, setDisplayUnit } = useCurrencyStore();
+
+  const { data: btcUsdPrice } = useQuery({
+    queryKey: ['btc-usd-price'],
+    queryFn: fetchBtcUsdPrice,
+    refetchInterval: 120_000,
+    staleTime: 60_000,
+  });
+
+  const usdPerSat = btcUsdPrice ? btcToSatsRate(btcUsdPrice) : null;
+
+  useEffect(() => {
+    if (displayUnit === 'usd' && usdPerSat === null) {
+      setDisplayUnit('sat');
+    }
+  }, [displayUnit, usdPerSat, setDisplayUnit]);
+
+  const getLabel = (unit: DisplayUnit) => {
+    switch (unit) {
+      case 'msat':
+        return 'mSAT';
+      case 'sat':
+        return 'sat';
+      case 'usd':
+        return 'USD';
+      default:
+        return unit;
+    }
+  };
+
+  return (
+    <DropdownMenu>
+      <DropdownMenuTrigger asChild>
+        <Button variant="ghost" size="sm" className="h-9 w-9 px-0 gap-2 w-auto px-3 font-normal">
+          <Coins className="h-4 w-4" />
+          <span className="hidden sm:inline-block">{getLabel(displayUnit)}</span>
+          <span className="sm:hidden uppercase">{displayUnit}</span>
+        </Button>
+      </DropdownMenuTrigger>
+      <DropdownMenuContent align="end">
+        <DropdownMenuItem onClick={() => setDisplayUnit('msat')}>
+          Millisatoshis (mSAT)
+        </DropdownMenuItem>
+        <DropdownMenuItem onClick={() => setDisplayUnit('sat')}>
+          Satoshis (sat)
+        </DropdownMenuItem>
+        <DropdownMenuItem 
+          onClick={() => setDisplayUnit('usd')}
+          disabled={!usdPerSat}
+        >
+          US Dollar (USD)
+        </DropdownMenuItem>
+      </DropdownMenuContent>
+    </DropdownMenu>
+  );
+}
+

ui/components/dashboard-balance-summary.tsx

@@ -0,0 +1,99 @@
+'use client';
+
+import { useQuery } from '@tanstack/react-query';
+import { WalletService, BalanceDetail } from '@/lib/api/services/wallet';
+import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
+import { convertToMsat, formatFromMsat } from '@/lib/currency';
+import { Wallet, User, Coins } from 'lucide-react';
+import type { DisplayUnit } from '@/lib/types/units';
+
+interface DashboardBalanceSummaryProps {
+  displayUnit?: DisplayUnit;
+  usdPerSat?: number | null;
+}
+
+export function DashboardBalanceSummary({
+  displayUnit = 'sat',
+  usdPerSat = null,
+}: DashboardBalanceSummaryProps) {
+  const { data } = useQuery({
+    queryKey: ['detailed-wallet-balance'],
+    queryFn: async () => {
+      return WalletService.getDetailedBalances();
+    },
+    refetchInterval: 30000,
+  });
+
+  const calculateTotals = (balances: BalanceDetail[]) => {
+    let totalWallet = 0;
+    let totalUser = 0;
+    let totalOwner = 0;
+
+    balances.forEach((detail) => {
+      if (!detail.error) {
+        const walletMsat = convertToMsat(
+          detail.wallet_balance || 0,
+          detail.unit
+        );
+        const userMsat = convertToMsat(detail.user_balance || 0, detail.unit);
+        const ownerMsat = convertToMsat(detail.owner_balance || 0, detail.unit);
+
+        totalWallet += walletMsat;
+        totalUser += userMsat;
+        totalOwner += ownerMsat;
+      }
+    });
+
+    return { totalWallet, totalUser, totalOwner };
+  };
+
+  const totals = data
+    ? calculateTotals(data)
+    : { totalWallet: 0, totalUser: 0, totalOwner: 0 };
+
+  const formatAmount = (msatAmount: number): string =>
+    formatFromMsat(msatAmount, displayUnit, usdPerSat);
+
+  const cards = [
+    {
+      title: 'Your Balance',
+      value: formatAmount(totals.totalOwner),
+      icon: Coins,
+      color: 'text-green-600',
+      bgColor: 'bg-green-100 dark:bg-green-900/20',
+    },
+    {
+      title: 'Total Wallet',
+      value: formatAmount(totals.totalWallet),
+      icon: Wallet,
+      color: 'text-blue-600',
+      bgColor: 'bg-blue-100 dark:bg-blue-900/20',
+    },
+    {
+      title: 'User Balance',
+      value: formatAmount(totals.totalUser),
+      icon: User,
+      color: 'text-purple-600',
+      bgColor: 'bg-purple-100 dark:bg-purple-900/20',
+    },
+  ];
+
+  return (
+    <div className='grid gap-4 md:grid-cols-3'>
+      {cards.map((card) => (
+        <Card key={card.title}>
+          <CardHeader className='flex flex-row items-center justify-between space-y-0 pb-2'>
+            <CardTitle className='text-sm font-medium'>{card.title}</CardTitle>
+            <div className={`rounded-full p-2 ${card.bgColor}`}>
+              <card.icon className={`h-4 w-4 ${card.color}`} />
+            </div>
+          </CardHeader>
+          <CardContent>
+            <div className='text-2xl font-bold'>{card.value}</div>
+          </CardContent>
+        </Card>
+      ))}
+    </div>
+  );
+}
+

ui/components/error-details-table.tsx

@@ -0,0 +1,78 @@
+'use client';
+
+import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
+import {
+  Table,
+  TableBody,
+  TableCell,
+  TableHead,
+  TableHeader,
+  TableRow,
+} from '@/components/ui/table';
+import { Badge } from '@/components/ui/badge';
+import { ErrorDetail } from '@/lib/api/services/admin';
+
+interface ErrorDetailsTableProps {
+  errors: ErrorDetail[];
+}
+
+export function ErrorDetailsTable({ errors }: ErrorDetailsTableProps) {
+  if (errors.length === 0) {
+    return (
+      <Card>
+        <CardHeader>
+          <CardTitle>Recent Errors</CardTitle>
+        </CardHeader>
+        <CardContent>
+          <p className='text-muted-foreground text-center py-8'>
+            No errors found in the selected time period
+          </p>
+        </CardContent>
+      </Card>
+    );
+  }
+
+  return (
+    <Card>
+      <CardHeader>
+        <CardTitle>Recent Errors ({errors.length})</CardTitle>
+      </CardHeader>
+      <CardContent>
+        <div className='max-h-[400px] overflow-y-auto'>
+          <Table>
+            <TableHeader>
+              <TableRow>
+                <TableHead>Timestamp</TableHead>
+                <TableHead>Type</TableHead>
+                <TableHead>Message</TableHead>
+                <TableHead>Location</TableHead>
+                <TableHead>Request ID</TableHead>
+              </TableRow>
+            </TableHeader>
+            <TableBody>
+              {errors.map((error, index) => (
+                <TableRow key={index}>
+                  <TableCell className='font-mono text-xs'>
+                    {new Date(error.timestamp).toLocaleString()}
+                  </TableCell>
+                  <TableCell>
+                    <Badge variant='destructive'>{error.error_type}</Badge>
+                  </TableCell>
+                  <TableCell className='max-w-md truncate'>
+                    {error.message}
+                  </TableCell>
+                  <TableCell className='font-mono text-xs'>
+                    {error.pathname}:{error.lineno}
+                  </TableCell>
+                  <TableCell className='font-mono text-xs'>
+                    {error.request_id || '-'}
+                  </TableCell>
+                </TableRow>
+              ))}
+            </TableBody>
+          </Table>
+        </div>
+      </CardContent>
+    </Card>
+  );
+}

ui/components/landing/cheat-sheet.tsx

@@ -0,0 +1,746 @@
+'use client';
+
+import { type JSX, useCallback, useEffect, useMemo, useState } from 'react';
+import { useQuery } from '@tanstack/react-query';
+import {
+  Bolt,
+  Copy,
+  KeyRound,
+  RefreshCcw,
+  ShieldCheck,
+  Terminal,
+} from 'lucide-react';
+import { toast } from 'sonner';
+import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
+import { Button } from '@/components/ui/button';
+import { Textarea } from '@/components/ui/textarea';
+import { Input } from '@/components/ui/input';
+import { Badge } from '@/components/ui/badge';
+import { Separator } from '@/components/ui/separator';
+import { ConfigurationService } from '@/lib/api/services/configuration';
+
+type NodeInfo = {
+  name: string;
+  description: string;
+  version: string;
+  npub?: string | null;
+  mints: string[];
+  http_url?: string | null;
+  onion_url?: string | null;
+};
+
+type WalletSnapshot = {
+  apiKey: string;
+  balanceMsats: number;
+  reservedMsats: number;
+};
+
+type RefundReceipt = {
+  token?: string;
+  recipient?: string;
+  sats?: string;
+  msats?: string;
+};
+
+const DEFAULT_BASE_URL = 'http://127.0.0.1:8000';
+
+async function fetchNodeInfo(baseUrl: string): Promise<NodeInfo> {
+  const response = await fetch(`${baseUrl}/v1/info`, {
+    cache: 'no-store',
+    headers: { 'Content-Type': 'application/json' },
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(errorText || 'Unable to load node info');
+  }
+
+  const payload = (await response.json()) as NodeInfo;
+  return {
+    ...payload,
+    mints: Array.isArray(payload.mints) ? payload.mints : [],
+  };
+}
+
+async function fetchWalletInfo(
+  baseUrl: string,
+  apiKey: string
+): Promise<WalletSnapshot> {
+  const response = await fetch(`${baseUrl}/v1/balance/info`, {
+    cache: 'no-store',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${apiKey}`,
+    },
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(errorText || 'Unable to load wallet info');
+  }
+
+  const payload = (await response.json()) as {
+    api_key: string;
+    balance: number;
+    reserved?: number;
+  };
+
+  return {
+    apiKey: payload.api_key || apiKey,
+    balanceMsats: payload.balance ?? 0,
+    reservedMsats: payload.reserved ?? 0,
+  };
+}
+
+function normalizeBaseUrl(url: string): string {
+  const trimmed = url.trim();
+  if (!trimmed) {
+    return '';
+  }
+  return trimmed.replace(/\/+$/, '');
+}
+
+function formatMsats(msats: number): string {
+  return new Intl.NumberFormat('en-US').format(msats);
+}
+
+function formatSats(msats: number): string {
+  return new Intl.NumberFormat('en-US').format(Math.floor(msats / 1000));
+}
+
+export function CheatSheet(): JSX.Element {
+  const [baseUrl, setBaseUrl] = useState(() =>
+    typeof window === 'undefined' ? '' : ConfigurationService.getLocalBaseUrl()
+  );
+  const [initialToken, setInitialToken] = useState('');
+  const [topupToken, setTopupToken] = useState('');
+  const [apiKeyInput, setApiKeyInput] = useState('');
+  const [walletInfo, setWalletInfo] = useState<WalletSnapshot | null>(null);
+  const [refundReceipt, setRefundReceipt] = useState<RefundReceipt | null>(null);
+  const [isCreatingKey, setIsCreatingKey] = useState(false);
+  const [isTopupLoading, setIsTopupLoading] = useState(false);
+  const [isRefunding, setIsRefunding] = useState(false);
+  const [isSyncingBalance, setIsSyncingBalance] = useState(false);
+  const [hasInteractedCreate, setHasInteractedCreate] = useState(false);
+  const [hasInteractedManage, setHasInteractedManage] = useState(false);
+  const [hasInteractedTopup, setHasInteractedTopup] = useState(false);
+
+  useEffect(() => {
+    if (!baseUrl && typeof window !== 'undefined') {
+      setBaseUrl(ConfigurationService.getLocalBaseUrl());
+    }
+  }, [baseUrl]);
+
+  const normalizedBaseUrl = useMemo(
+    () => normalizeBaseUrl(baseUrl) || DEFAULT_BASE_URL,
+    [baseUrl]
+  );
+
+  const activeApiKey = apiKeyInput.trim();
+
+  const {
+    data: nodeInfo,
+    isLoading: isInfoLoading,
+    isError: isInfoError,
+    refetch: refetchNodeInfo,
+  } = useQuery({
+    queryKey: ['node-info', normalizedBaseUrl],
+    queryFn: () => fetchNodeInfo(normalizedBaseUrl),
+    enabled: Boolean(normalizedBaseUrl),
+    refetchInterval: 300_000,
+    staleTime: 120_000,
+  });
+
+  const handleCopy = useCallback(async (value: string): Promise<void> => {
+    if (!value) {
+      return;
+    }
+    if (typeof navigator === 'undefined' || !navigator.clipboard) {
+      toast.error('Clipboard API unavailable');
+      return;
+    }
+    try {
+      await navigator.clipboard.writeText(value);
+      toast.success('Copied to clipboard');
+    } catch (error) {
+      console.error(error);
+      toast.error('Unable to copy');
+    }
+  }, []);
+
+  const handleCreateKey = useCallback(async (): Promise<void> => {
+    if (!initialToken.trim()) {
+      toast.error('Cashu token required');
+      return;
+    }
+
+    setIsCreatingKey(true);
+    setRefundReceipt(null);
+
+    try {
+      const params = new URLSearchParams({
+        initial_balance_token: initialToken.trim(),
+      });
+      const response = await fetch(
+        `${normalizedBaseUrl}/v1/balance/create?${params.toString()}`,
+        {
+          method: 'GET',
+          headers: { 'Content-Type': 'application/json' },
+        }
+      );
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(errorText || 'Failed to create API key');
+      }
+      const payload = (await response.json()) as {
+        api_key: string;
+        balance: number;
+      };
+      const snapshot: WalletSnapshot = {
+        apiKey: payload.api_key,
+        balanceMsats: payload.balance ?? 0,
+        reservedMsats: 0,
+      };
+      setApiKeyInput(snapshot.apiKey);
+      setWalletInfo(snapshot);
+      setInitialToken('');
+      toast.success('API key ready');
+    } catch (error) {
+      console.error(error);
+      toast.error(
+        error instanceof Error ? error.message : 'Failed to create API key'
+      );
+    } finally {
+      setIsCreatingKey(false);
+    }
+  }, [initialToken, normalizedBaseUrl]);
+
+  const handleSyncBalance = useCallback(async (): Promise<void> => {
+    if (!activeApiKey) {
+      toast.error('Paste an API key first');
+      return;
+    }
+
+    setIsSyncingBalance(true);
+    try {
+      const snapshot = await fetchWalletInfo(normalizedBaseUrl, activeApiKey);
+      setWalletInfo(snapshot);
+      toast.success('Balance synced');
+    } catch (error) {
+      console.error(error);
+      toast.error(
+        error instanceof Error ? error.message : 'Failed to sync balance'
+      );
+    } finally {
+      setIsSyncingBalance(false);
+    }
+  }, [activeApiKey, normalizedBaseUrl]);
+
+  const handleTopup = useCallback(async (): Promise<void> => {
+    if (!activeApiKey) {
+      toast.error('Paste an API key first');
+      return;
+    }
+    if (!topupToken.trim()) {
+      toast.error('Cashu token required for top-up');
+      return;
+    }
+
+    setIsTopupLoading(true);
+    setRefundReceipt(null);
+    try {
+      const response = await fetch(`${normalizedBaseUrl}/v1/balance/topup`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${activeApiKey}`,
+        },
+        body: JSON.stringify({ cashu_token: topupToken.trim() }),
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(errorText || 'Failed to top up');
+      }
+      const payload = (await response.json()) as { msats: number };
+      toast.success(`Added ${formatSats(payload.msats)} sats`);
+      setTopupToken('');
+      const snapshot = await fetchWalletInfo(normalizedBaseUrl, activeApiKey);
+      setWalletInfo(snapshot);
+    } catch (error) {
+      console.error(error);
+      toast.error(error instanceof Error ? error.message : 'Top-up failed');
+    } finally {
+      setIsTopupLoading(false);
+    }
+  }, [activeApiKey, normalizedBaseUrl, topupToken]);
+
+  const handleRefund = useCallback(async (): Promise<void> => {
+    if (!activeApiKey) {
+      toast.error('Paste an API key first');
+      return;
+    }
+
+    setIsRefunding(true);
+    try {
+      const response = await fetch(`${normalizedBaseUrl}/v1/balance/refund`, {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${activeApiKey}`,
+        },
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(errorText || 'Refund failed');
+      }
+      const payload = (await response.json()) as RefundReceipt;
+      setRefundReceipt(payload);
+      setWalletInfo(null);
+      toast.success('Refund requested');
+    } catch (error) {
+      console.error(error);
+      toast.error(error instanceof Error ? error.message : 'Refund failed');
+    } finally {
+      setIsRefunding(false);
+    }
+  }, [activeApiKey, normalizedBaseUrl]);
+
+  const handleRefreshInfo = useCallback(async (): Promise<void> => {
+    const result = await refetchNodeInfo();
+    if (result.error) {
+      toast.error('Unable to refresh node info');
+    } else {
+      toast.success('Node info refreshed');
+    }
+  }, [refetchNodeInfo]);
+
+  const curlSnippet = useMemo(() => {
+    const keyPreview = activeApiKey || 'YOUR_API_KEY';
+    return [
+      `curl -X POST "${normalizedBaseUrl}/v1/chat/completions"`,
+      `  -H "Authorization: Bearer ${keyPreview}"`,
+      '  -H "Content-Type: application/json"',
+      "  -d '{",
+      '    "model": "openai/gpt-4o-mini",',
+      '    "messages": [',
+      '      {"role":"system","content":"You are Routstr."},',
+      '      {"role":"user","content":"Ping the node"}',
+      '    ]',
+      "  }'",
+    ].join('\n');
+  }, [activeApiKey, normalizedBaseUrl]);
+
+  const showCreateDetails =
+    hasInteractedCreate || initialToken.trim().length > 0;
+  const showManageDetails = hasInteractedManage || Boolean(walletInfo);
+  const showTopupDetails =
+    hasInteractedTopup || topupToken.trim().length > 0;
+  const refundToken = refundReceipt?.token ?? null;
+  const canTopup = Boolean(activeApiKey);
+
+  return (
+    <div className='min-h-screen bg-gradient-to-b from-background via-background to-muted'>
+      <main className='mx-auto flex w-full max-w-6xl flex-col gap-8 px-4 py-10 sm:px-6 lg:px-8'>
+        <section className='relative space-y-3 text-center md:text-left'>
+          <div className='absolute right-0 top-0 hidden md:block'>
+            <Button asChild size='sm' className='px-3 text-xs'>
+              <a href='/login'>Admin</a>
+            </Button>
+          </div>
+          <div className='inline-flex items-center gap-2 rounded-full border px-3 py-1 text-[0.65rem] uppercase tracking-wider text-muted-foreground'>
+            <Bolt className='h-4 w-4 text-primary' />
+            Routstr cheat sheet
+          </div>
+          <h1 className='text-3xl font-semibold tracking-tight sm:text-4xl'>
+            Node Identity and Cheat Sheet
+          </h1>
+          <div className='md:hidden'>
+            <Button asChild size='sm' className='w-full sm:w-auto'>
+              <a href='/login'>Admin</a>
+            </Button>
+          </div>
+        </section>
+
+        <section className='grid gap-4 lg:grid-cols-2'>
+          <Card>
+            <CardHeader className='flex flex-row items-start justify-between gap-4'>
+              <div>
+                <CardTitle className='flex items-center gap-2 text-lg'>
+                  <ShieldCheck className='h-4 w-4 text-primary' />
+                  Node identity
+                </CardTitle>
+                <p className='text-xs uppercase tracking-wide text-muted-foreground'>
+                  /v1/info snapshot
+                </p>
+              </div>
+              <Button
+                variant='ghost'
+                size='sm'
+                className='gap-1 text-xs'
+                onClick={handleRefreshInfo}
+                disabled={isInfoLoading}
+              >
+                <RefreshCcw className='h-4 w-4' />
+                Refresh
+              </Button>
+            </CardHeader>
+            <CardContent className='space-y-4'>
+              {isInfoLoading && (
+                <p className='text-muted-foreground text-sm'>
+                  Loading node profile…
+                </p>
+              )}
+              {isInfoError && !isInfoLoading && (
+                <p className='text-destructive text-sm'>
+                  Unable to reach /v1/info at {normalizedBaseUrl}
+                </p>
+              )}
+              {nodeInfo && (
+                <>
+                  <div className='space-y-2'>
+                    <p className='text-2xl font-medium'>{nodeInfo.name}</p>
+                    <p className='text-muted-foreground text-sm'>
+                      {nodeInfo.description}
+                    </p>
+                  </div>
+                  <dl className='grid gap-4 sm:grid-cols-2'>
+                    <div>
+                      <dt className='text-muted-foreground text-xs uppercase tracking-wide'>
+                        Version
+                      </dt>
+                      <dd className='text-base font-medium'>
+                        {nodeInfo.version}
+                      </dd>
+                    </div>
+                    <div>
+                      <dt className='text-muted-foreground text-xs uppercase tracking-wide'>
+                        HTTP
+                      </dt>
+                      <dd className='text-base font-medium break-all'>
+                        {nodeInfo.http_url || normalizedBaseUrl}
+                      </dd>
+                    </div>
+                    {nodeInfo.onion_url && (
+                      <div className='sm:col-span-2'>
+                        <dt className='text-muted-foreground text-xs uppercase tracking-wide'>
+                          Onion
+                        </dt>
+                        <dd className='text-base font-medium break-all'>
+                          {nodeInfo.onion_url}
+                        </dd>
+                      </div>
+                    )}
+                    {nodeInfo.npub && (
+                      <div className='sm:col-span-2'>
+                        <dt className='text-muted-foreground text-xs uppercase tracking-wide'>
+                          npub
+                        </dt>
+                        <dd className='flex items-center gap-2 break-all text-sm font-mono'>
+                          {nodeInfo.npub}
+                          <Button
+                            variant='ghost'
+                            size='icon'
+                            className='h-8 w-8'
+                            onClick={() => handleCopy(nodeInfo.npub ?? '')}
+                          >
+                            <Copy className='h-4 w-4' />
+                          </Button>
+                        </dd>
+                      </div>
+                    )}
+                  </dl>
+                  <div className='space-y-2'>
+                    <p className='text-xs uppercase tracking-wide text-muted-foreground'>
+                      Cashu mints
+                    </p>
+                    <div className='flex flex-wrap gap-2'>
+                      {nodeInfo.mints.length ? (
+                        nodeInfo.mints.map((mint) => (
+                          <Badge
+                            key={mint}
+                            variant='secondary'
+                            className='font-mono text-xs'
+                          >
+                            {mint}
+                          </Badge>
+                        ))
+                      ) : (
+                        <p className='text-muted-foreground text-sm'>
+                          No mint list published
+                        </p>
+                      )}
+                    </div>
+                  </div>
+                </>
+              )}
+            </CardContent>
+          </Card>
+
+          <Card>
+            <CardHeader className='flex flex-row items-center justify-between'>
+              <CardTitle className='flex items-center gap-2 text-lg'>
+                <Terminal className='h-4 w-4 text-primary' />
+                Quick docs
+              </CardTitle>
+              <span className='text-xs uppercase tracking-wide text-muted-foreground'>
+                curl-ready
+              </span>
+            </CardHeader>
+            <CardContent className='space-y-4'>
+              <div className='flex items-center gap-2'>
+                <Input
+                  value={baseUrl}
+                  placeholder={normalizedBaseUrl}
+                  onChange={(event) => setBaseUrl(event.target.value)}
+                  className='text-sm'
+                />
+                <Button
+                  variant='outline'
+                  size='icon'
+                  className='h-9 w-9'
+                  onClick={() => handleCopy(normalizedBaseUrl)}
+                >
+                  <Copy className='h-4 w-4' />
+                </Button>
+              </div>
+              <div className='rounded-lg bg-muted p-4 font-mono text-sm leading-6'>
+                <pre className='whitespace-pre-wrap break-all'>{curlSnippet}</pre>
+              </div>
+              <div className='flex gap-2'>
+                <Button
+                  variant='secondary'
+                  className='gap-2'
+                  onClick={() => handleCopy(curlSnippet)}
+                >
+                  <Copy className='h-4 w-4' />
+                  Copy curl
+                </Button>
+                <Button variant='outline' asChild className='gap-2'>
+                  <a
+                    href='https://docs.routstr.com'
+                    target='_blank'
+                    rel='noreferrer'
+                  >
+                    <Terminal className='h-4 w-4' />
+                    Full docs
+                  </a>
+                </Button>
+              </div>
+            </CardContent>
+          </Card>
+        </section>
+
+        <Card>
+          <CardHeader className='space-y-1'>
+            <CardTitle className='flex items-center gap-2 text-xl'>
+              <KeyRound className='h-5 w-5 text-primary' />
+              API key workflow
+            </CardTitle>
+            <p className='text-xs uppercase tracking-wide text-muted-foreground'>
+              Sections expand as soon as you interact
+            </p>
+          </CardHeader>
+          <CardContent className='space-y-6'>
+            <section className='space-y-2'>
+              <header className='flex items-center justify-between text-[0.7rem] uppercase tracking-wider text-muted-foreground'>
+                <span>1 · Create key</span>
+                {showCreateDetails && (
+                  <span className='text-primary'>Cashu token detected</span>
+                )}
+              </header>
+              <Textarea
+                value={initialToken}
+                onChange={(event) => setInitialToken(event.target.value)}
+                placeholder='cashuA1...'
+                rows={showCreateDetails ? 4 : 2}
+                className='font-mono text-sm transition-all duration-200'
+                onFocus={() => setHasInteractedCreate(true)}
+              />
+              {showCreateDetails && (
+                <div className='flex flex-wrap gap-2'>
+                  <Button
+                    onClick={handleCreateKey}
+                    disabled={isCreatingKey}
+                    className='gap-2'
+                  >
+                    {isCreatingKey ? 'Creating…' : 'Create API key'}
+                  </Button>
+                  <span className='text-xs text-muted-foreground'>
+                    Redeems instantly and returns <code>sk-</code> key.
+                  </span>
+                </div>
+              )}
+            </section>
+
+            <Separator />
+
+            <section className='space-y-2'>
+              <header className='flex items-center justify-between text-[0.7rem] uppercase tracking-wider text-muted-foreground'>
+                <span>2 · Manage key</span>
+                {walletInfo && (
+                  <span className='text-primary'>
+                    {formatSats(walletInfo.balanceMsats)} sats
+                  </span>
+                )}
+              </header>
+              <div className='flex flex-col gap-2 sm:flex-row'>
+                <Input
+                  value={apiKeyInput}
+                  onChange={(event) => {
+                    setApiKeyInput(event.target.value);
+                    setWalletInfo(null);
+                  }}
+                  placeholder='sk-...'
+                  className='font-mono text-sm'
+                  onFocus={() => setHasInteractedManage(true)}
+                />
+                <div className='flex gap-2'>
+                  <Button
+                    variant='outline'
+                    size='icon'
+                    className='h-10 w-10'
+                    onClick={() => handleCopy(activeApiKey)}
+                    disabled={!activeApiKey}
+                  >
+                    <Copy className='h-4 w-4' />
+                  </Button>
+                  <Button
+                    variant='secondary'
+                    size='sm'
+                    className='gap-1'
+                    onClick={handleSyncBalance}
+                    disabled={isSyncingBalance || !activeApiKey}
+                  >
+                    <RefreshCcw className='h-4 w-4' />
+                    Sync
+                  </Button>
+                </div>
+              </div>
+              {showManageDetails && (
+                <div className='grid gap-3 sm:grid-cols-2'>
+                  <div className='rounded-lg border p-3'>
+                    <p className='text-[0.65rem] uppercase tracking-wide text-muted-foreground'>
+                      Spendable
+                    </p>
+                    <p className='text-xl font-semibold'>
+                      {walletInfo
+                        ? `${formatSats(walletInfo.balanceMsats)} sats`
+                        : '—'}
+                    </p>
+                    {walletInfo && (
+                      <p className='text-muted-foreground text-xs'>
+                        {formatMsats(walletInfo.balanceMsats)} msats
+                      </p>
+                    )}
+                  </div>
+                  <div className='rounded-lg border p-3'>
+                    <p className='text-[0.65rem] uppercase tracking-wide text-muted-foreground'>
+                      Reserved
+                    </p>
+                    <p className='text-xl font-semibold'>
+                      {walletInfo
+                        ? `${formatSats(walletInfo.reservedMsats)} sats`
+                        : '—'}
+                    </p>
+                    {walletInfo && (
+                      <p className='text-muted-foreground text-xs'>
+                        {formatMsats(walletInfo.reservedMsats)} msats
+                      </p>
+                    )}
+                  </div>
+                </div>
+              )}
+            </section>
+
+            <Separator />
+
+            <section className='space-y-2'>
+              <header className='flex items-center justify-between text-[0.7rem] uppercase tracking-wider text-muted-foreground'>
+                <span>3 · Top up</span>
+                {showTopupDetails && (
+                  <span className={canTopup ? 'text-primary' : 'text-destructive'}>
+                    {canTopup ? 'Ready to redeem' : 'Paste API key first'}
+                  </span>
+                )}
+              </header>
+              <Textarea
+                value={topupToken}
+                onChange={(event) => setTopupToken(event.target.value)}
+                placeholder='cashuB1...'
+                rows={showTopupDetails ? 3 : 1}
+                className='font-mono text-sm transition-all duration-200'
+                onFocus={() => setHasInteractedTopup(true)}
+                disabled={!canTopup}
+              />
+              {showTopupDetails && (
+                <div className='flex flex-wrap gap-2'>
+                  <Button
+                    onClick={handleTopup}
+                    disabled={isTopupLoading || !canTopup}
+                    variant='outline'
+                    className='gap-2'
+                  >
+                    {isTopupLoading ? 'Topping up…' : 'Top up this key'}
+                  </Button>
+                  <span className='text-xs text-muted-foreground'>
+                    {canTopup
+                      ? (
+                          <>
+                            Adds balance to the same <code>sk-</code> token.
+                          </>
+                        )
+                      : 'Enter your sk- key above to unlock top ups.'}
+                  </span>
+                </div>
+              )}
+            </section>
+
+            <Separator />
+
+            <section className='space-y-2'>
+              <header className='flex items-center justify-between text-[0.7rem] uppercase tracking-wider text-muted-foreground'>
+                <span>4 · Refund</span>
+                {refundReceipt && <span className='text-primary'>Done</span>}
+              </header>
+              <div className='flex flex-wrap gap-2'>
+                <Button
+                  onClick={handleRefund}
+                  disabled={isRefunding}
+                  variant='destructive'
+                  className='gap-2'
+                >
+                  {isRefunding ? 'Processing…' : 'Refund remaining balance'}
+                </Button>
+                <span className='text-xs text-muted-foreground'>
+                  Burns the key and returns a fresh Cashu token.
+                </span>
+              </div>
+              {refundToken && (
+                <div className='space-y-2 rounded-lg border bg-muted/30 p-4'>
+                  <div className='flex items-center justify-between text-[0.7rem] uppercase tracking-wider text-muted-foreground'>
+                    <span>Cashu refund token</span>
+                    <Button
+                      variant='outline'
+                      size='sm'
+                      className='gap-1 text-xs'
+                      onClick={() => handleCopy(refundToken)}
+                    >
+                      <Copy className='h-3 w-3' />
+                      Copy
+                    </Button>
+                  </div>
+                  <Textarea
+                    value={refundToken}
+                    readOnly
+                    rows={4}
+                    className='font-mono text-xs'
+                  />
+                </div>
+              )}
+            </section>
+          </CardContent>
+        </Card>
+      </main>
+    </div>
+  );
+}
+

ui/components/revenue-by-model-table.tsx

@@ -0,0 +1,106 @@
+'use client';
+
+import {
+  Table,
+  TableBody,
+  TableCell,
+  TableHead,
+  TableHeader,
+  TableRow,
+} from '@/components/ui/table';
+import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
+import { Progress } from '@/components/ui/progress';
+import { ModelRevenueData } from '@/lib/api/services/admin';
+import { useCurrencyStore } from '@/lib/stores/currency';
+import { useQuery } from '@tanstack/react-query';
+import { fetchBtcUsdPrice, btcToSatsRate } from '@/lib/exchange-rate';
+import { formatFromMsat, convertToMsat } from '@/lib/currency';
+
+interface RevenueByModelTableProps {
+  models: ModelRevenueData[];
+  totalRevenue: number;
+}
+
+export function RevenueByModelTable({
+  models,
+  totalRevenue,
+}: RevenueByModelTableProps) {
+  const { displayUnit } = useCurrencyStore();
+  const { data: btcUsdPrice } = useQuery({
+    queryKey: ['btc-usd-price'],
+    queryFn: fetchBtcUsdPrice,
+    refetchInterval: 120_000,
+    staleTime: 60_000,
+  });
+  const usdPerSat = btcUsdPrice ? btcToSatsRate(btcUsdPrice) : null;
+
+  const formatAmount = (sats: number) =>
+    formatFromMsat(convertToMsat(sats, 'sat'), displayUnit, usdPerSat);
+
+  return (
+    <Card>
+      <CardHeader>
+        <CardTitle>Revenue by Model</CardTitle>
+        <p className="text-sm text-muted-foreground">
+          Total Revenue: <span className="font-mono font-medium text-foreground">{formatAmount(totalRevenue)}</span>
+        </p>
+      </CardHeader>
+      <CardContent>
+        <Table>
+          <TableHeader>
+            <TableRow>
+              <TableHead>Model</TableHead>
+              <TableHead className="text-right">Requests</TableHead>
+              <TableHead className="text-right">Successful</TableHead>
+              <TableHead className="text-right">Failed</TableHead>
+              <TableHead className="text-right">Revenue</TableHead>
+              <TableHead className="w-[100px]">Share</TableHead>
+              <TableHead className="text-right">Refunds</TableHead>
+              <TableHead className="text-right">Net Revenue</TableHead>
+              <TableHead className="text-right">Avg/Request</TableHead>
+            </TableRow>
+          </TableHeader>
+          <TableBody>
+            {models.length === 0 ? (
+              <TableRow>
+                <TableCell colSpan={9} className="text-center text-muted-foreground">
+                  No model data available
+                </TableCell>
+              </TableRow>
+            ) : (
+              models.map((model) => {
+                const share = totalRevenue > 0 ? (model.revenue_sats / totalRevenue) * 100 : 0;
+                return (
+                  <TableRow key={model.model}>
+                    <TableCell className="font-medium">{model.model}</TableCell>
+                    <TableCell className="text-right font-mono">{model.requests}</TableCell>
+                    <TableCell className="text-right text-green-600 font-mono">{model.successful}</TableCell>
+                    <TableCell className="text-right text-red-600 font-mono">{model.failed}</TableCell>
+                    <TableCell className="text-right font-mono">
+                      {formatAmount(model.revenue_sats)}
+                    </TableCell>
+                    <TableCell>
+                      <div className="flex items-center gap-2">
+                        <Progress value={share} className="h-2" />
+                        <span className="text-xs text-muted-foreground w-8 text-right">{share.toFixed(0)}%</span>
+                      </div>
+                    </TableCell>
+                    <TableCell className="text-right text-red-500 font-mono">
+                      {formatAmount(model.refunds_sats)}
+                    </TableCell>
+                    <TableCell className="text-right font-semibold font-mono">
+                      {formatAmount(model.net_revenue_sats)}
+                    </TableCell>
+                    <TableCell className="text-right text-muted-foreground font-mono">
+                      {formatAmount(model.avg_revenue_per_request)}
+                    </TableCell>
+                  </TableRow>
+                );
+              })
+            )}
+          </TableBody>
+        </Table>
+      </CardContent>
+    </Card>
+  );
+}

ui/components/site-header.tsx

@@ -8,6 +8,7 @@ import { useRouter } from 'next/navigation';
 import { adminLogout } from '@/lib/api/services/auth';
 import { toast } from 'sonner';
 import { ThemeToggle } from '@/components/theme-toggle';
+import { CurrencyToggle } from '@/components/currency-toggle';
 
 export function SiteHeader() {
   const router = useRouter();
@@ -35,6 +36,7 @@ export function SiteHeader() {
           <h1 className='text-base font-medium lg:hidden'>Routstr Node</h1>
         </div>
         <div className='flex items-center gap-2'>
+          <CurrencyToggle />
           <ThemeToggle />
           <Button
             variant='ghost'

ui/components/temporary-balances.tsx

@@ -9,7 +9,6 @@ import {
   Key,
   Clock,
   DollarSign,
-  Activity,
 } from 'lucide-react';
 import { AdminService, TemporaryBalance } from '@/lib/api/services/admin';
 import {
@@ -56,21 +55,17 @@ export function TemporaryBalances({
 
   const calculateTotals = (balances: TemporaryBalance[]) => {
     let totalBalance = 0;
-    let totalSpent = 0;
-    let totalRequests = 0;
 
     balances.forEach((balance) => {
       totalBalance += balance.balance || 0;
-      totalSpent += balance.total_spent || 0;
-      totalRequests += balance.total_requests || 0;
     });
 
-    return { totalBalance, totalSpent, totalRequests };
+    return { totalBalance };
   };
 
   const totals = data
     ? calculateTotals(data)
-    : { totalBalance: 0, totalSpent: 0, totalRequests: 0 };
+    : { totalBalance: 0 };
 
   return (
     <>
@@ -142,32 +137,6 @@ export function TemporaryBalances({
                     {formatBalance(totals.totalBalance)}
                   </div>
                 </div>
-                <div className='rounded-lg border border-green-200 bg-gradient-to-r from-green-50 to-emerald-50 p-4'>
-                  <div className='flex items-center justify-between'>
-                    <div className='flex items-center gap-2'>
-                      <Activity className='h-5 w-5 text-green-600' />
-                      <span className='text-sm font-medium text-green-800'>
-                        Total Spent
-                      </span>
-                    </div>
-                  </div>
-                  <div className='mt-2 text-2xl font-bold text-green-900'>
-                    {formatBalance(totals.totalSpent)}
-                  </div>
-                </div>
-                <div className='rounded-lg border border-purple-200 bg-gradient-to-r from-purple-50 to-pink-50 p-4'>
-                  <div className='flex items-center justify-between'>
-                    <div className='flex items-center gap-2'>
-                      <Key className='h-5 w-5 text-purple-600' />
-                      <span className='text-sm font-medium text-purple-800'>
-                        Total Requests
-                      </span>
-                    </div>
-                  </div>
-                  <div className='mt-2 text-2xl font-bold text-purple-900'>
-                    {totals.totalRequests.toLocaleString()}
-                  </div>
-                </div>
               </div>
 
               {/* Table */}
@@ -176,9 +145,9 @@ export function TemporaryBalances({
                 <div className='bg-muted hidden grid-cols-6 gap-2 p-3 text-sm font-semibold md:grid'>
                   <div>Hashed Key</div>
                   <div className='text-right'>Balance</div>
-                  <div className='text-right'>Total Spent</div>
-                  <div className='text-right'>Total Requests</div>
                   <div>Refund Address</div>
+                  <div>Refund Mint</div>
+                  <div>Currency</div>
                   <div className='text-right'>Expiry Time</div>
                 </div>
 
@@ -199,22 +168,22 @@ export function TemporaryBalances({
                         <div className='text-right font-mono'>
                           {formatBalance(balance.balance)}
                         </div>
-                        <div className='text-right font-mono'>
-                          {formatBalance(balance.total_spent)}
-                        </div>
-                        <div className='text-right font-mono'>
-                          {balance.total_requests.toLocaleString()}
-                        </div>
                         <div className='max-w-32 truncate font-mono text-xs break-all'>
                           {balance.refund_address || '-'}
                         </div>
+                        <div className='max-w-32 truncate font-mono text-xs break-all'>
+                          {balance.refund_mint_url || '-'}
+                        </div>
+                        <div className='truncate font-mono text-xs'>
+                          {balance.refund_currency || '-'}
+                        </div>
                         <div className='text-right font-mono text-xs'>
-                          {balance.key_expiry_time ? (
+                          {balance.refund_expiration_time ? (
                             <div className='flex items-center justify-end gap-1'>
                               <Clock className='h-3 w-3' />
                               <span>
                                 {new Date(
-                                  balance.key_expiry_time * 1000
+                                  balance.refund_expiration_time * 1000
                                 ).toLocaleDateString()}
                               </span>
                             </div>
@@ -246,34 +215,26 @@ export function TemporaryBalances({
                           </div>
                           <div className='space-y-1'>
                             <div className='text-muted-foreground text-xs font-medium'>
-                              Spent
+                              Currency
                             </div>
                             <div className='truncate font-mono text-sm'>
-                              {formatBalance(balance.total_spent)}
+                              {balance.refund_currency || '-'}
                             </div>
                           </div>
                         </div>
 
                         <div className='grid grid-cols-2 gap-3'>
-                          <div className='space-y-1'>
-                            <div className='text-muted-foreground text-xs font-medium'>
-                              Requests
-                            </div>
-                            <div className='truncate font-mono text-sm'>
-                              {balance.total_requests.toLocaleString()}
-                            </div>
-                          </div>
                           <div className='space-y-1'>
                             <div className='text-muted-foreground text-xs font-medium'>
                               Expires
                             </div>
                             <div className='font-mono text-xs'>
-                              {balance.key_expiry_time ? (
+                              {balance.refund_expiration_time ? (
                                 <div className='flex items-center gap-1'>
                                   <Clock className='h-3 w-3 flex-shrink-0' />
                                   <span className='truncate'>
                                     {new Date(
-                                      balance.key_expiry_time * 1000
+                                      balance.refund_expiration_time * 1000
                                     ).toLocaleDateString()}
                                   </span>
                                 </div>
@@ -294,6 +255,17 @@ export function TemporaryBalances({
                             </div>
                           </div>
                         )}
+                        
+                         {balance.refund_mint_url && (
+                          <div className='space-y-1 pt-2'>
+                            <div className='text-muted-foreground text-xs font-medium'>
+                              Refund Mint
+                            </div>
+                            <div className='font-mono text-xs break-all'>
+                              {balance.refund_mint_url}
+                            </div>
+                          </div>
+                        )}
                       </div>
                     </div>
                   ))

ui/components/ui/calendar.tsx

@@ -0,0 +1,72 @@
+'use client';
+
+import * as React from 'react';
+import { ChevronLeft, ChevronRight } from 'lucide-react';
+import { DayPicker } from 'react-day-picker';
+
+import { cn } from '@/lib/utils';
+import { buttonVariants } from '@/components/ui/button';
+
+export type CalendarProps = React.ComponentProps<typeof DayPicker>;
+
+function Calendar({
+  className,
+  classNames,
+  showOutsideDays = true,
+  ...props
+}: CalendarProps) {
+  return (
+    <DayPicker
+      showOutsideDays={showOutsideDays}
+      className={cn('p-3', className)}
+      classNames={{
+        months: 'flex flex-col sm:flex-row space-y-4 sm:space-x-4 sm:space-y-0',
+        month: 'space-y-4',
+        caption: 'flex justify-center pt-1 relative items-center',
+        caption_label: 'text-sm font-medium',
+        nav: 'space-x-1 flex items-center',
+        button_previous: cn(
+          buttonVariants({ variant: 'outline' }),
+          'h-7 w-7 bg-transparent p-0 opacity-50 hover:opacity-100 absolute left-1'
+        ),
+        button_next: cn(
+          buttonVariants({ variant: 'outline' }),
+          'h-7 w-7 bg-transparent p-0 opacity-50 hover:opacity-100 absolute right-1'
+        ),
+        month_grid: 'w-full border-collapse space-y-1',
+        weekdays: 'flex',
+        weekday:
+          'text-muted-foreground rounded-md w-9 font-normal text-[0.8rem]',
+        week: 'flex w-full mt-2',
+        day: cn(
+          buttonVariants({ variant: 'ghost' }),
+          'h-9 w-9 p-0 font-normal aria-selected:opacity-100'
+        ),
+        day_button: 'h-9 w-9 p-0 font-normal',
+        range_end: 'day-range-end',
+        selected:
+          'bg-primary text-primary-foreground hover:bg-primary hover:text-primary-foreground focus:bg-primary focus:text-primary-foreground',
+        today: 'bg-accent text-accent-foreground',
+        outside:
+          'day-outside text-muted-foreground opacity-50 aria-selected:bg-accent/50 aria-selected:text-muted-foreground aria-selected:opacity-30',
+        disabled: 'text-muted-foreground opacity-50',
+        range_middle:
+          'aria-selected:bg-accent aria-selected:text-accent-foreground',
+        hidden: 'invisible',
+        ...classNames,
+      }}
+      components={{
+        Chevron: ({ orientation }) => {
+          if (orientation === 'left') {
+            return <ChevronLeft className='h-4 w-4' />;
+          }
+          return <ChevronRight className='h-4 w-4' />;
+        },
+      }}
+      {...props}
+    />
+  );
+}
+Calendar.displayName = 'Calendar';
+
+export { Calendar };

ui/components/usage-metrics-chart.tsx

@@ -0,0 +1,114 @@
+'use client';
+
+import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
+import {
+  Area,
+  AreaChart,
+  ResponsiveContainer,
+  Tooltip,
+  XAxis,
+  YAxis,
+  Legend,
+  CartesianGrid,
+} from 'recharts';
+
+interface UsageMetricsChartProps {
+  data: Array<Record<string, unknown> & { timestamp: string }>;
+  title: string;
+  dataKeys: Array<{
+    key: string;
+    name: string;
+    color: string;
+  }>;
+}
+
+export function UsageMetricsChart({
+  data,
+  title,
+  dataKeys,
+}: UsageMetricsChartProps) {
+  const formattedData = data.map((item) => ({
+    ...item,
+    time: new Date(item.timestamp).toLocaleTimeString([], {
+      hour: '2-digit',
+      minute: '2-digit',
+    }),
+  }));
+
+  return (
+    <Card>
+      <CardHeader>
+        <CardTitle>{title}</CardTitle>
+      </CardHeader>
+      <CardContent>
+        <ResponsiveContainer width='100%' height={300}>
+          <AreaChart data={formattedData}>
+            <defs>
+              {dataKeys.map((dataKey) => (
+                <linearGradient
+                  key={dataKey.key}
+                  id={`color${dataKey.key}`}
+                  x1='0'
+                  y1='0'
+                  x2='0'
+                  y2='1'
+                >
+                  <stop
+                    offset='5%'
+                    stopColor={dataKey.color}
+                    stopOpacity={0.3}
+                  />
+                  <stop
+                    offset='95%'
+                    stopColor={dataKey.color}
+                    stopOpacity={0}
+                  />
+                </linearGradient>
+              ))}
+            </defs>
+            <CartesianGrid strokeDasharray='3 3' className='stroke-muted/30' />
+            <XAxis
+              dataKey='time'
+              className='text-xs'
+              tick={{ fill: 'hsl(var(--muted-foreground))' }}
+              tickLine={false}
+              axisLine={false}
+              minTickGap={32}
+            />
+            <YAxis
+              className='text-xs'
+              tick={{ fill: 'hsl(var(--muted-foreground))' }}
+              tickLine={false}
+              axisLine={false}
+              width={40}
+            />
+            <Tooltip
+              contentStyle={{
+                backgroundColor: 'hsl(var(--background))',
+                border: '1px solid hsl(var(--border))',
+                borderRadius: '8px',
+                boxShadow: '0 4px 6px -1px rgb(0 0 0 / 0.1)',
+              }}
+              itemStyle={{ fontSize: '12px' }}
+              labelStyle={{ fontSize: '12px', color: 'hsl(var(--muted-foreground))', marginBottom: '8px' }}
+            />
+            <Legend wrapperStyle={{ fontSize: '12px', paddingTop: '16px' }} />
+            {dataKeys.map((dataKey) => (
+              <Area
+                key={dataKey.key}
+                type='monotone'
+                dataKey={dataKey.key}
+                stroke={dataKey.color}
+                fillOpacity={1}
+                fill={`url(#color${dataKey.key})`}
+                name={dataKey.name}
+                strokeWidth={2}
+                animationDuration={1000}
+              />
+            ))}
+          </AreaChart>
+        </ResponsiveContainer>
+      </CardContent>
+    </Card>
+  );
+}

ui/components/usage-summary-cards.tsx

@@ -0,0 +1,131 @@
+'use client';
+
+import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
+import { UsageSummary } from '@/lib/api/services/admin';
+import {
+  CheckCircle2,
+  XCircle,
+  AlertTriangle,
+  Activity,
+  Database,
+  CreditCard,
+  TrendingUp,
+  DollarSign,
+  TrendingDown,
+  Coins,
+} from 'lucide-react';
+import { useCurrencyStore } from '@/lib/stores/currency';
+import { useQuery } from '@tanstack/react-query';
+import { fetchBtcUsdPrice, btcToSatsRate } from '@/lib/exchange-rate';
+import { formatFromMsat } from '@/lib/currency';
+
+interface UsageSummaryCardsProps {
+  summary: UsageSummary;
+}
+
+export function UsageSummaryCards({ summary }: UsageSummaryCardsProps) {
+  const { displayUnit } = useCurrencyStore();
+  const { data: btcUsdPrice } = useQuery({
+    queryKey: ['btc-usd-price'],
+    queryFn: fetchBtcUsdPrice,
+    refetchInterval: 120_000,
+    staleTime: 60_000,
+  });
+  const usdPerSat = btcUsdPrice ? btcToSatsRate(btcUsdPrice) : null;
+
+  const formatAmount = (msat: number) =>
+    formatFromMsat(msat, displayUnit, usdPerSat);
+
+  const cards = [
+    {
+      title: 'Total Requests',
+      value: summary.total_requests.toLocaleString(),
+      icon: Activity,
+      color: 'text-blue-500',
+    },
+    {
+      title: 'Successful Completions',
+      value: summary.successful_chat_completions.toLocaleString(),
+      icon: CheckCircle2,
+      color: 'text-green-500',
+    },
+    {
+      title: 'Revenue',
+      value: formatAmount(summary.revenue_msats),
+      icon: Coins,
+      color: 'text-green-600',
+    },
+    {
+      title: 'Net Revenue',
+      value: formatAmount(summary.net_revenue_msats),
+      icon: DollarSign,
+      color: 'text-emerald-600',
+    },
+    {
+      title: 'Refunds',
+      value: formatAmount(summary.refunds_msats),
+      icon: TrendingDown,
+      color: 'text-red-500',
+    },
+    {
+      title: 'Avg Revenue/Request',
+      value: formatAmount(summary.avg_revenue_per_request_msats),
+      icon: CreditCard,
+      color: 'text-cyan-500',
+    },
+    {
+      title: 'Success Rate',
+      value: `${summary.success_rate.toFixed(1)}%`,
+      icon: TrendingUp,
+      color: 'text-emerald-500',
+    },
+    {
+      title: 'Refund Rate',
+      value: `${summary.refund_rate.toFixed(1)}%`,
+      icon: XCircle,
+      color: 'text-orange-500',
+    },
+    {
+      title: 'Failed Requests',
+      value: summary.failed_requests.toLocaleString(),
+      icon: XCircle,
+      color: 'text-red-400',
+    },
+    {
+      title: 'Errors',
+      value: summary.total_errors.toLocaleString(),
+      icon: AlertTriangle,
+      color: 'text-orange-500',
+    },
+    {
+      title: 'Unique Models',
+      value: summary.unique_models_count.toLocaleString(),
+      icon: Database,
+      color: 'text-purple-500',
+    },
+    {
+      title: 'Upstream Errors',
+      value: summary.upstream_errors.toLocaleString(),
+      icon: AlertTriangle,
+      color: 'text-yellow-500',
+    },
+  ];
+
+  return (
+    <div className='grid gap-6 md:grid-cols-2 lg:grid-cols-4'>
+      {cards.map((card) => (
+        <Card key={card.title} className="hover:bg-muted/50 transition-colors">
+          <CardHeader className='flex flex-row items-center justify-between space-y-0 pb-2'>
+            <CardTitle className='text-sm font-medium text-muted-foreground'>{card.title}</CardTitle>
+            <div className={`p-2 rounded-full bg-secondary`}>
+                <card.icon className={`h-4 w-4 ${card.color}`} />
+            </div>
+          </CardHeader>
+          <CardContent>
+            <div className='text-2xl font-bold tracking-tight'>{card.value}</div>
+          </CardContent>
+        </Card>
+      ))}
+    </div>
+  );
+}

ui/lib/api/services/admin.ts

@@ -797,20 +797,170 @@ export class AdminService {
     return await apiClient.post<{ ok: boolean }>('/admin/api/logout', {});
   }
 
+  static async getLogs(
+    date?: string,
+    level?: string,
+    requestId?: string,
+    search?: string,
+    limit: number = 100
+  ): Promise<LogResponse> {
+    const params = new URLSearchParams();
+    if (date) params.append('date', date);
+    if (level) params.append('level', level);
+    if (requestId) params.append('request_id', requestId);
+    if (search) params.append('search', search);
+    params.append('limit', limit.toString());
+
+    return await apiClient.get<LogResponse>(`/admin/api/logs?${params.toString()}`);
+  }
+
+  static async getLogDates(): Promise<{ dates: string[] }> {
+    return await apiClient.get<{ dates: string[] }>('/admin/api/logs/dates');
+  }
+
   static async getTemporaryBalances(): Promise<TemporaryBalance[]> {
     return await apiClient.get<TemporaryBalance[]>(
       '/admin/api/temporary-balances'
     );
   }
+
+  static async getUsageMetrics(
+    interval: number = 15,
+    hours: number = 24
+  ): Promise<UsageMetrics> {
+    return await apiClient.get<UsageMetrics>(
+      `/admin/api/usage/metrics?interval=${interval}&hours=${hours}`
+    );
+  }
+
+  static async getUsageSummary(hours: number = 24): Promise<UsageSummary> {
+    return await apiClient.get<UsageSummary>(
+      `/admin/api/usage/summary?hours=${hours}`
+    );
+  }
+
+  static async getErrorDetails(
+    hours: number = 24,
+    limit: number = 100
+  ): Promise<ErrorDetails> {
+    return await apiClient.get<ErrorDetails>(
+      `/admin/api/usage/error-details?hours=${hours}&limit=${limit}`
+    );
+  }
+
+  static async getRevenueByModel(
+    hours: number = 24,
+    limit: number = 20
+  ): Promise<RevenueByModel> {
+    return await apiClient.get<RevenueByModel>(
+      `/admin/api/usage/revenue-by-model?hours=${hours}&limit=${limit}`
+    );
+  }
 }
 
 export const TemporaryBalanceSchema = z.object({
   hashed_key: z.string(),
   balance: z.number(),
-  total_spent: z.number(),
-  total_requests: z.number(),
   refund_address: z.string().nullable(),
-  key_expiry_time: z.number().nullable(),
+  refund_mint_url: z.string().nullable(),
+  refund_currency: z.string().nullable(),
+  refund_expiration_time: z.number().nullable(),
 });
 
 export type TemporaryBalance = z.infer<typeof TemporaryBalanceSchema>;
+
+export interface UsageMetricData {
+  timestamp: string;
+  total_requests: number;
+  successful_chat_completions: number;
+  failed_requests: number;
+  errors: number;
+  warnings: number;
+  payment_processed: number;
+  upstream_errors: number;
+  revenue_msats: number;
+  refunds_msats: number;
+  [key: string]: unknown;
+}
+
+export interface UsageMetrics {
+  metrics: UsageMetricData[];
+  interval_minutes: number;
+  hours_back: number;
+  total_buckets: number;
+}
+
+export interface UsageSummary {
+  total_entries: number;
+  total_requests: number;
+  successful_chat_completions: number;
+  failed_requests: number;
+  total_errors: number;
+  total_warnings: number;
+  payment_processed: number;
+  upstream_errors: number;
+  unique_models_count: number;
+  unique_models: string[];
+  error_types: Record<string, number>;
+  success_rate: number;
+  revenue_msats: number;
+  refunds_msats: number;
+  revenue_sats: number;
+  refunds_sats: number;
+  net_revenue_msats: number;
+  net_revenue_sats: number;
+  avg_revenue_per_request_msats: number;
+  refund_rate: number;
+}
+
+export interface ErrorDetail {
+  timestamp: string;
+  message: string;
+  error_type: string;
+  pathname: string;
+  lineno: number;
+  request_id: string;
+}
+
+export interface ErrorDetails {
+  errors: ErrorDetail[];
+  total_count: number;
+}
+
+export interface ModelRevenueData {
+  model: string;
+  revenue_sats: number;
+  refunds_sats: number;
+  net_revenue_sats: number;
+  requests: number;
+  successful: number;
+  failed: number;
+  avg_revenue_per_request: number;
+}
+
+export interface RevenueByModel {
+  models: ModelRevenueData[];
+  total_revenue_sats: number;
+  total_models: number;
+}
+
+export interface LogEntry {
+  asctime: string;
+  name: string;
+  levelname: string;
+  message: string;
+  pathname?: string;
+  lineno?: number;
+  request_id?: string;
+  [key: string]: unknown;
+}
+
+export interface LogResponse {
+  logs: LogEntry[];
+  total: number;
+  date: string | null;
+  level: string | null;
+  request_id: string | null;
+  search: string | null;
+  limit: number;
+}

ui/lib/auth/ProtectedRoute.tsx

@@ -9,8 +9,10 @@ export function ProtectedRoute({ children }: { children: React.ReactNode }) {
   const pathname = usePathname();
 
   useEffect(() => {
-    const publicPaths = ['/login', '/_register', '/unauthorized'];
-    const isPublicPath = publicPaths.some((path) => pathname.startsWith(path));
+    const publicPaths = ['/', '/login', '/unauthorized'];
+    const isPublicPath = publicPaths.some((path) =>
+      path === '/' ? pathname === '/' : pathname.startsWith(path)
+    );
 
     if (!isPublicPath && !ConfigurationService.isTokenValid()) {
       router.push('/login');

ui/lib/currency.ts

@@ -25,7 +25,8 @@ export function formatFromMsat(
 
   if (displayUnit === 'sat') {
     const sats = amountMsat / 1000;
-    return `${sats.toLocaleString()} sats`;
+    // Format as integer for sats
+    return `${Math.floor(sats).toLocaleString()} sats`;
   }
 
   if (usdPerSat === null) {
@@ -34,12 +35,11 @@ export function formatFromMsat(
 
   const sats = amountMsat / 1000;
   const usd = sats * usdPerSat;
-  const precision = Math.abs(usd) >= 1 ? 2 : 4;
   const formatter = new Intl.NumberFormat(undefined, {
     style: 'currency',
     currency: 'USD',
-    minimumFractionDigits: precision,
-    maximumFractionDigits: Math.max(precision, 6),
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2,
   });
   return formatter.format(usd);
 }

ui/lib/stores/currency.ts

@@ -0,0 +1,21 @@
+import { create } from 'zustand';
+import { persist } from 'zustand/middleware';
+import type { DisplayUnit } from '@/lib/types/units';
+
+interface CurrencyState {
+  displayUnit: DisplayUnit;
+  setDisplayUnit: (unit: DisplayUnit) => void;
+}
+
+export const useCurrencyStore = create<CurrencyState>()(
+  persist(
+    (set) => ({
+      displayUnit: 'sat',
+      setDisplayUnit: (unit) => set({ displayUnit: unit }),
+    }),
+    {
+      name: 'currency-storage',
+    }
+  )
+);
+

uv.lock

@@ -1878,7 +1878,7 @@ wheels = [
 
 [[package]]
 name = "routstr"
-version = "0.2.0c0"
+version = "0.2.1"
 source = { editable = "." }
 dependencies = [
     { name = "aiosqlite" },
@@ -1923,7 +1923,7 @@ requires-dist = [
     { name = "marshmallow", specifier = ">=3.13,<4.0" },
     { name = "mdurl", specifier = "==0.1.2" },
     { name = "nostr", specifier = ">=0.0.2" },
-    { name = "pillow", specifier = ">=10.0.0" },
+    { name = "pillow", specifier = ">=10" },
     { name = "python-json-logger", specifier = ">=2.0.0" },
     { name = "secp256k1", git = "https://github.com/saschanaz/secp256k1-py?branch=upgrade060" },
     { name = "sqlmodel", specifier = ">=0.0.24" },