Merge branch 'fix-open-claude-cost-calculation' into otrta

# Conflicts:
#	routstr/upstream/base.py

README.md

@@ -51,26 +51,14 @@ curl https://api.routstr.com/v1/chat/completions \
 
 ## Quick Start (Docker)
 
-If you are a node runner, start a Routstr Core instance using Docker Compose:
+If you are a node runner, start a Routstr Core instance and configure upstream access in the dashboard.
 
-1. **Prepare your `.env`**:
-   ```bash
-   ADMIN_PASSWORD=mysecretpassword
-   NAME="My AI Node"
-   DESCRIPTION="Fast access to models"
-   NSEC=yournsec
-   RECEIVE_LN_ADDRESS=yourname@wallet.com
-   ```
-
-2. **Start the services**:
-   ```bash
-   docker compose up -d
-   ```
-
-3. **Configure**:
-   Open [http://localhost:8000/admin/](http://localhost:8000/admin/) to connect your AI providers and set pricing.
-
-For full instructions, see the **[Provider Quick Start Guide](https://docs.routstr.com/provider/quickstart/)**.
+```bash
+docker run -d \
+  --name routstr-proxy \
+  -p 8000:8000 \
+  ghcr.io/routstr/proxy:latest
+```
 
 ## Development
 

docs/provider/deployment.md

@@ -6,7 +6,16 @@ Production deployment guide for Routstr Provider nodes.
 
 For production, use Docker Compose with persistent storage and optional Tor support.
 
-Use the included `compose.yml` for a flexible setup that handles both the UI and the node execution. This is useful for development or when you want to manage Tor as a separate service.
+### Unified Setup (All-in-one)
+To build and run the node with the UI integrated in a single container using the multi-stage build:
+
+```bash
+docker build -f Dockerfile.full -t routstr-full .
+docker run -d -p 8000:8000 --env-file .env routstr-full
+```
+
+### Advanced Setup (Separated UI & Node)
+Use the included `compose.yml` for a more flexible setup that separates the UI build process from the node execution. This is useful for development or when you want to manage Tor as a separate service.
 
 ```bash
 docker compose up -d
@@ -175,16 +184,20 @@ docker compose up -d
 
 ## Building from Source
 
-### Using Docker Compose
-The easiest way to build everything from source:
+### Unified Image (UI + Node)
+The easiest way to build everything from source into a single production-ready image:
 
 ```bash
-docker compose build
+docker build -f Dockerfile.full -t routstr-full .
 ```
 
 ### Individual Components
-If you prefer building the node only (requires manual UI build first):
+If you prefer building them separately or using Docker Compose:
 
 ```bash
+# Build using compose
+docker compose build
+
+# Or build the node only (requires manual UI build first)
 docker build -t routstr-node .
 ```

docs/provider/quickstart.md

@@ -35,7 +35,6 @@ ADMIN_PASSWORD=mysecretpassword
 # Node Identity
 NAME="My AI Node"
 DESCRIPTION="Fast access to models"
-NSEC=yournsec
 
 # Lightning Payouts
 RECEIVE_LN_ADDRESS=yourname@wallet.com
@@ -44,10 +43,32 @@ RECEIVE_LN_ADDRESS=yourname@wallet.com
 
 ## 2. Start the Node
 
-The recommended way to run Routstr is using Docker Compose, which handles the node, the UI, and optional services like Tor.
+You can run the pre-built image directly:
 
 ```bash
-docker compose up -d
+docker run -d \
+  --name routstr \
+  -p 8000:8000 \
+  --env-file .env \
+  -v routstr-data:/app/data \
+  ghcr.io/routstr/proxy:latest
+```
+
+*Note: The pre-built image does not contain the UI. For the all-in-one experience with the Admin Dashboard, use the Build from Source instructions below.*
+
+### Build from Source (Recommended)
+
+If you want to build the node and UI yourself from source, use the unified Dockerfile:
+
+```bash
+git clone https://github.com/routstr/routstr-core.git
+cd routstr-core
+# Edit your .env with ADMIN_PASSWORD and API keys
+cp .env.example .env
+nano .env
+
+docker build -f Dockerfile.full -t routstr-local .
+docker run -d -p 8000:8000 --env-file .env --name routstr routstr-local
 ```
 
 Verify it's running:
@@ -56,15 +77,6 @@ Verify it's running:
 curl http://localhost:8000/v1/info
 ```
 
-### Build from Source (Optional)
-
-If you've cloned the repository and want to build the images yourself:
-
-```bash
-docker compose build
-docker compose up -d
-```
-
 ---
 
 ## 3. Configure via Dashboard

migrations/versions/b1c2d3e4f5a6_add_upstream_model_id_to_models.py

@@ -1,33 +0,0 @@
-"""add forwarded_model_id to models
-
-Revision ID: b1c2d3e4f5a6
-Revises: a776ca70e5fe
-Create Date: 2026-04-05 00:00:00.000000
-"""
-
-import sqlalchemy as sa
-import sqlmodel
-from alembic import op
-
-# revision identifiers, used by Alembic.
-revision = "b1c2d3e4f5a6"
-down_revision = "a776ca70e5fe"
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    op.add_column(
-        "models",
-        sa.Column(
-            "forwarded_model_id",
-            sqlmodel.sql.sqltypes.AutoString(),
-            nullable=True,
-        ),
-    )
-    # Backfill: set forwarded_model_id = id for all existing rows
-    op.execute("UPDATE models SET forwarded_model_id = id WHERE forwarded_model_id IS NULL")
-
-
-def downgrade() -> None:
-    op.drop_column("models", "forwarded_model_id")

migrations/versions/c3d4e5f6a7b8_add_source_to_cashu_transactions.py

@@ -1,36 +0,0 @@
-"""add source to cashu_transactions
-
-Revision ID: c3d4e5f6a7b8
-Revises: b1c2d3e4f5a6
-Create Date: 2026-04-10 00:00:00.000000
-"""
-
-import sqlalchemy as sa
-import sqlmodel
-from alembic import op
-
-# revision identifiers, used by Alembic.
-revision = "c3d4e5f6a7b8"
-down_revision = "b1c2d3e4f5a6"
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    conn = op.get_bind()
-    inspector = sa.inspect(conn)
-    columns = [col["name"] for col in inspector.get_columns("cashu_transactions")]
-    if "source" not in columns:
-        op.add_column(
-            "cashu_transactions",
-            sa.Column(
-                "source",
-                sqlmodel.sql.sqltypes.AutoString(),
-                nullable=False,
-                server_default="x-cashu",
-            ),
-        )
-
-
-def downgrade() -> None:
-    op.drop_column("cashu_transactions", "source")

routstr/algorithm.py

@@ -217,10 +217,6 @@ def create_model_mappings(
                 if prefixed_id not in aliases:
                     aliases.append(prefixed_id)
 
-            # Register forwarded_model_id as a routable alias
-            if model_to_use.forwarded_model_id and model_to_use.forwarded_model_id not in aliases:
-                aliases.append(model_to_use.forwarded_model_id)
-
             # Try to set each alias
             for alias in aliases:
                 _add_candidate(alias, model_to_use, upstream)
@@ -309,10 +305,6 @@ def create_model_mappings(
             if prefixed_id not in aliases:
                 aliases.append(prefixed_id)
 
-        # Register forwarded_model_id as a routable alias
-        if model_to_use.forwarded_model_id and model_to_use.forwarded_model_id not in aliases:
-            aliases.append(model_to_use.forwarded_model_id)
-
         for alias in aliases:
             _add_candidate(alias, model_to_use, upstream_for_override)
         seen_model_provider.add(dedupe_key)

routstr/auth.py

@@ -7,7 +7,6 @@ from datetime import datetime
 from typing import Optional
 
 from fastapi import HTTPException
-from sqlalchemy import case
 from sqlalchemy.exc import IntegrityError
 from sqlmodel import col, select, update
 
@@ -23,7 +22,6 @@ from .payment.cost_calculation import (
 from .wallet import credit_balance, deserialize_token_from_string
 
 logger = get_logger(__name__)
-payments_logger = get_logger("routstr.payments")
 
 # TODO: implement prepaid api key (not like it was before)
 # PREPAID_API_KEY = os.environ.get("PREPAID_API_KEY", None)
@@ -586,18 +584,6 @@ async def pay_for_request(
             "total_requests": billing_key.total_requests,
         },
     )
-    payments_logger.info(
-        "RESERVE",
-        extra={
-            "event": "reserve",
-            "key_hash": key.hashed_key[:8] + "...",
-            "billing_key_hash": billing_key.hashed_key[:8] + "...",
-            "cost_reserved": cost_per_request,
-            "balance": billing_key.balance,
-            "reserved_balance": billing_key.reserved_balance,
-            "total_spent": billing_key.total_spent,
-        },
-    )
 
     return cost_per_request
 
@@ -649,17 +635,6 @@ async def revert_pay_for_request(
     await session.refresh(billing_key)
     if billing_key.hashed_key != key.hashed_key:
         await session.refresh(key)
-    payments_logger.info(
-        "REVERT",
-        extra={
-            "event": "revert",
-            "key_hash": key.hashed_key[:8] + "...",
-            "billing_key_hash": billing_key.hashed_key[:8] + "...",
-            "cost_reverted": cost_per_request,
-            "balance": billing_key.balance,
-            "reserved_balance": billing_key.reserved_balance,
-        },
-    )
     return True
 
 
@@ -753,51 +728,24 @@ async def adjust_payment_for_tokens(
                 },
             )
             # Finalize by releasing reservation and charging max cost
-            if billing_key.reserved_balance < deducted_max_cost:
-                logger.error(
-                    "reserved_balance below deducted_max_cost before MaxCost finalization — clamping to 0",
-                    extra={
-                        "key_hash": key.hashed_key[:8] + "...",
-                        "billing_key_hash": billing_key.hashed_key[:8] + "...",
-                        "reserved_balance": billing_key.reserved_balance,
-                        "deducted_max_cost": deducted_max_cost,
-                        "total_cost_msats": cost.total_msats,
-                        "balance": billing_key.balance,
-                        "total_spent": billing_key.total_spent,
-                        "model": model,
-                    },
-                )
-
-            safe_reserved = case(
-                (col(ApiKey.reserved_balance) >= deducted_max_cost,
-                 col(ApiKey.reserved_balance) - deducted_max_cost),
-                else_=0,
-            )
-
             finalize_stmt = (
                 update(ApiKey)
                 .where(col(ApiKey.hashed_key) == billing_key.hashed_key)
                 .values(
-                    reserved_balance=safe_reserved,
                     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]
 
-            # Also update total_spent and reserved_balance on the child key if it's different
+            # Also update total_spent and balance on the child key if it's different
             if billing_key.hashed_key != key.hashed_key:
-                child_safe_reserved = case(
-                    (col(ApiKey.reserved_balance) >= deducted_max_cost,
-                     col(ApiKey.reserved_balance) - deducted_max_cost),
-                    else_=0,
-                )
                 child_stmt = (
                     update(ApiKey)
                     .where(col(ApiKey.hashed_key) == key.hashed_key)
                     .values(
                         total_spent=col(ApiKey.total_spent) + cost.total_msats,
-                        reserved_balance=child_safe_reserved,
+                        balance=col(ApiKey.balance) - cost.total_msats,
                     )
                 )
                 await session.exec(child_stmt)  # type: ignore[call-overload]
@@ -832,23 +780,6 @@ async def adjust_payment_for_tokens(
                         "model": model,
                     },
                 )
-                payments_logger.info(
-                    "FINALIZE",
-                    extra={
-                        "event": "finalize",
-                        "key_hash": key.hashed_key[:8] + "...",
-                        "billing_key_hash": billing_key.hashed_key[:8] + "...",
-                        "model": model,
-                        "cost_reserved": deducted_max_cost,
-                        "cost_charged": cost.total_msats,
-                        "input_tokens": cost.input_tokens,
-                        "output_tokens": cost.output_tokens,
-                        "balance": billing_key.balance,
-                        "reserved_balance": billing_key.reserved_balance,
-                        "total_spent": billing_key.total_spent,
-                        "finalize_type": "max_cost",
-                    },
-                )
             return cost.dict()
 
         case CostData() as cost:
@@ -882,51 +813,24 @@ async def adjust_payment_for_tokens(
                         "model": model,
                     },
                 )
-                if billing_key.reserved_balance < deducted_max_cost:
-                    logger.error(
-                        "reserved_balance below deducted_max_cost on exact-cost finalization — clamping to 0",
-                        extra={
-                            "key_hash": key.hashed_key[:8] + "...",
-                            "billing_key_hash": billing_key.hashed_key[:8] + "...",
-                            "reserved_balance": billing_key.reserved_balance,
-                            "deducted_max_cost": deducted_max_cost,
-                            "total_cost_msats": total_cost_msats,
-                            "balance": billing_key.balance,
-                            "total_spent": billing_key.total_spent,
-                            "model": model,
-                        },
-                    )
-
-                exact_safe_reserved = case(
-                    (col(ApiKey.reserved_balance) >= deducted_max_cost,
-                     col(ApiKey.reserved_balance) - deducted_max_cost),
-                    else_=0,
-                )
-
                 finalize_stmt = (
                     update(ApiKey)
                     .where(col(ApiKey.hashed_key) == billing_key.hashed_key)
                     .values(
-                        reserved_balance=exact_safe_reserved,
                         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]
 
-                # Also update total_spent and reserved_balance on the child key if it's different
+                # Also update total_spent and balance on the child key if it's different
                 if billing_key.hashed_key != key.hashed_key:
-                    child_exact_safe_reserved = case(
-                        (col(ApiKey.reserved_balance) >= deducted_max_cost,
-                         col(ApiKey.reserved_balance) - deducted_max_cost),
-                        else_=0,
-                    )
                     child_stmt = (
                         update(ApiKey)
                         .where(col(ApiKey.hashed_key) == key.hashed_key)
                         .values(
                             total_spent=col(ApiKey.total_spent) + total_cost_msats,
-                            reserved_balance=child_exact_safe_reserved,
+                            balance=col(ApiKey.balance) - total_cost_msats,
                         )
                     )
                     await session.exec(child_stmt)  # type: ignore[call-overload]
@@ -935,55 +839,44 @@ async def adjust_payment_for_tokens(
                 await session.refresh(billing_key)
                 if billing_key.hashed_key != key.hashed_key:
                     await session.refresh(key)
-                payments_logger.info(
-                    "FINALIZE",
-                    extra={
-                        "event": "finalize",
-                        "key_hash": key.hashed_key[:8] + "...",
-                        "billing_key_hash": billing_key.hashed_key[:8] + "...",
-                        "model": model,
-                        "cost_reserved": deducted_max_cost,
-                        "cost_charged": total_cost_msats,
-                        "input_tokens": cost.input_tokens,
-                        "output_tokens": cost.output_tokens,
-                        "balance": billing_key.balance,
-                        "reserved_balance": billing_key.reserved_balance,
-                        "total_spent": billing_key.total_spent,
-                        "finalize_type": "exact",
-                    },
-                )
                 return cost.dict()
 
-            # actual cost exceeded discounted reservation (due to tolerance_percentage)
+            # this should never happen why do we handle this???
             if cost_difference > 0:
-                # Always release the reservation and charge min(actual_cost, balance).
-                # Using a CASE expression makes this a single atomic UPDATE — no
-                # multi-level fallback needed and balance can never go negative.
-                chargeable = case(
-                    (col(ApiKey.balance) >= total_cost_msats, total_cost_msats),
-                    else_=col(ApiKey.balance),
+                # 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] + "...",
+                        "billing_key_hash": billing_key.hashed_key[:8] + "...",
+                        "additional_charge": cost_difference,
+                        "current_balance": billing_key.balance,
+                        "sufficient_balance": billing_key.balance >= cost_difference,
+                        "model": model,
+                    },
                 )
 
                 finalize_stmt = (
                     update(ApiKey)
                     .where(col(ApiKey.hashed_key) == billing_key.hashed_key)
-                    .where(col(ApiKey.reserved_balance) >= deducted_max_cost)
                     .values(
-                        reserved_balance=col(ApiKey.reserved_balance) - deducted_max_cost,
-                        balance=col(ApiKey.balance) - chargeable,
-                        total_spent=col(ApiKey.total_spent) + chargeable,
+                        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]
 
+                # Also update total_spent and reserved_balance on the child key if it's different
                 if billing_key.hashed_key != key.hashed_key:
                     child_stmt = (
                         update(ApiKey)
                         .where(col(ApiKey.hashed_key) == key.hashed_key)
-                        .where(col(ApiKey.reserved_balance) >= deducted_max_cost)
                         .values(
-                            reserved_balance=col(ApiKey.reserved_balance) - deducted_max_cost,
-                            total_spent=col(ApiKey.total_spent) + min(billing_key.balance, total_cost_msats),
+                            total_spent=col(ApiKey.total_spent) + total_cost_msats,
+                            reserved_balance=col(ApiKey.reserved_balance)
+                            - deducted_max_cost,
                         )
                     )
                     await session.exec(child_stmt)  # type: ignore[call-overload]
@@ -991,10 +884,11 @@ async def adjust_payment_for_tokens(
                 await session.commit()
 
                 if result.rowcount:
+                    cost.total_msats = total_cost_msats
                     await session.refresh(billing_key)
                     if billing_key.hashed_key != key.hashed_key:
                         await session.refresh(key)
-                    cost.total_msats = total_cost_msats
+
                     logger.info(
                         "Finalized payment with additional charge",
                         extra={
@@ -1005,28 +899,9 @@ async def adjust_payment_for_tokens(
                             "model": model,
                         },
                     )
-                    payments_logger.info(
-                        "FINALIZE",
-                        extra={
-                            "event": "finalize",
-                            "key_hash": key.hashed_key[:8] + "...",
-                            "billing_key_hash": billing_key.hashed_key[:8] + "...",
-                            "model": model,
-                            "cost_reserved": deducted_max_cost,
-                            "cost_charged": total_cost_msats,
-                            "input_tokens": cost.input_tokens,
-                            "output_tokens": cost.output_tokens,
-                            "balance": billing_key.balance,
-                            "reserved_balance": billing_key.reserved_balance,
-                            "total_spent": billing_key.total_spent,
-                            "finalize_type": "overrun",
-                        },
-                    )
                 else:
-                    # Guard fired: reservation was already released by a concurrent
-                    # finalization for this key. Nothing left to do.
                     logger.warning(
-                        "Finalization skipped - reservation already released",
+                        "Failed to finalize additional charge - releasing reservation",
                         extra={
                             "key_hash": key.hashed_key[:8] + "...",
                             "billing_key_hash": billing_key.hashed_key[:8] + "...",
@@ -1034,6 +909,7 @@ async def adjust_payment_for_tokens(
                             "model": model,
                         },
                     )
+                    await release_reservation_only()
             else:
                 # Refund some of the base cost
                 refund = abs(cost_difference)
@@ -1048,33 +924,12 @@ async def adjust_payment_for_tokens(
                     },
                 )
 
-                if billing_key.reserved_balance < deducted_max_cost:
-                    logger.error(
-                        "reserved_balance below deducted_max_cost on refund finalization — clamping to 0",
-                        extra={
-                            "key_hash": key.hashed_key[:8] + "...",
-                            "billing_key_hash": billing_key.hashed_key[:8] + "...",
-                            "reserved_balance": billing_key.reserved_balance,
-                            "deducted_max_cost": deducted_max_cost,
-                            "total_cost_msats": total_cost_msats,
-                            "refund_amount": refund,
-                            "balance": billing_key.balance,
-                            "total_spent": billing_key.total_spent,
-                            "model": model,
-                        },
-                    )
-
-                refund_safe_reserved = case(
-                    (col(ApiKey.reserved_balance) >= deducted_max_cost,
-                     col(ApiKey.reserved_balance) - deducted_max_cost),
-                    else_=0,
-                )
-
                 refund_stmt = (
                     update(ApiKey)
                     .where(col(ApiKey.hashed_key) == billing_key.hashed_key)
                     .values(
-                        reserved_balance=refund_safe_reserved,
+                        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,
                     )
@@ -1083,17 +938,13 @@ async def adjust_payment_for_tokens(
 
                 # Also update total_spent and reserved_balance on the child key if it's different
                 if billing_key.hashed_key != key.hashed_key:
-                    child_refund_safe_reserved = case(
-                        (col(ApiKey.reserved_balance) >= deducted_max_cost,
-                         col(ApiKey.reserved_balance) - deducted_max_cost),
-                        else_=0,
-                    )
                     child_stmt = (
                         update(ApiKey)
                         .where(col(ApiKey.hashed_key) == key.hashed_key)
                         .values(
                             total_spent=col(ApiKey.total_spent) + total_cost_msats,
-                            reserved_balance=child_refund_safe_reserved,
+                            reserved_balance=col(ApiKey.reserved_balance)
+                            - deducted_max_cost,
                         )
                     )
                     await session.exec(child_stmt)  # type: ignore[call-overload]
@@ -1130,24 +981,6 @@ async def adjust_payment_for_tokens(
                             "model": model,
                         },
                     )
-                    payments_logger.info(
-                        "FINALIZE",
-                        extra={
-                            "event": "finalize",
-                            "key_hash": key.hashed_key[:8] + "...",
-                            "billing_key_hash": billing_key.hashed_key[:8] + "...",
-                            "model": model,
-                            "cost_reserved": deducted_max_cost,
-                            "cost_charged": total_cost_msats,
-                            "refunded": refund,
-                            "input_tokens": cost.input_tokens,
-                            "output_tokens": cost.output_tokens,
-                            "balance": billing_key.balance,
-                            "reserved_balance": billing_key.reserved_balance,
-                            "total_spent": billing_key.total_spent,
-                            "finalize_type": "refund",
-                        },
-                    )
 
             return cost.dict()
 

routstr/balance.py

@@ -10,13 +10,7 @@ from pydantic import BaseModel
 from sqlmodel import select
 
 from .auth import get_billing_key, validate_bearer_key
-from .core.db import (
-    ApiKey,
-    AsyncSession,
-    CashuTransaction,
-    get_session,
-    store_cashu_transaction,
-)
+from .core.db import ApiKey, AsyncSession, CashuTransaction, get_session
 from .core.logging import get_logger
 from .core.settings import settings
 from .lightning import lightning_router
@@ -211,57 +205,37 @@ async def _refund_cache_set(authorization: str, value: dict[str, str]) -> None:
         _refund_cache[key] = (expiry, value)
 
 
-@router.post("/refund", response_model=None)
+@router.post("/refund")
 async def refund_wallet_endpoint(
-    authorization: Annotated[str | None, Header()] = None,
+    authorization: Annotated[str, Header(...)],
     x_cashu: Annotated[str | None, Header()] = None,
     session: AsyncSession = Depends(get_session),
-) -> JSONResponse | dict[str, str]:
-    if x_cashu:
-        # Find the "in" transaction by the original payment token
-        in_tx_result = await session.exec(
-            select(CashuTransaction).where(
-                CashuTransaction.token == x_cashu,
-                CashuTransaction.type == "in",
-            )
-        )
-        in_tx = in_tx_result.first()
-        if in_tx is None:
-            raise HTTPException(status_code=404, detail="Refund not found")
-
-        # Use the request_id to find the associated "out" (refund) transaction
-        if in_tx.request_id is None:
-            raise HTTPException(status_code=404, detail="Refund not found")
-
-        out_tx_result = await session.exec(
-            select(CashuTransaction).where(
-                CashuTransaction.request_id == in_tx.request_id,
-                CashuTransaction.type == "out",
-            )
-        )
-        out_tx = out_tx_result.first()
-        if out_tx is None:
-            raise HTTPException(status_code=404, detail="Refund not found")
-        if out_tx.swept:
-            raise HTTPException(status_code=410, detail="Refund has been swept")
-
-        out_tx.collected = True
-        session.add(out_tx)
-        await session.commit()
-        body: dict[str, str] = {"token": out_tx.token}
-        if out_tx.unit == "sat":
-            body["sats"] = str(out_tx.amount)
-        else:
-            body["msats"] = str(out_tx.amount)
-        return JSONResponse(content=body, headers={"X-Cashu": out_tx.token})
-
-    if authorization is None or not authorization.startswith("Bearer "):
+) -> dict[str, str]:
+    if not authorization.startswith("Bearer "):
         raise HTTPException(
             status_code=401,
             detail="Invalid authorization. Use 'Bearer <cashu-token>' or 'Bearer <api-key>'",
         )
 
     bearer_value: str = authorization[7:]
+
+    if x_cashu:
+        payment_token_hash = hashlib.sha256(x_cashu.strip().encode()).hexdigest()
+        result = await session.get(CashuTransaction, payment_token_hash)
+        if result is None:
+            raise HTTPException(status_code=404, detail="Refund not found")
+        if result.swept:
+            raise HTTPException(status_code=410, detail="Refund has been swept")
+        result.collected = True
+        session.add(result)
+        await session.commit()
+        body: dict[str, str] = {"token": result.token}
+        if result.unit == "sat":
+            body["sats"] = str(result.amount)
+        else:
+            body["msats"] = str(result.amount)
+        return JSONResponse(content=body, headers={"X-Cashu": result.token})
+
     key: ApiKey = await validate_bearer_key(bearer_value, session)
 
     if key.total_balance <= 0:
@@ -274,12 +248,6 @@ async def refund_wallet_endpoint(
             detail="Cannot refund child key. Please refund the parent key instead.",
         )
 
-    if key.reserved_balance > 0:
-        raise HTTPException(
-            status_code=400,
-            detail="Cannot refund key. There are ongoing requests for this api key.",
-        )
-
     remaining_balance_msats: int = key.total_balance
 
     if key.refund_currency == "sat":
@@ -316,17 +284,6 @@ async def refund_wallet_endpoint(
         else:
             result["msats"] = str(remaining_balance_msats)
 
-        if "token" in result:
-            logger.info(
-                "refund_wallet_endpoint: cashu token issued",
-                extra={
-                    "path": "/v1/wallet/refund",
-                    "token": result["token"],
-                    "amount": remaining_balance,
-                    "currency": key.refund_currency or "sat",
-                },
-            )
-
     except HTTPException:
         # Re-raise HTTP exceptions (like 400 for balance too small)
         raise
@@ -345,34 +302,11 @@ async def refund_wallet_endpoint(
 
     await _refund_cache_set(bearer_value, result)
 
-    previous_reserved_balance = key.reserved_balance
     key.balance = 0
     key.reserved_balance = 0
     session.add(key)
     await session.commit()
 
-    if "token" in result:
-        try:
-            await store_cashu_transaction(
-                token=result["token"],
-                amount=remaining_balance,
-                unit=key.refund_currency or "sat",
-                mint_url=key.refund_mint_url,
-                typ="out",
-                collected=False,
-                source="apikey",
-            )
-        except Exception:
-            pass  # store_cashu_transaction already logs
-
-    logger.info(
-        "refund_wallet_endpoint: refund successful",
-        extra={
-            "refunded_msats": remaining_balance_msats,
-            "previous_reserved_balance": previous_reserved_balance,
-        },
-    )
-
     return result
 
 

routstr/core/admin.py

@@ -295,7 +295,6 @@ class ModelCreate(BaseModel):
     canonical_slug: str | None = None
     alias_ids: list[str] | None = None
     enabled: bool = True
-    forwarded_model_id: str | None = None
 
 
 @admin_router.post(
@@ -340,7 +339,6 @@ async def upsert_provider_model(
                 json.dumps(payload.alias_ids) if payload.alias_ids else None
             )
             existing_row.enabled = payload.enabled
-            existing_row.forwarded_model_id = payload.forwarded_model_id or payload.id
 
             session.add(existing_row)
             await session.commit()
@@ -373,7 +371,6 @@ async def upsert_provider_model(
                 ),
                 upstream_provider_id=provider_id,
                 enabled=payload.enabled,
-                forwarded_model_id=payload.forwarded_model_id or payload.id,
             )
             session.add(row)
             await session.commit()

routstr/core/db.py

@@ -10,7 +10,6 @@ from alembic import command
 from alembic.config import Config
 from alembic.util.exc import CommandError
 from sqlalchemy import UniqueConstraint
-from sqlalchemy.exc import OperationalError
 from sqlalchemy.ext.asyncio.engine import create_async_engine
 from sqlmodel import Field, Relationship, SQLModel, func, select, update
 from sqlmodel.ext.asyncio.session import AsyncSession
@@ -106,10 +105,6 @@ class ModelRow(SQLModel, table=True):  # type: ignore
         default=None, description="JSON array of model alias IDs"
     )
     enabled: bool = Field(default=True, description="Whether this model is enabled")
-    forwarded_model_id: str | None = Field(
-        default=None,
-        description="Model ID to use when forwarding requests to upstream provider. Defaults to id if not set.",
-    )
     upstream_provider: "UpstreamProviderRow" = Relationship(back_populates="models")
 
 
@@ -155,10 +150,6 @@ class CashuTransaction(SQLModel, table=True):  # type: ignore
     )
     collected: bool = Field(default=False)
     swept: bool = Field(default=False)
-    source: str = Field(
-        default="x-cashu",
-        description="Payment source: x-cashu or apikey",
-    )
 
 
 async def store_cashu_transaction(
@@ -170,7 +161,6 @@ async def store_cashu_transaction(
     request_id: str | None = None,
     collected: bool = False,
     created_at: int | None = None,
-    source: str = "x-cashu",
 ) -> None:
     try:
         async with create_session() as session:
@@ -183,7 +173,6 @@ async def store_cashu_transaction(
                 request_id=request_id,
                 collected=collected,
                 created_at=created_at or int(time.time()),
-                source=source,
             )
             session.add(tx)
             await session.commit()
@@ -338,17 +327,6 @@ def run_migrations() -> None:
                 command.stamp(alembic_cfg, "head")
             else:
                 raise
-        except OperationalError as e:
-            if "duplicate column name" in str(e).lower():
-                logger.warning(
-                    "Migration hit a column that already exists (likely added via "
-                    "create_all on another branch). Stamping to current head.",
-                    extra={"error": str(e)},
-                )
-                _clear_alembic_version()
-                command.stamp(alembic_cfg, "head")
-            else:
-                raise
 
         logger.info("Database migrations completed successfully")
 

routstr/core/middleware.py

@@ -38,6 +38,11 @@ class LoggingMiddleware(BaseHTTPMiddleware):
             except Exception:
                 pass
 
+        # Extract request info
+        client_host = None
+        if request.client:
+            client_host = request.client.host
+
         # Log incoming request
         logger.info(
             "Incoming request",
@@ -46,6 +51,7 @@ class LoggingMiddleware(BaseHTTPMiddleware):
                 "method": request.method,
                 "path": request.url.path,
                 "query_params": dict(request.query_params),
+                "client_host": client_host,
                 "headers": {
                     k: v
                     for k, v in request.headers.items()
@@ -94,6 +100,7 @@ class LoggingMiddleware(BaseHTTPMiddleware):
                     "path": request.url.path,
                     "status_code": response.status_code,
                     "duration_ms": round(duration * 1000, 2),
+                    "client_host": client_host,
                 },
             )
             if hasattr(response, "headers"):
@@ -113,6 +120,7 @@ class LoggingMiddleware(BaseHTTPMiddleware):
                     "method": request.method,
                     "path": request.url.path,
                     "duration_ms": round(duration * 1000, 2),
+                    "client_host": client_host,
                     "error": str(e),
                     "error_type": type(e).__name__,
                 },

routstr/core/settings.py

@@ -74,7 +74,7 @@ class Settings(BaseSettings):
     enable_pricing_refresh: bool = Field(default=True, env="ENABLE_PRICING_REFRESH")
     enable_models_refresh: bool = Field(default=True, env="ENABLE_MODELS_REFRESH")
     refund_cache_ttl_seconds: int = Field(default=3600, env="REFUND_CACHE_TTL_SECONDS")
-    refund_sweep_ttl_seconds: int = Field(default=604800, env="REFUND_SWEEP_TTL_SECONDS")
+    refund_sweep_ttl_seconds: int = Field(default=86400, env="REFUND_SWEEP_TTL_SECONDS")
 
     # Logging
     log_level: str = Field(default="INFO", env="LOG_LEVEL")

routstr/payment/cost_calculation.py

@@ -109,20 +109,12 @@ async def calculate_cost(  # todo: can be sync
     )
 
     usd_cost = 0.0
-    input_usd = 0.0
-    output_usd = 0.0
 
+    # Prioritize cost_details.upstream_inference_cost
     if "cost_details" in usage_data:
         usd_cost = float(
             usage_data["cost_details"].get("upstream_inference_cost", 0) or 0
         )
-        input_usd = float(
-            usage_data["cost_details"].get("upstream_inference_prompt_cost", 0) or 0
-        )
-        output_usd = float(
-            usage_data["cost_details"].get("upstream_inference_completions_cost", 0)
-            or 0
-        )
 
     # Fallback to cost field if upstream_inference_cost is 0
     if usd_cost == 0 and "cost" in usage_data:
@@ -131,34 +123,12 @@ async def calculate_cost(  # todo: can be sync
         except Exception:
             pass
 
-    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 usd_cost > 0:
         try:
             sats_per_usd = 1.0 / sats_usd_price()
             cost_in_sats = usd_cost * sats_per_usd
             cost_in_msats = math.ceil(cost_in_sats * 1000)
 
-            input_msats = 0
-            output_msats = 0
-
-            if input_usd > 0 or output_usd > 0:
-                input_msats = int((input_usd * sats_per_usd) * 1000)
-                output_msats = int((output_usd * sats_per_usd) * 1000)
-            else:
-                total_tokens = input_tokens + output_tokens
-                if total_tokens > 0:
-                    input_ratio = input_tokens / total_tokens
-                    input_msats = int(cost_in_msats * input_ratio)
-                    output_msats = cost_in_msats - input_msats
-                else:
-                    output_msats = cost_in_msats
-
             logger.info(
                 "Using cost from usage data/details",
                 extra={
@@ -170,9 +140,9 @@ async def calculate_cost(  # todo: can be sync
             )
 
             return CostData(
-                base_msats=0,
-                input_msats=input_msats,
-                output_msats=output_msats,
+                base_msats=-1,
+                input_msats=-1,  # Cost field doesn't break down by token type
+                output_msats=-1,
                 total_msats=cost_in_msats,
                 total_usd=usd_cost,
                 input_tokens=input_tokens,
@@ -189,6 +159,13 @@ async def calculate_cost(  # todo: can be sync
             )
             # Fall through to token-based calculation
 
+    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(
@@ -254,10 +231,10 @@ async def calculate_cost(  # todo: can be sync
             output_tokens=output_tokens,
         )
 
-    calc_input_msats = round(input_tokens / 1000 * MSATS_PER_1K_INPUT_TOKENS, 3)
+    input_msats = round(input_tokens / 1000 * MSATS_PER_1K_INPUT_TOKENS, 3)
 
-    calc_output_msats = round(output_tokens / 1000 * MSATS_PER_1K_OUTPUT_TOKENS, 3)
-    token_based_cost = math.ceil(calc_input_msats + calc_output_msats)
+    output_msats = round(output_tokens / 1000 * MSATS_PER_1K_OUTPUT_TOKENS, 3)
+    token_based_cost = math.ceil(input_msats + output_msats)
     total_usd = (token_based_cost / 1000.0) * sats_usd_price()
 
     logger.info(
@@ -265,8 +242,8 @@ async def calculate_cost(  # todo: can be sync
         extra={
             "input_tokens": input_tokens,
             "output_tokens": output_tokens,
-            "input_cost_msats": calc_input_msats,
-            "output_cost_msats": calc_output_msats,
+            "input_cost_msats": input_msats,
+            "output_cost_msats": output_msats,
             "total_cost_msats": token_based_cost,
             "total_usd": total_usd,
             "model": response_data.get("model", "unknown"),
@@ -275,8 +252,8 @@ async def calculate_cost(  # todo: can be sync
 
     return CostData(
         base_msats=0,
-        input_msats=int(calc_input_msats),
-        output_msats=int(calc_output_msats),
+        input_msats=int(input_msats),
+        output_msats=int(output_msats),
         total_msats=token_based_cost,
         total_usd=total_usd,
         input_tokens=input_tokens,

routstr/payment/models.py

@@ -60,7 +60,6 @@ class Model(BaseModel):
     upstream_provider_id: int | str | None = None
     canonical_slug: str | None = None
     alias_ids: list[str] | None = None
-    forwarded_model_id: str | None = None
 
     def __hash__(self) -> int:
         return hash(self.id)
@@ -178,7 +177,6 @@ def _row_to_model(
         upstream_provider_id=row.upstream_provider_id,
         canonical_slug=getattr(row, "canonical_slug", None),
         alias_ids=json.loads(row.alias_ids) if row.alias_ids else None,
-        forwarded_model_id=getattr(row, "forwarded_model_id", None) or row.id,
     )
 
     if apply_provider_fee:
@@ -331,7 +329,6 @@ def _update_model_sats_pricing(model: Model, sats_to_usd: float) -> Model:
             upstream_provider_id=model.upstream_provider_id,
             canonical_slug=model.canonical_slug,
             alias_ids=model.alias_ids,
-            forwarded_model_id=model.forwarded_model_id,
         )
     except Exception as e:
         logger.error(
@@ -414,10 +411,4 @@ async def models(session: AsyncSession = Depends(get_session)) -> dict:
     from ..proxy import get_unique_models
 
     items = get_unique_models()
-    data = []
-    for model in items:
-        m = model.dict()
-        if model.forwarded_model_id:
-            m["id"] = model.forwarded_model_id
-        data.append(m)
-    return {"data": data}
+    return {"data": items}

routstr/proxy.py

@@ -207,7 +207,7 @@ async def proxy(
 
     elif auth := headers.get("authorization", None):
         key = await get_bearer_token_key(
-            headers, path, session, auth, max_cost_for_model, model_id
+            headers, path, session, auth, max_cost_for_model
         )
 
     else:
@@ -387,12 +387,7 @@ async def proxy(
 
 
 async def get_bearer_token_key(
-    headers: dict,
-    path: str,
-    session: AsyncSession,
-    auth: str,
-    min_cost: int = 0,
-    model_id: str = "unknown",
+    headers: dict, path: str, session: AsyncSession, auth: str, min_cost: int = 0
 ) -> ApiKey:
     """Handle bearer token authentication proxy requests."""
     parts = auth.split()
@@ -462,13 +457,11 @@ async def get_bearer_token_key(
     except Exception as e:
         key_preview = bearer_key[:20] + "..." if len(bearer_key) > 20 else bearer_key
         logger.error(
-            f"Bearer token validation failed: {type(e).__name__}: {e} path={path} model={model_id!r} min_cost={min_cost} key={key_preview!r}",
+            f"Bearer token validation failed: {type(e).__name__}: {e} path={path} key={key_preview!r}",
             extra={
                 "error": str(e),
                 "error_type": type(e).__name__,
                 "path": path,
-                "model_id": model_id,
-                "min_cost_msat": min_cost,
                 "bearer_key_preview": key_preview,
             },
         )

routstr/wallet.py

@@ -155,20 +155,6 @@ async def swap_to_primary_mint(
         raise ValueError("Invalid unit")
     primary_wallet = await get_wallet(settings.primary_mint, settings.primary_mint_unit)
 
-    # If the token is already from the primary mint, we don't need to swap
-    # and we definitely don't want to calculate or pay fees.
-    if token_obj.mint == settings.primary_mint:
-        logger.info(
-            "swap_to_primary_mint: token already on primary mint, skipping swap",
-            extra={
-                "mint": token_obj.mint,
-                "amount": token_amount,
-                "unit": token_obj.unit,
-            },
-        )
-        await token_wallet.split(proofs=token_obj.proofs, amount=0, include_fees=True)
-        return token_amount, token_obj.unit, token_obj.mint
-
     minted_amount = await _calculate_swap_amount(
         amount_msat,
         token_obj.unit,
@@ -549,7 +535,7 @@ async def periodic_refund_sweep() -> None:
                     except Exception as e:
                         error_msg = str(e).lower()
                         if "already spent" in error_msg:
-                            refund.collected = True
+                            refund.swept = True
                             session.add(refund)
                             logger.info(
                                 "Refund already spent (client collected), marking swept",

tests/integration/conftest.py

@@ -380,13 +380,6 @@ async def integration_session(
         yield session
 
 
-@pytest_asyncio.fixture
-async def patched_db_engine(integration_engine: Any) -> AsyncGenerator[None, None]:
-    """Patch the global db engine so create_session() uses the test engine."""
-    with patch("routstr.core.db.engine", integration_engine):
-        yield
-
-
 class DatabaseSnapshot:
     """Utility to capture and compare database states"""
 

tests/integration/test_balance_negative_on_cost_overrun.py

@@ -1,369 +0,0 @@
-"""
-Integration tests for the balance-goes-negative bug in adjust_payment_for_tokens.
-
-Root cause: when actual token cost exceeds the discounted reservation
-(cost_difference > 0, caused by tolerance_percentage discounting the reservation),
-the finalization UPDATE had no WHERE guard on balance, allowing balance to go negative.
-
-Fix: added `.where(col(ApiKey.balance) >= total_cost_msats)` so the UPDATE is a no-op
-when balance is insufficient, then falls back to charging only deducted_max_cost.
-"""
-
-import uuid
-from unittest.mock import patch
-
-import pytest
-from sqlmodel.ext.asyncio.session import AsyncSession
-
-from routstr.core.db import ApiKey
-from routstr.payment.cost_calculation import CostData
-
-
-def _make_key(balance: int, reserved: int) -> ApiKey:
-    return ApiKey(
-        hashed_key=f"test_{uuid.uuid4().hex}",
-        balance=balance,
-        reserved_balance=reserved,
-        total_spent=0,
-        total_requests=1,
-    )
-
-
-async def _refresh(session: AsyncSession, key: ApiKey) -> ApiKey:
-    await session.refresh(key)
-    return key
-
-
-# ---------------------------------------------------------------------------
-# Helper: build a CostData where token cost > deducted_max_cost
-# ---------------------------------------------------------------------------
-
-def _cost_data(total_msats: int) -> CostData:
-    return CostData(
-        base_msats=0,
-        input_msats=total_msats // 2,
-        output_msats=total_msats - total_msats // 2,
-        total_msats=total_msats,
-        total_usd=0.0,
-        input_tokens=100,
-        output_tokens=100,
-    )
-
-
-# ---------------------------------------------------------------------------
-# Test 1 — exact reproduction of the bug
-#
-# Setup: balance == deducted_max_cost (user has just enough for the reservation,
-#         nothing extra). Actual token cost is 1% higher (tolerance_percentage).
-#
-# Before fix: balance -= total_cost_msats → goes negative.
-# After fix:  WHERE balance >= total_cost_msats fails → fallback charges
-#             deducted_max_cost → balance reaches 0, never negative.
-# ---------------------------------------------------------------------------
-
-@pytest.mark.asyncio
-async def test_balance_never_negative_when_cost_exceeds_reservation(
-    integration_session: AsyncSession,
-) -> None:
-    """Balance must not go negative when actual token cost > discounted reservation."""
-    from routstr.auth import adjust_payment_for_tokens
-
-    deducted_max_cost = 990  # reserved (1% below true max of 1000)
-    actual_token_cost = 1000  # actual cost at true max
-
-    # User has balance exactly equal to the reservation — tight budget
-    key = _make_key(balance=deducted_max_cost, reserved=deducted_max_cost)
-    integration_session.add(key)
-    await integration_session.commit()
-
-    response_data = {"model": "test-model", "usage": {"prompt_tokens": 100, "completion_tokens": 100}}
-
-    with patch(
-        "routstr.auth.calculate_cost",
-        return_value=_cost_data(actual_token_cost),
-    ):
-        await adjust_payment_for_tokens(key, response_data, integration_session, deducted_max_cost)
-
-    await _refresh(integration_session, key)
-
-    assert key.balance >= 0, f"Balance went negative: {key.balance}"
-    assert key.reserved_balance >= 0, f"Reserved balance went negative: {key.reserved_balance}"
-    assert key.reserved_balance == 0, "Reservation must be fully released after finalization"
-
-
-# ---------------------------------------------------------------------------
-# Test 2 — balance is ZERO after the reservation is accounted for
-#           (absolute floor case)
-# ---------------------------------------------------------------------------
-
-@pytest.mark.asyncio
-async def test_balance_floor_at_zero_on_overrun(
-    integration_session: AsyncSession,
-) -> None:
-    """When balance exactly covers deducted_max_cost and cost overruns, balance reaches 0 not negative."""
-    from routstr.auth import adjust_payment_for_tokens
-
-    deducted_max_cost = 500
-    actual_token_cost = 550  # 10% overrun
-
-    key = _make_key(balance=500, reserved=500)
-    integration_session.add(key)
-    await integration_session.commit()
-
-    response_data = {"model": "test-model", "usage": {"prompt_tokens": 50, "completion_tokens": 50}}
-
-    with patch(
-        "routstr.auth.calculate_cost",
-        return_value=_cost_data(actual_token_cost),
-    ):
-        await adjust_payment_for_tokens(key, response_data, integration_session, deducted_max_cost)
-
-    await _refresh(integration_session, key)
-
-    assert key.balance == 0, (
-        f"Expected balance=0 (charged deducted_max_cost fallback), got {key.balance}"
-    )
-    assert key.reserved_balance == 0, f"Reserved balance should be 0, got {key.reserved_balance}"
-    # Fallback charges deducted_max_cost
-    assert key.total_spent == deducted_max_cost, (
-        f"Expected total_spent={deducted_max_cost}, got {key.total_spent}"
-    )
-
-
-# ---------------------------------------------------------------------------
-# Test 3 — balance has enough room: full token cost should be charged
-# ---------------------------------------------------------------------------
-
-@pytest.mark.asyncio
-async def test_full_cost_charged_when_balance_sufficient_for_overrun(
-    integration_session: AsyncSession,
-) -> None:
-    """When balance covers total_cost_msats, the full amount is charged (not just deducted_max_cost)."""
-    from routstr.auth import adjust_payment_for_tokens
-
-    deducted_max_cost = 990
-    actual_token_cost = 1000
-
-    # User has extra balance beyond the reservation
-    key = _make_key(balance=2000, reserved=990)
-    integration_session.add(key)
-    await integration_session.commit()
-
-    response_data = {"model": "test-model", "usage": {"prompt_tokens": 100, "completion_tokens": 100}}
-
-    with patch(
-        "routstr.auth.calculate_cost",
-        return_value=_cost_data(actual_token_cost),
-    ):
-        await adjust_payment_for_tokens(key, response_data, integration_session, deducted_max_cost)
-
-    await _refresh(integration_session, key)
-
-    assert key.balance >= 0, f"Balance went negative: {key.balance}"
-    assert key.reserved_balance == 0, f"Reservation not released: {key.reserved_balance}"
-    assert key.total_spent == actual_token_cost, (
-        f"Expected full charge of {actual_token_cost}, got {key.total_spent}"
-    )
-    assert key.balance == 2000 - actual_token_cost, (
-        f"Expected balance={2000 - actual_token_cost}, got {key.balance}"
-    )
-
-
-# ---------------------------------------------------------------------------
-# Test 4 — concurrent finalizations with cost overrun
-#
-# Multiple requests finish concurrently. Each has a small overrun.
-# None should drive balance negative.
-# ---------------------------------------------------------------------------
-
-@pytest.mark.asyncio
-async def test_concurrent_cost_overruns_never_negative(
-    integration_session: AsyncSession,
-    patched_db_engine: None,
-) -> None:
-    """Concurrent finalization with cost overruns must never produce negative balance."""
-    import asyncio
-
-    from routstr.auth import adjust_payment_for_tokens, pay_for_request
-    from routstr.core.db import create_session
-
-    deducted_max_cost = 990
-    actual_token_cost = 1000
-    n_requests = 5
-
-    # Fund the key with exactly enough for n_requests reservations + a tiny buffer
-    starting_balance = deducted_max_cost * n_requests
-    key_hash = f"test_concurrent_{uuid.uuid4().hex}"
-
-    async with create_session() as session:
-        key = ApiKey(
-            hashed_key=key_hash,
-            balance=starting_balance,
-            reserved_balance=0,
-            total_spent=0,
-            total_requests=0,
-        )
-        session.add(key)
-        await session.commit()
-
-    # Reserve n_requests slots (sequentially, as pay_for_request is atomic)
-    async with create_session() as session:
-        key_to_reserve = await session.get(ApiKey, key_hash)
-        assert key_to_reserve is not None
-        for _ in range(n_requests):
-            await pay_for_request(key_to_reserve, deducted_max_cost, session)
-            await session.refresh(key_to_reserve)
-
-    # Now finalize all concurrently with cost overrun
-    async def finalize() -> None:
-        response_data = {
-            "model": "test-model",
-            "usage": {"prompt_tokens": 100, "completion_tokens": 100},
-        }
-        async with create_session() as session:
-            fresh_key = await session.get(ApiKey, key_hash)
-            assert fresh_key is not None
-            with patch(
-                "routstr.auth.calculate_cost",
-                return_value=_cost_data(actual_token_cost),
-            ):
-                await adjust_payment_for_tokens(
-                    fresh_key, response_data, session, deducted_max_cost
-                )
-
-    await asyncio.gather(*[finalize() for _ in range(n_requests)])
-
-    async with create_session() as session:
-        final_key = await session.get(ApiKey, key_hash)
-        assert final_key is not None
-
-    assert final_key.balance >= 0, (
-        f"Balance went negative after concurrent overruns: {final_key.balance}"
-    )
-    assert final_key.reserved_balance == 0, (
-        f"Reserved balance not fully released: {final_key.reserved_balance}"
-    )
-    assert final_key.total_spent <= starting_balance, (
-        f"Total spent ({final_key.total_spent}) exceeds starting balance ({starting_balance})"
-    )
-    # Every request must have been charged at least deducted_max_cost — no free inference.
-    assert final_key.total_spent == starting_balance, (
-        f"Expected total_spent={starting_balance} (all {n_requests} reservations charged), "
-        f"got {final_key.total_spent} — at least one request got free inference"
-    )
-
-
-# ---------------------------------------------------------------------------
-# Test 5 — overrun with no balance at all (reserved_balance == balance)
-#           simulates a user who topped up to exactly the reservation floor
-# ---------------------------------------------------------------------------
-
-@pytest.mark.asyncio
-async def test_zero_free_balance_overrun_is_safe(
-    integration_session: AsyncSession,
-) -> None:
-    """User with zero free balance (all reserved) should never go negative on overrun."""
-    from routstr.auth import adjust_payment_for_tokens
-
-    deducted_max_cost = 1000
-    actual_token_cost = 1050
-
-    # balance == reserved_balance: zero free balance
-    key = _make_key(balance=1000, reserved=1000)
-    integration_session.add(key)
-    await integration_session.commit()
-
-    response_data = {"model": "test-model", "usage": {"prompt_tokens": 50, "completion_tokens": 100}}
-
-    with patch(
-        "routstr.auth.calculate_cost",
-        return_value=_cost_data(actual_token_cost),
-    ):
-        await adjust_payment_for_tokens(key, response_data, integration_session, deducted_max_cost)
-
-    await _refresh(integration_session, key)
-
-    assert key.balance >= 0, f"Balance went negative: {key.balance}"
-    assert key.reserved_balance >= 0, f"Reserved balance went negative: {key.reserved_balance}"
-
-
-# ---------------------------------------------------------------------------
-# Test 6 — parallel requests: second finalization must not get free inference
-#
-# Root cause of the bug fixed in auth.py:
-#   `.where(col(ApiKey.balance) >= total_cost_msats)` ignores other requests'
-#   reservations, so after Request A charges total_cost_msats, balance can drop
-#   below deducted_max_cost, causing Request B's fallback to release for free.
-#
-# Fix: use `balance - reserved_balance + deducted_max_cost >= total_cost_msats`
-#   so the check accounts for concurrent reservations.
-# ---------------------------------------------------------------------------
-
-
-@pytest.mark.asyncio
-async def test_parallel_requests_no_free_inference(
-    integration_session: AsyncSession,
-    patched_db_engine: None,
-) -> None:
-    """Second parallel finalization must be charged even when first depleted free balance."""
-    import asyncio
-
-    from routstr.auth import adjust_payment_for_tokens
-    from routstr.core.db import create_session
-
-    deducted_max_cost = 100
-    actual_token_cost = 150  # overrun: 50 more than reserved
-
-    # Fund the key with exactly 2 * deducted_max_cost.
-    # Both requests pre-reserved 100 each → balance=200, reserved=200, free=0.
-    # Old check (balance >= total_cost_msats):
-    #   Request A: 200 >= 150 ✓ → charges 150 → balance=50, reserved=100
-    #   Request B: 50 >= 150 ✗ → fallback: 50 >= 100 ✗ → releases FREE
-    # New check (balance - reserved + deducted >= total_cost_msats):
-    #   Both fall to fallback (0 free balance).
-    #   Both charge deducted_max_cost=100 → total_spent=200, balance=0.
-    starting_balance = deducted_max_cost * 2
-    key_hash = f"test_parallel_no_free_{uuid.uuid4().hex}"
-
-    async with create_session() as session:
-        key = ApiKey(
-            hashed_key=key_hash,
-            balance=starting_balance,
-            reserved_balance=deducted_max_cost * 2,  # both slots pre-reserved
-            total_spent=0,
-            total_requests=2,
-        )
-        session.add(key)
-        await session.commit()
-
-    async def finalize() -> None:
-        response_data = {
-            "model": "test-model",
-            "usage": {"prompt_tokens": 50, "completion_tokens": 100},
-        }
-        async with create_session() as session:
-            fresh_key = await session.get(ApiKey, key_hash)
-            assert fresh_key is not None
-            with patch(
-                "routstr.auth.calculate_cost",
-                return_value=_cost_data(actual_token_cost),
-            ):
-                await adjust_payment_for_tokens(
-                    fresh_key, response_data, session, deducted_max_cost
-                )
-
-    await asyncio.gather(finalize(), finalize())
-
-    async with create_session() as session:
-        final_key = await session.get(ApiKey, key_hash)
-        assert final_key is not None
-
-    assert final_key.balance >= 0, f"Balance went negative: {final_key.balance}"
-    assert final_key.reserved_balance == 0, (
-        f"Reserved balance not released: {final_key.reserved_balance}"
-    )
-    # Both requests must have been charged — no free inference.
-    assert final_key.total_spent == starting_balance, (
-        f"Expected total_spent={starting_balance} (both reservations charged), "
-        f"got {final_key.total_spent} — one request got free inference"
-    )

tests/integration/test_insufficient_balance.py

@@ -1,240 +0,0 @@
-"""
-Tests showing how a user hits "Insufficient balance: X mSats required for this model"
-when their balance is too low for the model's cost.
-
-The log line that triggered this:
-  WARNING  Insufficient billing balance during validation
-  ERROR    Bearer token validation failed: HTTPException: 402:
-           {'error': {'message': 'Insufficient balance: 622888 mSats required
-           for this model. 20320 available.', ...}}
-
-This happens in validate_bearer_key (auth.py) when:
-  billing_key.total_balance < min_cost   (model's max cost)
-
-and also in pay_for_request when the atomic UPDATE finds no available balance.
-"""
-
-import uuid
-from unittest.mock import patch
-
-import pytest
-from fastapi import HTTPException
-from httpx import AsyncClient
-from sqlmodel.ext.asyncio.session import AsyncSession
-
-from routstr.core.db import ApiKey
-
-
-def _key(balance: int, reserved: int = 0) -> ApiKey:
-    return ApiKey(
-        hashed_key=f"test_{uuid.uuid4().hex}",
-        balance=balance,
-        reserved_balance=reserved,
-        total_spent=0,
-    )
-
-
-# ---------------------------------------------------------------------------
-# Test 1 — simplest case: balance < model cost → pay_for_request raises 402
-# ---------------------------------------------------------------------------
-
-@pytest.mark.asyncio
-async def test_pay_for_request_raises_402_when_balance_too_low(
-    integration_session: AsyncSession,
-) -> None:
-    """
-    User has 20_000 msats. Model costs 622_888 msats.
-    pay_for_request must raise HTTP 402 with a clear message.
-    """
-    from routstr.auth import pay_for_request
-
-    model_cost = 622_888
-    user_balance = 20_000
-
-    key = _key(balance=user_balance)
-    integration_session.add(key)
-    await integration_session.commit()
-
-    with pytest.raises(HTTPException) as exc_info:
-        await pay_for_request(key, model_cost, integration_session)
-
-    assert exc_info.value.status_code == 402
-    detail = exc_info.value.detail
-    assert isinstance(detail, dict)
-    error = detail["error"]
-    assert error["code"] == "insufficient_balance"
-    assert str(model_cost) in error["message"]
-    assert str(user_balance) in error["message"]
-
-    # Balance must be untouched
-    await integration_session.refresh(key)
-    assert key.balance == user_balance
-    assert key.reserved_balance == 0
-
-
-# ---------------------------------------------------------------------------
-# Test 2 — balance is zero
-# ---------------------------------------------------------------------------
-
-@pytest.mark.asyncio
-async def test_pay_for_request_raises_402_on_zero_balance(
-    integration_session: AsyncSession,
-) -> None:
-    """User with zero balance cannot make any request."""
-    from routstr.auth import pay_for_request
-
-    key = _key(balance=0)
-    integration_session.add(key)
-    await integration_session.commit()
-
-    with pytest.raises(HTTPException) as exc_info:
-        await pay_for_request(key, 1_000, integration_session)
-
-    assert exc_info.value.status_code == 402
-    detail = exc_info.value.detail
-    assert isinstance(detail, dict)
-    assert detail["error"]["code"] == "insufficient_balance"
-
-
-# ---------------------------------------------------------------------------
-# Test 3 — all balance is reserved (total_balance = balance - reserved = 0)
-# ---------------------------------------------------------------------------
-
-@pytest.mark.asyncio
-async def test_pay_for_request_raises_402_when_all_balance_reserved(
-    integration_session: AsyncSession,
-) -> None:
-    """
-    User has 50_000 msats balance but 50_000 is already reserved for in-flight
-    requests. Free balance (total_balance) = 0. Should get 402.
-    """
-    from routstr.auth import pay_for_request
-
-    key = _key(balance=50_000, reserved=50_000)
-    integration_session.add(key)
-    await integration_session.commit()
-
-    with pytest.raises(HTTPException) as exc_info:
-        await pay_for_request(key, 1_000, integration_session)
-
-    assert exc_info.value.status_code == 402
-    # Balance and reserved must be untouched
-    await integration_session.refresh(key)
-    assert key.balance == 50_000
-    assert key.reserved_balance == 50_000
-
-
-# ---------------------------------------------------------------------------
-# Test 4 — balance just one msat below model cost
-# ---------------------------------------------------------------------------
-
-@pytest.mark.asyncio
-async def test_pay_for_request_raises_402_one_msat_short(
-    integration_session: AsyncSession,
-) -> None:
-    """Off-by-one: balance is exactly model_cost - 1."""
-    from routstr.auth import pay_for_request
-
-    model_cost = 10_000
-    key = _key(balance=model_cost - 1)
-    integration_session.add(key)
-    await integration_session.commit()
-
-    with pytest.raises(HTTPException) as exc_info:
-        await pay_for_request(key, model_cost, integration_session)
-
-    assert exc_info.value.status_code == 402
-    await integration_session.refresh(key)
-    assert key.balance == model_cost - 1   # untouched
-    assert key.reserved_balance == 0
-
-
-# ---------------------------------------------------------------------------
-# Test 5 — balance exactly equal to model cost → succeeds
-# ---------------------------------------------------------------------------
-
-@pytest.mark.asyncio
-async def test_pay_for_request_succeeds_when_balance_equals_cost(
-    integration_session: AsyncSession,
-) -> None:
-    """Balance == model cost: the request should be reserved successfully."""
-    from routstr.auth import pay_for_request
-
-    model_cost = 10_000
-    key = _key(balance=model_cost)
-    integration_session.add(key)
-    await integration_session.commit()
-
-    # Should not raise
-    await pay_for_request(key, model_cost, integration_session)
-
-    await integration_session.refresh(key)
-    assert key.reserved_balance == model_cost
-    assert key.balance == model_cost   # balance unchanged, only reserved goes up
-
-
-# ---------------------------------------------------------------------------
-# Test 6 — HTTP layer returns 402 JSON with the right shape
-# ---------------------------------------------------------------------------
-
-@pytest.mark.asyncio
-async def test_http_402_response_shape_on_insufficient_balance(
-    integration_client: AsyncClient,
-    integration_session: AsyncSession,
-) -> None:
-    """
-    End-to-end: POST /v1/chat/completions with a key whose balance is far below
-    the mocked model cost returns HTTP 402 with the expected JSON error body.
-
-    Matches exactly the log snippet in the bug report:
-      'Insufficient balance: X mSats required for this model. Y available.'
-    """
-    from unittest.mock import AsyncMock, MagicMock
-
-    model_cost = 622_888
-    user_balance = 20_320
-
-    key = _key(balance=user_balance)
-    integration_session.add(key)
-    await integration_session.commit()
-
-    # Minimal model stub so proxy routing doesn't 400 before reaching balance check
-    mock_model = MagicMock()
-    mock_model.sats_pricing = None
-
-    # Upstream stub — never reached because balance check fires first
-    mock_upstream = MagicMock()
-    mock_upstream.prepare_headers = MagicMock(return_value={})
-
-    with (
-        patch("routstr.proxy.get_model_instance", return_value=mock_model),
-        patch("routstr.proxy.get_provider_for_model", return_value=[mock_upstream]),
-        # Patch where it is used (proxy imports it at module level)
-        patch(
-            "routstr.proxy.get_max_cost_for_model",
-            new=AsyncMock(return_value=model_cost),
-        ),
-    ):
-        response = await integration_client.post(
-            "/v1/chat/completions",
-            headers={"Authorization": f"Bearer sk-{key.hashed_key}"},
-            json={
-                "model": "gpt-4o",
-                "messages": [{"role": "user", "content": "hello"}],
-            },
-        )
-
-    assert response.status_code == 402
-    body = response.json()
-    # FastAPI wraps HTTPException detail under "detail"
-    error = body["detail"]["error"]
-    assert error["code"] == "insufficient_balance"
-    assert error["type"] == "insufficient_quota"
-    assert str(model_cost) in error["message"]
-    assert str(user_balance) in error["message"]
-
-    # Balance must be completely untouched
-    await integration_session.refresh(key)
-    assert key.balance == user_balance
-    assert key.reserved_balance == 0
-    assert key.total_spent == 0

tests/integration/test_reservation_lifecycle.py

@@ -1,268 +0,0 @@
-"""
-Tests for the reservation lifecycle:
-
-  1. Reserve  → reserved_balance increases, available (total_balance) decreases.
-  2. Reserve  → revert  → reserved_balance restored, balance untouched.
-  3. Reserve  → finalise → reserved_balance released, balance charged.
-  4. Two parallel reserves, only one fits → second blocked with 402.
-  5. Three parallel reserves, two fit, third blocked with 402.
-  6. Sequential reserves until balance exhausted → next request blocked.
-
-Reservation invariant enforced by the atomic WHERE clause in pay_for_request:
-    balance - reserved_balance >= cost_per_request
-"""
-
-import asyncio
-import uuid
-
-import pytest
-from fastapi import HTTPException
-from sqlmodel.ext.asyncio.session import AsyncSession
-
-from routstr.auth import pay_for_request, revert_pay_for_request
-from routstr.core.db import ApiKey, create_session
-
-# ---------------------------------------------------------------------------
-# Helpers
-# ---------------------------------------------------------------------------
-
-def _make_key(balance: int, reserved: int = 0) -> ApiKey:
-    return ApiKey(
-        hashed_key=f"test_{uuid.uuid4().hex}",
-        balance=balance,
-        reserved_balance=reserved,
-        total_spent=0,
-        total_requests=0,
-    )
-
-
-async def _persist(session: AsyncSession, key: ApiKey) -> ApiKey:
-    session.add(key)
-    await session.commit()
-    await session.refresh(key)
-    return key
-
-
-# ---------------------------------------------------------------------------
-# Test 1 — Reserve: reserved_balance increases, available balance decreases
-# ---------------------------------------------------------------------------
-
-@pytest.mark.asyncio
-async def test_reserve_increases_reserved_balance(
-    integration_session: AsyncSession,
-) -> None:
-    """pay_for_request must increment reserved_balance by cost_per_request."""
-    cost = 100
-    key = await _persist(integration_session, _make_key(balance=500))
-
-    await pay_for_request(key, cost, integration_session)
-    await integration_session.refresh(key)
-
-    assert key.reserved_balance == cost
-    assert key.balance == 500  # balance column is NOT decremented on reserve
-    assert key.total_balance == 500 - cost  # available = balance - reserved
-
-
-# ---------------------------------------------------------------------------
-# Test 2 — Revert: reserved_balance restored, balance untouched
-# ---------------------------------------------------------------------------
-
-@pytest.mark.asyncio
-async def test_revert_releases_reservation(
-    integration_session: AsyncSession,
-) -> None:
-    """revert_pay_for_request must release the reservation without touching balance."""
-    cost = 150
-    key = await _persist(integration_session, _make_key(balance=300))
-
-    await pay_for_request(key, cost, integration_session)
-    await integration_session.refresh(key)
-    assert key.reserved_balance == cost
-
-    await revert_pay_for_request(key, integration_session, cost)
-    await integration_session.refresh(key)
-
-    assert key.reserved_balance == 0
-    assert key.balance == 300  # balance unchanged after revert
-
-
-# ---------------------------------------------------------------------------
-# Test 3 — Finalise: reservation released + balance charged
-# ---------------------------------------------------------------------------
-
-@pytest.mark.asyncio
-async def test_finalise_releases_reservation_and_charges_balance(
-    integration_session: AsyncSession,
-) -> None:
-    """adjust_payment_for_tokens must zero reserved_balance and deduct actual cost."""
-    from unittest.mock import patch
-
-    from routstr.auth import adjust_payment_for_tokens
-    from routstr.payment.cost_calculation import CostData
-
-    cost = 100
-    actual = 80  # actual < reserved → refund path
-    key = await _persist(integration_session, _make_key(balance=500))
-
-    await pay_for_request(key, cost, integration_session)
-    await integration_session.refresh(key)
-    assert key.reserved_balance == cost
-
-    cost_data = CostData(
-        base_msats=0,
-        input_msats=40,
-        output_msats=40,
-        total_msats=actual,
-        total_usd=0.0,
-        input_tokens=50,
-        output_tokens=50,
-    )
-    response_data = {"model": "test-model", "usage": {"prompt_tokens": 50, "completion_tokens": 50}}
-
-    with patch("routstr.auth.calculate_cost", return_value=cost_data):
-        await adjust_payment_for_tokens(key, response_data, integration_session, cost)
-
-    await integration_session.refresh(key)
-
-    assert key.reserved_balance == 0
-    assert key.balance == 500 - actual
-    assert key.total_spent == actual
-
-
-# ---------------------------------------------------------------------------
-# Test 4 — Concurrent: second parallel reserve blocked when balance exhausted
-# ---------------------------------------------------------------------------
-
-@pytest.mark.asyncio
-async def test_concurrent_second_reserve_blocked_when_balance_exhausted(
-    patched_db_engine: None,
-) -> None:
-    """When two requests race for the same balance, only one succeeds; the other gets 402."""
-    cost = 300
-    key_hash = f"test_concurrent_{uuid.uuid4().hex}"
-
-    async with create_session() as session:
-        key = ApiKey(
-            hashed_key=key_hash,
-            balance=300,       # exactly enough for ONE reservation
-            reserved_balance=0,
-            total_spent=0,
-            total_requests=0,
-        )
-        session.add(key)
-        await session.commit()
-
-    results: list[str] = []
-
-    async def attempt_reserve() -> None:
-        async with create_session() as session:
-            fresh_key = await session.get(ApiKey, key_hash)
-            assert fresh_key is not None
-            try:
-                await pay_for_request(fresh_key, cost, session)
-                results.append("success")
-            except HTTPException as exc:
-                assert exc.status_code == 402
-                results.append("blocked")
-
-    await asyncio.gather(attempt_reserve(), attempt_reserve())
-
-    assert sorted(results) == ["blocked", "success"], (
-        f"Expected exactly one success and one 402, got: {results}"
-    )
-
-    async with create_session() as session:
-        final = await session.get(ApiKey, key_hash)
-        assert final is not None
-
-    # reserved_balance must equal exactly one reservation (not two)
-    assert final.reserved_balance == cost, (
-        f"Expected reserved_balance={cost}, got {final.reserved_balance}"
-    )
-    assert final.balance == 300, "Balance column must not be modified by reservation"
-
-
-# ---------------------------------------------------------------------------
-# Test 5 — Concurrent: three requests, two fit, third blocked
-# ---------------------------------------------------------------------------
-
-@pytest.mark.asyncio
-async def test_three_parallel_reserves_third_blocked(
-    patched_db_engine: None,
-) -> None:
-    """Balance covers two reservations exactly; the third concurrent request must be blocked."""
-    cost = 100
-    key_hash = f"test_three_parallel_{uuid.uuid4().hex}"
-
-    async with create_session() as session:
-        key = ApiKey(
-            hashed_key=key_hash,
-            balance=200,       # fits exactly 2 reservations of 100
-            reserved_balance=0,
-            total_spent=0,
-            total_requests=0,
-        )
-        session.add(key)
-        await session.commit()
-
-    results: list[str] = []
-
-    async def attempt_reserve() -> None:
-        async with create_session() as session:
-            fresh_key = await session.get(ApiKey, key_hash)
-            assert fresh_key is not None
-            try:
-                await pay_for_request(fresh_key, cost, session)
-                results.append("success")
-            except HTTPException as exc:
-                assert exc.status_code == 402
-                results.append("blocked")
-
-    await asyncio.gather(
-        attempt_reserve(),
-        attempt_reserve(),
-        attempt_reserve(),
-    )
-
-    successes = results.count("success")
-    blocked = results.count("blocked")
-
-    assert successes == 2, f"Expected 2 successes, got {successes}: {results}"
-    assert blocked == 1, f"Expected 1 blocked, got {blocked}: {results}"
-
-    async with create_session() as session:
-        final = await session.get(ApiKey, key_hash)
-        assert final is not None
-
-    assert final.reserved_balance == cost * 2, (
-        f"Expected reserved_balance={cost * 2}, got {final.reserved_balance}"
-    )
-    assert final.balance == 200, "Balance column must not be modified by reservation"
-
-
-# ---------------------------------------------------------------------------
-# Test 6 — Sequential exhaustion: reserve until empty, next request blocked
-# ---------------------------------------------------------------------------
-
-@pytest.mark.asyncio
-async def test_sequential_reserves_block_when_balance_exhausted(
-    integration_session: AsyncSession,
-) -> None:
-    """Repeated reservations should block as soon as available balance drops below cost."""
-    cost = 100
-    key = await _persist(integration_session, _make_key(balance=250))
-
-    # First two succeed (100 + 100 = 200 ≤ 250)
-    await pay_for_request(key, cost, integration_session)
-    await pay_for_request(key, cost, integration_session)
-    await integration_session.refresh(key)
-    assert key.reserved_balance == 200
-    assert key.total_balance == 50  # 250 - 200
-
-    # Third: only 50 available, need 100 → blocked
-    with pytest.raises(HTTPException) as exc_info:
-        await pay_for_request(key, cost, integration_session)
-
-    assert exc_info.value.status_code == 402
-    await integration_session.refresh(key)
-    assert key.reserved_balance == 200  # unchanged after failed reserve

tests/unit/test_balance.py

@@ -1,42 +1,27 @@
-import json
-from unittest.mock import AsyncMock, MagicMock, patch
+import hashlib
+from unittest.mock import AsyncMock, MagicMock
 
 import pytest
-from fastapi.responses import JSONResponse
 
 from routstr.balance import refund_wallet_endpoint
-from routstr.core.db import ApiKey, CashuTransaction
+from routstr.core.db import CashuTransaction
 
 
-def _make_cashu_tx(
-    token: str,
-    amount: int,
-    unit: str,
-    type: str = "out",
-    request_id: str | None = "req-abc",
-    swept: bool = False,
-    collected: bool = False,
-) -> CashuTransaction:
-    tx = CashuTransaction(token=token, amount=amount, unit=unit, type=type, request_id=request_id)
+def _make_cashu_tx(token: str, amount: int, unit: str, swept: bool = False) -> CashuTransaction:
+    tx = CashuTransaction(token=token, amount=amount, unit=unit)
     tx.swept = swept
-    tx.collected = collected
+    tx.collected = False
     return tx
 
 
-def _exec_result(tx: CashuTransaction | None) -> MagicMock:
-    result = MagicMock()
-    result.first.return_value = tx
-    return result
-
-
 @pytest.mark.asyncio
 async def test_refund_x_cashu_returns_token() -> None:
     x_cashu_token = "cashuAtest_token_value"
-    in_tx = _make_cashu_tx(token=x_cashu_token, amount=0, unit="msat", type="in", request_id="req-abc")
-    out_tx = _make_cashu_tx(token="cashuArefund_token", amount=1000, unit="msat", type="out", request_id="req-abc")
+    expected_hash = hashlib.sha256(x_cashu_token.strip().encode()).hexdigest()
+    tx = _make_cashu_tx(token="cashuArefund_token", amount=1000, unit="msat")
 
     session = MagicMock()
-    session.exec = AsyncMock(side_effect=[_exec_result(in_tx), _exec_result(out_tx)])
+    session.get = AsyncMock(return_value=tx)
     session.add = MagicMock()
     session.commit = AsyncMock()
 
@@ -46,22 +31,22 @@ async def test_refund_x_cashu_returns_token() -> None:
         session=session,
     )
 
-    assert isinstance(result, JSONResponse)
+    session.get.assert_awaited_once_with(CashuTransaction, expected_hash)
+    import json
     body = json.loads(result.body)
     assert body["token"] == "cashuArefund_token"
     assert body["msats"] == "1000"
     assert result.headers["X-Cashu"] == "cashuArefund_token"
-    assert out_tx.collected is True
+    assert tx.collected is True
 
 
 @pytest.mark.asyncio
 async def test_refund_x_cashu_sat_unit() -> None:
     x_cashu_token = "cashuAsat_token"
-    in_tx = _make_cashu_tx(token=x_cashu_token, amount=0, unit="sat", type="in", request_id="req-sat")
-    out_tx = _make_cashu_tx(token="cashuArefund_sat", amount=500, unit="sat", type="out", request_id="req-sat")
+    tx = _make_cashu_tx(token="cashuArefund_sat", amount=500, unit="sat")
 
     session = MagicMock()
-    session.exec = AsyncMock(side_effect=[_exec_result(in_tx), _exec_result(out_tx)])
+    session.get = AsyncMock(return_value=tx)
     session.add = MagicMock()
     session.commit = AsyncMock()
 
@@ -71,7 +56,7 @@ async def test_refund_x_cashu_sat_unit() -> None:
         session=session,
     )
 
-    assert isinstance(result, JSONResponse)
+    import json
     body = json.loads(result.body)
     assert body["token"] == "cashuArefund_sat"
     assert body["sats"] == "500"
@@ -84,7 +69,7 @@ async def test_refund_x_cashu_not_found_raises_404() -> None:
     from fastapi import HTTPException
 
     session = MagicMock()
-    session.exec = AsyncMock(return_value=_exec_result(None))
+    session.get = AsyncMock(return_value=None)
 
     with pytest.raises(HTTPException) as exc_info:
         await refund_wallet_endpoint(
@@ -100,11 +85,10 @@ async def test_refund_x_cashu_not_found_raises_404() -> None:
 async def test_refund_x_cashu_swept_raises_410() -> None:
     from fastapi import HTTPException
 
-    in_tx = _make_cashu_tx(token="cashuAswept_token", amount=0, unit="msat", type="in", request_id="req-swept")
-    out_tx = _make_cashu_tx(token="cashuAswept", amount=100, unit="msat", type="out", request_id="req-swept", swept=True)
+    tx = _make_cashu_tx(token="cashuAswept", amount=100, unit="msat", swept=True)
 
     session = MagicMock()
-    session.exec = AsyncMock(side_effect=[_exec_result(in_tx), _exec_result(out_tx)])
+    session.get = AsyncMock(return_value=tx)
 
     with pytest.raises(HTTPException) as exc_info:
         await refund_wallet_endpoint(
@@ -114,137 +98,3 @@ async def test_refund_x_cashu_swept_raises_410() -> None:
         )
 
     assert exc_info.value.status_code == 410
-
-
-# ---------------------------------------------------------------------------
-# source field defaults
-# ---------------------------------------------------------------------------
-
-
-def test_cashu_transaction_source_defaults_to_x_cashu() -> None:
-    tx = CashuTransaction(token="cashuAtest", amount=100, unit="msat")
-    assert tx.source == "x-cashu"
-
-
-def test_cashu_transaction_source_can_be_apikey() -> None:
-    tx = CashuTransaction(token="cashuAtest", amount=100, unit="msat", source="apikey")
-    assert tx.source == "apikey"
-
-
-# ---------------------------------------------------------------------------
-# apikey-based refund: token logging and CashuTransaction storage
-# ---------------------------------------------------------------------------
-
-
-def _make_api_key(
-    balance: int = 5000,
-    refund_currency: str | None = "sat",
-    refund_mint_url: str | None = "https://mint.example.com",
-    refund_address: str | None = None,
-    parent_key_hash: str | None = None,
-) -> ApiKey:
-    key = ApiKey(hashed_key="testhash")
-    key.balance = balance
-    key.reserved_balance = 0
-    key.refund_currency = refund_currency
-    key.refund_mint_url = refund_mint_url
-    key.refund_address = refund_address
-    key.parent_key_hash = parent_key_hash
-    key.total_spent = 0
-    key.total_requests = 0
-    return key
-
-
-@pytest.mark.asyncio
-async def test_apikey_refund_stores_cashu_transaction_with_apikey_source() -> None:
-    key = _make_api_key(balance=5000, refund_currency="sat")
-    refund_token = "cashuArefund_apikey_token"
-
-    session = MagicMock()
-    session.add = MagicMock()
-    session.commit = AsyncMock()
-
-    with (
-        patch("routstr.balance.validate_bearer_key", AsyncMock(return_value=key)),
-        patch("routstr.balance.get_billing_key", AsyncMock(return_value=key)),
-        patch("routstr.balance.send_token", AsyncMock(return_value=refund_token)),
-        patch("routstr.balance.store_cashu_transaction", AsyncMock()) as mock_store,
-        patch("routstr.balance._refund_cache_get", AsyncMock(return_value=None)),
-        patch("routstr.balance._refund_cache_set", AsyncMock()),
-    ):
-        result = await refund_wallet_endpoint(
-            authorization="Bearer sk-testhash",
-            x_cashu=None,
-            session=session,
-        )
-
-    assert isinstance(result, dict)
-    assert result["token"] == refund_token
-
-    mock_store.assert_awaited_once()
-    call_kwargs = mock_store.call_args.kwargs
-    assert call_kwargs["source"] == "apikey"
-    assert call_kwargs["token"] == refund_token
-    assert call_kwargs["typ"] == "out"
-
-
-@pytest.mark.asyncio
-async def test_apikey_refund_logs_token() -> None:
-    key = _make_api_key(balance=5000, refund_currency="sat")
-    refund_token = "cashuAlogged_token"
-
-    session = MagicMock()
-    session.add = MagicMock()
-    session.commit = AsyncMock()
-
-    with (
-        patch("routstr.balance.validate_bearer_key", AsyncMock(return_value=key)),
-        patch("routstr.balance.get_billing_key", AsyncMock(return_value=key)),
-        patch("routstr.balance.send_token", AsyncMock(return_value=refund_token)),
-        patch("routstr.balance.store_cashu_transaction", AsyncMock()),
-        patch("routstr.balance._refund_cache_get", AsyncMock(return_value=None)),
-        patch("routstr.balance._refund_cache_set", AsyncMock()),
-        patch("routstr.balance.logger") as mock_logger,
-    ):
-        await refund_wallet_endpoint(
-            authorization="Bearer sk-testhash",
-            x_cashu=None,
-            session=session,
-        )
-
-    calls = [str(c) for c in mock_logger.info.call_args_list]
-    assert any("cashu token issued" in c for c in calls)
-
-
-@pytest.mark.asyncio
-async def test_apikey_refund_log_includes_path() -> None:
-    key = _make_api_key(balance=5000, refund_currency="sat")
-    refund_token = "cashuApath_token"
-
-    session = MagicMock()
-    session.add = MagicMock()
-    session.commit = AsyncMock()
-
-    with (
-        patch("routstr.balance.validate_bearer_key", AsyncMock(return_value=key)),
-        patch("routstr.balance.get_billing_key", AsyncMock(return_value=key)),
-        patch("routstr.balance.send_token", AsyncMock(return_value=refund_token)),
-        patch("routstr.balance.store_cashu_transaction", AsyncMock()),
-        patch("routstr.balance._refund_cache_get", AsyncMock(return_value=None)),
-        patch("routstr.balance._refund_cache_set", AsyncMock()),
-        patch("routstr.balance.logger") as mock_logger,
-    ):
-        await refund_wallet_endpoint(
-            authorization="Bearer sk-testhash",
-            x_cashu=None,
-            session=session,
-        )
-
-    # Find the "cashu token issued" call and verify extra contains the path
-    token_issued_calls = [
-        c for c in mock_logger.info.call_args_list
-        if c.args and "cashu token issued" in c.args[0]
-    ]
-    assert len(token_issued_calls) == 1
-    extra = token_issued_calls[0].kwargs.get("extra", {})
-    assert extra.get("path") == "/v1/wallet/refund"

tests/unit/test_wallet.py

@@ -220,33 +220,6 @@ async def test_recieve_token_untrusted_mint() -> None:
 
 
 @pytest.mark.asyncio
-@pytest.mark.asyncio
-async def test_swap_to_primary_mint_already_on_primary() -> None:
-    from routstr.core.settings import settings
-    from routstr.wallet import swap_to_primary_mint
-
-    mock_token = Mock()
-    mock_token.mint = settings.primary_mint
-    mock_token.amount = 1000
-    mock_token.unit = "sat"
-    mock_token.proofs = []
-
-    mock_token_wallet = Mock()
-    mock_token_wallet.split = AsyncMock(return_value=None)
-    mock_token_wallet.request_mint = AsyncMock()
-    mock_token_wallet.melt_quote = AsyncMock()
-
-    with patch("routstr.wallet.get_wallet", AsyncMock(return_value=mock_token_wallet)):
-        amount, unit, mint = await swap_to_primary_mint(mock_token, mock_token_wallet)
-
-    assert amount == 1000
-    assert unit == "sat"
-    assert mint == settings.primary_mint
-    mock_token_wallet.split.assert_called_once()
-    mock_token_wallet.request_mint.assert_not_called()
-    mock_token_wallet.melt_quote.assert_not_called()
-
-
 async def test_swap_to_primary_mint_success() -> None:
     """Test successful swap with dynamic fee calculation."""
     from routstr.wallet import swap_to_primary_mint

tests/unit/test_x_cashu_cost_sats.py

@@ -1,216 +0,0 @@
-import json
-import os
-from unittest.mock import AsyncMock, patch
-
-import httpx
-import pytest
-
-os.environ.setdefault("UPSTREAM_BASE_URL", "http://test")
-os.environ.setdefault("UPSTREAM_API_KEY", "test")
-
-from routstr.payment.cost_calculation import CostData  # noqa: E402
-from routstr.upstream.base import BaseUpstreamProvider  # noqa: E402
-
-
-def _make_provider() -> BaseUpstreamProvider:
-    return BaseUpstreamProvider(base_url="http://test", api_key="test-key")
-
-
-def _make_httpx_response(status_code: int = 200) -> httpx.Response:
-    return httpx.Response(status_code, headers={})
-
-
-def _make_cost_data(total_msats: int = 5000) -> CostData:
-    return CostData(
-        base_msats=0,
-        input_msats=3000,
-        output_msats=2000,
-        total_msats=total_msats,
-        total_usd=0.00025,
-        input_tokens=100,
-        output_tokens=50,
-    )
-
-
-# ---------------------------------------------------------------------------
-# Non-streaming (chat completions)
-# ---------------------------------------------------------------------------
-
-@pytest.mark.asyncio
-async def test_non_streaming_includes_cost_sats() -> None:
-    provider = _make_provider()
-    cost_data = _make_cost_data(total_msats=5000)
-
-    response_body = {
-        "model": "gpt-4o",
-        "usage": {
-            "prompt_tokens": 100,
-            "completion_tokens": 50,
-            "total_tokens": 150,
-            "cost": 0.00025,
-        },
-    }
-    content_str = json.dumps(response_body)
-    httpx_response = _make_httpx_response()
-
-    with (
-        patch.object(provider, "get_x_cashu_cost", new=AsyncMock(return_value=cost_data)),
-        patch.object(provider, "send_refund", new=AsyncMock(return_value="cashuA_refund_token")),
-    ):
-        response = await provider.handle_x_cashu_non_streaming_response(
-            content_str=content_str,
-            response=httpx_response,
-            amount=10000,
-            unit="msat",
-            max_cost_for_model=10000,
-            mint=None,
-            payment_token_hash=None,
-        )
-
-    body = json.loads(response.body)
-    assert "cost_sats" in body["usage"]
-    assert body["usage"]["cost_sats"] == 5  # 5000 msats // 1000
-
-
-@pytest.mark.asyncio
-async def test_non_streaming_cost_sats_value_rounds_down() -> None:
-    provider = _make_provider()
-    cost_data = _make_cost_data(total_msats=1999)
-
-    response_body = {"model": "gpt-4o", "usage": {"prompt_tokens": 10}}
-    content_str = json.dumps(response_body)
-
-    with (
-        patch.object(provider, "get_x_cashu_cost", new=AsyncMock(return_value=cost_data)),
-        patch.object(provider, "send_refund", new=AsyncMock(return_value="cashuA_refund_token")),
-    ):
-        response = await provider.handle_x_cashu_non_streaming_response(
-            content_str=content_str,
-            response=_make_httpx_response(),
-            amount=10000,
-            unit="msat",
-            max_cost_for_model=10000,
-        )
-
-    body = json.loads(response.body)
-    assert body["usage"]["cost_sats"] == 1  # 1999 // 1000
-
-
-@pytest.mark.asyncio
-async def test_non_streaming_preserves_existing_usage_fields() -> None:
-    provider = _make_provider()
-    cost_data = _make_cost_data(total_msats=3000)
-
-    response_body = {
-        "model": "gpt-4o",
-        "usage": {
-            "prompt_tokens": 100,
-            "completion_tokens": 50,
-            "total_tokens": 150,
-            "cost": 0.00015,
-        },
-    }
-
-    with (
-        patch.object(provider, "get_x_cashu_cost", new=AsyncMock(return_value=cost_data)),
-        patch.object(provider, "send_refund", new=AsyncMock(return_value="cashuA_refund_token")),
-    ):
-        response = await provider.handle_x_cashu_non_streaming_response(
-            content_str=json.dumps(response_body),
-            response=_make_httpx_response(),
-            amount=10000,
-            unit="msat",
-            max_cost_for_model=10000,
-        )
-
-    body = json.loads(response.body)
-    usage = body["usage"]
-    assert usage["prompt_tokens"] == 100
-    assert usage["completion_tokens"] == 50
-    assert usage["total_tokens"] == 150
-    assert usage["cost"] == 0.00015
-    assert usage["cost_sats"] == 3
-
-
-# ---------------------------------------------------------------------------
-# Streaming (chat completions)
-# ---------------------------------------------------------------------------
-
-async def _collect_streaming(response: object) -> list[str]:
-    chunks: list[str] = []
-    async for chunk in response.body_iterator:  # type: ignore[attr-defined]
-        if isinstance(chunk, bytes):
-            chunks.append(chunk.decode("utf-8"))
-        else:
-            chunks.append(str(chunk))
-    return chunks
-
-
-@pytest.mark.asyncio
-async def test_streaming_includes_cost_sats_in_usage_chunk() -> None:
-    provider = _make_provider()
-    cost_data = _make_cost_data(total_msats=7000)
-
-    usage_chunk = {
-        "id": "chatcmpl-123",
-        "model": "gpt-4o",
-        "usage": {"prompt_tokens": 100, "completion_tokens": 50, "total_tokens": 150},
-    }
-    content_str = "\n".join([
-        'data: {"id":"chatcmpl-123","model":"gpt-4o","choices":[]}',
-        f"data: {json.dumps(usage_chunk)}",
-        "data: [DONE]",
-    ])
-
-    with patch.object(provider, "get_x_cashu_cost", new=AsyncMock(return_value=cost_data)):
-        response = await provider.handle_x_cashu_streaming_response(
-            content_str=content_str,
-            response=_make_httpx_response(),
-            amount=10000,
-            unit="msat",
-            max_cost_for_model=10000,
-            mint=None,
-            payment_token_hash=None,
-        )
-
-    chunks = await _collect_streaming(response)
-
-    full_output = "".join(chunks)
-    usage_line = next(
-        line for line in full_output.split("\n") if '"usage"' in line and "cost_sats" in line
-    )
-    data_json = json.loads(usage_line.lstrip("data: ").strip())
-    assert data_json["usage"]["cost_sats"] == 7  # 7000 // 1000
-
-
-@pytest.mark.asyncio
-async def test_streaming_non_usage_chunks_unmodified() -> None:
-    provider = _make_provider()
-    cost_data = _make_cost_data(total_msats=2000)
-
-    regular_chunk = {"id": "chatcmpl-123", "model": "gpt-4o", "choices": [{"delta": {"content": "hi"}}]}
-    usage_chunk = {"id": "chatcmpl-123", "model": "gpt-4o", "usage": {"prompt_tokens": 10}}
-    content_str = "\n".join([
-        f"data: {json.dumps(regular_chunk)}",
-        f"data: {json.dumps(usage_chunk)}",
-        "data: [DONE]",
-    ])
-
-    with patch.object(provider, "get_x_cashu_cost", new=AsyncMock(return_value=cost_data)):
-        response = await provider.handle_x_cashu_streaming_response(
-            content_str=content_str,
-            response=_make_httpx_response(),
-            amount=10000,
-            unit="msat",
-            max_cost_for_model=10000,
-        )
-
-    chunks = await _collect_streaming(response)
-
-    lines = [
-        line for line in "".join(chunks).split("\n")
-        if line.startswith("data: ") and line != "data: [DONE]"
-    ]
-    regular_line_data = json.loads(lines[0][6:])
-    # regular chunk should not have cost_sats injected
-    assert "cost_sats" not in regular_line_data.get("usage", {})

ui/app/transactions/page.tsx

@@ -22,7 +22,6 @@ import {
   SelectValue,
 } from '@/components/ui/select';
 import { Badge } from '@/components/ui/badge';
-import { Tabs, TabsContent, TabsList, TabsTrigger } from '@/components/ui/tabs';
 import {
   Table,
   TableBody,
@@ -48,8 +47,6 @@ import {
   Copy,
   Check,
   Receipt,
-  Key,
-  Zap,
 } from 'lucide-react';
 import { AdminService, type Transaction } from '@/lib/api/services/admin';
 import { format } from 'date-fns';
@@ -57,118 +54,6 @@ import { toast } from 'sonner';
 
 const STORAGE_KEY = 'routstr-transaction-filters';
 
-function TransactionTable({
-  transactions,
-  copiedId,
-  onCopy,
-  getStatusBadge,
-}: {
-  transactions: Transaction[];
-  copiedId: string | null;
-  onCopy: (text: string, id: string) => void;
-  getStatusBadge: (tx: Transaction) => React.ReactNode;
-}) {
-  if (transactions.length === 0) {
-    return (
-      <Empty className='py-8'>
-        <EmptyHeader>
-          <EmptyMedia variant='icon'>
-            <Receipt className='h-4 w-4' />
-          </EmptyMedia>
-          <EmptyTitle>No transactions found</EmptyTitle>
-          <EmptyDescription>
-            Try adjusting your filters or check back later.
-          </EmptyDescription>
-        </EmptyHeader>
-      </Empty>
-    );
-  }
-
-  return (
-    <ScrollArea className='h-[55svh] min-h-[420px] w-full sm:h-[600px]'>
-      <Table>
-        <TableHeader>
-          <TableRow>
-            <TableHead>Type</TableHead>
-            <TableHead>Amount</TableHead>
-            <TableHead>Status</TableHead>
-            <TableHead>Request ID</TableHead>
-            <TableHead>Mint</TableHead>
-            <TableHead>Date</TableHead>
-            <TableHead className='text-right'>Actions</TableHead>
-          </TableRow>
-        </TableHeader>
-        <TableBody>
-          {transactions.map((tx) => (
-            <TableRow key={tx.id}>
-              <TableCell>
-                <div className='flex items-center gap-2'>
-                  {tx.type === 'in' ? (
-                    <ArrowDownLeft className='h-4 w-4 text-green-500' />
-                  ) : (
-                    <ArrowUpRight className='h-4 w-4 text-blue-500' />
-                  )}
-                  <span className='capitalize'>{tx.type}</span>
-                </div>
-              </TableCell>
-              <TableCell className='font-mono'>
-                {tx.amount} {tx.unit}
-              </TableCell>
-              <TableCell>{getStatusBadge(tx)}</TableCell>
-              <TableCell>
-                {tx.request_id ? (
-                  <div className='flex items-center gap-1 text-xs'>
-                    <span className='max-w-[150px] truncate font-mono'>
-                      {tx.request_id}
-                    </span>
-                    <Button
-                      variant='ghost'
-                      size='icon'
-                      className='h-4 w-4'
-                      onClick={() => onCopy(tx.request_id!, tx.id + '-req')}
-                    >
-                      {copiedId === tx.id + '-req' ? (
-                        <Check className='h-3 w-3' />
-                      ) : (
-                        <Copy className='h-3 w-3' />
-                      )}
-                    </Button>
-                  </div>
-                ) : (
-                  <span className='text-muted-foreground text-xs'>—</span>
-                )}
-              </TableCell>
-              <TableCell>
-                <div className='flex max-w-[150px] items-center gap-1 truncate text-xs'>
-                  <span className='truncate'>{tx.mint_url}</span>
-                </div>
-              </TableCell>
-              <TableCell className='text-xs whitespace-nowrap'>
-                {format(tx.created_at * 1000, 'yyyy-MM-dd HH:mm:ss')}
-              </TableCell>
-              <TableCell className='text-right'>
-                <Button
-                  variant='ghost'
-                  size='icon'
-                  className='h-8 w-8'
-                  onClick={() => onCopy(tx.token, tx.id + '-token')}
-                  title='Copy Token'
-                >
-                  {copiedId === tx.id + '-token' ? (
-                    <Check className='h-4 w-4' />
-                  ) : (
-                    <Copy className='h-4 w-4' />
-                  )}
-                </Button>
-              </TableCell>
-            </TableRow>
-          ))}
-        </TableBody>
-      </Table>
-    </ScrollArea>
-  );
-}
-
 export default function TransactionsPage() {
   const [search, setSearch] = useState('');
   const [type, setType] = useState<string>('all');
@@ -260,41 +145,12 @@ export default function TransactionsPage() {
     .filter(Boolean)
     .join(' • ');
 
-  const xcashuTxs =
-    data?.transactions.filter((tx) => !tx.source || tx.source === 'x-cashu') ??
-    [];
-  const apikeyTxs =
-    data?.transactions.filter((tx) => tx.source === 'apikey') ?? [];
-
-  const renderCardContent = (txs: Transaction[]) => {
-    if (isLoading) {
-      return (
-        <div className='space-y-2'>
-          {Array.from({ length: 8 }).map((_, index) => (
-            <Skeleton
-              key={`tx-loading-${index}`}
-              className='h-16 w-full rounded-lg'
-            />
-          ))}
-        </div>
-      );
-    }
-    return (
-      <TransactionTable
-        transactions={txs}
-        copiedId={copiedId}
-        onCopy={copyToClipboard}
-        getStatusBadge={getStatusBadge}
-      />
-    );
-  };
-
   return (
     <AppPageShell contentClassName='mx-auto w-full max-w-5xl overflow-x-hidden'>
       <div className='space-y-6'>
         <PageHeader
-          title='Cashu Transactions'
-          description='View all incoming and outgoing Cashu token transactions.'
+          title='X-Cashu Transactions'
+          description='View all incoming and outgoing X-Cashu token transactions.'
           actions={
             <Button
               onClick={() => refetch()}
@@ -372,64 +228,138 @@ export default function TransactionsPage() {
           </CardContent>
         </Card>
 
-        <Tabs defaultValue='x-cashu'>
-          <TabsList className='mb-4'>
-            <TabsTrigger value='x-cashu' className='flex items-center gap-2'>
-              <Zap className='h-4 w-4' />
-              X-Cashu
+        <Card>
+          <CardHeader>
+            <div className='flex flex-col items-start gap-2 sm:flex-row sm:items-center sm:justify-between'>
+              <CardTitle>Transaction History</CardTitle>
               {data && (
-                <Badge variant='secondary' className='ml-1'>
-                  {xcashuTxs.length}
+                <Badge variant='secondary'>
+                  {data.transactions.length} entries
                 </Badge>
               )}
-            </TabsTrigger>
-            <TabsTrigger value='apikey' className='flex items-center gap-2'>
-              <Key className='h-4 w-4' />
-              API Key Refunds
-              {data && (
-                <Badge variant='secondary' className='ml-1'>
-                  {apikeyTxs.length}
-                </Badge>
-              )}
-            </TabsTrigger>
-          </TabsList>
-
-          <TabsContent value='x-cashu'>
-            <Card>
-              <CardHeader>
-                <div className='flex flex-col items-start gap-2 sm:flex-row sm:items-center sm:justify-between'>
-                  <CardTitle>X-Cashu Transaction History</CardTitle>
-                  {hasActiveFilters && (
-                    <CardDescription>
-                      Filtered by {activeFilterDescription}
-                    </CardDescription>
-                  )}
-                </div>
-              </CardHeader>
-              <CardContent className='overflow-hidden'>
-                {renderCardContent(xcashuTxs)}
-              </CardContent>
-            </Card>
-          </TabsContent>
-
-          <TabsContent value='apikey'>
-            <Card>
-              <CardHeader>
-                <div className='flex flex-col items-start gap-2 sm:flex-row sm:items-center sm:justify-between'>
-                  <CardTitle>API Key Refund History</CardTitle>
-                  {hasActiveFilters && (
-                    <CardDescription>
-                      Filtered by {activeFilterDescription}
-                    </CardDescription>
-                  )}
-                </div>
-              </CardHeader>
-              <CardContent className='overflow-hidden'>
-                {renderCardContent(apikeyTxs)}
-              </CardContent>
-            </Card>
-          </TabsContent>
-        </Tabs>
+            </div>
+            {hasActiveFilters && (
+              <CardDescription>
+                Showing transactions filtered by {activeFilterDescription}
+              </CardDescription>
+            )}
+          </CardHeader>
+          <CardContent className='overflow-hidden'>
+            {isLoading ? (
+              <div className='space-y-2'>
+                {Array.from({ length: 8 }).map((_, index) => (
+                  <Skeleton
+                    key={`tx-loading-${index}`}
+                    className='h-16 w-full rounded-lg'
+                  />
+                ))}
+              </div>
+            ) : data?.transactions && data.transactions.length > 0 ? (
+              <ScrollArea className='h-[55svh] min-h-[420px] w-full sm:h-[600px]'>
+                <Table>
+                  <TableHeader>
+                    <TableRow>
+                      <TableHead>Type</TableHead>
+                      <TableHead>Amount</TableHead>
+                      <TableHead>Status</TableHead>
+                      <TableHead>Request ID</TableHead>
+                      <TableHead>Mint</TableHead>
+                      <TableHead>Date</TableHead>
+                      <TableHead className='text-right'>Actions</TableHead>
+                    </TableRow>
+                  </TableHeader>
+                  <TableBody>
+                    {data.transactions.map((tx) => (
+                      <TableRow key={tx.id}>
+                        <TableCell>
+                          <div className='flex items-center gap-2'>
+                            {tx.type === 'in' ? (
+                              <ArrowDownLeft className='h-4 w-4 text-green-500' />
+                            ) : (
+                              <ArrowUpRight className='h-4 w-4 text-blue-500' />
+                            )}
+                            <span className='capitalize'>{tx.type}</span>
+                          </div>
+                        </TableCell>
+                        <TableCell className='font-mono'>
+                          {tx.amount} {tx.unit}
+                        </TableCell>
+                        <TableCell>{getStatusBadge(tx)}</TableCell>
+                        <TableCell>
+                          {tx.request_id ? (
+                            <div className='flex items-center gap-1 text-xs'>
+                              <span className='max-w-[150px] truncate font-mono'>
+                                {tx.request_id}
+                              </span>
+                              <Button
+                                variant='ghost'
+                                size='icon'
+                                className='h-4 w-4'
+                                onClick={() =>
+                                  copyToClipboard(
+                                    tx.request_id!,
+                                    tx.id + '-req'
+                                  )
+                                }
+                              >
+                                {copiedId === tx.id + '-req' ? (
+                                  <Check className='h-3 w-3' />
+                                ) : (
+                                  <Copy className='h-3 w-3' />
+                                )}
+                              </Button>
+                            </div>
+                          ) : (
+                            <span className='text-muted-foreground text-xs'>
+                              —
+                            </span>
+                          )}
+                        </TableCell>
+                        <TableCell>
+                          <div className='flex max-w-[150px] items-center gap-1 truncate text-xs'>
+                            <span className='truncate'>{tx.mint_url}</span>
+                          </div>
+                        </TableCell>
+                        <TableCell className='text-xs whitespace-nowrap'>
+                          {format(tx.created_at * 1000, 'yyyy-MM-dd HH:mm:ss')}
+                        </TableCell>
+                        <TableCell className='text-right'>
+                          <Button
+                            variant='ghost'
+                            size='icon'
+                            className='h-8 w-8'
+                            onClick={() =>
+                              copyToClipboard(tx.token, tx.id + '-token')
+                            }
+                            title='Copy Token'
+                          >
+                            {copiedId === tx.id + '-token' ? (
+                              <Check className='h-4 w-4' />
+                            ) : (
+                              <Copy className='h-4 w-4' />
+                            )}
+                          </Button>
+                        </TableCell>
+                      </TableRow>
+                    ))}
+                  </TableBody>
+                </Table>
+              </ScrollArea>
+            ) : (
+              <Empty className='py-8'>
+                <EmptyHeader>
+                  <EmptyMedia variant='icon'>
+                    <Receipt className='h-4 w-4' />
+                  </EmptyMedia>
+                  <EmptyTitle>No transactions found</EmptyTitle>
+                  <EmptyDescription>
+                    Try adjusting your filters or check back later.
+                  </EmptyDescription>
+                </EmptyHeader>
+              </Empty>
+            )}
+          </CardContent>
+        </Card>
       </div>
     </AppPageShell>
   );

ui/components/add-provider-model-dialog.tsx

@@ -1,6 +1,6 @@
 'use client';
 
-import React, { useCallback, useEffect, useMemo, useState } from 'react';
+import React, { useEffect, useMemo, useState } from 'react';
 import { useForm } from 'react-hook-form';
 import { z } from 'zod';
 import { zodResolver } from '@hookform/resolvers/zod';
@@ -39,7 +39,7 @@ import {
   FormMessage,
 } from '@/components/ui/form';
 import { Switch } from '@/components/ui/switch';
-import { Check, Copy, Loader2, Plus } from 'lucide-react';
+import { Loader2, Plus } from 'lucide-react';
 import { toast } from 'sonner';
 import { AdminService, type AdminModel } from '@/lib/api/services/admin';
 
@@ -64,7 +64,6 @@ const FormSchema = z.object({
   instruct_type: z.string().default(''),
   canonical_slug: z.string().default(''),
   alias_ids_raw: z.string().default(''),
-  forwarded_model_id: z.string().default(''),
   upstream_provider_id: z.string().default(''),
   input_cost: z.coerce.number().min(0).default(0),
   output_cost: z.coerce.number().min(0).default(0),
@@ -105,7 +104,6 @@ export function AddProviderModelDialog({
   const [isPresetOpen, setIsPresetOpen] = useState(false);
   const [selectedPresetLabel, setSelectedPresetLabel] =
     useState('Select a preset');
-  const [forwardedModelIdCopied, setForwardedModelIdCopied] = useState(false);
 
   const form = useForm<FormData>({
     resolver: zodResolver(FormSchema) as never,
@@ -121,7 +119,6 @@ export function AddProviderModelDialog({
       instruct_type: '',
       canonical_slug: '',
       alias_ids_raw: '',
-      forwarded_model_id: '',
       upstream_provider_id: '',
       input_cost: 0,
       output_cost: 0,
@@ -183,7 +180,6 @@ export function AddProviderModelDialog({
             : '',
         canonical_slug: initialData.canonical_slug || '',
         alias_ids_raw: listToString(initialData.alias_ids),
-        forwarded_model_id: initialData.forwarded_model_id || initialData.id,
         upstream_provider_id:
           typeof initialData.upstream_provider_id === 'string'
             ? initialData.upstream_provider_id
@@ -227,7 +223,6 @@ export function AddProviderModelDialog({
         instruct_type: '',
         canonical_slug: '',
         alias_ids_raw: '',
-        forwarded_model_id: '',
         upstream_provider_id: '',
         input_cost: 0,
         output_cost: 0,
@@ -285,7 +280,6 @@ export function AddProviderModelDialog({
     );
     form.setValue('canonical_slug', model.canonical_slug || '');
     form.setValue('alias_ids_raw', listToString(model.alias_ids));
-    form.setValue('forwarded_model_id', model.forwarded_model_id || model.id);
     form.setValue(
       'upstream_provider_id',
       typeof model.upstream_provider_id === 'string'
@@ -391,7 +385,6 @@ export function AddProviderModelDialog({
         canonical_slug: data.canonical_slug?.trim() || null,
         alias_ids: listFromString(data.alias_ids_raw || ''),
         enabled: data.enabled,
-        forwarded_model_id: data.forwarded_model_id?.trim() || data.id,
       };
 
       if (isEdit) {
@@ -527,53 +520,6 @@ export function AddProviderModelDialog({
                 )}
               />
 
-              <FormField
-                control={form.control}
-                name='forwarded_model_id'
-                render={({ field }) => {
-                  const handleCopy = () => {
-                    const value = field.value || form.getValues('id');
-                    if (!value) return;
-                    navigator.clipboard.writeText(value);
-                    setForwardedModelIdCopied(true);
-                    setTimeout(() => setForwardedModelIdCopied(false), 1500);
-                  };
-                  return (
-                    <FormItem>
-                      <FormLabel>Upstream Model ID</FormLabel>
-                      <FormControl>
-                        <div className='flex gap-2'>
-                          <Input
-                            placeholder={
-                              form.watch('id') || 'e.g., openai/gpt-4o'
-                            }
-                            {...field}
-                          />
-                          <Button
-                            type='button'
-                            variant='outline'
-                            size='icon'
-                            onClick={handleCopy}
-                            title='Copy model ID'
-                          >
-                            {forwardedModelIdCopied ? (
-                              <Check className='h-4 w-4 text-green-500' />
-                            ) : (
-                              <Copy className='h-4 w-4' />
-                            )}
-                          </Button>
-                        </div>
-                      </FormControl>
-                      <FormDescription>
-                        Model ID sent to the upstream provider. Defaults to the
-                        model&apos;s own ID.
-                      </FormDescription>
-                      <FormMessage />
-                    </FormItem>
-                  );
-                }}
-              />
-
               <FormField
                 control={form.control}
                 name='name'

ui/components/edit-model-form.tsx

@@ -0,0 +1,577 @@
+'use client';
+
+import React, { useState, useEffect, useCallback } from 'react';
+import { useForm } from 'react-hook-form';
+import { zodResolver } from '@hookform/resolvers/zod';
+import { z } from 'zod';
+import { type Model } from '@/lib/api/schemas/models';
+import { AdminService, type AdminModel } from '@/lib/api/services/admin';
+import { Button } from '@/components/ui/button';
+import { Input } from '@/components/ui/input';
+import { Textarea } from '@/components/ui/textarea';
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogHeader,
+  DialogTitle,
+} from '@/components/ui/dialog';
+import {
+  Form,
+  FormControl,
+  FormDescription,
+  FormField,
+  FormItem,
+  FormLabel,
+  FormMessage,
+} from '@/components/ui/form';
+import { Edit3, Loader2 } from 'lucide-react';
+import { toast } from 'sonner';
+import { Switch } from '@/components/ui/switch';
+
+const EditModelFormSchema = z.object({
+  name: z.string().min(1, 'Name is required'),
+  description: z.string().optional(),
+  context_length: z.number().min(0),
+  prompt: z.number().min(0),
+  completion: z.number().min(0),
+  enabled: z.boolean(),
+});
+
+type EditModelFormData = z.infer<typeof EditModelFormSchema>;
+
+const roundToFiveDecimals = (value: number | undefined | null): number => {
+  if (value === undefined || value === null || isNaN(value)) {
+    return 0;
+  }
+  return Math.round(value * 100000) / 100000;
+};
+
+const toNumber = (value: unknown, fallback = 0): number => {
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === 'string') {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed)) {
+      return parsed;
+    }
+  }
+  return fallback;
+};
+
+const toStringArray = (value: unknown, fallback: string[]): string[] => {
+  if (!Array.isArray(value)) {
+    return fallback;
+  }
+  const filtered = value.filter(
+    (item): item is string => typeof item === 'string'
+  );
+  return filtered.length > 0 ? filtered : fallback;
+};
+
+interface EditModelFormProps {
+  model: Model;
+  providerId?: number;
+  onModelUpdate?: () => void;
+  onCancel?: () => void;
+  isOpen: boolean;
+}
+
+interface AdminModelData {
+  id: string;
+  name: string;
+  description?: string;
+  created: number;
+  context_length: number;
+  architecture: {
+    modality: string;
+    input_modalities: string[];
+    output_modalities: string[];
+    tokenizer: string;
+    instruct_type: string | null;
+  };
+  pricing: {
+    prompt: number;
+    completion: number;
+    request: number;
+    image: number;
+    web_search: number;
+    internal_reasoning: number;
+  };
+  per_request_limits: null | undefined;
+  top_provider: null | undefined;
+  upstream_provider_id: number;
+  enabled: boolean;
+}
+
+const normalizeAdminModelData = (
+  adminModel: AdminModel,
+  fallbackModel: Model,
+  providerId: number
+): AdminModelData => {
+  const pricingRecord =
+    adminModel.pricing && typeof adminModel.pricing === 'object'
+      ? (adminModel.pricing as Record<string, unknown>)
+      : {};
+
+  const architectureRecord =
+    adminModel.architecture && typeof adminModel.architecture === 'object'
+      ? (adminModel.architecture as Record<string, unknown>)
+      : {};
+
+  return {
+    id: adminModel.id,
+    name: adminModel.name,
+    description: adminModel.description || '',
+    created: toNumber(adminModel.created, Math.floor(Date.now() / 1000)),
+    context_length: Math.max(
+      0,
+      Math.trunc(
+        toNumber(adminModel.context_length, fallbackModel.contextLength || 4096)
+      )
+    ),
+    architecture: {
+      modality:
+        typeof architectureRecord.modality === 'string'
+          ? architectureRecord.modality
+          : fallbackModel.modelType || 'text',
+      input_modalities: toStringArray(architectureRecord.input_modalities, [
+        fallbackModel.modelType || 'text',
+      ]),
+      output_modalities: toStringArray(architectureRecord.output_modalities, [
+        fallbackModel.modelType || 'text',
+      ]),
+      tokenizer:
+        typeof architectureRecord.tokenizer === 'string'
+          ? architectureRecord.tokenizer
+          : '',
+      instruct_type:
+        typeof architectureRecord.instruct_type === 'string'
+          ? architectureRecord.instruct_type
+          : null,
+    },
+    pricing: {
+      prompt: roundToFiveDecimals(
+        toNumber(pricingRecord.prompt, fallbackModel.input_cost)
+      ),
+      completion: roundToFiveDecimals(
+        toNumber(pricingRecord.completion, fallbackModel.output_cost)
+      ),
+      request: toNumber(pricingRecord.request, 0),
+      image: toNumber(pricingRecord.image, 0),
+      web_search: toNumber(pricingRecord.web_search, 0),
+      internal_reasoning: toNumber(pricingRecord.internal_reasoning, 0),
+    },
+    per_request_limits:
+      adminModel.per_request_limits === null ||
+      adminModel.per_request_limits === undefined
+        ? adminModel.per_request_limits
+        : null,
+    top_provider:
+      adminModel.top_provider === null || adminModel.top_provider === undefined
+        ? adminModel.top_provider
+        : null,
+    upstream_provider_id:
+      typeof adminModel.upstream_provider_id === 'number'
+        ? adminModel.upstream_provider_id
+        : providerId,
+    enabled: adminModel.enabled !== false,
+  };
+};
+
+export function EditModelForm({
+  model,
+  providerId,
+  onModelUpdate,
+  onCancel,
+  isOpen,
+}: EditModelFormProps) {
+  const [isSubmitting, setIsSubmitting] = useState(false);
+  const [adminModelData, setAdminModelData] = useState<AdminModelData | null>(
+    null
+  );
+  const [isNewOverride, setIsNewOverride] = useState(false);
+
+  const form = useForm<EditModelFormData>({
+    resolver: zodResolver(EditModelFormSchema),
+    defaultValues: {
+      name: model.name,
+      description: model.description || '',
+      context_length: model.contextLength || 4096,
+      prompt: roundToFiveDecimals(model.input_cost),
+      completion: roundToFiveDecimals(model.output_cost),
+      enabled: model.isEnabled !== false,
+    },
+  });
+
+  const loadAdminModel = useCallback(async () => {
+    if (!providerId) {
+      console.error('loadAdminModel called without providerId');
+      return;
+    }
+
+    try {
+      const adminModel = await AdminService.getProviderModel(
+        providerId,
+        model.id
+      );
+
+      const normalizedAdminModel = normalizeAdminModelData(
+        adminModel,
+        model,
+        providerId
+      );
+      setAdminModelData(normalizedAdminModel);
+      setIsNewOverride(false);
+
+      form.reset({
+        name: normalizedAdminModel.name,
+        description: normalizedAdminModel.description || '',
+        context_length: normalizedAdminModel.context_length,
+        prompt: normalizedAdminModel.pricing.prompt,
+        completion: normalizedAdminModel.pricing.completion,
+        enabled: normalizedAdminModel.enabled !== false,
+      });
+    } catch {
+      setIsNewOverride(true);
+      setAdminModelData({
+        id: model.full_name,
+        name: model.name,
+        description: model.description || '',
+        created: Math.floor(Date.now() / 1000),
+        context_length: model.contextLength || 4096,
+        architecture: {
+          modality: model.modelType || 'text',
+          input_modalities: [model.modelType || 'text'],
+          output_modalities: [model.modelType || 'text'],
+          tokenizer: '',
+          instruct_type: null,
+        },
+        pricing: {
+          prompt: roundToFiveDecimals(model.input_cost),
+          completion: roundToFiveDecimals(model.output_cost),
+          request: 0,
+          image: 0,
+          web_search: 0,
+          internal_reasoning: 0,
+        },
+        per_request_limits: null,
+        top_provider: null,
+        upstream_provider_id: providerId,
+        enabled: model.isEnabled !== false,
+      });
+
+      form.reset({
+        name: model.name,
+        description: model.description || '',
+        context_length: model.contextLength || 4096,
+        prompt: roundToFiveDecimals(model.input_cost),
+        completion: roundToFiveDecimals(model.output_cost),
+        enabled: model.isEnabled !== false,
+      });
+    }
+  }, [providerId, model, form]);
+
+  useEffect(() => {
+    if (isOpen && providerId) {
+      loadAdminModel();
+    } else if (isOpen && !providerId) {
+      console.error('EditModelForm opened without providerId', {
+        model,
+        providerId,
+      });
+      toast.error('Missing provider information for this model');
+    }
+  }, [isOpen, providerId, model, loadAdminModel]);
+
+  const onSubmit = async (data: EditModelFormData) => {
+    if (!providerId) {
+      console.error('onSubmit called without providerId', {
+        model,
+        providerId,
+      });
+      toast.error('Missing provider ID - cannot update model');
+      return;
+    }
+
+    if (!adminModelData) {
+      console.error('onSubmit called without adminModelData', {
+        model,
+        providerId,
+        adminModelData,
+      });
+      toast.error('Model data not loaded - please try reopening the form');
+      return;
+    }
+
+    setIsSubmitting(true);
+    try {
+      const payload = {
+        id: adminModelData.id,
+        name: data.name,
+        description: data.description || '',
+        created: adminModelData.created || Math.floor(Date.now() / 1000),
+        context_length: data.context_length,
+        architecture: adminModelData.architecture || {
+          modality: 'text',
+          input_modalities: ['text'],
+          output_modalities: ['text'],
+          tokenizer: '',
+          instruct_type: null,
+        },
+        pricing: {
+          prompt: roundToFiveDecimals(data.prompt),
+          completion: roundToFiveDecimals(data.completion),
+          request: 0,
+          image: 0,
+          web_search: 0,
+          internal_reasoning: 0,
+        },
+        per_request_limits: adminModelData.per_request_limits,
+        top_provider: adminModelData.top_provider,
+        upstream_provider_id: providerId,
+        enabled: data.enabled,
+      };
+
+      if (isNewOverride) {
+        await AdminService.createProviderModel(providerId, payload);
+        toast.success('Model override created successfully!');
+      } else {
+        await AdminService.updateProviderModel(
+          providerId,
+          adminModelData.id,
+          payload
+        );
+        toast.success('Model updated successfully!');
+      }
+
+      onModelUpdate?.();
+      onCancel?.();
+    } catch (error) {
+      const action = isNewOverride ? 'create' : 'update';
+      toast.error(`Failed to ${action} model. Please try again.`);
+      console.error(`Error ${action}ing model:`, error);
+    } finally {
+      setIsSubmitting(false);
+    }
+  };
+
+  const handleClose = () => {
+    if (!isSubmitting) {
+      onCancel?.();
+    }
+  };
+
+  return (
+    <Dialog open={isOpen} onOpenChange={handleClose}>
+      <DialogContent className='max-h-[90vh] overflow-y-auto sm:max-w-[600px]'>
+        <DialogHeader>
+          <DialogTitle className='flex items-center gap-2'>
+            <Edit3 className='h-5 w-5' />
+            {isNewOverride ? 'Create Model Override' : 'Edit Model Override'}
+          </DialogTitle>
+          <DialogDescription>
+            {isNewOverride
+              ? `Create an override for &quot;${model.name}&quot;`
+              : `Update the model override for &quot;${model.name}&quot;`}
+          </DialogDescription>
+        </DialogHeader>
+
+        <Form {...form}>
+          <form onSubmit={form.handleSubmit(onSubmit)} className='space-y-4'>
+            <div className='grid grid-cols-1 gap-4 sm:grid-cols-2'>
+              <FormField
+                control={form.control}
+                name='name'
+                render={({ field }) => (
+                  <FormItem>
+                    <FormLabel>Display Name *</FormLabel>
+                    <FormControl>
+                      <Input
+                        placeholder='e.g., GPT-4'
+                        {...field}
+                        className='w-full'
+                      />
+                    </FormControl>
+                    <FormDescription>
+                      Custom display name for the model
+                    </FormDescription>
+                    <FormMessage />
+                  </FormItem>
+                )}
+              />
+
+              <FormField
+                control={form.control}
+                name='context_length'
+                render={({ field }) => (
+                  <FormItem>
+                    <FormLabel>Context Length *</FormLabel>
+                    <FormControl>
+                      <Input
+                        type='number'
+                        min='0'
+                        placeholder='4096'
+                        value={field.value ?? ''}
+                        onChange={(e) => {
+                          const value = e.target.value;
+                          field.onChange(
+                            value === '' ? 0 : parseInt(value, 10) || 0
+                          );
+                        }}
+                        onBlur={(e) => {
+                          const value = parseInt(e.target.value, 10);
+                          field.onChange(
+                            Number.isNaN(value) ? 0 : Math.max(0, value)
+                          );
+                        }}
+                        className='w-full'
+                      />
+                    </FormControl>
+                    <FormDescription>
+                      Maximum context window size
+                    </FormDescription>
+                    <FormMessage />
+                  </FormItem>
+                )}
+              />
+            </div>
+
+            <FormField
+              control={form.control}
+              name='description'
+              render={({ field }) => (
+                <FormItem>
+                  <FormLabel>Description</FormLabel>
+                  <FormControl>
+                    <Textarea
+                      placeholder='Brief description of the model...'
+                      {...field}
+                      rows={3}
+                      className='w-full'
+                    />
+                  </FormControl>
+                  <FormDescription>
+                    Optional description or notes about the model
+                  </FormDescription>
+                  <FormMessage />
+                </FormItem>
+              )}
+            />
+
+            <div className='grid grid-cols-1 gap-4 sm:grid-cols-2'>
+              <FormField
+                control={form.control}
+                name='prompt'
+                render={({ field }) => (
+                  <FormItem>
+                    <FormLabel>Input Cost (per 1M tokens) *</FormLabel>
+                    <FormControl>
+                      <Input
+                        type='number'
+                        step='0.00001'
+                        min='0'
+                        placeholder='5.00000'
+                        value={field.value ?? ''}
+                        onChange={(e) => {
+                          const value = e.target.value;
+                          field.onChange(value === '' ? 0 : parseFloat(value));
+                        }}
+                        onBlur={(e) => {
+                          const value = parseFloat(e.target.value);
+                          field.onChange(roundToFiveDecimals(value));
+                        }}
+                        className='w-full'
+                      />
+                    </FormControl>
+                    <FormDescription>
+                      Cost in USD per 1,000,000 input tokens (max 5 decimals)
+                    </FormDescription>
+                    <FormMessage />
+                  </FormItem>
+                )}
+              />
+
+              <FormField
+                control={form.control}
+                name='completion'
+                render={({ field }) => (
+                  <FormItem>
+                    <FormLabel>Output Cost (per 1M tokens) *</FormLabel>
+                    <FormControl>
+                      <Input
+                        type='number'
+                        step='0.00001'
+                        min='0'
+                        placeholder='15.00000'
+                        value={field.value ?? ''}
+                        onChange={(e) => {
+                          const value = e.target.value;
+                          field.onChange(value === '' ? 0 : parseFloat(value));
+                        }}
+                        onBlur={(e) => {
+                          const value = parseFloat(e.target.value);
+                          field.onChange(roundToFiveDecimals(value));
+                        }}
+                        className='w-full'
+                      />
+                    </FormControl>
+                    <FormDescription>
+                      Cost in USD per 1,000,000 output tokens (max 5 decimals)
+                    </FormDescription>
+                    <FormMessage />
+                  </FormItem>
+                )}
+              />
+            </div>
+
+            <FormField
+              control={form.control}
+              name='enabled'
+              render={({ field }) => (
+                <FormItem className='flex flex-row items-center justify-between rounded-lg border p-4'>
+                  <div className='space-y-0.5'>
+                    <FormLabel className='text-base'>Model Enabled</FormLabel>
+                    <FormDescription>
+                      Enable or disable this model override
+                    </FormDescription>
+                  </div>
+                  <FormControl>
+                    <Switch
+                      checked={field.value}
+                      onCheckedChange={field.onChange}
+                    />
+                  </FormControl>
+                </FormItem>
+              )}
+            />
+
+            <div className='flex justify-end gap-2 pt-4'>
+              <Button
+                type='button'
+                variant='outline'
+                onClick={handleClose}
+                disabled={isSubmitting}
+              >
+                Cancel
+              </Button>
+              <Button type='submit' disabled={isSubmitting}>
+                {isSubmitting ? (
+                  <>
+                    <Loader2 className='mr-2 h-4 w-4 animate-spin' />
+                    {isNewOverride ? 'Creating...' : 'Updating...'}
+                  </>
+                ) : isNewOverride ? (
+                  'Create Override'
+                ) : (
+                  'Update Model'
+                )}
+              </Button>
+            </div>
+          </form>
+        </Form>
+      </DialogContent>
+    </Dialog>
+  );
+}

ui/components/landing/cashu-payment-workflow.tsx

@@ -50,6 +50,7 @@ export function CashuPaymentWorkflow({
   const [apiKeyInput, setApiKeyInput] = useState(apiKey);
   const [isCreatingKey, setIsCreatingKey] = useState(false);
   const [isTopupLoading, setIsTopupLoading] = useState(false);
+  const [hasInteractedManage, setHasInteractedManage] = useState(false);
   const [hasInteractedTopup, setHasInteractedTopup] = useState(false);
   const [balanceLimit, setBalanceLimit] = useState<string>('');
   const [balanceLimitReset, setBalanceLimitReset] = useState<string>('');
@@ -294,6 +295,7 @@ export function CashuPaymentWorkflow({
             <ApiKeyInput
               value={apiKeyInput}
               onApiKeyChange={handleApiKeyChange}
+              onFocus={() => setHasInteractedManage(true)}
             />
             <div className='flex gap-2'>
               <Button

ui/components/providers/RoutstrCreateKeySection.tsx

@@ -1,6 +1,6 @@
 'use client';
 
-import { useState } from 'react';
+import { useCallback, useState } from 'react';
 import Image from 'next/image';
 import { Copy, Loader2, Zap, KeyRound } from 'lucide-react';
 import { toast } from 'sonner';
@@ -10,6 +10,7 @@ import { Input } from '@/components/ui/input';
 import { Textarea } from '@/components/ui/textarea';
 import { Label } from '@/components/ui/label';
 import { Badge } from '@/components/ui/badge';
+import { Separator } from '@/components/ui/separator';
 import { Tabs, TabsContent, TabsList, TabsTrigger } from '@/components/ui/tabs';
 
 interface RoutstrCreateKeySectionProps {

ui/lib/api/services/admin.ts

@@ -76,7 +76,6 @@ export const AdminModelSchema = z.object({
   canonical_slug: z.string().nullable().optional(),
   alias_ids: z.array(z.string()).nullable().optional(),
   enabled: z.boolean().default(true),
-  forwarded_model_id: z.string().nullable().optional(),
 });
 
 export const ProviderModelsSchema = z.object({
@@ -1135,7 +1134,6 @@ export interface Transaction {
   created_at: number;
   collected: boolean;
   swept: boolean;
-  source: 'x-cashu' | 'apikey';
 }
 
 export interface TransactionsResponse {