Merge pull request #492 from Routstr/main

deploy v0.4.3

Dockerfile.full

@@ -4,7 +4,7 @@ FROM node:23-alpine AS ui-builder
 WORKDIR /app/ui
 
 # Install pnpm
-RUN corepack enable pnpm && corepack prepare pnpm@10.15.0 --activate
+RUN corepack enable pnpm && corepack prepare pnpm@latest --activate
 
 # Copy UI source
 COPY ui/package.json ui/pnpm-lock.yaml* ./

docs/provider/configuration.md

@@ -78,15 +78,9 @@ Which mints to accept payments from:
 
 Automatic profit withdrawal:
 
-| Setting                              | Description                                                                                                | Default |
-| ------------------------------------ | ---------------------------------------------------------------------------------------------------------- | ------- |
-| **Lightning Address**                | Your LN address for withdrawals                                                                            | —       |
-| **Minimum Payout (sat)**             | Min available balance (in sats) before profit is paid out. Applies to both `sat` and `msat` mints (auto-converted). | `210`   |
-| **Payout Interval (seconds)**        | How often the payout loop wakes up and checks balances                                                     | `900`   |
-
-All payout amounts must be positive. Set the minimums above your wallet's
-minimum-invoice constraint (typically 1 sat) and high enough to amortise
-routing fees.
+| Setting               | Description                     |
+| --------------------- | ------------------------------- |
+| **Lightning Address** | Your LN address for withdrawals |
 
 ### Security
 
@@ -132,8 +126,6 @@ Use environment variables for:
 | `ENABLE_ANALYTICS_SHARING` | Enable usage analytics sharing to Nostr | `true`                         |
 | `CASHU_MINTS`        | Comma-separated mint URLs         | `https://mint.minibits.cash/Bitcoin` |
 | `RECEIVE_LN_ADDRESS` | Lightning address for withdrawals | —                                    |
-| `MIN_PAYOUT_SAT`     | Min payout balance in sats (applies to all mints) | `210`                |
-| `PAYOUT_INTERVAL_SECONDS` | Payout loop interval (seconds) | `900`                            |
 | `TOR_PROXY_URL`      | SOCKS5 proxy for Tor              | `socks5://127.0.0.1:9050`            |
 | `CORS_ORIGINS`       | Allowed CORS origins              | `*`                                  |
 | `RELAYS`             | Nostr relays (comma-separated)    | (default set)                        |

routstr/core/admin.py

@@ -6,7 +6,6 @@ from pathlib import Path
 
 from fastapi import APIRouter, Depends, HTTPException, Query, Request
 from pydantic import BaseModel, RootModel
-from pydantic.v1 import ValidationError as PydanticValidationError
 from sqlmodel import select
 
 from ..payment.models import _row_to_model, list_models
@@ -161,13 +160,8 @@ async def update_settings(request: Request, update: SettingsUpdate) -> dict:
         if field in settings_data:
             del settings_data[field]
 
-    try:
-        async with create_session() as session:
-            new_settings = await SettingsService.update(settings_data, session)
-    except PydanticValidationError as e:
-        # Surface validation issues (e.g. non-positive payout amounts)
-        # as a clean 400 instead of a 500.
-        raise HTTPException(status_code=400, detail=e.errors()) from e
+    async with create_session() as session:
+        new_settings = await SettingsService.update(settings_data, session)
     data = new_settings.dict()
     if "upstream_api_key" in data:
         data["upstream_api_key"] = "[REDACTED]" if data["upstream_api_key"] else ""

routstr/core/settings.py

@@ -41,15 +41,6 @@ class Settings(BaseSettings):
     primary_mint: str = Field(default="", env="PRIMARY_MINT_URL")
     primary_mint_unit: str = Field(default="sat", env="PRIMARY_MINT_UNIT")
 
-    # Lightning payout configuration
-    # Minimum available balance (in satoshis) before profit is paid out over
-    # Lightning
-    min_payout_sat: int = Field(default=210, gt=0, env="MIN_PAYOUT_SAT")
-    # Interval (seconds) between periodic payout attempts. Must be positive.
-    payout_interval_seconds: int = Field(
-        default=900, gt=0, env="PAYOUT_INTERVAL_SECONDS"
-    )
-
     # Pricing
     # Default behavior: derive pricing from MODELS
     # If fixed_pricing is True -> use fixed_cost_per_request and ignore tokens

