What changed, and why it matters
This commit fixes a packaging/build issue in LNbits, but the code changes also harden how sensitive funding-source settings (wallet seeds, API keys, macaroons) are exposed and edited through the admin web interface. Previously, non-super admin users could read and modify these credentials; now only the superuser can. The patch also prevents the desktop launcher from accidentally overwriting or leaking wallet seeds when switching funding providers, and it stops startup if the saved seed does not match the configured one. These are defensive security improvements rather than a reported vulnerability fix.
Treat this as a security-hardening patch and include it in the next release. Review whether prior versions allowed non-super admins to view or modify funding credentials, and consider issuing a security note or low-severity advisory if supported deployments relied on that boundary. No immediate incident response is indicated by the commit content alone.
Security signals we found
Authorization boundary tightened: funding-source credentials restricted to superuser in API and UI
Seed-integrity check added: configured mnemonic must match persisted seed.dat before settings are written
Backup confirmation reset when funding seed changes, preventing silent wallet substitution
Database error sanitization in sync_settings to avoid leaking credentials in logs
Admin settings GET/PATCH/PUT/default endpoints now return Cache-Control: no-store
Partial settings updates no longer overwrite live funding configuration for non-super admins
PyInstaller build now collects _wallycore and nostr_sdk native binaries
Evidence from the diff
The commit modifies the admin settings API and CRUD layer so that FundingSourcesSettings fields are only returned to, and only writable by, the superuser. It adds _check_funding_settings_access() in admin_api.py, filters FundingSourcesSettings from AdminSettings for non-super users in settings.py, and hides corresponding UI blocks in funding.vue. The desktop packaging code now synchronizes bundled funding configuration during app lifespan, validates the configured mnemonic against the on-disk seed before persisting settings, clears the backup-confirmed flag when the seed changes, and sanitizes database errors so credentials are not logged. Launcher preferences are saved separately from secrets, and the build script adds missing native-library hooks for PyInstaller.
Changed components
lnbits/core/views/admin_api.pylnbits/core/crud/settings.pylnbits/templates/components/admin/funding.vue.github/packaging/funding.py.github/packaging/desktop.py.github/packaging/build.py.github/workflows/macos.ymlInspect captured patch +913 / −69
### .github/packaging/README.md
@@ -7,18 +7,27 @@ an authenticated wallet API response, and configure the existing LNbits backend.
Python, Node.js and the daemons do not need to be installed by the user.
An internet connection is needed for either funding service.
-Managed funding requires a new local SQLite data folder on first setup. An
-existing LNbits database cannot be attached to a newly generated backing wallet,
-and changing between Spark and Phoenixd requires a separate data folder. These
-guards prevent existing user balances being backed by a different wallet.
+You can switch between Spark and Phoenixd using the same LNbits data folder.
+Stop the app, select the other provider, and launch again. The launcher sets the
+selected funding source's environment variables and keeps the LNbits database.
+Each provider retains its own seed and runtime data, so switching back reuses its
+existing wallet. Switching providers does not transfer funds between them.
External database URLs are not supported in managed mode. Neither retains the
normal LNbits database and funding configuration options.
## Persistence and backup
+Clicking **Launch LNbits** remembers the host, port, data folder, HTTPS/admin
+checkboxes, and funding selection for the next GUI launch. These preferences are
+stored in `launcher.json` under the standard application data directory
+(`~/.local/share/lnbits-desktop` on Linux, or `$XDG_DATA_HOME/lnbits-desktop` when set).
+The preferences stay there even when you select a different LNbits data folder.
+Explicit environment variables override the saved host, port, folder and checkbox
+values. Headless launches keep their existing command-line/environment behavior.
+
The selected provider and port are remembered in `funding/profile.json` within
-the chosen LNbits data folder. Selecting Neither explicitly skips daemon startup
-for that launch. Each provider's identity is generated once:
+the chosen LNbits data folder. Selecting Neither explicitly skips daemon startup.
+Each provider's identity is generated once:
- Spark: 24 words in `funding/spark/seed.dat`.
- Phoenixd: 12 words in `funding/phoenixd/seed.dat`, alongside its database and
@@ -35,6 +44,12 @@ The daemon binds to `127.0.0.1` and requires a random API password/key generated
for each launch. Connection settings are authoritative for the managed LNbits
worker, so stale saved backend settings cannot override the selected daemon.
Change the managed port/provider in the launcher, rather than LNbits admin.
+After database initialization, the launcher saves the selected provider's connection
+settings and existing seed for the superuser's Funding page. A changed seed requires
+backup confirmation again; an unchanged seed retains its confirmation. The inactive
+provider's settings are preserved. A synchronization failure stops startup before
+requests are accepted. This desktop-only step does not run for Neither, Docker, or
+normal server startup, and never generates or rewrites a seed file.
Closing the launcher stops LNbits first, then the daemon. LNbits' own restart
keeps the daemon running. A daemon failure stops LNbits and reports an error;
@@ -58,7 +73,7 @@ The terms flag is needed only for Phoenixd's first headless setup. Omit
## Build and verification
`build.py` on macOS prepares runtimes before invoking PyInstaller. `sidecars/pins.json`
-pins Node 24.21.0, Phoenixd 0.9.0 and Spark sidecar v0.1.5 with SHA-256 checksums.
+pins Node 24.21.0, Phoenixd 0.9.0 and Spark sidecar v0.1.6 with SHA-256 checksums.
Spark is downloaded at its fixed release commit; its tag and revision appear
in the build log and are included in the bundled `sidecars/pins.json`.
Downloads occur at build time only. A failed download or checksum mismatch fails
### .github/packaging/build.py
@@ -48,9 +48,13 @@
"--specpath",
"build",
"--hidden-import=embit",
+ # Wally's SWIG wrapper imports this top-level native module dynamically.
+ "--hidden-import=_wallycore",
"--hidden-import=bitstring.bitstore_bitarray",
"--collect-data=pyinstrument",
"--collect-data=random_username",
+ # Nostr SDK loads its native library by package-relative path via ctypes.
+ "--collect-binaries=nostr_sdk",
]
# Keep external executables as binaries so macOS signs them with the app.
sidecars = Path("build/sidecars").resolve()
### .github/packaging/desktop.py
@@ -4,6 +4,7 @@
import asyncio
import contextlib
import importlib.util
+import json
import multiprocessing as mp
import os
import signal
@@ -12,9 +13,27 @@
import time
import traceback
import webbrowser
+from functools import partial
from pathlib import Path
-from funding import PROVIDERS, Funding, load_profile, protect_settings
+from funding import (
+ PROVIDERS,
+ Funding,
+ configure_app,
+ load_profile,
+ protect_settings,
+ save_private,
+)
+
+LAUNCHER_SETTINGS = (
+ "HOST",
+ "PORT",
+ "LNBITS_DATA_FOLDER",
+ "AUTH_HTTPS_ONLY",
+ "LNBITS_ADMIN_UI",
+ "LNBITS_DESKTOP_FUNDING",
+ "LNBITS_DESKTOP_FUNDING_PORT",
+)
def default_folder():
@@ -28,6 +47,27 @@ def default_folder():
)
+def load_launcher_settings():
+ try:
+ values = json.loads((default_folder() / "launcher.json").read_text())
+ except (OSError, ValueError):
+ return {}
+ if not isinstance(values, dict):
+ return {}
+ return {
+ key: values[key]
+ for key in LAUNCHER_SETTINGS
+ if isinstance(values.get(key), str)
+ }
+
+
+def save_launcher_settings(environment):
+ folder = default_folder()
+ folder.mkdir(parents=True, exist_ok=True)
+ values = {key: environment[key] for key in LAUNCHER_SETTINGS}
+ save_private(folder / "launcher.json", json.dumps(values))
+
+
def configuration(
host,
port,
@@ -114,6 +154,14 @@ def worker(environment, stop, ready):
sys.exit(1)
+def create_desktop_app(environment):
+ from lnbits.app import create_app
+
+ app = create_app()
+ configure_app(app, environment)
+ return app
+
+
def run_server(environment, stop, ready):
import uvicorn
@@ -124,9 +172,11 @@ def run_server(environment, stop, ready):
parents=True, exist_ok=True
)
settings.wasm_extensions_dir.mkdir(parents=True, exist_ok=True)
+
server = uvicorn.Server(
uvicorn.Config(
- "lnbits.__main__:app",
+ partial(create_desktop_app, environment),
+ factory=True,
host=environment["HOST"],
port=int(environment["PORT"]),
loop="asyncio",
@@ -256,6 +306,8 @@ def gui(smoke=False): # noqa: C901 - Shared UI callbacks.
import tkinter as tk
from tkinter import filedialog, messagebox, ttk
+ saved = {} if smoke else load_launcher_settings()
+ defaults_env = {**saved, **os.environ}
root = tk.Tk()
root.title("LNbits")
frame = ttk.Frame(root, padding=24)
@@ -284,7 +336,7 @@ def gui(smoke=False): # noqa: C901 - Shared UI callbacks.
]
for index, (key, label, default, tip) in enumerate(defaults):
row = index * 2 + 1
- fields[key] = tk.StringVar(value=os.environ.get(key, default))
+ fields[key] = tk.StringVar(value=defaults_env.get(key, default))
ttk.Label(frame, text=label).grid(row=row, column=0, sticky="w", padx=(0, 12))
ttk.Entry(frame, textvariable=fields[key], width=48).grid(
row=row, column=1, sticky="ew"
@@ -300,10 +352,12 @@ def browse():
ttk.Button(frame, text="Browse…", command=browse).grid(row=5, column=2, padx=(8, 0))
https = tk.BooleanVar(
- value=os.environ.get("AUTH_HTTPS_ONLY", "false").lower() in ("true", "1", "yes")
+ value=defaults_env.get("AUTH_HTTPS_ONLY", "false").lower()
+ in ("true", "1", "yes")
)
admin = tk.BooleanVar(
- value=os.environ.get("LNBITS_ADMIN_UI", "true").lower() in ("true", "1", "yes")
+ value=defaults_env.get("LNBITS_ADMIN_UI", "true").lower()
+ in ("true", "1", "yes")
)
ttk.Checkbutton(frame, text="AUTH_HTTPS_ONLY", variable=https).grid(
row=7, columnspan=3, sticky="w"
@@ -350,7 +404,18 @@ def browse():
def load_funding(*_):
try:
- profile = load_profile(fields["LNBITS_DATA_FOLDER"].get())
+ folder = fields["LNBITS_DATA_FOLDER"].get()
+ profile = load_profile(folder)
+ if (
+ saved.get("LNBITS_DATA_FOLDER")
+ == str(Path(folder).expanduser().resolve())
+ and saved.get("LNBITS_DESKTOP_FUNDING") in funding_choices.values()
+ ):
+ profile = {
+ **profile,
+ "provider": saved["LNBITS_DESKTOP_FUNDING"],
+ "port": saved.get("LNBITS_DESKTOP_FUNDING_PORT", "8765"),
+ }
label = next(
(
label
@@ -454,6 +519,14 @@ def start():
funding_port.get(),
accepted,
)
+ if not smoke:
+ try:
+ save_launcher_settings(env)
+ except OSError as exc:
+ raise ValueError(
+ "Cannot save launcher settings. Check write permissions for "
+ f"{default_folder()}."
+ ) from exc
server = Server(env)
server.start()
except (ValueError, OSError) as exc:
### .github/packaging/funding.py
@@ -12,6 +12,7 @@
import time
import urllib.error
import urllib.request
+from contextlib import asynccontextmanager
from pathlib import Path
from embit.bip39 import mnemonic_from_bytes, mnemonic_is_valid
@@ -30,7 +31,15 @@ def load_profile(folder):
if not path.exists():
return {}
profile = json.loads(path.read_text())
- if not isinstance(profile, dict) or profile.get("provider") not in PROVIDERS:
+ if (
+ not isinstance(profile, dict)
+ or profile.get("provider") not in PROVIDERS
+ or not isinstance(profile.get("initialized_providers", []), list)
+ or any(
+ not isinstance(provider, str) or provider not in PROVIDERS
+ for provider in profile.get("initialized_providers", [])
+ )
+ ):
raise ValueError(
"The funding profile is invalid. Restore your data folder backup."
)
@@ -84,6 +93,86 @@ def protect_settings(environment):
readonly_variables.append(name)
+def configure_app(app, environment):
+ """Sync managed funding after core startup, before accepting requests."""
+ if environment.get("LNBITS_DESKTOP_FUNDING") not in PROVIDERS:
+ return
+ original_lifespan = app.router.lifespan_context
+
+ @asynccontextmanager
+ async def lifespan(application):
+ error = None
+ async with original_lifespan(application) as state:
+ try:
+ await sync_settings(environment)
+ except Exception as exc:
+ # Let core finish its normal shutdown before failing startup.
+ error = exc
+ else:
+ yield state
+ if error is not None:
+ raise error
+
+ app.router.lifespan_context = lifespan
+
+
+async def sync_settings(environment):
+ """Persist only this launcher's configuration; never generate or write seeds."""
+ provider = environment.get("LNBITS_DESKTOP_FUNDING")
+ if provider not in PROVIDERS:
+ return
+
+ from lnbits.core.crud.settings import get_settings_field, set_settings_field
+ from lnbits.settings import FundingSourcesSettings, settings
+
+ if not settings.lnbits_admin_ui:
+ return
+ prefix = "SPARK_L2_" if provider == "spark" else "PHOENIXD_"
+ values = {
+ key.lower(): value
+ for key, value in environment.items()
+ if key.startswith(prefix) and key.lower() in FundingSourcesSettings.model_fields
+ }
+ seed_field = prefix.lower() + "mnemonic"
+ seed = values.get(seed_field)
+ seed_file = (
+ Path(environment["LNBITS_DATA_FOLDER"]) / "funding" / provider / "seed.dat"
+ )
+ try:
+ saved_seed = seed_file.read_text().strip()
+ except OSError:
+ raise ValueError(
+ "Cannot read the bundled funding seed. Restore your backup."
+ ) from None
+ if (
+ not seed
+ or not mnemonic_is_valid(seed)
+ or seed != saved_seed
+ or environment.get("LNBITS_BACKEND_WALLET_CLASS") != PROVIDERS[provider]
+ ):
+ raise ValueError(
+ "Bundled funding configuration does not match its saved wallet."
+ )
+
+ try:
+ previous = await get_settings_field(seed_field)
+ if previous is None or previous.value != seed:
+ # Clear acknowledgement before changing the saved seed, so even an
+ # interrupted save cannot confirm a different wallet's backup.
+ confirmed_field = seed_field + "_backup_confirmed"
+ await set_settings_field(confirmed_field, False)
+ setattr(settings, confirmed_field, False)
+ for field, value in values.items():
+ await set_settings_field(field, value)
+ # Select the backend only after all its connection settings are saved.
+ await set_settings_field("lnbits_backend_wallet_class", PROVIDERS[provider])
+ except Exception:
+ # Database exceptions can contain bound credentials; do not log them.
+ raise RuntimeError(
+ "Cannot save bundled funding settings. Startup stopped."
+ ) from None
+
+
class Funding:
def __init__(self, environment):
self.environment = environment
@@ -129,15 +218,6 @@ def start(self):
fcntl.flock(self.lock.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
profile = load_profile(self.folder.parent)
- if not profile and (self.folder.parent / "database.sqlite3").exists():
- raise ValueError(
- "Choose a new data folder for bundled funding. Existing balances "
- "cannot be moved to a new funding wallet."
- )
- if profile and profile.get("provider") != self.provider:
- raise ValueError(
- "Choose a separate data folder to use a different funding wallet."
- )
if self.provider == "phoenixd" and not (
profile.get("phoenix_terms")
or self.environment.get("LNBITS_DESKTOP_PHOENIX_TERMS") == "true"
@@ -151,7 +231,11 @@ def start(self):
raise
def _start(self, resources, node, profile):
+ initialized = set(profile.get("initialized_providers", []))
+ if profile.get("provider"):
+ initialized.add(profile["provider"])
data = self.folder / self.provider
+ existing_data = data.exists()
data.mkdir(mode=0o700, exist_ok=True)
seed_file = data / "seed.dat"
if seed_file.exists():
@@ -161,7 +245,7 @@ def _start(self, resources, node, profile):
"The saved funding seed is invalid. Restore your backup; "
"it will not be replaced."
)
- elif profile:
+ elif self.provider in initialized or existing_data:
raise ValueError(
"The funding seed is missing. Restore your backup; "
"a replacement wallet will not be created."
@@ -171,7 +255,12 @@ def _start(self, resources, node, profile):
secrets.token_bytes(32 if self.provider == "spark" else 16)
)
save_private(seed_file, mnemonic + "\n")
- profile.update(provider=self.provider, port=self.port)
+ initialized.add(self.provider)
+ profile.update(
+ provider=self.provider,
+ port=self.port,
+ initialized_providers=sorted(initialized),
+ )
if self.provider == "phoenixd":
profile["phoenix_terms"] = True
save_private(self.folder / "profile.json", json.dumps(profile))
### .github/packaging/macos/Read me unsigned.txt
@@ -19,9 +19,9 @@ by default in ~/Library/Application Support/LNbits. The launcher lets you
choose another data folder. Keep that folder backed up.
Bundled funding
-Choose Spark L2, Phoenixd or Neither in the launcher. First setup of a bundled
-funding source requires a new data folder. The app starts the selected daemon
-and configures LNbits automatically. The funding seed persists in
+Choose Spark L2, Phoenixd or Neither in the launcher. You can switch providers
+using the same LNbits data folder. Switching back reuses the provider's saved
+wallet. The app starts the selected daemon and configures LNbits automatically. The funding seed persists in
funding/spark/seed.dat (24 words) or funding/phoenixd/seed.dat (12 words).
Back up the entire data folder and keep a private offline seed backup.
Never run another Phoenix instance with the same seed. Phoenixd first setup
### .github/packaging/macos/Read me.txt
@@ -19,9 +19,9 @@ by default in ~/Library/Application Support/LNbits. The launcher lets you
choose another data folder. Keep that folder backed up.
Bundled funding
-Choose Spark L2, Phoenixd or Neither in the launcher. First setup of a bundled
-funding source requires a new data folder. The app starts the selected daemon
-and configures LNbits automatically. The funding seed persists in
+Choose Spark L2, Phoenixd or Neither in the launcher. You can switch providers
+using the same LNbits data folder. Switching back reuses the provider's saved
+wallet. The app starts the selected daemon and configures LNbits automatically. The funding seed persists in
funding/spark/seed.dat (24 words) or funding/phoenixd/seed.dat (12 words).
Back up the entire data folder and keep a private offline seed backup.
Never run another Phoenix instance with the same seed. Phoenixd first setup
### .github/packaging/sidecars/pins.json
@@ -1,8 +1,8 @@
{
"spark": {
- "release": "v0.1.5",
- "revision": "dbfed1fd9cb72f0a589d7479022f2cbb209b5924",
- "sha256": "e6720e4a5ad2ee7746403ab766ccbb6d97ae5dd3d0f9f364f7c56064b9583730"
+ "release": "v0.1.6",
+ "revision": "d83aef342fe520e2eff85aa5ac31aaf5d6e8df6f",
+ "sha256": "599859a7e56683456dd675500f9d119c0c4c23b7c45a98cc47b9f4f69122a7a8"
},
"phoenixd": {
"version": "0.9.0",
### .github/packaging/test_build.py
@@ -59,6 +59,8 @@ def test_only_macos_uses_the_native_embit_hook(self):
"--additional-hooks-dir" in command, system == "darwin"
)
self.assertIn("--hidden-import=embit", command)
+ self.assertIn("--hidden-import=_wallycore", command)
+ self.assertIn("--collect-binaries=nostr_sdk", command)
def check_bindings(self, imports, error):
bindepend = Mock()
### .github/packaging/test_desktop.py
@@ -314,6 +314,7 @@ def interact():
)
with (
patch.dict(os.environ, environment),
+ patch("desktop.default_folder", return_value=Path(folder) / "defaults"),
patch("tkinter.Tk", return_value=root),
):
root.after(100, interact)
@@ -325,5 +326,69 @@ def interact():
self.assertNotEqual(probe.connect_ex(("127.0.0.1", port)), 0)
+class LauncherSettingsTests(unittest.TestCase):
+ def test_settings_restore_custom_folder_and_exclude_secrets(self):
+ with (
+ tempfile.TemporaryDirectory() as folder,
+ patch("desktop.default_folder", return_value=Path(folder) / "defaults"),
+ ):
+ values = desktop.configuration(
+ "127.0.0.1",
+ "5001",
+ str(Path(folder) / "chosen"),
+ True,
+ False,
+ "spark",
+ "8766",
+ )
+ values["SPARK_API_KEY"] = "not-a-real-key"
+ values["LNBITS_DESKTOP_PHOENIX_TERMS"] = "true"
+ desktop.save_launcher_settings(values)
+ restored = desktop.load_launcher_settings()
+ self.assertEqual(
+ restored, {key: values[key] for key in desktop.LAUNCHER_SETTINGS}
+ )
+ self.assertNotIn("SPARK_API_KEY", restored)
+ self.assertNotIn("LNBITS_DESKTOP_PHOENIX_TERMS", restored)
+ self.assertEqual(
+ restored["LNBITS_DATA_FOLDER"], str((Path(folder) / "chosen").resolve())
+ )
+ values["LNBITS_DESKTOP_FUNDING"] = "none"
+ desktop.save_launcher_settings(values)
+ self.assertEqual(
+ desktop.load_launcher_settings()["LNBITS_DESKTOP_FUNDING"], "none"
+ )
+
+ def test_missing_or_malformed_preferences_fall_back(self):
+ with (
+ tempfile.TemporaryDirectory() as folder,
+ patch("desktop.default_folder", return_value=Path(folder)),
+ ):
+ path = Path(folder) / "launcher.json"
+ self.assertEqual(desktop.load_launcher_settings(), {})
+ for contents in ("{", "[]", "null", '{"PORT": null}', '{"HOST": []}'):
+ with self.subTest(contents=contents):
+ path.write_text(contents)
+ self.assertEqual(desktop.load_launcher_settings(), {})
+
+ def test_loading_preferences_does_not_create_data_folder(self):
+ with (
+ tempfile.TemporaryDirectory() as folder,
+ patch("desktop.default_folder", return_value=Path(folder) / "defaults"),
+ ):
+ desktop.save_launcher_settings(
+ {
+ key: (
+ str(Path(folder) / "missing")
+ if key == "LNBITS_DATA_FOLDER"
+ else ""
+ )
+ for key in desktop.LAUNCHER_SETTINGS
+ }
+ )
+ desktop.load_launcher_settings()
+ self.assertFalse((Path(folder) / "missing").exists())
+
+
if __name__ == "__main__":
unittest.main()
### .github/packaging/test_funding.py
@@ -63,7 +63,7 @@ def test_identity_survives_restart_and_port_change(self):
if provider == "phoenixd" and sys.platform == "win32":
continue
with self.subTest(provider=provider):
- # Each backing wallet owns a separate LNbits data folder.
+ # Isolate each restart case from the previous case.
self.folder = self.folder / provider
self.folder.mkdir()
self.process.poll.return_value = None
@@ -104,13 +104,16 @@ def test_missing_or_invalid_seed_is_never_replaced(self):
self.start()
self.assertEqual(seed.read_text(), "damaged")
- def test_existing_balance_cannot_be_assigned_a_new_backing_wallet(self):
+ def test_existing_database_can_use_bundled_funding(self):
data = self.folder / "data"
data.mkdir()
- (data / "database.sqlite3").touch()
- with self.assertRaisesRegex(ValueError, "new data folder"):
- self.start()
- self.popen.assert_not_called()
+ database = data / "database.sqlite3"
+ database.write_bytes(b"existing database contents")
+ daemon = self.start()
+ self.assertEqual(
+ daemon.environment["LNBITS_BACKEND_WALLET_CLASS"], "SparkL2Wallet"
+ )
+ self.assertEqual(database.read_bytes(), b"existing database contents")
def test_one_owner_per_wallet(self):
daemon = self.start()
@@ -119,18 +122,71 @@ def test_one_owner_per_wallet(self):
daemon.close()
self.start().close()
- def test_provider_change_and_corrupt_profile_are_rejected(self):
+ @unittest.skipIf(
+ sys.platform == "win32", "Bundled Phoenixd is not available on Windows"
+ )
+ def test_switching_providers_reuses_seeds_and_preserves_database(self):
+ data = self.folder / "data"
+ data.mkdir()
+ database = data / "database.sqlite3"
+ database.write_bytes(b"existing database contents")
+ identities = {}
+ for provider in ("spark", "phoenixd", "spark", "phoenixd"):
+ self.process.poll.return_value = None
+ daemon = self.start(provider)
+ seed = daemon.folder / provider / "seed.dat"
+ if provider in identities:
+ self.assertEqual(seed.read_bytes(), identities[provider])
+ else:
+ identities[provider] = seed.read_bytes()
+ self.assertEqual(
+ daemon.environment["LNBITS_BACKEND_WALLET_CLASS"],
+ funding.PROVIDERS[provider],
+ )
+ self.assertEqual(database.read_bytes(), b"existing database contents")
+ daemon.close()
+ self.assertEqual(
+ set(funding.load_profile(data)["initialized_providers"]),
+ {"spark", "phoenixd"},
+ )
+ # Removing an inactive provider's whole directory must not create a new wallet.
+ seed = data / "funding/spark/seed.dat"
+ seed.unlink()
+ seed.parent.rmdir()
+ with self.assertRaisesRegex(ValueError, "seed is missing"):
+ self.start("spark")
+ self.assertFalse(seed.exists())
+
+ @unittest.skipIf(
+ sys.platform == "win32", "Bundled Phoenixd is not available on Windows"
+ )
+ def test_legacy_profile_remembers_old_provider_when_switching(self):
+ daemon = self.start("spark")
+ daemon.close()
+ profile = daemon.folder / "profile.json"
+ values = json.loads(profile.read_text())
+ values.pop("initialized_providers")
+ profile.write_text(json.dumps(values))
+ self.process.poll.return_value = None
+ self.start("phoenixd").close()
+ self.assertEqual(
+ set(funding.load_profile(daemon.folder.parent)["initialized_providers"]),
+ {"spark", "phoenixd"},
+ )
+
+ def test_corrupt_profile_is_rejected(self):
daemon = self.start()
daemon.close()
profile = daemon.folder / "profile.json"
- data = json.loads(profile.read_text())
- data["provider"] = "phoenixd"
- profile.write_text(json.dumps(data))
- with self.assertRaisesRegex(ValueError, "separate data folder"):
- self.start()
- profile.write_text("[]")
- with self.assertRaisesRegex(ValueError, "profile is invalid"):
- self.start()
+ for contents in (
+ "[]",
+ '{"provider":"spark","initialized_providers":null}',
+ '{"provider":"spark","initialized_providers":[{}]}',
+ ):
+ with self.subTest(contents=contents):
+ profile.write_text(contents)
+ with self.assertRaisesRegex(ValueError, "profile is invalid"):
+ self.start()
def test_local_only_authenticated_configuration(self):
daemon = self.start()
### .github/packaging/test_funding_settings.py
@@ -0,0 +1,258 @@
+"""Desktop funding persistence uses temporary SQLite and deterministic test seeds."""
+
+import traceback
+import unittest
+from contextlib import asynccontextmanager
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from types import SimpleNamespace
+from unittest.mock import AsyncMock, Mock, patch
+
+import desktop
+import funding
+from embit.bip39 import mnemonic_from_bytes
+
+
+class FundingSettingsTests(unittest.IsolatedAsyncioTestCase):
+ async def asyncSetUp(self):
+ from lnbits.core.crud import settings as crud
+ from lnbits.db import Database
+ from lnbits.settings import settings
+
+ self.crud = crud
+ self.settings = settings
+ temporary = self.enterContext(TemporaryDirectory())
+ self.folder = Path(temporary)
+ self.enterContext(patch.object(settings, "lnbits_data_folder", temporary))
+ self.enterContext(patch.object(settings, "lnbits_database_url", None))
+ self.enterContext(patch.object(settings, "lnbits_admin_ui", True))
+ for field in (
+ "spark_l2_mnemonic_backup_confirmed",
+ "phoenixd_mnemonic_backup_confirmed",
+ ):
+ self.enterContext(patch.object(settings, field, True))
+ self.database = Database("funding-sync-test")
+ self.enterContext(patch.object(crud, "db", self.database))
+ await self.database.execute(
+ "CREATE TABLE system_settings "
+ "(id TEXT, value TEXT, tag TEXT, UNIQUE(id, tag))"
+ )
+ await crud.set_settings_field("super_user", "test-superuser")
+ await crud.set_settings_field("lnbits_site_title", "Preserved title")
+ self.seeds = {}
+ for provider, size in (("spark", 32), ("phoenixd", 16)):
+ seed = mnemonic_from_bytes(bytes(range(size)))
+ path = self.folder / "funding" / provider / "seed.dat"
+ path.parent.mkdir(parents=True)
+ path.write_text(seed + "\n")
+ self.seeds[provider] = seed
+ # Synchronizing must never invoke the launcher's seed generation/writer.
+ self.enterContext(
+ patch("funding.secrets.token_bytes", side_effect=AssertionError)
+ )
+ self.enterContext(patch("funding.save_private", side_effect=AssertionError))
+
+ async def asyncTearDown(self):
+ await self.database.engine.dispose()
+
+ def environment(self, provider):
+ values = {
+ "LNBITS_DESKTOP_FUNDING": provider,
+ "LNBITS_DATA_FOLDER": str(self.folder),
+ "LNBITS_BACKEND_WALLET_CLASS": funding.PROVIDERS[provider],
+ "LNBITS_SITE_TITLE": "Must not overwrite unrelated settings",
+ }
+ if provider == "spark":
+ values.update(
+ SPARK_L2_EXTERNAL_ENDPOINT="http://127.0.0.1:8765",
+ SPARK_L2_EXTERNAL_API_KEY="synthetic-spark-key",
+ SPARK_L2_MNEMONIC=self.seeds[provider],
+ SPARK_L2_NETWORK="MAINNET",
+ PHOENIXD_MNEMONIC="must-not-touch-inactive-provider",
+ )
+ else:
+ values.update(
+ PHOENIXD_API_ENDPOINT="http://127.0.0.1:9740",
+ PHOENIXD_API_PASSWORD="synthetic-phoenix-password",
+ PHOENIXD_DATA_DIR=str(self.folder / "funding/phoenixd"),
+ PHOENIXD_MNEMONIC=self.seeds[provider],
+ SPARK_L2_MNEMONIC="must-not-touch-inactive-provider",
+ )
+ return values
+
+ async def test_switching_and_restarting_preserve_both_wallets(self):
+ confirmed = set()
+ for provider in ("spark", "spark", "phoenixd", "phoenixd", "spark", "phoenixd"):
+ with self.subTest(provider=provider, confirmed=sorted(confirmed)):
+ before = await self.crud.get_settings_by_tag("core")
+ prefix = "spark_l2_" if provider == "spark" else "phoenixd_"
+ inactive = "phoenixd_" if provider == "spark" else "spark_l2_"
+ env = self.environment(provider)
+ # Connection credentials may change on every launch.
+ key = (
+ "SPARK_L2_EXTERNAL_API_KEY"
+ if provider == "spark"
+ else "PHOENIXD_API_PASSWORD"
+ )
+ env[key] += str(len(confirmed))
+ await funding.sync_settings(env)
+ view = await self.crud.get_admin_settings(True)
+ self.assertEqual(
+ view.lnbits_backend_wallet_class, funding.PROVIDERS[provider]
+ )
+ self.assertEqual(
+ getattr(view, prefix + "mnemonic"), self.seeds[provider]
+ )
+ self.assertEqual(getattr(view, key.lower()), env[key])
+ self.assertEqual(
+ getattr(view, prefix + "mnemonic_backup_confirmed"),
+ provider in confirmed,
+ )
+ after = await self.crud.get_settings_by_tag("core")
+ self.assertEqual(
+ {k: v for k, v in before.items() if k.startswith(inactive)},
+ {k: v for k, v in after.items() if k.startswith(inactive)},
+ )
+ self.assertEqual(after["lnbits_site_title"], "Preserved title")
+ for name, seed in self.seeds.items():
+ self.assertEqual(
+ (self.folder / "funding" / name / "seed.dat").read_text(),
+ seed + "\n",
+ )
+ await self.crud.set_settings_field(
+ prefix + "mnemonic_backup_confirmed", True
+ )
+ confirmed.add(provider)
+
+ async def test_different_saved_seed_requires_backup_again(self):
+ for provider, prefix in (("spark", "spark_l2"), ("phoenixd", "phoenixd")):
+ with self.subTest(provider=provider):
+ await self.crud.set_settings_field(
+ prefix + "_mnemonic", "synthetic-old-seed"
+ )
+ await self.crud.set_settings_field(
+ prefix + "_mnemonic_backup_confirmed", True
+ )
+ await funding.sync_settings(self.environment(provider))
+ view = await self.crud.get_admin_settings(True)
+ self.assertFalse(getattr(view, prefix + "_mnemonic_backup_confirmed"))
+ self.assertFalse(
+ getattr(self.settings, prefix + "_mnemonic_backup_confirmed")
+ )
+ self.assertEqual(
+ getattr(view, prefix + "_mnemonic"), self.seeds[provider]
+ )
+
+ async def test_missing_invalid_or_mismatched_seed_stops_without_writes(self):
+ path = self.folder / "funding/spark/seed.dat"
+ for contents in (None, "invalid", self.seeds["phoenixd"]):
+ with self.subTest(contents=contents):
+ if contents is None:
+ path.unlink()
+ else:
+ path.write_text(contents)
+ before = await self.crud.get_settings_by_tag("core")
+ with self.assertRaises(ValueError):
+ await funding.sync_settings(self.environment("spark"))
+ self.assertEqual(await self.crud.get_settings_by_tag("core"), before)
+ if contents is None:
+ self.assertFalse(path.exists())
+ else:
+ self.assertEqual(path.read_text(), contents)
+
+ async def test_database_failure_is_sanitized_and_does_not_select_new_backend(self):
+ await self.crud.set_settings_field(
+ "lnbits_backend_wallet_class", "PhoenixdWallet"
+ )
+ await self.crud.set_settings_field("spark_l2_mnemonic", "old-seed")
+ await self.crud.set_settings_field("spark_l2_mnemonic_backup_confirmed", True)
+ original = self.crud.set_settings_field
+
+ async def fail_seed(field, value, *args):
+ if field == "spark_l2_mnemonic":
+ raise RuntimeError("database parameters: synthetic-sensitive-value")
+ return await original(field, value, *args)
+
+ with patch.object(self.crud, "set_settings_field", side_effect=fail_seed):
+ try:
+ await funding.sync_settings(self.environment("spark"))
+ except RuntimeError as exc:
+ self.assertIn("Startup stopped", str(exc))
+ self.assertNotIn("synthetic-sensitive-value", traceback.format_exc())
+ else:
+ self.fail("A failed settings write must stop startup")
+ saved = await self.crud.get_settings_by_tag("core")
+ self.assertEqual(saved["lnbits_backend_wallet_class"], "PhoenixdWallet")
+ self.assertEqual(saved["spark_l2_mnemonic"], "old-seed")
+ self.assertFalse(saved["spark_l2_mnemonic_backup_confirmed"])
+ # Retrying a partial save completes using the same seed file.
+ await funding.sync_settings(self.environment("spark"))
+ saved = await self.crud.get_settings_by_tag("core")
+ self.assertEqual(saved["spark_l2_mnemonic"], self.seeds["spark"])
+ self.assertEqual(saved["lnbits_backend_wallet_class"], "SparkL2Wallet")
+
+ async def test_unmanaged_and_admin_ui_disabled_do_not_write_settings(self):
+ before = await self.crud.get_settings_by_tag("core")
+ with patch.object(
+ self.crud, "set_settings_field", new_callable=AsyncMock
+ ) as write:
+ for env in ({}, {"LNBITS_DESKTOP_FUNDING": "none"}):
+ await funding.sync_settings(env)
+ with patch.object(self.settings, "lnbits_admin_ui", False):
+ await funding.sync_settings(self.environment("spark"))
+ write.assert_not_awaited()
+ self.assertEqual(await self.crud.get_settings_by_tag("core"), before)
+
+
+class FundingLifespanTests(unittest.IsolatedAsyncioTestCase):
+ async def test_sync_happens_after_core_startup_and_before_serving(self):
+ for fail in (False, True):
+ with self.subTest(fail=fail):
+ events = []
+
+ @asynccontextmanager
+ async def original(app, events=events):
+ events.append("core-startup")
+ yield {"state": "preserved"}
+ # Match core's existing normal-exit shutdown semantics.
+ events.append("core-shutdown")
+
+ async def sync(env, events=events, fail=fail):
+ self.assertEqual(events, ["core-startup"])
+ events.append("sync")
+ if fail:
+ raise RuntimeError("Cannot save bundled funding settings")
+
+ app = SimpleNamespace(router=SimpleNamespace(lifespan_context=original))
+ with patch("funding.sync_settings", side_effect=sync):
+ funding.configure_app(app, {"LNBITS_DESKTOP_FUNDING": "spark"})
+ try:
+ async with app.router.lifespan_context(app) as state:
+ self.assertEqual(state, {"state": "preserved"})
+ events.append("serving")
+ except RuntimeError:
+ self.assertTrue(fail)
+ expected = ["core-startup", "sync"]
+ if not fail:
+ expected.append("serving")
+ self.assertEqual(events, [*expected, "core-shutdown"])
+
+ async def test_unmanaged_lifespan_is_untouched(self):
+ original = Mock()
+ app = SimpleNamespace(router=SimpleNamespace(lifespan_context=original))
+ for env in ({}, {"LNBITS_DESKTOP_FUNDING": "none"}):
+ funding.configure_app(app, env)
+ self.assertIs(app.router.lifespan_context, original)
+
+ async def test_desktop_factory_wraps_only_its_own_app(self):
+ from lnbits import app as core_app
+
+ instance = Mock()
+ environment = {"LNBITS_DESKTOP_FUNDING": "spark"}
+ with (
+ patch.object(core_app, "create_app", return_value=instance) as create,
+ patch("desktop.configure_app") as configure,
+ ):
+ self.assertIs(desktop.create_desktop_app(environment), instance)
+ create.assert_called_once_with()
+ configure.assert_called_once_with(instance, environment)
### .github/workflows/macos.yml
@@ -70,6 +70,14 @@ jobs:
run: python3 .github/packaging/macos/release.py --prepare-only
- name: Test launcher and packaging
run: uv run --no-sync python -m unittest discover -s .github/packaging -v
+ # Intel runners can lose HTTP/3 connections to Apple's ticket service.
+ # Keep HTTPS on TCP for this disposable runner; retain stapling/validation.
+ # https://github.com/actions/runner-images/issues/14924
+ - name: Work around Intel runner notarization connectivity
+ if: matrix.runner == 'macos-15-intel'
+ run: |
+ echo 'block return out quick proto udp from any to any port 443' | sudo /sbin/pfctl -f -
+ sudo /sbin/pfctl -E
- name: Build signed and notarized release artifacts
env:
BUILD_CERTIFICATE_BASE64: ${{ secrets.BUILD_CERTIFICATE_BASE64 }}
### lnbits/core/crud/settings.py
@@ -33,18 +33,23 @@ async def get_super_settings() -> SuperSettings | None:
async def get_admin_settings(is_super_user: bool = False) -> AdminSettings | None:
+ """Build role-filtered settings; serialize with exclude_unset=True."""
sets = await get_super_settings()
if not sets:
return None
row_dict = dict(sets)
row_dict.pop("super_user")
row_dict.pop("auth_all_methods")
- admin_settings = AdminSettings(
- is_super_user=is_super_user,
- lnbits_allowed_funding_sources=settings.lnbits_allowed_funding_sources,
- **row_dict,
- )
+ if is_super_user:
+ row_dict["lnbits_allowed_funding_sources"] = (
+ settings.lnbits_allowed_funding_sources
+ )
+ else:
+ for field in FundingSourcesSettings.model_fields:
+ row_dict.pop(field, None)
+
+ admin_settings = AdminSettings(is_super_user=is_super_user, **row_dict)
return admin_settings
### lnbits/core/views/admin_api.py
@@ -2,6 +2,7 @@
import json
import os
import time
+from collections.abc import Iterable
from http import HTTPStatus
from pathlib import Path
from shutil import make_archive
@@ -39,12 +40,19 @@
)
from lnbits.decorators import access_token_payload, check_admin, check_super_user
from lnbits.server import server_restart
-from lnbits.settings import AdminSettings, Settings, UpdateSettings, settings
+from lnbits.settings import (
+ AdminSettings,
+ FundingSourcesSettings,
+ Settings,
+ UpdateSettings,
+ settings,
+)
from lnbits.task_manager import PublicTask, task_manager
from .. import core_app_extra
from ..crud import (
get_admin_settings,
+ get_super_settings,
get_total_balance,
reset_core_settings,
update_admin_settings,
@@ -108,12 +116,13 @@ async def api_test_email():
)
-@admin_router.get("/api/v1/settings")
+@admin_router.get("/api/v1/settings", response_model_exclude_unset=True)
async def api_get_settings(
+ response: Response,
account: Account = Depends(check_admin),
) -> AdminSettings | None:
- admin_settings = await get_admin_settings(account.is_super_user)
- return admin_settings
+ response.headers["Cache-Control"] = "no-store"
+ return await get_admin_settings(account.is_super_user)
@admin_router.put(
@@ -125,6 +134,7 @@ async def api_update_settings(
account: Account = Depends(check_admin),
payload: AccessTokenPayload = Depends(access_token_payload),
):
+ _check_funding_settings_access(data.model_fields_set, account)
policy_changed = await validate_two_factor_policy(data, account.id, payload)
if "lnbits_allow_onchain_payments" in data.model_fields_set:
enabled = data.lnbits_allow_onchain_payments
@@ -147,10 +157,13 @@ async def api_update_settings(
NotificationType.settings_update, {"username": account.username}
)
await update_admin_settings(data)
- admin_settings = await get_admin_settings(account.is_super_user)
- if not admin_settings:
+ # Reload the complete stored configuration, not the caller's filtered view.
+ stored_settings = await get_super_settings()
+ if not stored_settings:
raise ValueError("Updated admin settings not found.")
- update_cached_settings(admin_settings.model_dump())
+ update_cached_settings(
+ stored_settings.model_dump(exclude={"super_user", "auth_all_methods"})
+ )
core_app_extra.register_new_ratelimiter()
if policy_changed:
from lnbits.core.views.auth_api import _auth_success_response
@@ -246,16 +259,29 @@ async def api_update_settings_partial(
account: Account = Depends(check_admin),
payload: AccessTokenPayload = Depends(access_token_payload),
):
- updatable_settings = dict_to_settings({**settings.model_dump(), **data})
+ _check_funding_settings_access(data, account)
+ current_settings = settings.model_dump(
+ exclude=(
+ set(FundingSourcesSettings.model_fields)
+ if not account.is_super_user
+ else set()
+ )
+ )
+ updatable_settings = dict_to_settings({**current_settings, **data})
return await api_update_settings(updatable_settings, account, payload)
@admin_router.get(
"/api/v1/settings/default",
status_code=HTTPStatus.OK,
- dependencies=[Depends(check_admin)],
)
-async def api_reset_settings(field_name: str):
+async def api_reset_settings(
+ field_name: str,
+ response: Response,
+ account: Account = Depends(check_admin),
+):
+ _check_funding_settings_access({field_name}, account)
+ response.headers["Cache-Control"] = "no-store"
if field_name not in UpdateSettings.model_fields:
raise HTTPException(
HTTPStatus.FORBIDDEN, "Only editable settings have public defaults."
@@ -367,3 +393,13 @@ def _build_pg_dump_env(database_url: str) -> dict[str, str]:
if value is not None:
env[variable] = ",".join(value) if isinstance(value, tuple) else str(value)
return env
+
+
+def _check_funding_settings_access(fields: Iterable[str], account: Account) -> None:
+ if not account.is_super_user and set(fields).intersection(
+ FundingSourcesSettings.model_fields
+ ):
+ raise HTTPException(
+ HTTPStatus.FORBIDDEN,
+ "Only the super user can access funding source settings.",
+ )
### lnbits/templates/components/admin/funding.vue
@@ -11,6 +11,7 @@
</p>
<ul>
<li
+ v-if="isSuperUser"
v-text="
$t('funding_source', {
wallet_class: settings.lnbits_backend_wallet_class
@@ -180,7 +181,7 @@
>
</q-input>
</div>
- <div class="col-12 col-md-6">
+ <div v-if="isSuperUser" class="col-12 col-md-6">
<p>
<span v-text="$t('payment_wait_time') + ' (BOLT11)'"></span>
<sup>
@@ -202,7 +203,7 @@
min="0"
></q-input>
</div>
- <div class="col-12 col-md-6">
+ <div v-if="isSuperUser" class="col-12 col-md-6">
<p>
<span v-text="$t('payment_wait_time') + ' (BOLT12)'"></span>
</p>
@@ -220,7 +221,7 @@
min="0"
></q-input>
</div>
- <div class="col-12 col-md-6">
+ <div v-if="isSuperUser" class="col-12 col-md-6">
<p>
<span v-text="$t('payment_pending_interval')"></span>
<sup>
### pyproject.toml
@@ -1,6 +1,6 @@
[project]
name = "lnbits"
-version = "1.7.0-rc2"
+version = "1.7.0-rc4"
requires-python = ">=3.10,<3.14"
description = "LNbits, free and open-source Lightning wallet and accounts system."
authors = [{ name = "Alan Bits", email = "alan@lnbits.com" }]
### tests/unit/test_funding_settings_permissions.py
@@ -0,0 +1,232 @@
+"""Funding settings authorization, with real routes/CRUD and synthetic storage."""
+
+import asyncio
+from unittest.mock import AsyncMock, Mock
+
+import pytest
+from fastapi import FastAPI, HTTPException
+from httpx import ASGITransport, AsyncClient
+
+from lnbits.core.crud import settings as settings_crud
+from lnbits.core.models.users import AccessTokenPayload, Account
+from lnbits.core.views import admin_api
+from lnbits.decorators import access_token_payload, check_account_exists
+from lnbits.settings import (
+ FundingSourcesSettings,
+ SuperSettings,
+ UpdateSettings,
+ settings,
+)
+
+FUNDING_DEFAULTS = FundingSourcesSettings().model_dump()
+
+
+@pytest.fixture
+def funding_api(monkeypatch):
+ monkeypatch.setattr(settings, "super_user", "super")
+ monkeypatch.setattr(settings, "lnbits_admin_users", ["admin"])
+ monkeypatch.setattr(settings, "lnbits_allow_onchain_payments", False)
+ stored = UpdateSettings(
+ lnbits_backend_wallet_class="LndRestWallet",
+ lnd_rest_macaroon="synthetic-macaroon",
+ spark_l2_mnemonic="synthetic-spark-seed",
+ phoenixd_mnemonic="synthetic-phoenix-seed",
+ lnbits_site_title="Original title",
+ ).model_dump()
+ state = {"role": "admin", "stored": stored}
+
+ async def read_super_settings():
+ return SuperSettings(super_user="super", **stored)
+
+ async def read_tag(_tag):
+ return dict(stored)
+
+ async def write_field(key, value, _tag=None):
+ stored[key] = value
+
+ async def account():
+ if state["role"] == "anonymous":
+ raise HTTPException(401, "Authentication required")
+ return Account(
+ id=state["role"], username=state["role"], password_hash="synthetic-hash"
+ )
+
+ app = FastAPI()
+ app.include_router(admin_api.admin_router)
+ # Exercise the actual admin permission check; stub only authentication lookup.
+ app.dependency_overrides[check_account_exists] = account
+ app.dependency_overrides[access_token_payload] = lambda: AccessTokenPayload(
+ sub=state["role"], usr=state["role"]
+ )
+ monkeypatch.setattr(settings_crud, "get_super_settings", read_super_settings)
+ monkeypatch.setattr(admin_api, "get_super_settings", read_super_settings)
+ monkeypatch.setattr(settings_crud, "get_settings_by_tag", read_tag)
+ writer = AsyncMock(side_effect=write_field)
+ monkeypatch.setattr(settings_crud, "set_settings_field", writer)
+ monkeypatch.setattr(
+ admin_api, "validate_two_factor_policy", AsyncMock(return_value=False)
+ )
+ monkeypatch.setattr(admin_api, "enqueue_admin_notification", Mock())
+ monkeypatch.setattr(
+ admin_api.core_app_extra, "register_new_ratelimiter", Mock(), raising=False
+ )
+ cache = Mock()
+ monkeypatch.setattr(admin_api, "update_cached_settings", cache)
+ # Defaults can contain environment credentials. Never read real .env secrets.
+ defaults = Mock(return_value=UpdateSettings(**stored))
+ monkeypatch.setattr(admin_api, "Settings", defaults)
+ state.update(writer=writer, cache=cache, defaults=defaults)
+ return app, state
+
+
+def request(app, method, path="/admin/api/v1/settings", **kwargs):
+ async def run():
+ async with AsyncClient(
+ transport=ASGITransport(app), base_url="http://test"
+ ) as client:
+ return await client.request(method, path, **kwargs)
+
+ return asyncio.run(run())
+
+
+@pytest.mark.parametrize(
+ "role,status", [("admin", 200), ("super", 200), ("user", 403), ("anonymous", 401)]
+)
+def test_funding_settings_read_access(funding_api, role, status):
+ app, state = funding_api
+ state["role"] = role
+ response = request(app, "GET")
+ assert response.status_code == status
+ if status == 200:
+ assert response.headers["cache-control"] == "no-store"
+ data = response.json()
+ assert data["lnbits_site_title"] == "Original title"
+ for field in FundingSourcesSettings.model_fields:
+ assert (field in data) is (role == "super")
+ if role == "super":
+ assert data["lnd_rest_macaroon"] == "synthetic-macaroon"
+ if role != "super":
+ assert "synthetic-" not in response.text
+ state["writer"].assert_not_awaited()
+
+
+@pytest.mark.parametrize("field", FUNDING_DEFAULTS)
+@pytest.mark.parametrize("method", ["PUT", "PATCH"])
+def test_admin_cannot_write_any_funding_field(funding_api, field, method):
+ app, state = funding_api
+ before = dict(state["stored"])
+ response = request(app, method, json={field: FUNDING_DEFAULTS[field]})
+ assert response.status_code == 403
+ assert state["stored"] == before
+ state["writer"].assert_not_awaited()
+ state["cache"].assert_not_called()
+
+
+@pytest.mark.parametrize("field", FUNDING_DEFAULTS)
+def test_admin_cannot_read_any_funding_default(funding_api, field):
+ app, state = funding_api
+ response = request(
+ app, "GET", "/admin/api/v1/settings/default", params={"field_name": field}
+ )
+ assert response.status_code == 403
+ state["defaults"].assert_not_called()
+
+
+@pytest.mark.parametrize("method", ["PUT", "PATCH"])
+def test_superuser_can_update_all_funding_fields(funding_api, method):
+ app, state = funding_api
+ state["role"] = "super"
+ values = {**FUNDING_DEFAULTS, "lnd_rest_macaroon": "synthetic-new-macaroon"}
+ response = request(app, method, json=values)
+ assert response.status_code == 200, response.text
+ for key, value in values.items():
+ assert state["stored"][key] == value
+ response = request(app, "GET")
+ assert response.json()["lnd_rest_macaroon"] == "synthetic-new-macaroon"
+
+
+@pytest.mark.parametrize("method", ["PUT", "PATCH"])
+def test_admin_unrelated_save_preserves_all_funding_settings(funding_api, method):
+ app, state = funding_api
+ before = {key: state["stored"][key] for key in FUNDING_DEFAULTS}
+ if method == "PUT":
+ # Match the admin page: it saves the settings it received, minus metadata.
+ data = request(app, "GET").json()
+ for key in ("is_super_user", "lnbits_allowed_funding_sources", "touch"):
+ data.pop(key, None)
+ else:
+ data = {}
+ data["lnbits_site_title"] = "New title"
+ response = request(app, method, json=data)
+ assert response.status_code == 200, response.text
+ assert state["stored"]["lnbits_site_title"] == "New title"
+ for key, value in before.items():
+ assert state["stored"][key] == value
+ assert state["cache"].call_args.args[0][key] == value
+
+
+def test_default_permissions(funding_api):
+ app, state = funding_api
+ response = request(
+ app,
+ "GET",
+ "/admin/api/v1/settings/default",
+ params={"field_name": "lnbits_site_title"},
+ )
+ assert response.status_code == 200
+ assert response.json()["default_value"] == "Original title"
+ state["role"] = "super"
+ response = request(
+ app,
+ "GET",
+ "/admin/api/v1/settings/default",
+ params={"field_name": "lnd_rest_macaroon"},
+ )
+ assert response.status_code == 200
+ assert response.json()["default_value"] == "synthetic-macaroon"
+ assert response.headers["cache-control"] == "no-store"
+
+
+@pytest.mark.parametrize("role", ["user", "anonymous"])
+@pytest.mark.parametrize("method", ["PUT", "PATCH"])
+def test_non_admin_cannot_update_settings(funding_api, role, method):
+ app, state = funding_api
+ state["role"] = role
+ response = request(app, method, json={"lnbits_site_title": "Changed"})
+ assert response.status_code in (401, 403)
+ state["writer"].assert_not_awaited()
+
+
+@pytest.mark.parametrize("is_super_user", [False, True])
+def test_crud_filters_funding_settings_by_role(funding_api, is_super_user):
+ _, state = funding_api
+ before = dict(state["stored"])
+ result = asyncio.run(settings_crud.get_admin_settings(is_super_user))
+ assert result is not None
+ data = result.model_dump(exclude_unset=True)
+ assert data["is_super_user"] is is_super_user
+ assert data["lnbits_site_title"] == "Original title"
+ for field in FundingSourcesSettings.model_fields:
+ assert (field in data) is is_super_user
+ assert ("lnbits_allowed_funding_sources" in data) is is_super_user
+ assert "super_user" not in data
+ assert state["stored"] == before
+
+
+@pytest.mark.parametrize("method", ["PUT", "PATCH"])
+def test_admin_save_preserves_live_funding_configuration(
+ funding_api, monkeypatch, method
+):
+ from lnbits.core.services.settings import update_cached_settings
+
+ app, state = funding_api
+ # Restore every setting that the real cache refresh can update after the test.
+ for field in UpdateSettings.model_fields:
+ monkeypatch.setattr(settings, field, getattr(settings, field))
+ monkeypatch.setattr(admin_api, "update_cached_settings", update_cached_settings)
+ response = request(app, method, json={"lnbits_site_title": "Cache check"})
+ assert response.status_code == 200
+ assert settings.lnbits_site_title == "Cache check"
+ for field in FundingSourcesSettings.model_fields:
+ assert getattr(settings, field) == state["stored"][field]
+ assert settings.super_user == "super"
### uv.lock
@@ -1668,7 +1668,7 @@ wheels = [
[[package]]
name = "lnbits"
-version = "1.7.0rc2"
+version = "1.7.0rc4"
source = { editable = "." }
dependencies = [
{ name = "aiosqlite" },Why this scored 60/100
Community notes
Notes can correct, qualify, or add evidence to the AI analysis. Every note shown here has been validated by a human moderator.
The AI analysis stands alone for now. Submit a note if you can add evidence or important context.