routstr/proxy.py

@@ -1,9 +1,8 @@
 import json
-from pathlib import Path
 from typing import Any
 
 from fastapi import APIRouter, Depends, HTTPException, Request
-from fastapi.responses import HTMLResponse, JSONResponse, Response, StreamingResponse
+from fastapi.responses import Response, StreamingResponse
 from sqlmodel import select
 
 from .algorithm import create_model_mappings
@@ -151,51 +150,10 @@ async def refresh_model_maps_periodically() -> None:
             )
 
 
-_API_PATH_PREFIXES = ("v1/", "responses")
-
-_NOT_FOUND_HTML_FILE = Path(__file__).parent.parent / "ui_out" / "404.html"
-
-
-def _read_not_found_html() -> str | None:
-    try:
-        return _NOT_FOUND_HTML_FILE.read_text(encoding="utf-8")
-    except OSError:
-        return None
-
-
-_NOT_FOUND_HTML: str | None = _read_not_found_html()
-
-
-def _build_not_found_response(request: Request, path: str) -> Response:
-    """Return a 404 for unknown paths.
-    """
-    accept = request.headers.get("accept", "").lower()
-    prefers_json = "application/json" in accept and "text/html" not in accept
-    request_id = getattr(request.state, "request_id", "unknown")
-
-    if not prefers_json and _NOT_FOUND_HTML is not None:
-        return HTMLResponse(content=_NOT_FOUND_HTML, status_code=404)
-
-    return JSONResponse(
-        status_code=404,
-        content={
-            "error": {
-                "message": f"Path '/{path}' not found",
-                "type": "not_found",
-                "code": 404,
-            },
-            "request_id": request_id,
-        },
-    )
-
-
 @proxy_router.api_route("/{path:path}", methods=["GET", "POST"], response_model=None)
 async def proxy(
     request: Request, path: str, session: AsyncSession = Depends(get_session)
 ) -> Response | StreamingResponse:
-    if not path.startswith(_API_PATH_PREFIXES):
-        return _build_not_found_response(request, path)
-
     headers = dict(request.headers)
 
     is_responses_api = path.startswith("v1/responses") or path.startswith("responses")

routstr/upstream/base.py

@@ -47,17 +47,6 @@ from .litellm_routing import detect_litellm_prefix
 logger = get_logger(__name__)
 
 
-def _is_json_content_type(content_type: str | None) -> bool:
-    """Return True when the upstream response should be parsed as JSON.
-    """
-    if not content_type:
-        return False
-    main = content_type.split(";", 1)[0].strip().lower()
-    if main in ("application/json", "text/json"):
-        return True
-    return main.startswith("application/") and main.endswith("+json")
-
-
 class TopupData(BaseModel):
     """Universal top-up data schema for Lightning Network invoices."""
 
@@ -534,8 +523,7 @@ class BaseUpstreamProvider:
     async def forward_upstream_error_response(
         self, request: Request, path: str, upstream_response: httpx.Response
     ) -> Response:
-        """Log upstream errors and forward the response in a JSON envelope.
-        """
+        """Log upstream errors and forward the upstream response unchanged."""
         status_code = upstream_response.status_code
         headers = dict(upstream_response.headers)
         content_type = headers.get("content-type") or headers.get("Content-Type", "")
@@ -557,10 +545,9 @@ class BaseUpstreamProvider:
 
         message, upstream_code = self._extract_upstream_error_message(body_bytes)
         body_preview = body_bytes.decode("utf-8", errors="ignore").strip()[:500]
-        is_json_body = _is_json_content_type(content_type)
 
         logger.warning(
-            "Forwarding upstream error response",
+            "Forwarding upstream error response as-is",
             extra={
                 "path": path,
                 "provider": self.provider_type,
@@ -572,7 +559,6 @@ class BaseUpstreamProvider:
                 "body_preview": body_preview,
                 "body_read_error": body_read_error,
                 "method": request.method,
-                "json_normalized": not is_json_body,
             },
         )
 
@@ -600,40 +586,17 @@ class BaseUpstreamProvider:
         ):
             headers.pop(header_name, None)
 
-        if is_json_body:
-            if not content_type:
-                headers.pop("content-type", None)
-                headers.pop("Content-Type", None)
-            media_type = content_type or None
-            return Response(
-                content=body_bytes,
-                status_code=status_code,
-                headers=headers,
-                media_type=media_type,
-            )
+        if not content_type:
+            headers.pop("content-type", None)
+            headers.pop("Content-Type", None)
 
-        # Non-JSON upstream error (HTML, plain text, empty, ...). Wrap it in
-        # the standard JSON envelope so callers don't need a second parser.
-        for header_name in ("content-type", "Content-Type"):
-            headers.pop(header_name, None)
-
-        envelope = {
-            "error": {
-                "message": message or "Upstream returned a non-JSON error response",
-                "type": "upstream_error",
-                "code": upstream_code or status_code,
-                "upstream_status": status_code,
-                "upstream_content_type": content_type or None,
-                "upstream_body_preview": body_preview or None,
-            },
-            "request_id": getattr(request.state, "request_id", None),
-        }
+        media_type = content_type or None
 
         return Response(
-            content=json.dumps(envelope).encode(),
+            content=body_bytes,
             status_code=status_code,
             headers=headers,
-            media_type="application/json",
+            media_type=media_type,
         )
 
     async def handle_streaming_chat_completion(

routstr/upstream/routstr.py

@@ -18,10 +18,6 @@ class RoutstrUpstreamProvider(BaseUpstreamProvider):
     provider_type = "routstr"
     default_base_url = None
     platform_url = None
-    # Upstream Routstr nodes serve `/v1/messages` natively, so forward the
-    # request as-is instead of round-tripping through litellm's
-    # Anthropic→OpenAI translator.
-    supports_anthropic_messages = True
 
     def __init__(
         self,
@@ -47,13 +43,6 @@ class RoutstrUpstreamProvider(BaseUpstreamProvider):
         )
         self.settings = provider_settings or {}
 
-    def normalize_request_path(
-        self, path: str, model_obj: "Model | None" = None
-    ) -> str:
-        """Preserve the ``v1/`` prefix when forwarding to an upstream Routstr.
-        """
-        return path.lstrip("/")
-
     @classmethod
     def from_db_row(
         cls, provider_row: "UpstreamProviderRow"

routstr/wallet.py

@@ -502,11 +502,11 @@ async def fetch_all_balances(
 
 
 async def periodic_payout() -> None:
+    if not settings.receive_ln_address:
+        logger.warning("RECEIVE_LN_ADDRESS is not set, periodic payout disabled")
+        return
     while True:
-        await asyncio.sleep(settings.payout_interval_seconds)
-        print(settings.payout_interval_seconds)
-        if not settings.receive_ln_address:
-            continue
+        await asyncio.sleep(60 * 15)
         try:
             async with db.create_session() as session:
                 for mint_url in settings.cashu_mints:
@@ -524,12 +524,7 @@ async def periodic_payout() -> None:
                             user_balance = user_balance // 1000
                         proofs_balance = sum(proof.amount for proof in proofs)
                         available_balance = proofs_balance - user_balance
-                        # Threshold is configured in sats; convert for msat wallets.
-                        min_amount = (
-                            settings.min_payout_sat
-                            if unit == "sat"
-                            else settings.min_payout_sat * 1000
-                        )
+                        min_amount = 210 if unit == "sat" else 210000
                         if available_balance > min_amount:
                             amount_received = await raw_send_to_lnurl(
                                 wallet,

tests/unit/test_proxy_not_found.py

@@ -1,64 +0,0 @@
-"""Tests for the built-in 404 handler in routstr.proxy."""
-
-from __future__ import annotations
-
-import pytest
-from fastapi import FastAPI
-from fastapi.testclient import TestClient
-
-from routstr import proxy
-from routstr.proxy import proxy_router
-
-
-def _make_app() -> FastAPI:
-    app = FastAPI()
-    app.include_router(proxy_router)
-    return app
-
-
-@pytest.mark.skipif(
-    proxy._NOT_FOUND_HTML is None,
-    reason="UI bundle (ui_out/404.html) not present in this environment",
-)
-def test_unknown_path_returns_html_404_for_browser() -> None:
-    client = TestClient(_make_app())
-    response = client.get("/some/random/page", headers={"accept": "text/html"})
-    assert response.status_code == 404
-    assert response.headers["content-type"].startswith("text/html")
-    assert "404" in response.text
-
-
-def test_unknown_path_returns_json_404_for_api_client() -> None:
-    client = TestClient(_make_app())
-    response = client.get(
-        "/some/random/page", headers={"accept": "application/json"}
-    )
-    assert response.status_code == 404
-    assert response.headers["content-type"].startswith("application/json")
-    payload = response.json()
-    assert payload["error"]["type"] == "not_found"
-    assert payload["error"]["code"] == 404
-    assert "/some/random/page" in payload["error"]["message"]
-
-
-def test_root_path_returns_404_for_proxy_router() -> None:
-    client = TestClient(_make_app())
-    response = client.get("/", headers={"accept": "application/json"})
-    assert response.status_code == 404
-
-
-def test_v1_path_is_not_intercepted_by_404_handler() -> None:
-    """Paths starting with v1/ must reach the proxy logic, not the 404 handler."""
-    client = TestClient(_make_app(), raise_server_exceptions=False)
-    response = client.get("/v1/anything")
-    if response.status_code == 404:
-        # Any 404 here must come from inner proxy logic, not our HTML page.
-        assert "<!DOCTYPE html>" not in response.text
-
-
-def test_json_returned_when_ui_html_missing(monkeypatch: pytest.MonkeyPatch) -> None:
-    monkeypatch.setattr(proxy, "_NOT_FOUND_HTML", None)
-    client = TestClient(_make_app())
-    response = client.get("/some/random/page", headers={"accept": "text/html"})
-    assert response.status_code == 404
-    assert response.headers["content-type"].startswith("application/json")

tests/unit/test_settings.py

@@ -1,12 +1,11 @@
 import os
 
 import pytest
-from pydantic.v1 import ValidationError
 from sqlalchemy.ext.asyncio import create_async_engine
 from sqlmodel import text
 from sqlmodel.ext.asyncio.session import AsyncSession
 
-from routstr.core.settings import Settings, SettingsService
+from routstr.core.settings import SettingsService
 
 
 @pytest.mark.asyncio
@@ -47,54 +46,6 @@ async def test_settings_db_precedence_over_env() -> None:
         assert again.enable_analytics_sharing is False
 
 
-def test_payout_settings_have_sensible_defaults() -> None:
-    s = Settings()
-    assert s.min_payout_sat == 210
-    assert s.payout_interval_seconds == 900
-
-
-@pytest.mark.parametrize(
-    "field,bad_value",
-    [
-        ("min_payout_sat", 0),
-        ("min_payout_sat", -1),
-        ("payout_interval_seconds", 0),
-        ("payout_interval_seconds", -10),
-    ],
-)
-def test_payout_settings_reject_invalid_values(field: str, bad_value: int) -> None:
-    kwargs: dict[str, object] = {field: bad_value}
-    with pytest.raises(ValidationError):
-        Settings(**kwargs)  # type: ignore[arg-type]
-
-
-def test_payout_settings_accept_custom_positive_values() -> None:
-    s = Settings(min_payout_sat=500, payout_interval_seconds=60)
-    assert s.min_payout_sat == 500
-    assert s.payout_interval_seconds == 60
-
-
-@pytest.mark.asyncio
-async def test_payout_settings_persist_via_settings_service() -> None:
-    engine = create_async_engine("sqlite+aiosqlite:///:memory:")
-    async with AsyncSession(engine, expire_on_commit=False) as session:
-        await SettingsService.initialize(session)
-        updated = await SettingsService.update(
-            {"min_payout_sat": 1000, "payout_interval_seconds": 300}, session
-        )
-        assert updated.min_payout_sat == 1000
-        assert updated.payout_interval_seconds == 300
-
-
-@pytest.mark.asyncio
-async def test_payout_settings_update_rejects_invalid() -> None:
-    engine = create_async_engine("sqlite+aiosqlite:///:memory:")
-    async with AsyncSession(engine, expire_on_commit=False) as session:
-        await SettingsService.initialize(session)
-        with pytest.raises(ValidationError):
-            await SettingsService.update({"min_payout_sat": 0}, session)
-
-
 @pytest.mark.asyncio
 async def test_settings_initialize_discards_unknown_keys() -> None:
     engine = create_async_engine("sqlite+aiosqlite:///:memory:")

tests/unit/test_upstream_error_response.py

@@ -1,150 +0,0 @@
-"""Tests for ``BaseUpstreamProvider.forward_upstream_error_response``.
-
-Upstream services (e.g. an Express server that doesn't expose ``/messages``)
-sometimes return a non-JSON error body. The proxy must surface those errors
-in a consistent JSON envelope so clients don't have to parse HTML.
-"""
-
-from __future__ import annotations
-
-import json
-from typing import Any
-from unittest.mock import Mock
-
-import httpx
-import pytest
-
-from routstr.upstream.base import BaseUpstreamProvider, _is_json_content_type
-
-
-def _make_request(request_id: str = "req-123") -> Mock:
-    request = Mock(spec=["method", "state"])
-    request.method = "POST"
-    request.state = Mock()
-    request.state.request_id = request_id
-    return request
-
-
-def _make_upstream_response(
-    *,
-    body: bytes,
-    status_code: int = 404,
-    content_type: str | None = "text/html",
-    extra_headers: dict[str, str] | None = None,
-) -> httpx.Response:
-    headers: dict[str, str] = {}
-    if content_type is not None:
-        headers["content-type"] = content_type
-    if extra_headers:
-        headers.update(extra_headers)
-    return httpx.Response(status_code=status_code, headers=headers, content=body)
-
-
-@pytest.fixture
-def provider() -> BaseUpstreamProvider:
-    return BaseUpstreamProvider(
-        base_url="https://privateprovider.xyz", api_key="k", provider_fee=1.0
-    )
-
-
-@pytest.mark.parametrize(
-    "content_type,expected",
-    [
-        ("application/json", True),
-        ("application/json; charset=utf-8", True),
-        ("text/json", True),
-        ("application/problem+json", True),
-        ("application/vnd.api+json", True),
-        ("text/html", False),
-        ("text/html; charset=utf-8", False),
-        ("text/plain", False),
-        ("", False),
-        (None, False),
-    ],
-)
-def test_is_json_content_type(content_type: str | None, expected: bool) -> None:
-    assert _is_json_content_type(content_type) is expected
-
-
-@pytest.mark.asyncio
-async def test_html_error_is_normalized_to_json_envelope(
-    provider: BaseUpstreamProvider,
-) -> None:
-    html_body = (
-        b"<!DOCTYPE html><html><head><title>Error</title></head>"
-        b"<body><pre>Cannot POST /messages</pre></body></html>"
-    )
-    upstream = _make_upstream_response(body=html_body, status_code=404)
-
-    response = await provider.forward_upstream_error_response(
-        _make_request(), "v1/messages", upstream
-    )
-
-    assert response.status_code == 404
-    assert response.media_type == "application/json"
-    payload: dict[str, Any] = json.loads(bytes(response.body))
-    assert payload["error"]["type"] == "upstream_error"
-    assert payload["error"]["upstream_status"] == 404
-    assert payload["error"]["upstream_content_type"] == "text/html"
-    assert "Cannot POST /messages" in payload["error"]["upstream_body_preview"]
-    assert payload["request_id"] == "req-123"
-    # The upstream's text/html content-type must not survive — Response()
-    # sets the JSON content-type for us via media_type.
-    assert response.headers["content-type"].startswith("application/json")
-
-
-@pytest.mark.asyncio
-async def test_plain_text_error_is_normalized(
-    provider: BaseUpstreamProvider,
-) -> None:
-    upstream = _make_upstream_response(
-        body=b"Service Unavailable", status_code=503, content_type="text/plain"
-    )
-
-    response = await provider.forward_upstream_error_response(
-        _make_request(), "v1/messages", upstream
-    )
-
-    assert response.status_code == 503
-    assert response.media_type == "application/json"
-    payload = json.loads(bytes(response.body))
-    assert payload["error"]["message"] == "Service Unavailable"
-
-
-@pytest.mark.asyncio
-async def test_empty_body_with_non_json_content_type_normalizes(
-    provider: BaseUpstreamProvider,
-) -> None:
-    upstream = _make_upstream_response(
-        body=b"", status_code=502, content_type="text/html"
-    )
-
-    response = await provider.forward_upstream_error_response(
-        _make_request(), "v1/messages", upstream
-    )
-
-    assert response.status_code == 502
-    assert response.media_type == "application/json"
-    payload = json.loads(bytes(response.body))
-    assert payload["error"]["type"] == "upstream_error"
-    assert payload["error"]["upstream_body_preview"] is None
-
-
-@pytest.mark.asyncio
-async def test_json_error_body_is_passed_through_unchanged(
-    provider: BaseUpstreamProvider,
-) -> None:
-    json_body = json.dumps(
-        {"error": {"message": "Invalid model", "type": "invalid_request_error"}}
-    ).encode()
-    upstream = _make_upstream_response(
-        body=json_body, status_code=400, content_type="application/json"
-    )
-
-    response = await provider.forward_upstream_error_response(
-        _make_request(), "v1/messages", upstream
-    )
-
-    assert response.status_code == 400
-    assert bytes(response.body) == json_body
-    assert response.media_type == "application/json"

tests/unit/test_upstream_routstr.py

@@ -74,39 +74,3 @@ async def test_get_balance_returns_none_on_connect_timeout(
     balance = await provider.get_balance()
 
     assert balance is None
-
-
-def test_normalize_request_path_keeps_v1_prefix() -> None:
-    """Routstr upstream stores ``base_url`` without ``/v1``; the prefix
-    must stay on the path so ``build_request_url`` produces ``/v1/<endpoint>``
-    instead of ``/<endpoint>`` (which the upstream Routstr 404s with HTML)."""
-    provider = RoutstrUpstreamProvider(
-        base_url="https://privateprovider.xyz", api_key="key"
-    )
-
-    assert provider.normalize_request_path("v1/messages") == "v1/messages"
-    assert provider.normalize_request_path("/v1/messages") == "v1/messages"
-    assert (
-        provider.normalize_request_path("v1/chat/completions")
-        == "v1/chat/completions"
-    )
-
-
-def test_build_request_url_for_v1_messages() -> None:
-    """Forwarding ``/v1/messages`` must hit the upstream's ``/v1/messages``."""
-    provider = RoutstrUpstreamProvider(
-        base_url="https://privateprovider.xyz", api_key="key"
-    )
-
-    normalized = provider.normalize_request_path("v1/messages")
-
-    assert (
-        provider.build_request_url(normalized)
-        == "https://privateprovider.xyz/v1/messages"
-    )
-
-
-def test_supports_anthropic_messages_natively() -> None:
-    """Routstr nodes serve ``/v1/messages`` directly, so the proxy must
-    forward as-is instead of round-tripping through litellm."""
-    assert RoutstrUpstreamProvider.supports_anthropic_messages is True

ui/components/settings/admin-settings.tsx

@@ -32,18 +32,9 @@ interface SettingsData {
   onion_url?: string;
   cashu_mints?: string[];
   relays?: string[];
-  receive_ln_address?: string;
-  min_payout_sat?: number;
-  payout_interval_seconds?: number;
   [key: string]: unknown;
 }
 
-const PAYOUT_KEYS = [
-  'receive_ln_address',
-  'min_payout_sat',
-  'payout_interval_seconds',
-] as const;
-
 const HANDLED_KEYS = [
   'name',
   'description',
@@ -57,7 +48,6 @@ const HANDLED_KEYS = [
   'admin_password',
   'id',
   'updated_at',
-  ...PAYOUT_KEYS,
 ];
 
 const IGNORED_KEYS = [
@@ -379,7 +369,6 @@ export function AdminSettings() {
   const cashuMintsChanged = hasFieldChanged('cashu_mints');
   const relaysChanged = hasFieldChanged('relays');
   const analyticsSharingChanged = hasFieldChanged('enable_analytics_sharing');
-  const payoutChanged = PAYOUT_KEYS.some(hasFieldChanged);
   const advancedKeys = Object.keys(settings).filter(
     (key) => !HANDLED_KEYS.includes(key) && !IGNORED_KEYS.includes(key)
   );
@@ -412,44 +401,8 @@ export function AdminSettings() {
     setNewRelay('');
   };
   const resetAnalyticsSharing = () => resetFields(['enable_analytics_sharing']);
-  const resetPayout = () => resetFields([...PAYOUT_KEYS]);
   const resetAdvanced = () => resetFields(advancedKeys);
 
-  const payoutFields: ReadonlyArray<{
-    key: (typeof PAYOUT_KEYS)[number];
-    label: string;
-    placeholder: string;
-    type: 'text' | 'number';
-    helpText: string;
-    min?: number;
-  }> = [
-    {
-      key: 'receive_ln_address',
-      label: 'Lightning Receive Address',
-      placeholder: 'you@walletofsatoshi.com or LNURL',
-      type: 'text',
-      helpText:
-        'Lightning address (or LNURL) profits are paid out to. Leave empty to disable periodic payouts.',
-    },
-    {
-      key: 'min_payout_sat',
-      label: 'Minimum Payout (sat)',
-      placeholder: '210',
-      type: 'number',
-      min: 1,
-      helpText:
-        'Wallet payouts only fire when at least this many satoshis are available. Must be > 0.',
-    },
-    {
-      key: 'payout_interval_seconds',
-      label: 'Payout Interval (seconds)',
-      placeholder: '900',
-      type: 'number',
-      min: 1,
-      helpText: 'How often the payout loop wakes up to check balances.',
-    },
-  ];
-
   if (loading) {
     return (
       <div className='space-y-4'>
@@ -667,89 +620,6 @@ export function AdminSettings() {
           ) : null}
         </Card>
 
-        {/* Lightning Payout Settings */}
-        <Card>
-          <CardHeader>
-            <CardTitle>Lightning Payout Settings</CardTitle>
-            <CardDescription>
-              Tune how node profit is paid out over Lightning. Amounts must be
-              positive and above your wallet&apos;s minimum-invoice constraints.
-            </CardDescription>
-          </CardHeader>
-          <CardContent className='space-y-4'>
-            {payoutFields.map((field) => {
-              const value = settings[field.key];
-              if (field.type === 'number') {
-                return (
-                  <div key={field.key} className='space-y-2'>
-                    <Label htmlFor={field.key}>{field.label}</Label>
-                    <Input
-                      id={field.key}
-                      type='number'
-                      min={field.min}
-                      value={
-                        typeof value === 'number'
-                          ? value
-                          : value === undefined || value === null
-                            ? ''
-                            : Number(value)
-                      }
-                      placeholder={field.placeholder}
-                      onChange={(e) => {
-                        const raw = e.target.value;
-                        if (raw === '') {
-                          handleInputChange(field.key, undefined);
-                        } else {
-                          const parsed = Number(raw);
-                          handleInputChange(
-                            field.key,
-                            Number.isFinite(parsed) ? parsed : undefined
-                          );
-                        }
-                      }}
-                    />
-                    <p className='text-muted-foreground text-xs'>
-                      {field.helpText}
-                    </p>
-                  </div>
-                );
-              }
-              return (
-                <div key={field.key} className='space-y-2'>
-                  <Label htmlFor={field.key}>{field.label}</Label>
-                  <Input
-                    id={field.key}
-                    value={(value as string) || ''}
-                    placeholder={field.placeholder}
-                    onChange={(e) =>
-                      handleInputChange(field.key, e.target.value)
-                    }
-                  />
-                  <p className='text-muted-foreground text-xs'>
-                    {field.helpText}
-                  </p>
-                </div>
-              );
-            })}
-          </CardContent>
-          {payoutChanged ? (
-            <CardFooter className='justify-start'>
-              <div className='flex w-full flex-col gap-2 sm:w-auto sm:flex-row sm:items-center'>
-                <Button
-                  variant='outline'
-                  onClick={resetPayout}
-                  disabled={loading || saving}
-                >
-                  Cancel
-                </Button>
-                <Button onClick={handleSave} disabled={loading || saving}>
-                  {saving ? 'Saving...' : 'Save'}
-                </Button>
-              </div>
-            </CardFooter>
-          ) : null}
-        </Card>
-
         {/* Relays */}
         <Card>
           <CardHeader>

ui/next.config.ts

@@ -6,9 +6,6 @@ const nextConfig: NextConfig = {
   images: {
     unoptimized: true,
   },
-  turbopack: {
-    root: __dirname,
-  },
 };
 
 export default nextConfig;

ui/package.json

@@ -1,6 +1,5 @@
 {
   "name": "routstr-service",
-  "packageManager": "pnpm@10.15.0",
   "version": "0.1.0",
   "private": true,
   "scripts": {
@@ -89,11 +88,5 @@
     "prettier-plugin-tailwindcss": "^0.7.2",
     "tailwindcss": "^4.2.0",
     "typescript": "^5.9.3"
-  },
-  "pnpm": {
-    "onlyBuiltDependencies": [
-      "sharp",
-      "unrs-resolver"
-    ]
   }
 }