refactor: extract functions

This reverts commit e7c359c1e0e21a8aeea391fd5b2cd6316526d42c.

.github/workflows/appimage.yml

@@ -7,6 +7,10 @@ on:
         description: 'The tag name for the release'
         required: true
         type: string
+      upload_url:
+        description: 'The upload URL for the release'
+        required: true
+        type: string
 
   workflow_dispatch:
     inputs:
@@ -14,6 +18,10 @@ on:
         description: 'The tag name for the release'
         required: true
         type: string
+      upload_url:
+        description: 'The upload URL for the release'
+        required: true
+        type: string
 
 jobs:
   build-linux-package:
@@ -105,6 +113,11 @@ jobs:
         shell: bash
 
       - name: Upload Linux Release Asset
+        uses: actions/upload-release-asset@v1
+        with:
+          upload_url: ${{ inputs.upload_url }}
+          asset_path: ${{ env.APPIMAGE_NAME }}
+          asset_name: ${{ env.APPIMAGE_NAME }}
+          asset_content_type: application/octet-stream
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: gh release upload "${{ inputs.tag_name }}" "${{ env.APPIMAGE_NAME }}" --clobber

.github/workflows/release-rc.yml

@@ -12,6 +12,8 @@ jobs:
 
   release:
     runs-on: ubuntu-24.04
+    outputs:
+      upload_url: ${{ steps.get_upload_url.outputs.upload_url }}
     steps:
       - uses: actions/checkout@v4
       - name: Create github pre-release
@@ -20,6 +22,14 @@ jobs:
           tag: ${{ github.ref_name }}
         run: |
           gh release create "$tag" --prerelease --generate-notes --draft
+      - id: get_upload_url
+        name: Get upload url of Github release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          tag: ${{ github.ref_name }}
+        run: |
+          upload_url=$(gh release view "$tag" --json uploadUrl -q ".uploadUrl")
+          echo "upload_url=$upload_url" >> "$GITHUB_OUTPUT"
 
   docker:
     if: github.repository == 'lnbits/lnbits'
@@ -64,3 +74,4 @@ jobs:
     uses: ./.github/workflows/appimage.yml
     with:
       tag_name: ${{ github.ref_name }}
+      upload_url: ${{ needs.release.outputs.upload_url }}

.github/workflows/release.yml

@@ -13,6 +13,8 @@ jobs:
 
   release:
     runs-on: ubuntu-24.04
+    outputs:
+      upload_url: ${{ steps.get_upload_url.outputs.upload_url }}
     steps:
       - uses: actions/checkout@v4
       - name: Create github release
@@ -21,6 +23,14 @@ jobs:
           tag: ${{ github.ref_name }}
         run: |
           gh release create "$tag" --generate-notes --draft
+      - id: get_upload_url
+        name: Get upload url of Github release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          tag: ${{ github.ref_name }}
+        run: |
+          upload_url=$(gh release view "$tag" --json uploadUrl -q ".uploadUrl")
+          echo "upload_url=$upload_url" >> "$GITHUB_OUTPUT"
 
   docker:
     if: github.repository == 'lnbits/lnbits'
@@ -75,3 +85,4 @@ jobs:
     uses: ./.github/workflows/appimage.yml
     with:
       tag_name: ${{ github.ref_name }}
+      upload_url: ${{ needs.release.outputs.upload_url }}

Dockerfile

@@ -43,4 +43,4 @@ ENV LNBITS_HOST="0.0.0.0"
 
 EXPOSE 5000
 
-CMD ["sh", "-c", "uv --offline run --no-sync lnbits --port $LNBITS_PORT --host $LNBITS_HOST --forwarded-allow-ips='*'"]
+CMD ["sh", "-c", "uv --offline run lnbits --port $LNBITS_PORT --host $LNBITS_HOST --forwarded-allow-ips='*'"]

lnbits/app.py

@@ -23,40 +23,36 @@ from lnbits.core.crud import (
     get_installed_extensions,
     update_installed_extension_state,
 )
-from lnbits.core.crud.audit import delete_expired_audit_entries
 from lnbits.core.crud.extensions import create_installed_extension
+from lnbits.core.extensions.events import dispatch_wasm_invoice_paid
+from lnbits.core.extensions.loader import (
+    is_wasm_extension_dir,
+    is_wasm_extension_id,
+)
+from lnbits.core.extensions.routes import register_wasm_extension
 from lnbits.core.helpers import migrate_extension_database
 from lnbits.core.models.notifications import NotificationType
 from lnbits.core.services.extensions import deactivate_extension, get_valid_extensions
-from lnbits.core.services.funding_source import (
-    check_balance_delta_changed,
-    check_server_balance_against_node,
-)
-from lnbits.core.services.notifications import (
-    dispatch_payment_notification,
-    enqueue_admin_notification,
-    process_next_notification,
-)
-from lnbits.core.services.payments import (
-    check_pending_payments,
-    fundingsource_invoice_producer,
-)
+from lnbits.core.services.notifications import enqueue_admin_notification
+from lnbits.core.services.payments import check_pending_payments
 from lnbits.core.tasks import (
     audit_queue,
     collect_exchange_rates_data,
-    notify_server_status,
-    process_next_audit_entry,
-    refresh_extension_cache,
-)
-from lnbits.core.wasm_ext.routes.register import register_wasm_extension
-from lnbits.core.wasm_ext.wasm.events import dispatch_wasm_invoice_paid
-from lnbits.core.wasm_ext.wasm.loader import (
-    is_wasm_extension_id,
+    purge_audit_data,
+    run_by_the_minute_tasks,
+    wait_for_audit_data,
+    wait_for_paid_invoices,
+    wait_notification_messages,
 )
 from lnbits.exceptions import register_exception_handlers
 from lnbits.helpers import version_parse
 from lnbits.llms_txt import create_llms_txt_route
 from lnbits.settings import settings
+from lnbits.tasks import (
+    cancel_all_tasks,
+    create_permanent_task,
+    register_invoice_listener,
+)
 from lnbits.utils.cache import cache
 from lnbits.utils.logger import (
     configure_logger,
@@ -79,7 +75,7 @@ from .middleware import (
     add_profiler_middleware,
     add_ratelimit_middleware,
 )
-from .task_manager import task_manager
+from .tasks import internal_invoice_listener, invoice_listener, run_interval
 
 
 async def startup(app: FastAPI):
@@ -143,7 +139,7 @@ async def shutdown():
     settings.lnbits_running = False
 
     # shutdown event
-    task_manager.cancel_all_tasks()
+    cancel_all_tasks()
 
     # wait a bit to allow them to finish, so that cleanup can run without problems
     await asyncio.sleep(0.1)
@@ -321,8 +317,9 @@ async def build_all_installed_extensions_list(  # noqa: C901
 
             installed_extensions.append(ext_info)
             await create_installed_extension(ext_info)
-            current_version = await get_db_version(ext_id)
-            await migrate_extension_database(ext_info, current_version)
+            if not is_wasm_extension_dir(ext_dir):
+                current_version = await get_db_version(ext_id)
+                await migrate_extension_database(ext_info, current_version)
 
         except Exception as e:
             logger.warning(e)
@@ -495,47 +492,34 @@ async def check_and_register_extensions(app: FastAPI) -> None:
 
 def register_async_tasks() -> None:
 
-    task_manager.init()
+    create_permanent_task(wait_for_audit_data)
+    create_permanent_task(wait_notification_messages)
 
-    # listen to all incoming payments and dispatch payment notifications
-    # note: should be the first in task list for a bit quicker notifications
-    task_manager.register_invoice_listener(dispatch_payment_notification, "core")
+    create_permanent_task(
+        run_interval(
+            settings.lnbits_funding_source_pending_interval_seconds,
+            check_pending_payments,
+        )
+    )
+    create_permanent_task(invoice_listener)
+    create_permanent_task(internal_invoice_listener)
+    create_permanent_task(cache.invalidate_forever)
 
-    # periodic tasks
-    task_manager.create_permanent_task(cache.invalidate_cache, interval=10)
-    task_manager.create_permanent_task(delete_expired_audit_entries, interval=60 * 60)
-    task_manager.create_permanent_task(
-        check_pending_payments,
-        interval=settings.lnbits_funding_source_pending_interval_seconds,
-    )
-    task_manager.create_permanent_task(
-        collect_exchange_rates_data,
-        interval=max(60, settings.lnbits_exchange_history_refresh_interval_seconds),
-    )
-    task_manager.create_permanent_task(check_balance_delta_changed, interval=60)
-    task_manager.create_permanent_task(
-        check_server_balance_against_node,
-        interval=60 * settings.lnbits_watchdog_interval_minutes,
-    )
-    task_manager.create_permanent_task(
-        notify_server_status,
-        interval=60 * 60 * settings.lnbits_notification_server_status_hours,
-    )
-    task_manager.create_permanent_task(refresh_extension_cache, interval=60)
-
-    # permanent tasks run in a loop, will be restarted if they fail
-    task_manager.create_permanent_task(fundingsource_invoice_producer)
-    task_manager.create_permanent_task(process_next_notification)
-    task_manager.create_permanent_task(process_next_audit_entry)
+    # core invoice listener
+    invoice_queue: asyncio.Queue = asyncio.Queue()
+    register_invoice_listener(invoice_queue, "core")
 
     async def dispatch_extension_invoice_paid(payment) -> None:
         await dispatch_wasm_invoice_paid(payment)
 
-    task_manager.register_invoice_listener(dispatch_extension_invoice_paid, "core_wasm")
+    core_app_extra.dispatch_extension_invoice_paid = dispatch_extension_invoice_paid
+    create_permanent_task(lambda: wait_for_paid_invoices(invoice_queue))
+
+    create_permanent_task(run_by_the_minute_tasks)
+    create_permanent_task(purge_audit_data)
+    create_permanent_task(collect_exchange_rates_data)
 
     # server logs for websocket
     if settings.lnbits_admin_ui:
         server_log_task = initialize_server_websocket_logger()
-        task_manager.create_permanent_task(
-            server_log_task, name="server_websocket_logger"
-        )
+        create_permanent_task(server_log_task)

lnbits/core/crud/__init__.py

@@ -18,13 +18,13 @@ from .extensions import (
     get_user_extensions,
     update_installed_extension,
     update_installed_extension_state,
-    update_installed_extension_wasm_runtime_limits,
     update_user_extension,
 )
 from .payments import (
     DateTrunc,
     check_internal,
     create_payment,
+    delete_expired_invoices,
     delete_wallet_payment,
     get_latest_payments_by_extension,
     get_payment,
@@ -102,6 +102,7 @@ __all__ = [
     "delete_accounts_no_wallets",
     "delete_admin_settings",
     "delete_dbversion",
+    "delete_expired_invoices",
     "delete_installed_extension",
     "delete_tinyurl",
     "delete_unused_wallets",
@@ -155,7 +156,6 @@ __all__ = [
     "update_admin_settings",
     "update_installed_extension",
     "update_installed_extension_state",
-    "update_installed_extension_wasm_runtime_limits",
     "update_migration_version",
     "update_payment",
     "update_payment_checking_id",

lnbits/core/crud/extensions.py

@@ -1,12 +1,7 @@
-import json
-from datetime import datetime, timedelta, timezone
-
 from lnbits.core.db import db
 from lnbits.core.models.extensions import (
     InstallableExtension,
     UserExtension,
-    WasmInvocation,
-    WasmInvocationStats,
 )
 from lnbits.db import Connection, Database
 
@@ -16,11 +11,6 @@ async def create_installed_extension(
     conn: Connection | None = None,
 ) -> None:
     await (conn or db).insert("installed_extensions", ext)
-    await update_installed_extension_wasm_runtime_limits(
-        ext_id=ext.id,
-        limits=ext.wasm_runtime_limits,
-        conn=conn,
-    )
 
 
 async def update_installed_extension(
@@ -28,11 +18,6 @@ async def update_installed_extension(
     conn: Connection | None = None,
 ) -> None:
     await (conn or db).update("installed_extensions", ext)
-    await update_installed_extension_wasm_runtime_limits(
-        ext_id=ext.id,
-        limits=ext.wasm_runtime_limits,
-        conn=conn,
-    )
 
 
 async def update_installed_extension_state(
@@ -46,33 +31,6 @@ async def update_installed_extension_state(
     )
 
 
-async def update_installed_extension_wasm_runtime_limits(
-    *, ext_id: str, limits: dict, conn: Connection | None = None
-) -> None:
-    if not await _has_installed_extension_wasm_runtime_limits_column(conn=conn):
-        return
-
-    await (conn or db).execute(
-        """
-        UPDATE installed_extensions
-        SET wasm_runtime_limits = :limits
-        WHERE id = :id
-        """,
-        {"id": ext_id, "limits": json.dumps(limits)},
-    )
-
-
-async def _has_installed_extension_wasm_runtime_limits_column(
-    conn: Connection | None = None,
-) -> bool:
-    row: dict | None = await (conn or db).fetchone(
-        "SELECT version FROM dbversions WHERE db = 'core'"
-    )
-    if not row:
-        return False
-    return int(row["version"] or 0) >= 48
-
-
 async def delete_installed_extension(
     *, ext_id: str, conn: Connection | None = None
 ) -> None:
@@ -186,158 +144,3 @@ async def get_user_active_extensions_ids(
         UserExtension,
     )
     return [ext.extension for ext in exts]
-
-
-async def create_wasm_invocation(
-    invocation: WasmInvocation,
-    conn: Connection | None = None,
-) -> None:
-    await (conn or db).insert("wasm_invocations", invocation)
-
-
-async def update_wasm_invocation(
-    invocation: WasmInvocation,
-    conn: Connection | None = None,
-) -> None:
-    await (conn or db).update("wasm_invocations", invocation)
-
-
-async def get_wasm_invocation(
-    invocation_id: str,
-    conn: Connection | None = None,
-) -> WasmInvocation | None:
-    return await (conn or db).fetchone(
-        "SELECT * FROM wasm_invocations WHERE id = :id",
-        {"id": invocation_id},
-        model=WasmInvocation,
-    )
-
-
-async def get_wasm_invocations(
-    *,
-    extension_id: str | None = None,
-    status: str | None = None,
-    limit: int = 100,
-    offset: int = 0,
-    conn: Connection | None = None,
-) -> list[WasmInvocation]:
-    where: list[str] = []
-    values: dict = {
-        "limit": max(1, min(limit, 500)),
-        "offset": max(offset, 0),
-    }
-    if extension_id:
-        where.append("extension_id = :extension_id")
-        values["extension_id"] = extension_id
-    if status:
-        where.append("status = :status")
-        values["status"] = status
-
-    query = "SELECT * FROM wasm_invocations"
-    if where:
-        query += f" WHERE {' AND '.join(where)}"
-    query += " ORDER BY started_at DESC LIMIT :limit OFFSET :offset"
-
-    return await (conn or db).fetchall(query, values, model=WasmInvocation)
-
-
-async def get_running_wasm_invocations(
-    conn: Connection | None = None,
-) -> list[WasmInvocation]:
-    return await get_wasm_invocations(status="running", conn=conn)
-
-
-async def get_wasm_invocation_stats(
-    *,
-    extension_id: str | None = None,
-    since: datetime | None = None,
-    conn: Connection | None = None,
-) -> WasmInvocationStats:
-    database = conn or db
-    where: list[str] = []
-    values: dict = {}
-    if extension_id:
-        where.append("extension_id = :extension_id")
-        values["extension_id"] = extension_id
-    if since:
-        where.append(f"started_at >= {database.timestamp_placeholder('since')}")
-        values["since"] = since
-
-    query = """
-        SELECT
-            COUNT(*) AS total,
-            COALESCE(SUM(CASE WHEN status = 'running' THEN 1 ELSE 0 END), 0)
-                AS running,
-            COALESCE(SUM(CASE WHEN status = 'completed' THEN 1 ELSE 0 END), 0)
-                AS completed,
-            COALESCE(SUM(CASE WHEN status = 'failed' THEN 1 ELSE 0 END), 0)
-                AS failed,
-            COALESCE(SUM(CASE WHEN status = 'stopped' THEN 1 ELSE 0 END), 0)
-                AS stopped,
-            COALESCE(SUM(CASE WHEN status = 'timeout' THEN 1 ELSE 0 END), 0)
-                AS timeout,
-            COALESCE(AVG(duration_ms), 0) AS avg_duration_ms,
-            COALESCE(MAX(duration_ms), 0) AS max_duration_ms,
-            COALESCE(SUM(host_call_count), 0) AS host_call_count,
-            COALESCE(SUM(http_call_count), 0) AS http_call_count,
-            COALESCE(SUM(storage_call_count), 0) AS storage_call_count,
-            COALESCE(SUM(wallet_call_count), 0) AS wallet_call_count
-        FROM wasm_invocations
-    """
-    if where:
-        query += f" WHERE {' AND '.join(where)}"
-
-    row: dict | None = await (conn or db).fetchone(query, values)
-    if not row:
-        return WasmInvocationStats()
-
-    return WasmInvocationStats(
-        total=int(row["total"] or 0),
-        running=int(row["running"] or 0),
-        completed=int(row["completed"] or 0),
-        failed=int(row["failed"] or 0),
-        stopped=int(row["stopped"] or 0),
-        timeout=int(row["timeout"] or 0),
-        avg_duration_ms=float(row["avg_duration_ms"] or 0),
-        max_duration_ms=int(row["max_duration_ms"] or 0),
-        host_call_count=int(row["host_call_count"] or 0),
-        http_call_count=int(row["http_call_count"] or 0),
-        storage_call_count=int(row["storage_call_count"] or 0),
-        wallet_call_count=int(row["wallet_call_count"] or 0),
-    )
-
-
-async def delete_old_wasm_invocations(
-    retention_days: int,
-    conn: Connection | None = None,
-) -> int:
-    if retention_days <= 0:
-        return 0
-
-    cutoff = datetime.now(timezone.utc) - timedelta(days=retention_days)
-    database = conn or db
-    result = await database.execute(
-        f"""
-        DELETE FROM wasm_invocations
-        WHERE status != 'running'
-            AND started_at < {database.timestamp_placeholder("cutoff")}
-        """,  # noqa: S608
-        {"cutoff": cutoff},
-    )
-    return int(result.rowcount or 0)
-
-
-async def mark_stale_wasm_invocations(
-    conn: Connection | None = None,
-) -> None:
-    database = conn or db
-    await database.execute(
-        f"""
-        UPDATE wasm_invocations
-        SET status = 'abandoned',
-            finished_at = {database.timestamp_placeholder("finished_at")},
-            stop_reason = 'Server restarted before invocation finished.'
-        WHERE status = 'running'
-        """,  # noqa: S608
-        {"finished_at": datetime.now(timezone.utc)},
-    )

lnbits/core/crud/payments.py

@@ -238,6 +238,32 @@ async def get_payments_status_count() -> PaymentsStatusCount:
     )
 
 
+async def delete_expired_invoices(
+    conn: Connection | None = None,
+) -> None:
+    # first we delete all invoices older than one month
+
+    await (conn or db).execute(
+        # Timestamp placeholder is safe from SQL injection (not user input)
+        f"""
+        DELETE FROM apipayments
+        WHERE status = :status AND amount > 0
+        AND time < {db.timestamp_placeholder("delta")}
+        """,  # noqa: S608
+        {"status": f"{PaymentState.PENDING}", "delta": int(time() - 2592000)},
+    )
+    # then we delete all invoices whose expiry date is in the past
+    await (conn or db).execute(
+        # Timestamp placeholder is safe from SQL injection (not user input)
+        f"""
+        DELETE FROM apipayments
+        WHERE status = :status AND amount > 0
+        AND expiry < {db.timestamp_placeholder("now")}
+        """,  # noqa: S608
+        {"status": f"{PaymentState.PENDING}", "now": int(time())},
+    )
+
+
 async def create_payment(
     checking_id: str,
     data: CreatePayment,

lnbits/core/crud/settings.py

@@ -8,18 +8,11 @@ from lnbits.db import dict_to_model
 from lnbits.settings import (
     AdminSettings,
     EditableSettings,
-    FundingSourcesSettings,
     SettingsField,
     SuperSettings,
     settings,
 )
 
-RESET_PRESERVED_SETTINGS = (
-    "lnbits_webpush_pubkey",
-    "lnbits_webpush_privkey",
-    *FundingSourcesSettings.__fields__,
-)
-
 
 async def get_super_settings() -> SuperSettings | None:
     data = await get_settings_by_tag("core")
@@ -76,14 +69,16 @@ async def delete_admin_settings(tag: str | None = "core") -> None:
 
 
 async def reset_core_settings() -> None:
-    core_settings = await get_settings_by_tag("core") or {}
-    super_user = await get_settings_field("super_user")
-    await delete_admin_settings()
-    if super_user:
-        await set_settings_field("super_user", super_user.value)
-    for field in RESET_PRESERVED_SETTINGS:
-        if field in core_settings:
-            await set_settings_field(field, core_settings[field])
+    await db.execute(
+        """
+        DELETE FROM system_settings WHERE tag = 'core'
+        AND id NOT IN (
+            'super_user',
+            'lnbits_webpush_pubkey',
+            'lnbits_webpush_privkey'
+        )
+        """,
+    )
 
 
 async def create_admin_settings(super_user: str, new_settings: dict) -> SuperSettings:

lnbits/core/extensions/__init__.py

@@ -0,0 +1,28 @@
+"""Extension runtime contracts."""
+
+from .api import (
+    ExtensionAPI,
+    ExtensionAPIMethod,
+    extension_api_contract,
+    extension_api_method,
+    get_extension_api_method,
+    list_extension_api_methods,
+)
+from .loader import WasmExtension, load_wasm_extension
+from .routes import register_wasm_extension
+from .runtime import ExtensionAPIHost
+from .wasm import invoke_wasm_extension_export
+
+__all__ = [
+    "ExtensionAPI",
+    "ExtensionAPIHost",
+    "ExtensionAPIMethod",
+    "WasmExtension",
+    "extension_api_contract",
+    "extension_api_method",
+    "get_extension_api_method",
+    "invoke_wasm_extension_export",
+    "list_extension_api_methods",
+    "load_wasm_extension",
+    "register_wasm_extension",
+]

lnbits/core/extensions/api.py

@@ -1,27 +1,19 @@
 from __future__ import annotations
 
+import inspect
 import json
 import logging
 import secrets
 import time
-from collections.abc import Iterable, Mapping
-from typing import Any
+from collections.abc import Awaitable, Callable, Iterable, Mapping
+from dataclasses import dataclass
+from functools import wraps
+from typing import Any, TypeVar, cast, get_type_hints
+
+from pydantic import BaseModel
 
 from lnbits.helpers import sha256s
 
-from ..client.extensions import send_extension_api_request
-from ..storage.crud import (
-    storage_delete_row,
-    storage_get_paginated_rows,
-    storage_get_public_row,
-    storage_get_row,
-    storage_set_row,
-)
-from .background_payments import (
-    WALLET_PAY_INVOICE_BACKGROUND_PERMISSION,
-    background_payment_extra,
-    invoice_amount_msat,
-)
 from .models import (
     CreateInvoicePublicRequest,
     CreateInvoiceRequest,
@@ -36,7 +28,6 @@ from .models import (
     NowResponse,
     PayInvoiceRequest,
     PayInvoiceResponse,
-    PayLnurlRequest,
     RandomIdRequest,
     RandomIdResponse,
     StorageDeleteRequest,
@@ -51,12 +42,102 @@ from .models import (
     WalletBalanceRequest,
     WalletBalanceResponse,
 )
-from .registry import extension_api_method
+from .storage import (
+    storage_delete_row,
+    storage_get_paginated_rows,
+    storage_get_public_row,
+    storage_get_row,
+    storage_set_row,
+)
 
 logger = logging.getLogger("lnbits.extensions")
 
+_EXTENSION_API_METHOD_ATTR = "__lnbits_extension_api_method__"
+_EXTENSION_RUNTIME_PERMISSION_IDS = {"ui.camera.scan_qr"}
+_RequestModel = TypeVar("_RequestModel", bound=BaseModel)
+_ResponseModel = TypeVar("_ResponseModel", bound=BaseModel)
 
-class ExtensionHostAPI:
+
+@dataclass(frozen=True)
+class ExtensionAPIMethodExport:
+    method_id: str
+    namespace: str
+    name: str
+    host_interface: str
+    host_name: str
+    sdk_name: str
+    description: str
+    required_permission: str | None = None
+    require_auth: bool = True
+
+
+@dataclass(frozen=True)
+class ExtensionAPIMethod:
+    method_id: str
+    namespace: str
+    name: str
+    python_name: str
+    host_interface: str
+    host_name: str
+    sdk_name: str
+    description: str
+    request_model: type[BaseModel]
+    response_model: type[BaseModel]
+    required_permission: str | None = None
+    require_auth: bool = True
+
+    @property
+    def sdk_qualified_name(self) -> str:
+        return f"{self.namespace}.{self.sdk_name}"
+
+
+def extension_api_method(
+    *,
+    method_id: str,
+    namespace: str,
+    name: str,
+    host_name: str,
+    sdk_name: str,
+    description: str,
+    host_interface: str = "host",
+    required_permission: str | None = None,
+    require_auth: bool = True,
+) -> Callable[
+    [Callable[[Any, _RequestModel], Awaitable[_ResponseModel]]],
+    Callable[[Any, _RequestModel], Awaitable[_ResponseModel]],
+]:
+    export = ExtensionAPIMethodExport(
+        method_id=method_id,
+        namespace=namespace,
+        name=name,
+        host_interface=host_interface,
+        host_name=host_name,
+        sdk_name=sdk_name,
+        description=description,
+        required_permission=required_permission,
+        require_auth=require_auth,
+    )
+
+    def decorator(
+        function: Callable[[Any, _RequestModel], Awaitable[_ResponseModel]],
+    ) -> Callable[[Any, _RequestModel], Awaitable[_ResponseModel]]:
+        @wraps(function)
+        async def wrapper(self: Any, request: _RequestModel) -> _ResponseModel:
+            api = getattr(self, "api", self)
+            if require_auth and not api.has_authenticated_context():
+                raise PermissionError(
+                    f"Extension API method '{method_id}' requires authentication."
+                )
+            api.require_permission(required_permission)
+            return await function(self, request)
+
+        setattr(wrapper, _EXTENSION_API_METHOD_ATTR, export)
+        return wrapper
+
+    return decorator
+
+
+class ExtensionAPI:
     def __init__(
         self,
         extension_id: str,
@@ -66,8 +147,6 @@ class ExtensionHostAPI:
         access_token: str | None = None,
         context: str = "user",
         owner_id: str | None = None,
-        invocation_id: str | None = None,
-        runtime_limits: dict[str, int] | None = None,
     ) -> None:
         self.extension_id = extension_id
         self.permissions, self.permission_policies = self._permission_data(permissions)
@@ -75,16 +154,34 @@ class ExtensionHostAPI:
         self.access_token = access_token
         self.context = context
         self.owner_id = sha256s(user_id) if user_id else owner_id
-        self.invocation_id = invocation_id
-        self.runtime_limits = runtime_limits or {}
-        from .utils import ExtensionAPIUtils
+        self._uuid = secrets.token_urlsafe(12).replace("-", "_")
+        from .api_utils import ExtensionAPIUtils
 
-        self.utils = ExtensionAPIUtils(
-            self.extension_id,
-            self.permissions,
-            authenticated=self.has_authenticated_context(),
+        self.utils = ExtensionAPIUtils(self)
+
+    def __repr__(self) -> str:
+        return (
+            "ExtensionAPI("
+            f"extension_id={self.extension_id!r}, "
+            f"context={self.context!r}, "
+            f"_uuid={self._uuid!r}"
+            ")"
         )
 
+    def require_permission(self, permission: str | None) -> None:
+        if permission and permission not in self.permissions:
+            raise PermissionError(
+                f"Extension '{self.extension_id}' is missing permission '{permission}'."
+            )
+
+    def has_authenticated_context(self) -> bool:
+        return bool(self.user_id) or self.context == "event"
+
+    def _require_owner_id(self) -> str:
+        if not self.owner_id:
+            raise PermissionError("Extension API method requires an owner context.")
+        return self.owner_id
+
     @extension_api_method(
         method_id="storage.get",
         namespace="storage",
@@ -126,7 +223,6 @@ class ExtensionHostAPI:
             for field_name, value in row.items()
             if field_name in public_fields
         }
-        # todo: check public fields filtering
         return StorageGetResponse(data_json=json.dumps(public_row))
 
     @extension_api_method(
@@ -216,14 +312,16 @@ class ExtensionHostAPI:
         from lnbits.core.models.payments import CreateInvoice
         from lnbits.core.services.payments import create_payment_request
 
-        if not self.user_id:
-            raise PermissionError(
-                "Creating an invoice for this wallet requires an "
-                "authenticated user context."
-            )
-        wallet = await get_wallet(request.wallet_id)
-        if wallet is None or wallet.user != self.user_id:
-            raise PermissionError("Not your wallet.")
+        if self.user_id:
+            wallet = await get_wallet(request.wallet_id)
+            if wallet is None or wallet.user != self.user_id:
+                raise PermissionError(
+                    "Creating an invoice for this wallet requires an "
+                    "authenticated user context."
+                )
+        else:
+            pass
+            # todo: security stuff here
 
         payment = await create_payment_request(
             request.wallet_id,
@@ -257,18 +355,8 @@ class ExtensionHostAPI:
         from lnbits.core.models.payments import CreateInvoice
         from lnbits.core.services.payments import create_payment_request
 
-        row: dict[str, Any] | None = None
-        wallet_field = ""
-        for policy in self._public_invoice_wallet_sources():
-            row = await storage_get_public_row(
-                self.extension_id,
-                policy["table"],
-                request.source_id,
-            )
-            if row:
-                wallet_field = policy["wallet_field"]
-                break
-
+        table, wallet_field = self._public_invoice_wallet_source()
+        row = await storage_get_public_row(self.extension_id, table, request.source_id)
         if not row:
             raise PermissionError("Public invoice source was not found.")
 
@@ -372,6 +460,7 @@ class ExtensionHostAPI:
         host_name="pay_invoice",
         sdk_name="payInvoice",
         description="Pay a Lightning invoice from a wallet available to the user.",
+        required_permission="wallet.pay_invoice",
     )
     async def wallet_pay_invoice(
         self, request: PayInvoiceRequest
@@ -380,135 +469,37 @@ class ExtensionHostAPI:
         from lnbits.core.services.payments import pay_invoice
         from lnbits.exceptions import PaymentError
 
+        if not self.user_id:
+            raise PermissionError(
+                "Paying an invoice requires an authenticated user context."
+            )
+
         wallet = await get_wallet(request.wallet_id)
-        if wallet is None:
+        if wallet is None or wallet.user != self.user_id:
             raise PermissionError("Paying invoices from this wallet is not allowed.")
 
         try:
-            if self.user_id:
-                self.require_permission("wallet.pay_invoice")
-                if wallet.user != self.user_id:
-                    raise PermissionError(
-                        "Paying invoices from this wallet is not allowed."
-                    )
-                payment = await pay_invoice(
-                    wallet_id=request.wallet_id,
-                    payment_request=request.payment_request,
-                    max_sat=request.max_sat,
-                    extra={"tag": self.extension_id, **request.extra},
-                    description=request.description,
-                    tag=self.extension_id,
-                )
-            else:
-                self.require_permission(WALLET_PAY_INVOICE_BACKGROUND_PERMISSION)
-                amount_msat = invoice_amount_msat(request.payment_request)
-                extra = await background_payment_extra(
-                    extension_id=self.extension_id,
-                    wallet=wallet,
-                    payment_request=request.payment_request,
-                    amount_msat=amount_msat,
-                )
-                payment = await pay_invoice(
-                    wallet_id=request.wallet_id,
-                    payment_request=request.payment_request,
-                    max_sat=request.max_sat,
-                    extra={**request.extra, **extra},
-                    description=request.description,
-                    tag=self.extension_id,
-                )
-        except (PaymentError, PermissionError, ValueError) as exc:
-            return PayInvoiceResponse(ok=False, error=str(exc))
-
-        return _pay_invoice_response(payment)
-
-    @extension_api_method(
-        method_id="wallet.pay_lnurl",
-        namespace="wallet",
-        name="Pay LNURL",
-        host_name="pay_lnurl",
-        sdk_name="payLnurl",
-        description="Pay a Lightning Address or LNURL-pay request from a wallet.",
-    )
-    async def wallet_pay_lnurl(self, request: PayLnurlRequest) -> PayInvoiceResponse:
-        from lnurl import LnAddressError, LnurlResponseException
-
-        from lnbits.core.crud.wallets import get_wallet
-        from lnbits.core.models.lnurl import CreateLnurlPayment
-        from lnbits.core.services.lnurl import fetch_lnurl_pay_request
-        from lnbits.core.services.payments import pay_invoice
-        from lnbits.exceptions import PaymentError
-
-        from .lnurl import (
-            lnurl_for_core,
-            lnurl_pay_response_text,
-            lnurl_payment_amount_for_core,
-            lnurl_payment_unit_for_core,
-        )
-
-        wallet = await get_wallet(request.wallet_id)
-        if wallet is None:
-            raise PermissionError("Paying from this wallet is not allowed.")
-
-        try:
-            if self.user_id:
-                self.require_permission("wallet.pay_invoice")
-                if wallet.user != self.user_id:
-                    raise PermissionError("Paying from this wallet is not allowed.")
-            else:
-                self.require_permission(WALLET_PAY_INVOICE_BACKGROUND_PERMISSION)
-
-            unit = lnurl_payment_unit_for_core(request.currency)
-            res, action = await fetch_lnurl_pay_request(
-                data=CreateLnurlPayment(
-                    lnurl=lnurl_for_core(request.lnurl),
-                    amount=lnurl_payment_amount_for_core(request.amount),
-                    unit=unit,
-                    comment=request.comment,
-                    internal_memo=request.description or None,
-                ),
-                wallet=None,
-            )
-            extra = {"tag": self.extension_id, **request.extra}
-            if action.successAction:
-                extra["success_action"] = action.successAction.json()
-            if request.comment:
-                extra["comment"] = request.comment
-            if unit != "sat":
-                extra["fiat_currency"] = unit
-                extra["fiat_amount"] = str(request.amount)
-
-            if not self.user_id:
-                amount_msat = invoice_amount_msat(str(action.pr))
-                extra = {
-                    **extra,
-                    **(
-                        await background_payment_extra(
-                            extension_id=self.extension_id,
-                            wallet=wallet,
-                            payment_request=str(action.pr),
-                            amount_msat=amount_msat,
-                        )
-                    ),
-                }
-
             payment = await pay_invoice(
                 wallet_id=request.wallet_id,
-                payment_request=str(action.pr),
+                payment_request=request.payment_request,
                 max_sat=request.max_sat,
-                extra=extra,
-                description=request.description or lnurl_pay_response_text(res),
+                extra={"tag": self.extension_id, **request.extra},
+                description=request.description,
                 tag=self.extension_id,
             )
-        except (
-            LnAddressError,
-            LnurlResponseException,
-            PaymentError,
-            PermissionError,
-            ValueError,
-        ) as exc:
+        except (PaymentError, ValueError) as exc:
             return PayInvoiceResponse(ok=False, error=str(exc))
 
-        return _pay_invoice_response(payment)
+        return PayInvoiceResponse(
+            ok=True,
+            checking_id=payment.checking_id,
+            payment_hash=payment.payment_hash,
+            status=payment.status,
+            amount_msat=abs(payment.amount),
+            fee_msat=abs(payment.fee),
+            pending=payment.pending,
+            success=payment.success,
+        )
 
     @extension_api_method(
         method_id="http.request",
@@ -521,18 +512,10 @@ class ExtensionHostAPI:
         require_auth=True,
     )
     async def http_request(self, request: HttpRequest) -> HttpResponse:
-        from ..client.http import send_extension_http_request
+        from .http_client import send_extension_http_request
 
-        policies = self.permission_policies.get("http.request") or []
-        return await send_extension_http_request(
-            self.extension_id,
-            policies,
-            request,
-            timeout_ms=self.runtime_limits.get("wasm_runtime_http_timeout_ms"),
-            max_response_bytes=self.runtime_limits.get(
-                "wasm_runtime_max_http_response_bytes"
-            ),
-        )
+        policy = self.permission_policies.get("http.request") or {}
+        return await send_extension_http_request(self.extension_id, policy, request)
 
     @extension_api_method(
         method_id="extension.api.request",
@@ -545,18 +528,15 @@ class ExtensionHostAPI:
         require_auth=True,
     )
     async def extension_api_request(self, request: ExtensionApiRequest) -> HttpResponse:
+        from .extension_client import send_extension_api_request
 
-        policies = self.permission_policies.get("extension.api.request") or []
+        policy = self.permission_policies.get("extension.api.request") or {}
         return await send_extension_api_request(
             self.extension_id,
-            policies,
+            policy,
             self.user_id,
             self.access_token,
             request,
-            timeout_ms=self.runtime_limits.get("wasm_runtime_http_timeout_ms"),
-            max_response_bytes=self.runtime_limits.get(
-                "wasm_runtime_max_http_response_bytes"
-            ),
         )
 
     @extension_api_method(
@@ -602,9 +582,9 @@ class ExtensionHostAPI:
     @staticmethod
     def _permission_data(
         permissions: Iterable[Any],
-    ) -> tuple[set[str], dict[str, list[Any]]]:
+    ) -> tuple[set[str], dict[str, dict[str, Any]]]:
         permission_ids: set[str] = set()
-        policies: dict[str, list[Any]] = {}
+        policies: dict[str, dict[str, Any]] = {}
 
         for permission in permissions:
             if isinstance(permission, str):
@@ -612,27 +592,28 @@ class ExtensionHostAPI:
                 continue
 
             permission_id: str | None = None
-            permission_policies: Any = None
+            policy: Any = None
             if isinstance(permission, Mapping):
                 permission_id = permission.get("id")  # type: ignore[assignment]
-                permission_policies = permission.get("policies")
+                policy = permission.get("policy")
             else:
                 permission_id = getattr(permission, "id", None)
-                permission_policies = getattr(permission, "policies", None)
+                policy = getattr(permission, "policy", None)
 
             if not permission_id:
                 continue
             permission_ids.add(permission_id)
-            if isinstance(permission_policies, list):
-                policies[permission_id] = permission_policies
+            if isinstance(policy, dict):
+                policies[permission_id] = policy
 
         return permission_ids, policies
 
     def _public_storage_fields(self, table: str) -> set[str]:
-        tables = self.permission_policies.get("ext.storage.read_public")
-        if not isinstance(tables, list) or not tables:
+        policy = self.permission_policies.get("ext.storage.read_public") or {}
+        tables = policy.get("tables")
+        if not isinstance(tables, list):
             raise PermissionError(
-                "Public storage reads require policies for "
+                "Public storage reads require a tables policy for "
                 "'ext.storage.read_public'."
             )
 
@@ -652,67 +633,145 @@ class ExtensionHostAPI:
 
         raise PermissionError(f"Storage table '{table}' is not publicly readable.")
 
-    def _public_invoice_wallet_sources(self) -> list[dict[str, str]]:
-        policies = self.permission_policies.get("wallet.create_invoice_public")
-        if not isinstance(policies, list) or not policies:
-            raise PermissionError("Public invoice creation requires a policies list.")
-
-        sources: list[dict[str, str]] = []
-        for source_policy in policies:
-            if not isinstance(source_policy, dict):
-                raise PermissionError(
-                    "Public invoice creation policies must be objects."
-                )
-            table = source_policy.get("table")
-            wallet_field = source_policy.get("wallet_field")
-            if not isinstance(table, str) or not table:
-                raise PermissionError(
-                    "Public invoice creation requires a storage table policy."
-                )
-            if not isinstance(wallet_field, str) or not wallet_field:
-                raise PermissionError(
-                    "Public invoice creation requires a wallet field policy."
-                )
-            sources.append({"table": table, "wallet_field": wallet_field})
-
-        if not sources:
+    def _public_invoice_wallet_source(self) -> tuple[str, str]:
+        policy = self.permission_policies.get("wallet.create_invoice_public") or {}
+        table = policy.get("table")
+        wallet_field = policy.get("wallet_field")
+        if not isinstance(table, str) or not table:
             raise PermissionError(
-                "Public invoice creation requires at least one valid policy."
+                "Public invoice creation requires a storage table policy."
             )
-        return sources
-
-    def require_permission(self, permission: str | None) -> None:
-        if permission and permission not in self.permissions:
+        if not isinstance(wallet_field, str) or not wallet_field:
             raise PermissionError(
-                f"Extension '{self.extension_id}' is missing permission '{permission}'."
+                "Public invoice creation requires a wallet field policy."
+            )
+        return table, wallet_field
+
+
+def list_extension_api_methods(
+    api_cls: type[ExtensionAPI] = ExtensionAPI,
+) -> list[ExtensionAPIMethod]:
+    methods: list[ExtensionAPIMethod] = []
+
+    for prefix, method_cls in _extension_api_method_sources(api_cls):
+        for python_name, function in inspect.getmembers(method_cls, inspect.isfunction):
+            export = getattr(function, _EXTENSION_API_METHOD_ATTR, None)
+            if not export:
+                continue
+
+            request_model, response_model = _get_method_models(function)
+            methods.append(
+                ExtensionAPIMethod(
+                    method_id=export.method_id,
+                    namespace=export.namespace,
+                    name=export.name,
+                    python_name=f"{prefix}.{python_name}" if prefix else python_name,
+                    host_interface=export.host_interface,
+                    host_name=export.host_name,
+                    sdk_name=export.sdk_name,
+                    description=export.description,
+                    request_model=request_model,
+                    response_model=response_model,
+                    required_permission=export.required_permission,
+                    require_auth=export.require_auth,
+                )
             )
 
-    def has_authenticated_context(self) -> bool:
-        return bool(self.user_id) or self.context == "event"
+    return sorted(methods, key=lambda method: method.method_id)
 
-    def _require_owner_id(self) -> str:
-        if not self.owner_id:
-            raise PermissionError("Extension API method requires an owner context.")
-        return self.owner_id
 
-    def __repr__(self) -> str:
-        return (
-            "ExtensionHostAPI("
-            f"extension_id={self.extension_id!r}, "
-            f"context={self.context!r}, "
-            f"owner_id={self.owner_id!r}"
-            ")"
+def _extension_api_method_sources(
+    api_cls: type[ExtensionAPI],
+) -> list[tuple[str, type[Any]]]:
+    sources: list[tuple[str, type[Any]]] = [("", api_cls)]
+    if issubclass(api_cls, ExtensionAPI):
+        from .api_utils import extension_api_utils_method_classes
+
+        sources.extend(extension_api_utils_method_classes().items())
+    return sources
+
+
+def extension_api_permission_ids(
+    api_cls: type[ExtensionAPI] = ExtensionAPI,
+) -> set[str]:
+    permissions = {
+        method.required_permission
+        for method in list_extension_api_methods(api_cls)
+        if method.required_permission
+    }
+    permissions.update(_EXTENSION_RUNTIME_PERMISSION_IDS)
+    return permissions
+
+
+def get_extension_api_method(
+    method_id: str,
+    api_cls: type[ExtensionAPI] = ExtensionAPI,
+) -> ExtensionAPIMethod:
+    for method in list_extension_api_methods(api_cls):
+        if method.method_id == method_id:
+            return method
+    raise KeyError(f"Unknown extension API method '{method_id}'.")
+
+
+def extension_api_contract(
+    api_cls: type[ExtensionAPI] = ExtensionAPI,
+) -> dict[str, object]:
+    return {
+        "version": 1,
+        "methods": [
+            {
+                "id": method.method_id,
+                "namespace": method.namespace,
+                "name": method.name,
+                "python_name": method.python_name,
+                "host_interface": method.host_interface,
+                "host_name": method.host_name,
+                "sdk_name": method.sdk_name,
+                "sdk_qualified_name": method.sdk_qualified_name,
+                "description": method.description,
+                "required_permission": method.required_permission,
+                "require_auth": method.require_auth,
+                "request_schema": method.request_model.schema(
+                    ref_template="#/definitions/{model}"
+                ),
+                "response_schema": method.response_model.schema(
+                    ref_template="#/definitions/{model}"
+                ),
+            }
+            for method in list_extension_api_methods(api_cls)
+        ],
+    }
+
+
+def _get_method_models(
+    function: Callable[..., object],
+) -> tuple[type[BaseModel], type[BaseModel]]:
+    signature = inspect.signature(function)
+    request_parameters = [
+        parameter
+        for parameter in signature.parameters.values()
+        if parameter.name != "self"
+    ]
+    if len(request_parameters) != 1:
+        raise TypeError(
+            f"Extension API method '{function.__name__}' must accept one request model."
         )
 
+    hints = get_type_hints(function)
+    request_model = hints.get(request_parameters[0].name)
+    response_model = hints.get("return")
 
-def _pay_invoice_response(payment: Any) -> PayInvoiceResponse:
-    return PayInvoiceResponse(
-        ok=True,
-        checking_id=payment.checking_id,
-        payment_hash=payment.payment_hash,
-        status=payment.status,
-        amount_msat=abs(payment.amount),
-        fee_msat=abs(payment.fee),
-        pending=payment.pending,
-        success=payment.success,
-    )
+    if not _is_pydantic_model(request_model):
+        raise TypeError(
+            f"Extension API method '{function.__name__}' request must be a BaseModel."
+        )
+    if not _is_pydantic_model(response_model):
+        raise TypeError(
+            f"Extension API method '{function.__name__}' response must be a BaseModel."
+        )
+
+    return cast(type[BaseModel], request_model), cast(type[BaseModel], response_model)
+
+
+def _is_pydantic_model(value: object) -> bool:
+    return isinstance(value, type) and issubclass(value, BaseModel)

lnbits/core/extensions/api_utils.py

@@ -1,29 +1,10 @@
 from __future__ import annotations
 
 import time
-from collections.abc import Iterable
 from datetime import datetime
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
-from lnurl import LnurlErrorResponse, LnurlPayResponse, LnurlResponseException
-from lnurl import handle as lnurl_handle
-
-from lnbits import bolt11
-from lnbits.settings import settings
-from lnbits.utils.crypto import random_secret_and_hash, verify_preimage
-from lnbits.utils.exchange_rates import (
-    allowed_currencies,
-    fiat_amount_as_satoshis,
-    get_fiat_rate_and_price_satoshis,
-    satoshis_amount_as_fiat,
-)
-
-from .lnurl import (
-    lnurl_pay_response_int,
-    lnurl_pay_response_metadata_json,
-    lnurl_pay_response_text,
-    normalize_lnurl,
-)
+from .api import extension_api_method
 from .models import (
     Bolt11Request,
     CurrencyConvertRequest,
@@ -39,8 +20,6 @@ from .models import (
     InvoiceExpiryResponse,
     InvoiceMemoResponse,
     InvoicePaymentHashResponse,
-    LnurlResolveRequest,
-    LnurlResolveResponse,
     RandomSecretAndHashRequest,
     RandomSecretAndHashResponse,
     SatsToFiatRequest,
@@ -50,52 +29,22 @@ from .models import (
     VerifyPreimageRequest,
     VerifyPreimageResponse,
 )
-from .registry import extension_api_method
+
+if TYPE_CHECKING:
+    from .api import ExtensionAPI
 
 
 class ExtensionAPIUtils:
-    def __init__(
-        self,
-        extension_id: str,
-        permissions: Iterable[str],
-        *,
-        authenticated: bool = False,
-    ) -> None:
-        permission_set = set(permissions)
-        self.currencies = ExtensionCurrencyUtils(
-            extension_id, permission_set, authenticated=authenticated
-        )
-        self.server = ExtensionServerUtils(
-            extension_id, permission_set, authenticated=authenticated
-        )
-        self.lightning = ExtensionLightningUtils(
-            extension_id, permission_set, authenticated=authenticated
-        )
-        self.lnurl = ExtensionLnurlUtils(
-            extension_id, permission_set, authenticated=authenticated
-        )
+    def __init__(self, api: ExtensionAPI) -> None:
+        self.api = api
+        self.currencies = ExtensionCurrencyUtils(api)
+        self.server = ExtensionServerUtils(api)
+        self.lightning = ExtensionLightningUtils(api)
 
 
 class _ExtensionAPIUtilsGroup:
-    def __init__(
-        self,
-        extension_id: str,
-        permissions: Iterable[str],
-        *,
-        authenticated: bool = False,
-    ) -> None:
-        self.extension_id = extension_id
-        self.permissions = set(permissions)
-        self.authenticated = authenticated
-
-    def require_permission(self, permission: str | None) -> None:
-        if permission and permission not in self.permissions:
-            raise PermissionError(
-                f"Extension '{self.extension_id}' is missing permission '{permission}'."
-            )
-
-    def has_authenticated_context(self) -> bool:
-        return self.authenticated
+    def __init__(self, api: ExtensionAPI) -> None:
+        self.api = api
 
 
 class ExtensionCurrencyUtils(_ExtensionAPIUtilsGroup):
@@ -111,6 +60,7 @@ class ExtensionCurrencyUtils(_ExtensionAPIUtilsGroup):
         require_auth=False,
     )
     async def list(self, request: EmptyRequest) -> CurrencyListResponse:
+        from lnbits.utils.exchange_rates import allowed_currencies
 
         return CurrencyListResponse(currencies=allowed_currencies())
 
@@ -126,6 +76,7 @@ class ExtensionCurrencyUtils(_ExtensionAPIUtilsGroup):
         require_auth=False,
     )
     async def rate(self, request: CurrencyRateRequest) -> CurrencyRateResponse:
+        from lnbits.utils.exchange_rates import get_fiat_rate_and_price_satoshis
 
         rate, price = await get_fiat_rate_and_price_satoshis(request.currency)
         return CurrencyRateResponse(rate=rate, price=price)
@@ -142,6 +93,10 @@ class ExtensionCurrencyUtils(_ExtensionAPIUtilsGroup):
         require_auth=False,
     )
     async def convert(self, request: CurrencyConvertRequest) -> CurrencyConvertResponse:
+        from lnbits.utils.exchange_rates import (
+            fiat_amount_as_satoshis,
+            satoshis_amount_as_fiat,
+        )
 
         from_currency = request.from_currency
         if from_currency == "sats":
@@ -180,6 +135,7 @@ class ExtensionCurrencyUtils(_ExtensionAPIUtilsGroup):
         require_auth=False,
     )
     async def fiat_to_sats(self, request: FiatToSatsRequest) -> FiatToSatsResponse:
+        from lnbits.utils.exchange_rates import fiat_amount_as_satoshis
 
         return FiatToSatsResponse(
             amount_sat=await fiat_amount_as_satoshis(
@@ -200,6 +156,7 @@ class ExtensionCurrencyUtils(_ExtensionAPIUtilsGroup):
         require_auth=False,
     )
     async def sats_to_fiat(self, request: SatsToFiatRequest) -> SatsToFiatResponse:
+        from lnbits.utils.exchange_rates import satoshis_amount_as_fiat
 
         return SatsToFiatResponse(
             amount=await satoshis_amount_as_fiat(request.amount, request.currency)
@@ -219,6 +176,7 @@ class ExtensionServerUtils(_ExtensionAPIUtilsGroup):
         require_auth=False,
     )
     async def health(self, request: EmptyRequest) -> ServerHealthResponse:
+        from lnbits.settings import settings
 
         return ServerHealthResponse(
             server_time=int(time.time()),
@@ -226,60 +184,6 @@ class ExtensionServerUtils(_ExtensionAPIUtilsGroup):
         )
 
 
-class ExtensionLnurlUtils(_ExtensionAPIUtilsGroup):
-    @extension_api_method(
-        method_id="utils.lnurl.resolve",
-        namespace="utils.lnurl",
-        name="Resolve LNURL-pay",
-        host_interface="utils-lnurl",
-        host_name="resolve",
-        sdk_name="resolve",
-        description="Resolve a Lightning Address or LNURL-pay request.",
-        required_permission="wallet.pay_invoice",
-        require_auth=True,
-    )
-    async def resolve(self, request: LnurlResolveRequest) -> LnurlResolveResponse:
-        normalized_lnurl = normalize_lnurl(request.lnurl)
-        response = await lnurl_handle(
-            normalized_lnurl,
-            user_agent=settings.user_agent,
-            timeout=5,
-        )
-        if isinstance(response, LnurlErrorResponse):
-            raise LnurlResponseException(response.reason)
-        if not isinstance(response, LnurlPayResponse):
-            raise LnurlResponseException(
-                "Invalid LNURL response. Expected LnurlPayResponse."
-            )
-
-        min_sendable_msat = lnurl_pay_response_int(
-            response, "min_sendable", "minSendable"
-        )
-        max_sendable_msat = lnurl_pay_response_int(
-            response, "max_sendable", "maxSendable"
-        )
-        image = getattr(response, "image", None)
-        return LnurlResolveResponse(
-            lnurl=normalized_lnurl,
-            domain=getattr(response, "domain", None),
-            description=lnurl_pay_response_text(response),
-            min_sendable_msat=min_sendable_msat,
-            max_sendable_msat=max_sendable_msat,
-            comment_allowed=lnurl_pay_response_int(
-                response, "comment_allowed", "commentAllowed"
-            ),
-            fixed=bool(
-                getattr(
-                    response,
-                    "fixed",
-                    min_sendable_msat == max_sendable_msat,
-                )
-            ),
-            image=str(image) if image is not None else None,
-            metadata_json=lnurl_pay_response_metadata_json(response),
-        )
-
-
 class ExtensionLightningUtils(_ExtensionAPIUtilsGroup):
     @extension_api_method(
         method_id="utils.lightning.decode_invoice",
@@ -394,6 +298,7 @@ class ExtensionLightningUtils(_ExtensionAPIUtilsGroup):
     async def verify_preimage(
         self, request: VerifyPreimageRequest
     ) -> VerifyPreimageResponse:
+        from lnbits.utils.crypto import verify_preimage
 
         return VerifyPreimageResponse(
             valid=verify_preimage(request.preimage, request.payment_hash)
@@ -413,6 +318,7 @@ class ExtensionLightningUtils(_ExtensionAPIUtilsGroup):
     async def random_secret_and_hash(
         self, request: RandomSecretAndHashRequest
     ) -> RandomSecretAndHashResponse:
+        from lnbits.utils.crypto import random_secret_and_hash
 
         secret, payment_hash = random_secret_and_hash(request.length)
         return RandomSecretAndHashResponse(secret=secret, hash=payment_hash)
@@ -422,12 +328,12 @@ def extension_api_utils_method_classes() -> dict[str, type[_ExtensionAPIUtilsGro
     return {
         "utils.currencies": ExtensionCurrencyUtils,
         "utils.server": ExtensionServerUtils,
-        "utils.lnurl": ExtensionLnurlUtils,
         "utils.lightning": ExtensionLightningUtils,
     }
 
 
 def _decode_bolt11(payment_request: str) -> Any:
+    from lnbits import bolt11
 
     return bolt11.decode(payment_request)
 

lnbits/core/extensions/events.py

@@ -0,0 +1,113 @@
+import json
+from typing import Any
+
+from loguru import logger
+
+from lnbits.core.db import core_app_extra
+
+
+async def dispatch_wasm_invoice_paid(payment: Any) -> None:
+    extension_id = _payment_extension_id(payment)
+    if not extension_id:
+        return
+
+    extension = core_app_extra.wasm_extension_registry.get(extension_id)
+    if not extension:
+        return
+
+    export_name = _wasm_invoice_paid_export(extension.config)
+    if not export_name:
+        return
+
+    if not _is_wasm_event_export(extension, export_name):
+        logger.warning(
+            f"WASM extension '{extension.id}' declares invalid onInvoicePaid "
+            f"export '{export_name}'."
+        )
+        return
+
+    try:
+        from lnbits.core.extensions.wasm import invoke_wasm_extension_export
+
+        await invoke_wasm_extension_export(
+            extension.id,
+            export_name,
+            _wasm_invoice_paid_payload(payment),
+            context="event",
+            owner_id=await _wasm_invoice_paid_owner_id(extension, payment),
+        )
+    except Exception as exc:
+        logger.warning(
+            f"WASM extension '{extension.id}' failed to handle paid invoice "
+            f"'{payment.payment_hash}': {exc!s}"
+        )
+
+
+def _payment_extension_id(payment: Any) -> str | None:
+    if isinstance(payment.extension, str) and payment.extension:
+        return payment.extension
+
+    extra = payment.extra or {}
+    tag = extra.get("tag") or payment.tag
+    return tag if isinstance(tag, str) and tag else None
+
+
+async def _wasm_invoice_paid_owner_id(extension: Any, payment: Any) -> str | None:
+    source_id = _payment_source_id(payment)
+    source_table = _wasm_public_invoice_source_table(extension.config)
+    if not source_id or not source_table:
+        return None
+
+    from lnbits.core.extensions.storage import storage_get_row_owner_id
+
+    return await storage_get_row_owner_id(extension.id, source_table, source_id)
+
+
+def _payment_source_id(payment: Any) -> str | None:
+    extra = payment.extra or {}
+    source_id = extra.get("source_id")
+    return source_id if isinstance(source_id, str) and source_id else None
+
+
+def _wasm_public_invoice_source_table(config: dict[str, Any]) -> str | None:
+    permissions = config.get("permissions") or []
+    for permission in permissions:
+        if not isinstance(permission, dict):
+            continue
+        if permission.get("id") != "wallet.create_invoice_public":
+            continue
+        policy = permission.get("policy") or {}
+        table = policy.get("table")
+        return table if isinstance(table, str) and table else None
+    return None
+
+
+def _wasm_invoice_paid_export(config: dict[str, Any]) -> str | None:
+    events = config.get("events") or {}
+    export_name = events.get("onInvoicePaid")
+    return export_name if isinstance(export_name, str) and export_name else None
+
+
+def _is_wasm_event_export(extension: Any, export_name: str) -> bool:
+    for export in extension.exports:
+        if export.get("name") == export_name:
+            return export.get("visibility") == "event"
+    return False
+
+
+def _wasm_invoice_paid_payload(payment: Any) -> dict[str, Any]:
+    return {
+        "checkingId": payment.checking_id,
+        "paymentHash": payment.payment_hash,
+        "walletId": payment.wallet_id,
+        "amount": payment.amount,
+        "fee": payment.fee,
+        "bolt11": payment.bolt11,
+        "memo": payment.memo,
+        "pending": payment.pending,
+        "status": payment.status,
+        "tag": payment.tag,
+        "extension": payment.extension,
+        "extra": payment.extra or {},
+        "payment": json.loads(payment.json()),
+    }

lnbits/core/extensions/extension_client.py

@@ -13,7 +13,7 @@ from lnbits.core.crud.extensions import (
 )
 from lnbits.settings import settings
 
-from ..api.models import ExtensionApiRequest, HttpResponse
+from .models import ExtensionApiRequest, HttpResponse
 
 EXTENSION_API_TIMEOUT_SECONDS = 10.0
 EXTENSION_API_MAX_RESPONSE_BYTES = 262_144
@@ -31,13 +31,10 @@ _FORBIDDEN_RESPONSE_HEADERS = {
 
 async def send_extension_api_request(
     caller_extension_id: str,
-    policies: list[Any],
+    policy: dict[str, Any],
     user_id: str | None,
     access_token: str | None,
     request: ExtensionApiRequest,
-    *,
-    timeout_ms: int | None = None,
-    max_response_bytes: int | None = None,
 ) -> HttpResponse:
     if not user_id:
         raise PermissionError("Extension API requests require authentication.")
@@ -45,7 +42,7 @@ async def send_extension_api_request(
         raise PermissionError("Extension API requests require an account access token.")
 
     target_extension_id = _target_extension_id(request.extension_id)
-    access = _target_extension_access(policies, target_extension_id)
+    access = _target_extension_access(policy, target_extension_id)
     _require_method_access(caller_extension_id, target_extension_id, access, request)
     await _require_enabled_extension(target_extension_id, user_id)
 
@@ -58,7 +55,7 @@ async def send_extension_api_request(
     try:
         async with httpx.AsyncClient(
             follow_redirects=False,
-            timeout=_timeout_seconds(timeout_ms, EXTENSION_API_TIMEOUT_SECONDS),
+            timeout=EXTENSION_API_TIMEOUT_SECONDS,
             trust_env=False,
         ) as client:
             async with client.stream(
@@ -67,10 +64,7 @@ async def send_extension_api_request(
                 headers={"Authorization": f"Bearer {access_token}"},
                 content=body,
             ) as response:
-                response_body = await _read_limited_response(
-                    response,
-                    max_response_bytes=max_response_bytes,
-                )
+                response_body = await _read_limited_response(response)
                 return HttpResponse(
                     status_code=response.status_code,
                     headers=_response_headers(dict(response.headers)),
@@ -87,13 +81,16 @@ def _target_extension_id(extension_id: str) -> str:
     return target
 
 
-def _target_extension_access(policies: list[Any], target_extension_id: str) -> set[str]:
-    if not isinstance(policies, list) or not policies:
+def _target_extension_access(
+    policy: dict[str, Any], target_extension_id: str
+) -> set[str]:
+    extensions = policy.get("extensions")
+    if not isinstance(extensions, list) or not extensions:
         raise PermissionError(
             "Extension API requests require a non-empty extensions policy."
         )
 
-    for extension in policies:
+    for extension in extensions:
         if isinstance(extension, str):
             extension_id = extension
             access = ["read"]
@@ -183,34 +180,17 @@ def _extension_api_path(path: str) -> str:
     return urlunsplit(("", "", parts.path, parts.query, ""))
 
 
-async def _read_limited_response(
-    response: httpx.Response,
-    *,
-    max_response_bytes: int | None = None,
-) -> bytes:
-    limit = (
-        EXTENSION_API_MAX_RESPONSE_BYTES
-        if max_response_bytes is None
-        else max_response_bytes
-    )
+async def _read_limited_response(response: httpx.Response) -> bytes:
     chunks: list[bytes] = []
     size = 0
     async for chunk in response.aiter_bytes():
         size += len(chunk)
-        if limit > 0 and size > limit:
+        if size > EXTENSION_API_MAX_RESPONSE_BYTES:
             raise ValueError("Extension API response is too large.")
         chunks.append(chunk)
     return b"".join(chunks)
 
 
-def _timeout_seconds(timeout_ms: int | None, default: float) -> float | None:
-    if timeout_ms is None:
-        return default
-    if timeout_ms <= 0:
-        return None
-    return timeout_ms / 1000
-
-
 def _response_headers(headers: dict[str, str]) -> dict[str, str]:
     return {
         key: value

lnbits/core/extensions/http_client.py

@@ -7,7 +7,7 @@ from urllib.parse import urlparse
 
 import httpx
 
-from ..api.models import HttpRequest, HttpResponse
+from .models import HttpRequest, HttpResponse
 
 HTTP_REQUEST_TIMEOUT_SECONDS = 10.0
 HTTP_MAX_RESPONSE_BYTES = 262_144
@@ -30,13 +30,10 @@ _FORBIDDEN_RESPONSE_HEADERS = {
 
 async def send_extension_http_request(
     extension_id: str,
-    policies: list[Any],
+    policy: dict[str, Any],
     request: HttpRequest,
-    *,
-    timeout_ms: int | None = None,
-    max_response_bytes: int | None = None,
 ) -> HttpResponse:
-    allowed_origins = _allowed_origins(policies)
+    allowed_origins = _allowed_origins(policy)
     origin = _request_origin(request.url)
     if origin not in allowed_origins:
         raise PermissionError(
@@ -52,7 +49,7 @@ async def send_extension_http_request(
     try:
         async with httpx.AsyncClient(
             follow_redirects=False,
-            timeout=_timeout_seconds(timeout_ms, HTTP_REQUEST_TIMEOUT_SECONDS),
+            timeout=HTTP_REQUEST_TIMEOUT_SECONDS,
             trust_env=False,
         ) as client:
             async with client.stream(
@@ -61,10 +58,7 @@ async def send_extension_http_request(
                 headers=headers,
                 content=body,
             ) as response:
-                response_body = await _read_limited_response(
-                    response,
-                    max_response_bytes=max_response_bytes,
-                )
+                response_body = await _read_limited_response(response)
                 return HttpResponse(
                     status_code=response.status_code,
                     headers=_response_headers(dict(response.headers)),
@@ -74,13 +68,13 @@ async def send_extension_http_request(
         raise ValueError("HTTP request failed.") from exc
 
 
-def _allowed_origins(policies: list[Any]) -> set[str]:
-    if not isinstance(policies, list) or not policies:
+def _allowed_origins(policy: dict[str, Any]) -> set[str]:
+    hosts = policy.get("hosts")
+    if not isinstance(hosts, list) or not hosts:
         raise PermissionError("HTTP requests require a non-empty hosts policy.")
 
     origins: set[str] = set()
-    for policy in policies:
-        host = policy.get("host") if isinstance(policy, dict) else policy
+    for host in hosts:
         if not isinstance(host, str) or not host:
             continue
         origins.add(_request_origin(host))
@@ -170,32 +164,17 @@ def _request_headers(headers: dict[str, str]) -> dict[str, str]:
     return clean
 
 
-async def _read_limited_response(
-    response: httpx.Response,
-    *,
-    max_response_bytes: int | None = None,
-) -> bytes:
-    limit = (
-        HTTP_MAX_RESPONSE_BYTES if max_response_bytes is None else max_response_bytes
-    )
+async def _read_limited_response(response: httpx.Response) -> bytes:
     chunks: list[bytes] = []
     size = 0
     async for chunk in response.aiter_bytes():
         size += len(chunk)
-        if limit > 0 and size > limit:
+        if size > HTTP_MAX_RESPONSE_BYTES:
             raise ValueError("HTTP response is too large.")
         chunks.append(chunk)
     return b"".join(chunks)
 
 
-def _timeout_seconds(timeout_ms: int | None, default: float) -> float | None:
-    if timeout_ms is None:
-        return default
-    if timeout_ms <= 0:
-        return None
-    return timeout_ms / 1000
-
-
 def _response_headers(headers: dict[str, str]) -> dict[str, str]:
     return {
         key: value

lnbits/core/extensions/loader.py

@@ -5,11 +5,6 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
 
-from lnbits.core.wasm_ext.wasm.config import (
-    WasmExtensionConfig,
-    WasmExtensionExport,
-    parse_wasm_extension_config,
-)
 from lnbits.settings import settings
 
 
@@ -22,13 +17,13 @@ class WasmExtension:
     module_path: Path
     wit_path: Path | None
     world: str
-    exports: list[WasmExtensionExport]
-    config: WasmExtensionConfig
+    host_api: str
+    exports: list[dict[str, Any]]
+    config: dict[str, Any]
 
 
 def is_wasm_extension_id(ext_id: str) -> bool:
-    ext_dir = Path(settings.lnbits_extensions_path, "extensions", ext_id)
-    config = _load_json(ext_dir / "config.json")
+    config = load_wasm_extension_config(ext_id)
     return bool(config and config.get("extension_type") == "wasm")
 
 
@@ -37,38 +32,36 @@ def is_wasm_extension_dir(ext_dir: Path) -> bool:
     return bool(config and config.get("extension_type") == "wasm")
 
 
-def load_wasm_extension_config(ext_id: str) -> WasmExtensionConfig | None:
+def load_wasm_extension_config(ext_id: str) -> dict[str, Any] | None:
     ext_dir = Path(settings.lnbits_extensions_path, "extensions", ext_id)
-    config = _load_json(ext_dir / "config.json")
-    if not config or config.get("extension_type") != "wasm":
-        return None
-    return parse_wasm_extension_config(ext_id, config)
+    return _load_json(ext_dir / "config.json")
 
 
 def load_wasm_extension(ext_id: str) -> WasmExtension:
     ext_dir = Path(settings.lnbits_extensions_path, "extensions", ext_id)
-    raw_config = _load_json(ext_dir / "config.json")
-    if not raw_config:
+    config = load_wasm_extension_config(ext_id)
+    if not config:
         raise FileNotFoundError(f"Missing WASM extension config for '{ext_id}'.")
-    if raw_config.get("extension_type") != "wasm":
+    if config.get("extension_type") != "wasm":
         raise ValueError(f"Extension '{ext_id}' is not a WASM extension.")
-    config = parse_wasm_extension_config(ext_id, raw_config)
 
-    module_path = _extension_path(ext_dir, config.wasm.module)
-    wit_path = _optional_extension_path(ext_dir, config.wasm.wit)
+    wasm_config = config.get("wasm") or {}
+    module_path = _extension_path(ext_dir, wasm_config.get("module"))
+    wit_path = _optional_extension_path(ext_dir, wasm_config.get("wit"))
     _check_wasm_module(module_path)
     if wit_path and not wit_path.is_file():
         raise FileNotFoundError(f"WIT file not found: {wit_path}")
 
     return WasmExtension(
-        id=config.id,
-        name=config.name,
-        version=config.version,
+        id=config.get("id") or ext_id,
+        name=config.get("name") or ext_id,
+        version=config.get("version") or "0.0",
         root_path=ext_dir,
         module_path=module_path,
         wit_path=wit_path,
-        world=config.wasm.world,
-        exports=config.wasm.exports,
+        world=wasm_config.get("world") or "",
+        host_api=wasm_config.get("host_api") or "lnbits.core.extensions.ExtensionAPI",
+        exports=wasm_config.get("exports") or [],
         config=config,
     )
 

lnbits/core/extensions/models.py

@@ -1,43 +1,9 @@
 import json
-from dataclasses import dataclass
 from typing import Any, Literal
 
 from pydantic import BaseModel, Field, root_validator
 
 
-@dataclass(frozen=True)
-class ExtensionAPIMethodExport:
-    method_id: str
-    namespace: str
-    name: str
-    host_interface: str
-    host_name: str
-    sdk_name: str
-    description: str
-    required_permission: str | None = None
-    require_auth: bool = True
-
-
-@dataclass(frozen=True)
-class ExtensionAPIMethod:
-    method_id: str
-    namespace: str
-    name: str
-    python_name: str
-    host_interface: str
-    host_name: str
-    sdk_name: str
-    description: str
-    request_model: type[BaseModel]
-    response_model: type[BaseModel]
-    required_permission: str | None = None
-    require_auth: bool = True
-
-    @property
-    def sdk_qualified_name(self) -> str:
-        return f"{self.namespace}.{self.sdk_name}"
-
-
 class EmptyRequest(BaseModel):
     pass
 
@@ -116,12 +82,7 @@ class CreateInvoiceRequest(BaseModel):
 
 
 class CreateInvoicePublicRequest(BaseModel):
-    source_id: str = Field(
-        ...,
-        min_length=1,
-        max_length=512,
-        description="The source ID (entry id) of the wallet to create the invoice for.",
-    )
+    source_id: str = Field(..., min_length=1, max_length=512)
     amount: float = Field(..., gt=0)
     currency: str = Field(..., min_length=1, max_length=8)
     memo: str = Field("", max_length=512)
@@ -181,17 +142,6 @@ class PayInvoiceRequest(BaseModel):
     extra: dict[str, str] = Field(default_factory=dict)
 
 
-class PayLnurlRequest(BaseModel):
-    wallet_id: str = Field(..., min_length=1, max_length=128)
-    lnurl: str = Field(..., min_length=1, max_length=2048)
-    amount: float = Field(..., gt=0)
-    currency: str = Field("sat", min_length=1, max_length=8)
-    comment: str | None = Field(None, max_length=512)
-    description: str = Field("", max_length=512)
-    max_sat: int | None = Field(None, gt=0)
-    extra: dict[str, str] = Field(default_factory=dict)
-
-
 class PayInvoiceResponse(BaseModel):
     ok: bool = True
     error: str | None = None
@@ -293,22 +243,6 @@ class SatsToFiatResponse(BaseModel):
     amount: float
 
 
-class LnurlResolveRequest(BaseModel):
-    lnurl: str = Field(..., min_length=1, max_length=2048)
-
-
-class LnurlResolveResponse(BaseModel):
-    lnurl: str
-    domain: str | None = None
-    description: str = ""
-    min_sendable_msat: int
-    max_sendable_msat: int
-    comment_allowed: int = 0
-    fixed: bool = False
-    image: str | None = None
-    metadata_json: str = "[]"
-
-
 class ServerHealthResponse(BaseModel):
     server_time: int
     up_time: str

lnbits/core/extensions/permissions.py

@@ -0,0 +1,59 @@
+from collections.abc import Iterable
+from typing import Any
+
+from lnbits.core.extensions.api import extension_api_permission_ids
+from lnbits.core.models.extensions import ExtensionPermission, InstallableExtension
+
+
+def validate_extension_permissions(
+    ext_id: str,
+    permissions: Iterable[ExtensionPermission],
+    *,
+    strict: bool = True,
+) -> list[ExtensionPermission]:
+    known_permission_ids = extension_api_permission_ids()
+    normalized_permissions: list[ExtensionPermission] = []
+    unknown_ids: list[str] = []
+
+    for permission in permissions:
+        if permission.id not in known_permission_ids:
+            unknown_ids.append(permission.id)
+            if strict:
+                continue
+        normalized_permissions.append(permission.copy(update={"label": None}))
+
+    if unknown_ids and strict:
+        raise ValueError(
+            f"Extension '{ext_id}' requests unknown permissions: "
+            + ", ".join(sorted(set(unknown_ids)))
+        )
+
+    return normalized_permissions
+
+
+def validate_wasm_extension_permissions(
+    ext_info: InstallableExtension,
+    granted_permissions: list[ExtensionPermission] | None,
+    extension_config: dict[str, Any],
+) -> list[ExtensionPermission]:
+    if extension_config.get("extension_type") != "wasm":
+        return []
+
+    requested_permissions = validate_extension_permissions(
+        ext_info.id,
+        ExtensionPermission.list_from_config(extension_config),
+    )
+    if not requested_permissions:
+        return []
+
+    if granted_permissions is None:
+        raise ValueError(f"Extension '{ext_info.id}' requires permission approval.")
+
+    requested_ids = {permission.id for permission in requested_permissions}
+    granted_ids = {permission.id for permission in granted_permissions}
+    if requested_ids != granted_ids:
+        raise ValueError(
+            f"Extension '{ext_info.id}' was not granted all requested permissions."
+        )
+
+    return requested_permissions

lnbits/core/extensions/routes.py

@@ -0,0 +1,777 @@
+from __future__ import annotations
+
+import json
+import os
+import re
+from pathlib import Path
+from typing import Annotated, Any, NoReturn
+from uuid import uuid4
+
+from fastapi import Depends, FastAPI, HTTPException, Request
+from fastapi.responses import FileResponse, Response
+from fastapi.staticfiles import StaticFiles
+from loguru import logger
+from pydantic import UUID4
+from starlette.staticfiles import PathLike as StaticFilesPathLike
+from starlette.types import Scope
+
+from lnbits.core.crud import get_installed_extension, get_user_from_account
+from lnbits.core.db import core_app_extra
+from lnbits.core.models import Account
+from lnbits.decorators import (
+    check_access_token,
+    check_account_exists,
+    optional_user_id,
+)
+from lnbits.helpers import template_renderer
+from lnbits.settings import settings
+from lnbits.utils.cache import cache
+
+from .loader import WasmExtension, load_wasm_extension
+from .wasm import invoke_wasm_extension_export, warm_wasm_extension
+
+WASM_FRAME_TOKEN_EXPIRY_SECONDS = 60
+WASM_EXTENSION_CORE_ASSET_PREFIX = "_lnbits"
+WASM_EXTENSION_CORE_STATIC_ASSETS = {
+    "bundle.min.css": ("static/bundle.min.css", "text/css; charset=utf-8"),
+    "material-icons-v50.woff2": (
+        "static/fonts/material-icons-v50.woff2",
+        "font/woff2",
+    ),
+    "quasar.css": ("static/vendor/quasar.css", "text/css; charset=utf-8"),
+    "quasar.umd.prod.js": (
+        "static/vendor/quasar.umd.prod.js",
+        "text/javascript; charset=utf-8",
+    ),
+    "qrcode.vue.browser.js": (
+        "static/vendor/qrcode.vue.browser.js",
+        "text/javascript; charset=utf-8",
+    ),
+    "vue.global.prod.js": (
+        "static/vendor/vue.global.prod.js",
+        "text/javascript; charset=utf-8",
+    ),
+}
+WASM_EXTENSION_GENERATED_CORE_ASSETS = {
+    "material-icons.css": (
+        """
+        @font-face {
+          font-family: 'Material Icons';
+          font-style: normal;
+          font-weight: 400;
+          src: url('./material-icons-v50.woff2') format('woff2');
+        }
+        """,
+        "text/css; charset=utf-8",
+    )
+}
+WASM_EXTENSION_STATIC_MIME_TYPES = {
+    ".css": "text/css; charset=utf-8",
+    ".gif": "image/gif",
+    ".ico": "image/x-icon",
+    ".jpeg": "image/jpeg",
+    ".jpg": "image/jpeg",
+    ".js": "text/javascript; charset=utf-8",
+    ".png": "image/png",
+    ".webp": "image/webp",
+    ".woff": "font/woff",
+    ".woff2": "font/woff2",
+}
+WASM_EXTENSION_TEXT_STATIC_EXTENSIONS = {".css", ".js"}
+WASM_EXTENSION_HTML_PREFIXES = (b"<!doctype", b"<html", b"<script")
+
+
+class GuardedWasmExtensionStaticFiles(StaticFiles):
+    async def get_response(self, path: str, scope: Scope) -> Response:
+        if path.startswith(f"{WASM_EXTENSION_CORE_ASSET_PREFIX}/"):
+            return _wasm_extension_core_asset_response(path)
+        if Path(path).suffix.lower() not in WASM_EXTENSION_STATIC_MIME_TYPES:
+            raise HTTPException(status_code=404)
+        return await super().get_response(path, scope)
+
+    def file_response(
+        self,
+        full_path: StaticFilesPathLike,
+        stat_result: os.stat_result,
+        scope: Scope,
+        status_code: int = 200,
+    ) -> Response:
+        suffix = Path(full_path).suffix.lower()
+        if suffix in WASM_EXTENSION_TEXT_STATIC_EXTENSIONS:
+            _reject_html_like_wasm_static_asset(Path(full_path))
+
+        response = super().file_response(full_path, stat_result, scope, status_code)
+        response.headers["Content-Type"] = WASM_EXTENSION_STATIC_MIME_TYPES[suffix]
+        response.headers["X-Content-Type-Options"] = "nosniff"
+        response.headers["Cache-Control"] = "no-store"
+        return response
+
+
+def register_wasm_extension(app: FastAPI, ext_id: str) -> WasmExtension:
+    loaded = load_wasm_extension(ext_id)
+
+    warm_wasm_extension(loaded)
+    _mount_wasm_extension_static(app, loaded)
+    _register_wasm_extension_ui_routes(app, loaded)
+    _register_wasm_extension_api_routes(app, loaded)
+
+    core_app_extra.wasm_extension_registry.register(loaded)
+
+    settings.activate_extension_paths(ext_id, "", [])
+    logger.info(
+        f"Loaded WASM extension '{loaded.id}' "
+        f"({loaded.module_path.stat().st_size} bytes)."
+    )
+    return loaded
+
+
+def _mount_wasm_extension_static(app: FastAPI, extension: WasmExtension) -> None:
+    static_path = extension.root_path / "static"
+
+    mount_path = f"/ext-assets/{extension.id}"
+    if any(getattr(route, "path", None) == mount_path for route in app.routes):
+        return
+
+    app.mount(
+        mount_path,
+        GuardedWasmExtensionStaticFiles(directory=static_path, check_dir=False),
+        name=f"{extension.id}-static",
+    )
+
+
+def _register_wasm_extension_ui_routes(app: FastAPI, extension: WasmExtension) -> None:
+    _add_wasm_extension_frame_config_route(app, extension)
+
+    for route_index, route_config in enumerate(extension.config.get("ui_routes") or []):
+        route_path = _wasm_extension_ui_route_path(extension, route_config.get("path"))
+        entrypoint = _wasm_extension_entrypoint(
+            extension, route_config.get("entrypoint")
+        )
+        frame_path = f"/ext-frame/{extension.id}/{route_index}"
+        auth = _wasm_extension_route_auth(extension, route_config.get("auth"))
+        _add_wasm_extension_frame_route(app, extension, frame_path, entrypoint)
+        _add_wasm_extension_wrapper_route(
+            app,
+            extension,
+            route_path,
+            auth,
+        )
+
+
+def _register_wasm_extension_api_routes(app: FastAPI, extension: WasmExtension) -> None:
+    for route_config in extension.config.get("api_routes") or []:
+        _add_wasm_extension_api_route(app, extension, route_config)
+
+
+def _add_wasm_extension_api_route(
+    app: FastAPI,
+    extension: WasmExtension,
+    route_config: dict[str, Any],
+) -> None:
+    method = _wasm_extension_api_method(extension, route_config.get("method"))
+    route_path = _wasm_extension_api_path(extension, route_config.get("path"))
+    export_name = _wasm_extension_api_export(extension, route_config.get("export"))
+    path_params = route_config.get("path_params") or {}
+    auth = _wasm_extension_route_auth(extension, route_config.get("auth"))
+
+    if _has_route(app, route_path, method):
+        return
+
+    async def invoke_wasm_api_request(
+        request: Request,
+        account: Account | None = None,
+        access_token: str | None = None,
+    ) -> dict[str, Any]:
+        try:
+            payload = await _read_api_payload(request, path_params)
+            return await invoke_wasm_extension_export(
+                extension.id,
+                export_name,
+                payload,
+                user=account,
+                access_token=access_token,
+            )
+        except KeyError as exc:
+            raise HTTPException(status_code=404, detail=str(exc)) from exc
+        except PermissionError as exc:
+            raise HTTPException(status_code=403, detail=str(exc)) from exc
+        except (TypeError, ValueError) as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+    async def invoke_private_wasm_extension_export(
+        request: Request,
+        access_token: Annotated[str | None, Depends(check_access_token)],
+        account: Account = Depends(check_account_exists),
+    ) -> dict[str, Any]:
+        return await invoke_wasm_api_request(request, account, access_token)
+
+    async def invoke_public_wasm_extension_export(request: Request) -> dict[str, Any]:
+        return await invoke_wasm_api_request(request)
+
+    app.add_api_route(
+        route_path,
+        (
+            invoke_public_wasm_extension_export
+            if auth == "public"
+            else invoke_private_wasm_extension_export
+        ),
+        methods=[method],
+        name=f"{extension.id}:{method}:{route_path}",
+        include_in_schema=False,
+    )
+
+
+def _add_wasm_extension_frame_config_route(
+    app: FastAPI,
+    extension: WasmExtension,
+) -> None:
+    route_path = _wasm_extension_frame_config_path(extension)
+    if _has_route(app, route_path, "POST"):
+        return
+
+    async def create_wasm_extension_frame_config(
+        request: Request,
+        access_token: Annotated[str | None, Depends(check_access_token)],
+        usr: UUID4 | None = None,
+    ) -> dict[str, Any]:
+        try:
+            body = await _read_json_object(request)
+        except (TypeError, ValueError) as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+        ui_route = _match_wasm_extension_ui_route(extension, body.get("path"))
+        auth = ui_route["auth"]
+
+        if auth == "user":
+            account = await check_account_exists(request, access_token, usr)
+            user_id: str | None = account.id
+        else:
+            user_id = await _optional_wasm_user_id(request, access_token, usr)
+
+        granted_permission_ids = await _wasm_extension_granted_permission_ids(extension)
+
+        return _wasm_extension_frame_config(
+            extension,
+            ui_route["frame_path"],
+            auth,
+            ui_route["path_params"],
+            ui_route["route_params"],
+            _read_wasm_extension_route_query(body.get("query")),
+            user_id,
+            granted_permission_ids,
+        )
+
+    app.add_api_route(
+        route_path,
+        create_wasm_extension_frame_config,
+        methods=["POST"],
+        name=f"{extension.id}:frame-config",
+        include_in_schema=False,
+    )
+
+
+async def _read_api_payload(
+    request: Request,
+    path_params: dict[str, str],
+) -> dict[str, Any]:
+    payload = _read_api_path_params(request, path_params)
+    payload.update(_read_api_query_params(request))
+    if request.method in {"POST", "PUT", "PATCH"}:
+        payload.update(await _read_json_object(request))
+    return payload
+
+
+async def _read_json_object(request: Request) -> dict[str, Any]:
+    body = await request.body()
+    if not body:
+        return {}
+    value = json.loads(body)
+    if not isinstance(value, dict):
+        raise TypeError("WASM extension API payload must be a JSON object.")
+    return value
+
+
+def _read_api_path_params(
+    request: Request,
+    path_params: dict[str, str],
+) -> dict[str, Any]:
+    payload: dict[str, Any] = {}
+    for key, value in request.path_params.items():
+        target = path_params.get(key) or _snake_to_camel(key)
+        payload[target] = value
+    return payload
+
+
+def _read_api_query_params(request: Request) -> dict[str, Any]:
+    return {_snake_to_camel(key): value for key, value in request.query_params.items()}
+
+
+def _wasm_extension_api_export(extension: WasmExtension, export_name: Any) -> str:
+    if not isinstance(export_name, str) or not export_name:
+        raise ValueError(f"Invalid API export for WASM extension '{extension.id}'.")
+
+    for export in extension.exports:
+        if export.get("name") != export_name:
+            continue
+        if export.get("visibility") in {"public", "authenticated"}:
+            return export_name
+        raise PermissionError(f"WASM export '{export_name}' is not callable over HTTP.")
+    raise KeyError(f"WASM extension '{extension.id}' has no export '{export_name}'.")
+
+
+def _wasm_extension_api_method(extension: WasmExtension, method: Any) -> str:
+    if not isinstance(method, str):
+        raise ValueError(f"Invalid API method for WASM extension '{extension.id}'.")
+    method = method.upper()
+    if method not in {"GET", "POST", "PUT", "PATCH", "DELETE"}:
+        raise ValueError(f"Unsupported API method for WASM extension '{extension.id}'.")
+    return method
+
+
+def _wasm_extension_api_path(extension: WasmExtension, path: Any) -> str:
+    if not isinstance(path, str) or not path.startswith("/"):
+        raise ValueError(f"Invalid API path for WASM extension '{extension.id}'.")
+    if path == "/":
+        return f"/api/v1/ext/{extension.id}"
+    return f"/api/v1/ext/{extension.id}{path}"
+
+
+def _has_route(app: FastAPI, route_path: str, method: str) -> bool:
+    for route in app.routes:
+        if getattr(route, "path", None) != route_path:
+            continue
+        methods = getattr(route, "methods", set()) or set()
+        if method in methods:
+            return True
+    return False
+
+
+def _snake_to_camel(value: str) -> str:
+    head, *tail = value.split("_")
+    return head + "".join(part.capitalize() for part in tail)
+
+
+def _add_wasm_extension_wrapper_route(
+    app: FastAPI,
+    extension: WasmExtension,
+    route_path: str,
+    auth: str,
+) -> None:
+    if _has_route(app, route_path, "GET"):
+        return
+
+    async def serve_private_wasm_extension_page(
+        request: Request,
+        account: Account = Depends(check_account_exists),
+    ) -> Any:
+        user = await get_user_from_account(account)
+        return _wasm_extension_wrapper_response(
+            request,
+            extension,
+            auth,
+            user.json() if user else None,
+        )
+
+    async def serve_public_wasm_extension_page(request: Request) -> Any:
+        return _wasm_extension_wrapper_response(
+            request,
+            extension,
+            auth,
+            None,
+        )
+
+    app.add_api_route(
+        route_path,
+        (
+            serve_public_wasm_extension_page
+            if auth == "public"
+            else serve_private_wasm_extension_page
+        ),
+        methods=["GET"],
+        name=f"{extension.id}:{route_path}",
+        include_in_schema=False,
+    )
+
+
+def _add_wasm_extension_frame_route(
+    app: FastAPI,
+    extension: WasmExtension,
+    frame_path: str,
+    entrypoint: Path,
+) -> None:
+    if _has_route(app, frame_path, "GET"):
+        return
+
+    async def serve_wasm_extension_frame(
+        request: Request,
+        user_id: str | None = Depends(_optional_wasm_user_id),
+    ) -> FileResponse:
+        _consume_wasm_extension_frame_token(request, extension, frame_path, user_id)
+        response = FileResponse(entrypoint)
+        response.headers["Content-Security-Policy"] = _wasm_extension_frame_csp(
+            request, extension
+        )
+        response.headers["Cache-Control"] = "no-store"
+        response.headers["Cross-Origin-Opener-Policy"] = "same-origin"
+        response.headers["Cross-Origin-Resource-Policy"] = "same-origin"
+        # Extension access goes through the parent bridge.
+        response.headers["Permissions-Policy"] = (
+            "camera=(), microphone=(), geolocation=(), payment=(), "
+            "clipboard-read=(), usb=()"
+        )
+        response.headers["Referrer-Policy"] = "no-referrer"
+        response.headers["X-Content-Type-Options"] = "nosniff"
+        return response
+
+    app.add_api_route(
+        frame_path,
+        serve_wasm_extension_frame,
+        methods=["GET"],
+        name=f"{extension.id}:frame:{frame_path}",
+        include_in_schema=False,
+    )
+
+
+def _wasm_extension_wrapper_response(
+    request: Request,
+    extension: WasmExtension,
+    auth: str,
+    user_json: str | None,
+) -> Any:
+    public = auth == "public"
+    response = template_renderer().TemplateResponse(
+        request,
+        "wasm_extension.html",
+        {
+            "extension": extension,
+            "public": public,
+            "user": user_json,
+        },
+    )
+    response.headers["Content-Security-Policy"] = "frame-ancestors 'self'"
+    response.headers["X-Frame-Options"] = "SAMEORIGIN"
+    return response
+
+
+def _wasm_extension_frame_csp(request: Request, extension: WasmExtension) -> str:
+    origin = str(request.base_url).rstrip("/")
+    extension_assets = f"{origin}/ext-assets/{extension.id}/"
+    return (
+        "sandbox allow-scripts; "
+        "default-src 'none'; "
+        f"script-src {extension_assets}; "
+        "script-src-attr 'none'; "
+        f"style-src {extension_assets}; "
+        "style-src-attr 'none'; "
+        f"img-src {extension_assets} data:; "
+        f"font-src {extension_assets}; "
+        "connect-src 'none'; "
+        "form-action 'none'; "
+        "object-src 'none'; "
+        "base-uri 'none'; "
+        "frame-src 'none'; "
+        "worker-src 'none'; "
+        "media-src 'none'; "
+        "manifest-src 'none'; "
+        "frame-ancestors 'self'"
+    )
+
+
+def _wasm_extension_frame_url(
+    extension: WasmExtension, frame_path: str, user_id: str | None
+) -> str:
+    token = _create_wasm_extension_frame_token(extension, frame_path, user_id)
+    return f"{frame_path}?frame_token={token}"
+
+
+def _create_wasm_extension_frame_token(
+    extension: WasmExtension,
+    frame_path: str,
+    user_id: str | None,
+) -> str:
+    token = uuid4().hex
+    cache.set(
+        _wasm_extension_frame_token_cache_key(token),
+        {
+            "extension_id": extension.id,
+            "frame_path": frame_path,
+            "user_id": user_id,
+        },
+        expiry=WASM_FRAME_TOKEN_EXPIRY_SECONDS,
+    )
+    return token
+
+
+def _consume_wasm_extension_frame_token(
+    request: Request,
+    extension: WasmExtension,
+    frame_path: str,
+    user_id: str | None,
+) -> None:
+    token = request.query_params.get("frame_token")
+    if not token:
+        _raise_wasm_extension_frame_not_found(extension, frame_path, "missing")
+
+    cache_key = _wasm_extension_frame_token_cache_key(token)
+    token_data = cache.get(cache_key)
+    if (
+        not isinstance(token_data, dict)
+        or token_data.get("extension_id") != extension.id
+        or token_data.get("frame_path") != frame_path
+    ):
+        _raise_wasm_extension_frame_not_found(
+            extension, frame_path, "unknown or expired"
+        )
+
+    token_user_id = token_data.get("user_id")
+    if token_user_id and token_user_id != user_id:
+        _raise_wasm_extension_frame_not_found(extension, frame_path, "wrong user")
+
+    cache.pop(cache_key)
+
+
+def _wasm_extension_frame_token_cache_key(token: str) -> str:
+    return f"wasm-frame-token:{token}"
+
+
+def _raise_wasm_extension_frame_not_found(
+    extension: WasmExtension,
+    frame_path: str,
+    reason: str,
+) -> NoReturn:
+    logger.warning(
+        f"WASM frame token {reason} for extension '{extension.id}' at '{frame_path}'."
+    )
+    raise HTTPException(status_code=404, detail="Not found")
+
+
+def _wasm_extension_bridge_api_routes(
+    extension: WasmExtension,
+    public: bool,
+) -> list[dict[str, str]]:
+    routes: list[dict[str, str]] = []
+    for route_config in extension.config.get("api_routes") or []:
+        auth = _wasm_extension_route_auth(extension, route_config.get("auth"))
+        if public and auth != "public":
+            continue
+        method = _wasm_extension_api_method(extension, route_config.get("method"))
+        path = _wasm_extension_api_path(extension, route_config.get("path"))
+        _wasm_extension_api_export(extension, route_config.get("export"))
+        routes.append(
+            {
+                "method": method,
+                "path": path,
+                "pattern": _path_template_pattern(path),
+            }
+        )
+    return routes
+
+
+def _wasm_extension_frame_config_path(extension: WasmExtension) -> str:
+    return f"/api/v1/ext/{extension.id}/_ui/frame"
+
+
+def _match_wasm_extension_ui_route(
+    extension: WasmExtension,
+    path: Any,
+) -> dict[str, Any]:
+    if not isinstance(path, str) or not path.startswith("/"):
+        raise HTTPException(status_code=404, detail="Not found")
+
+    for route_index, route_config in enumerate(extension.config.get("ui_routes") or []):
+        route_path = _wasm_extension_ui_route_path(extension, route_config.get("path"))
+        route_params = _path_template_params(route_path, path)
+        if route_params is None:
+            continue
+
+        return {
+            "frame_path": f"/ext-frame/{extension.id}/{route_index}",
+            "auth": _wasm_extension_route_auth(extension, route_config.get("auth")),
+            "path_params": route_config.get("path_params") or {},
+            "route_params": route_params,
+        }
+
+    raise HTTPException(status_code=404, detail="Not found")
+
+
+def _path_template_params(template: str, path: str) -> dict[str, str] | None:
+    template_parts = _path_parts(template)
+    path_parts = _path_parts(path)
+    if len(template_parts) != len(path_parts):
+        return None
+
+    params: dict[str, str] = {}
+    for template_part, path_part in zip(template_parts, path_parts, strict=False):
+        if template_part.startswith("{") and template_part.endswith("}"):
+            param_name = template_part[1:-1]
+            if not param_name:
+                return None
+            params[param_name] = path_part
+            continue
+
+        if template_part != path_part:
+            return None
+
+    return params
+
+
+def _path_parts(path: str) -> list[str]:
+    return [part for part in path.strip("/").split("/") if part]
+
+
+def _wasm_extension_frame_config(
+    extension: WasmExtension,
+    frame_path: str,
+    auth: str,
+    path_params: dict[str, str],
+    route_params: dict[str, str],
+    query: dict[str, Any],
+    user_id: str | None,
+    permissions: set[str],
+) -> dict[str, Any]:
+    public = auth == "public"
+    return {
+        "extension": {
+            "id": extension.id,
+            "name": extension.name,
+        },
+        "frameUrl": _wasm_extension_frame_url(extension, frame_path, user_id),
+        "bridge": {
+            "extensionId": extension.id,
+            "public": public,
+            "routeParams": _map_wasm_extension_route_params(route_params, path_params),
+            "query": query,
+            "permissions": sorted(permissions),
+            "apiRoutes": _wasm_extension_bridge_api_routes(extension, public),
+        },
+    }
+
+
+async def _wasm_extension_granted_permission_ids(
+    extension: WasmExtension,
+) -> set[str]:
+    installed_extension = await get_installed_extension(extension.id)
+    if not installed_extension:
+        return set()
+    return {permission.id for permission in installed_extension.permissions}
+
+
+def _map_wasm_extension_route_params(
+    route_params: dict[str, str],
+    path_params: dict[str, str],
+) -> dict[str, str]:
+    payload: dict[str, str] = {}
+    for key, value in route_params.items():
+        target = path_params.get(key) or _snake_to_camel(key)
+        payload[target] = value
+    return payload
+
+
+def _read_wasm_extension_route_query(query: Any) -> dict[str, Any]:
+    if not isinstance(query, dict):
+        return {}
+
+    payload: dict[str, Any] = {}
+    for key, value in query.items():
+        if value is None:
+            continue
+        payload[_snake_to_camel(str(key))] = value
+    return payload
+
+
+def _path_template_pattern(path: str) -> str:
+    pattern = re.sub(r"\\{[^/{}]+\\}", r"[^/]+", re.escape(path))
+    return f"^{pattern}$"
+
+
+async def _optional_wasm_user_id(
+    request: Request,
+    access_token: Annotated[str | None, Depends(check_access_token)],
+    usr: UUID4 | None = None,
+) -> str | None:
+    try:
+        return await optional_user_id(request, access_token, usr)
+    except HTTPException:
+        return None
+
+
+def _wasm_extension_route_auth(extension: WasmExtension, auth: Any) -> str:
+    if auth in {"public", "user"}:
+        return auth
+    raise ValueError(f"Invalid route auth for WASM extension '{extension.id}'.")
+
+
+def _wasm_extension_ui_route_path(extension: WasmExtension, path: Any) -> str:
+    if not isinstance(path, str) or not path.startswith("/"):
+        raise ValueError(f"Invalid route path for WASM extension '{extension.id}'.")
+    if path == "/":
+        return "/ext"
+    return f"/ext{path}"
+
+
+def _wasm_extension_entrypoint(extension: WasmExtension, entrypoint: Any) -> Path:
+    if not isinstance(entrypoint, str) or not entrypoint:
+        raise ValueError(
+            f"Invalid route entrypoint for WASM extension '{extension.id}'."
+        )
+    if entrypoint.startswith("/"):
+        raise ValueError(
+            f"Route entrypoint for WASM extension '{extension.id}' must be a "
+            "relative extension path."
+        )
+
+    path = (extension.root_path / entrypoint).resolve()
+    root_path = extension.root_path.resolve()
+    if path != root_path and root_path not in path.parents:
+        raise ValueError(f"Route entrypoint escapes extension root: {entrypoint}")
+
+    static_path = (extension.root_path / "static").resolve()
+    if path == static_path or static_path in path.parents:
+        raise ValueError(
+            f"Route entrypoint for WASM extension '{extension.id}' must not be "
+            "inside the static asset directory."
+        )
+    if path.suffix.lower() != ".html":
+        raise ValueError(
+            f"Route entrypoint for WASM extension '{extension.id}' must be "
+            "an HTML file."
+        )
+    if not path.is_file():
+        raise FileNotFoundError(f"Route entrypoint not found: {path}")
+    return path
+
+
+def _reject_html_like_wasm_static_asset(path: Path) -> None:
+    with path.open("rb") as asset_file:
+        prefix = asset_file.read(512).lstrip().lower()
+    if prefix.startswith(WASM_EXTENSION_HTML_PREFIXES):
+        raise HTTPException(status_code=404)
+
+
+def _wasm_extension_core_asset_response(path: str) -> Response:
+    asset_name = path.removeprefix(f"{WASM_EXTENSION_CORE_ASSET_PREFIX}/")
+    if not asset_name or "/" in asset_name or "\\" in asset_name:
+        raise HTTPException(status_code=404)
+
+    generated_asset = WASM_EXTENSION_GENERATED_CORE_ASSETS.get(asset_name)
+    if generated_asset:
+        content, content_type = generated_asset
+        response = Response(content=content, media_type=content_type)
+        response.headers["X-Content-Type-Options"] = "nosniff"
+        response.headers["Cache-Control"] = "no-store"
+        return response
+
+    asset_config = WASM_EXTENSION_CORE_STATIC_ASSETS.get(asset_name)
+    if not asset_config:
+        raise HTTPException(status_code=404)
+
+    relative_path, content_type = asset_config
+    asset_path = Path(settings.lnbits_path, relative_path)
+    if not asset_path.is_file():
+        raise HTTPException(status_code=404)
+
+    response = FileResponse(asset_path)
+    response.headers["Content-Type"] = content_type
+    response.headers["X-Content-Type-Options"] = "nosniff"
+    response.headers["Cache-Control"] = "no-store"
+    return response

lnbits/core/extensions/runtime.py

@@ -7,9 +7,7 @@ from typing import Any
 
 from pydantic import BaseModel
 
-from .host import ExtensionHostAPI
-from .models import ExtensionAPIMethod
-from .registry import list_extension_api_methods
+from .api import ExtensionAPI, ExtensionAPIMethod, list_extension_api_methods
 
 HostImport = Callable[..., Awaitable[dict[str, Any]]]
 
@@ -17,9 +15,9 @@ HostImport = Callable[..., Awaitable[dict[str, Any]]]
 class ExtensionAPIHost:
     def __init__(
         self,
-        api: ExtensionHostAPI,
+        api: ExtensionAPI,
         *,
-        api_cls: type[ExtensionHostAPI] = ExtensionHostAPI,
+        api_cls: type[ExtensionAPI] = ExtensionAPI,
     ) -> None:
         self.api = api
         self.methods = list_extension_api_methods(api_cls)
@@ -31,9 +29,6 @@ class ExtensionAPIHost:
         payload: Mapping[str, Any] | BaseModel | None = None,
     ) -> dict[str, Any]:
         method = self._require_method(host_name)
-        from lnbits.core.services.extensions import record_wasm_invocation_host_call
-
-        record_wasm_invocation_host_call(self.api.invocation_id, method.method_id)
         request = self._request_model(method, payload)
         handler = _resolve_attr_path(self.api, method.python_name)
         response = handler(request)

lnbits/core/extensions/storage.py

@@ -12,7 +12,7 @@ from lnbits.core.crud import update_migration_version
 from lnbits.core.db import db as core_db
 from lnbits.core.models import DbVersion
 from lnbits.core.models.extensions import InstallableExtension
-from lnbits.db import POSTGRES, SQLITE, Compat, Connection, Database
+from lnbits.db import POSTGRES, SQLITE, Connection, Database
 from lnbits.settings import settings
 
 _MIGRATION_FILE_RE = re.compile(r"^(\d+)_.*\.json$")
@@ -76,16 +76,9 @@ async def storage_set_row(
 ) -> None:
     table_schema = _load_table_schema(ext_id, table)
     clean_data = _data_to_db(table_schema, data, require_id=True)
-    columns = list(clean_data.keys())
-    database = Database(f"ext_{ext_id}")
-    fields = _fields_by_name(table_schema)
-    placeholders = [
-        _value_placeholder(database, fields[column], column) for column in columns
-    ]
-
     clean_data[OWNER_ID_FIELD] = owner_id
-    columns.append(OWNER_ID_FIELD)
-    placeholders.append(f":{OWNER_ID_FIELD}")
+    columns = list(clean_data.keys())
+    placeholders = [f":{column}" for column in columns]
     updates = [
         f"{column} = excluded.{column}"
         for column in columns
@@ -94,19 +87,19 @@ async def storage_set_row(
     conflict_sql = (
         "DO UPDATE SET "
         + ", ".join(updates)
-        + f" WHERE storage_row.{OWNER_ID_FIELD} = :{OWNER_ID_FIELD}"
+        + f" WHERE {OWNER_ID_FIELD} = :{OWNER_ID_FIELD}"
         if updates
         else "DO NOTHING"
     )
     query = f"""
-        INSERT INTO {_table_ref_for_schema(ext_id, table)} AS storage_row
+        INSERT INTO {_table_ref_for_schema(ext_id, table)}
             ({", ".join(columns)})
         VALUES
             ({", ".join(placeholders)})
         ON CONFLICT (id) {conflict_sql}
     """  # noqa: S608
 
-    async with database.connect() as conn:
+    async with Database(f"ext_{ext_id}").connect() as conn:
         await conn.execute(query, clean_data)
 
 
@@ -124,10 +117,7 @@ async def storage_get_paginated_rows(
     offset: int,
 ) -> dict[str, Any]:
     table_schema = _load_table_schema(ext_id, table)
-    database = Database(f"ext_{ext_id}")
-    where_sql, values = _where_sql(
-        database, table_schema, filters, search, search_fields
-    )
+    where_sql, values = _where_sql(table_schema, filters, search, search_fields)
     where_sql = _append_owner_where_sql(where_sql)
     values[OWNER_ID_FIELD] = owner_id
     order_sql = _order_sql(table_schema, sort_by, descending)
@@ -147,7 +137,7 @@ async def storage_get_paginated_rows(
         {where_sql}
     """  # noqa: S608
 
-    async with database.connect() as conn:
+    async with Database(f"ext_{ext_id}").connect() as conn:
         rows = await conn.fetchall(rows_query, values)
         count_row = await conn.fetchone(count_query, count_values)
 
@@ -413,25 +403,14 @@ def _filters_to_db(
     }
 
 
-def _value_placeholder(db: Compat, field: dict[str, Any], key: str) -> str:
-    if field.get("type") == "datetime" and not field.get("list"):
-        return db.timestamp_placeholder(key)
-    return f":{key}"
-
-
 def _where_sql(
-    db: Compat,
     table_schema: dict[str, Any],
     filters: dict[str, Any],
     search: str | None,
     search_fields: list[str],
 ) -> tuple[str, dict[str, Any]]:
     clean_filters = _filters_to_db(table_schema, filters)
-    fields = _fields_by_name(table_schema)
-    clauses = [
-        f"{field} = {_value_placeholder(db, fields[field], f'filter_{field}')}"
-        for field in clean_filters
-    ]
+    clauses = [f"{field} = :filter_{field}" for field in clean_filters]
     values = {f"filter_{field}": value for field, value in clean_filters.items()}
 
     clean_search = search.strip().lower() if search else ""

lnbits/core/extensions/wasm.py

@@ -0,0 +1,230 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import re
+from collections.abc import Mapping
+from functools import lru_cache
+from typing import Any
+
+from lnbits.core.crud.extensions import get_installed_extension
+from lnbits.core.db import core_app_extra
+
+from .api import ExtensionAPI, list_extension_api_methods
+from .loader import WasmExtension
+from .runtime import ExtensionAPIHost
+
+
+async def invoke_wasm_extension_export(
+    ext_id: str,
+    export_name: str,
+    payload: Mapping[str, Any] | None = None,
+    *,
+    user: Any | None = None,
+    access_token: str | None = None,
+    context: str = "user",
+    owner_id: str | None = None,
+) -> dict[str, Any]:
+    extension = _get_registered_extension(ext_id)
+    permissions = await _extension_permissions(extension)
+    api = ExtensionAPI(
+        extension.id,
+        permissions,
+        user_id=_user_id(user),
+        access_token=access_token,
+        context=context,
+        owner_id=owner_id,
+    )
+    event_loop = asyncio.get_running_loop()
+
+    return await asyncio.to_thread(
+        _invoke_wasm_extension_export_sync,
+        extension,
+        export_name,
+        payload or {},
+        api,
+        event_loop,
+    )
+
+
+def warm_wasm_extension(extension: WasmExtension) -> None:
+    _wasm_component(extension)
+
+
+def _invoke_wasm_extension_export_sync(
+    extension: WasmExtension,
+    export_name: str,
+    payload: Mapping[str, Any],
+    api: ExtensionAPI,
+    event_loop: asyncio.AbstractEventLoop,
+) -> dict[str, Any]:
+    try:
+        from wasmtime import Store, WasiConfig, component
+    except ImportError as exc:
+        raise RuntimeError(
+            "WASM extension runtime is not installed. Install the 'wasmtime' "
+            "Python package to run WASM extensions."
+        ) from exc
+
+    engine = _wasm_engine()
+    store = Store(engine)
+    store.set_wasi(WasiConfig())
+
+    linker = component.Linker(engine)
+    linker.add_wasip2()
+    _add_extension_host_imports(linker, ExtensionAPIHost(api), event_loop)
+
+    wasm_component = _wasm_component(extension)
+    instance = linker.instantiate(store, wasm_component)
+    function = instance.get_func(store, export_name)
+    if not function:
+        raise KeyError(
+            f"WASM extension '{extension.id}' has no export '{export_name}'."
+        )
+
+    result = function(store, json.dumps(payload))
+    function.post_return(store)
+    return _parse_wasm_export_result(extension, result)
+
+
+@lru_cache(maxsize=1)
+def _wasm_engine() -> Any:
+    try:
+        from wasmtime import Config, Engine
+    except ImportError as exc:
+        raise RuntimeError(
+            "WASM extension runtime is not installed. Install the 'wasmtime' "
+            "Python package to run WASM extensions."
+        ) from exc
+
+    config = Config()
+    config.wasm_component_model = True
+    return Engine(config)
+
+
+def _wasm_component(extension: WasmExtension) -> Any:
+    stat = extension.module_path.stat()
+    return _cached_wasm_component(
+        str(extension.module_path),
+        stat.st_mtime_ns,
+        stat.st_size,
+    )
+
+
+@lru_cache(maxsize=32)
+def _cached_wasm_component(
+    module_path: str,
+    mtime_ns: int,
+    size: int,
+) -> Any:
+    from wasmtime import component
+
+    return component.Component.from_file(_wasm_engine(), module_path)
+
+
+def _add_extension_host_imports(
+    linker: Any,
+    api_host: ExtensionAPIHost,
+    event_loop: asyncio.AbstractEventLoop,
+) -> None:
+    with linker.root() as root:
+        methods_by_interface: dict[str, list[Any]] = {}
+        for method in list_extension_api_methods():
+            methods_by_interface.setdefault(method.host_interface, []).append(method)
+
+        for host_interface, methods in methods_by_interface.items():
+            with root.add_instance(f"lnbits:extension/{host_interface}") as host:
+                for method in methods:
+                    host.add_func(
+                        method.host_name.replace("_", "-"),
+                        _make_host_import(api_host, method.method_id, event_loop),
+                    )
+
+
+def _make_host_import(
+    api_host: ExtensionAPIHost,
+    host_name: str,
+    event_loop: asyncio.AbstractEventLoop,
+) -> Any:
+    def host_import(_store: Any, request: Any = None) -> Any:
+        payload = _component_payload_to_dict(request)
+        future = asyncio.run_coroutine_threadsafe(
+            api_host.invoke(host_name, payload), event_loop
+        )
+        response = future.result()
+        return _dict_to_component_record(response)
+
+    return host_import
+
+
+def _component_payload_to_dict(value: Any) -> dict[str, Any]:
+    if value is None:
+        return {}
+    if hasattr(value, "__dict__"):
+        return dict(value.__dict__)
+    if isinstance(value, Mapping):
+        return dict(value)
+    raise TypeError("WASM host function payload must be a record.")
+
+
+def _dict_to_component_record(value: Mapping[str, Any]) -> Any:
+    from wasmtime import component
+
+    record = component.Record()
+    for key, item in value.items():
+        setattr(record, _camel_to_kebab(key), _to_component_value(item))
+    return record
+
+
+def _to_component_value(value: Any) -> Any:
+    if isinstance(value, Mapping):
+        return _dict_to_component_record(value)
+    if isinstance(value, list):
+        return [_to_component_value(item) for item in value]
+    return value
+
+
+def _parse_wasm_export_result(extension: WasmExtension, value: Any) -> dict[str, Any]:
+    if isinstance(value, bytes):
+        value = value.decode()
+    if not isinstance(value, str):
+        return {"ok": True, "data": value}
+
+    max_response_bytes = (
+        (extension.config.get("wasm") or {})
+        .get("resource_limits", {})
+        .get("max_response_bytes")
+    )
+    if isinstance(max_response_bytes, int):
+        response_size = len(value.encode())
+        if response_size > max_response_bytes:
+            raise ValueError(
+                f"WASM extension response is too large: {response_size} bytes."
+            )
+
+    parsed = json.loads(value)
+    if isinstance(parsed, dict):
+        return parsed
+    return {"ok": True, "data": parsed}
+
+
+def _get_registered_extension(ext_id: str) -> WasmExtension:
+    extension = core_app_extra.wasm_extension_registry.get(ext_id)
+    if extension:
+        return extension
+    raise RuntimeError(f"WASM extension '{ext_id}' is not registered.")
+
+
+async def _extension_permissions(extension: WasmExtension) -> list[Any]:
+    installed_extension = await get_installed_extension(extension.id)
+    if not installed_extension:
+        return []
+    return installed_extension.permissions
+
+
+def _user_id(user: Any | None) -> str | None:
+    return getattr(user, "id", None) if user else None
+
+
+def _camel_to_kebab(value: str) -> str:
+    return re.sub(r"([a-z0-9])([A-Z])", r"\1-\2", value).replace("_", "-").lower()

lnbits/core/helpers.py

@@ -13,10 +13,10 @@ from lnbits.core.crud import (
     update_migration_version,
 )
 from lnbits.core.db import db as core_db
+from lnbits.core.extensions.loader import is_wasm_extension_id
+from lnbits.core.extensions.storage import migrate_wasm_extension_database
 from lnbits.core.models import DbVersion
 from lnbits.core.models.extensions import InstallableExtension
-from lnbits.core.wasm_ext.storage.crud import migrate_wasm_extension_database
-from lnbits.core.wasm_ext.wasm.loader import is_wasm_extension_id
 from lnbits.db import COCKROACH, POSTGRES, SQLITE, Connection
 from lnbits.settings import settings
 
@@ -27,13 +27,7 @@ async def migrate_extension_database(
     if is_wasm_extension_id(ext.id):
         await migrate_wasm_extension_database(ext, current_version)
         return
-    else:
-        await migrate_py_extension_database(ext, current_version)
 
-
-async def migrate_py_extension_database(
-    ext: InstallableExtension, current_version: DbVersion | None = None
-):
     try:
         ext_migrations = importlib.import_module(f"{ext.module_name}.migrations")
         ext_db = importlib.import_module(ext.module_name).db

lnbits/core/migrations.py

@@ -824,69 +824,3 @@ async def m046_add_permissions_to_installed_extensions(db: Connection):
     await db.execute(
         "ALTER TABLE installed_extensions ADD COLUMN permissions TEXT DEFAULT '[]'"
     )
-
-
-async def m047_create_wasm_invocations_table(db: Connection):
-    """
-    Tracks WASM extension invocations for runtime monitoring and controls.
-    """
-    await db.execute(f"""
-        CREATE TABLE IF NOT EXISTS wasm_invocations (
-            id TEXT PRIMARY KEY,
-            extension_id TEXT NOT NULL,
-            export_name TEXT NOT NULL,
-            trigger_type TEXT NOT NULL DEFAULT 'unknown',
-            status TEXT NOT NULL DEFAULT 'running',
-            started_at TIMESTAMP NOT NULL DEFAULT {db.timestamp_now},
-            finished_at TIMESTAMP,
-            duration_ms INT,
-            user_id TEXT,
-            wallet_id TEXT,
-            request_id TEXT,
-            method TEXT,
-            path TEXT,
-            event_type TEXT,
-            payment_hash TEXT,
-            checking_id TEXT,
-            memory_peak_bytes INT,
-            request_bytes INT,
-            response_bytes INT,
-            host_call_count INT NOT NULL DEFAULT 0,
-            http_call_count INT NOT NULL DEFAULT 0,
-            storage_call_count INT NOT NULL DEFAULT 0,
-            wallet_call_count INT NOT NULL DEFAULT 0,
-            error_type TEXT,
-            error_message TEXT,
-            stop_reason TEXT,
-            "context" TEXT NOT NULL DEFAULT '{{}}'
-        );
-        """)
-    await db.execute("""
-        CREATE INDEX IF NOT EXISTS idx_wasm_invocations_extension_started
-        ON wasm_invocations (extension_id, started_at);
-        """)
-    await db.execute("""
-        CREATE INDEX IF NOT EXISTS idx_wasm_invocations_status
-        ON wasm_invocations (status);
-        """)
-    await db.execute("""
-        CREATE INDEX IF NOT EXISTS idx_wasm_invocations_started
-        ON wasm_invocations (started_at);
-        """)
-
-
-async def m048_add_wasm_runtime_limits_to_installed_extensions(db: Connection):
-    """
-    Adds per-extension WASM runtime limit overrides.
-    """
-    await db.execute(
-        "ALTER TABLE installed_extensions "
-        "ADD COLUMN wasm_runtime_limits TEXT DEFAULT '{}'"
-    )
-
-
-async def m049_add_permissions_to_user_extensions(db: Connection):
-    """
-    Adds user-level extension permission grants.
-    """
-    await db.execute("ALTER TABLE extensions ADD COLUMN permissions TEXT DEFAULT '{}'")

lnbits/core/models/extensions.py

@@ -6,16 +6,14 @@ import json
 import os
 import shutil
 import zipfile
+from asyncio.tasks import create_task
 from collections.abc import Mapping
-from datetime import datetime, timezone
-from enum import Enum
 from pathlib import Path, PurePosixPath
 from typing import Any
-from uuid import uuid4
 
 import httpx
 from loguru import logger
-from pydantic import BaseModel, Field, StrictStr
+from pydantic import BaseModel, Field
 
 from lnbits.helpers import (
     download_url,
@@ -24,7 +22,6 @@ from lnbits.helpers import (
     version_parse,
 )
 from lnbits.settings import settings
-from lnbits.task_manager import task_manager
 from lnbits.utils.cache import cache
 
 
@@ -82,12 +79,10 @@ class GitHubRepo(BaseModel):
 
 
 class ExtensionPermission(BaseModel):
-    id: StrictStr
-    description: StrictStr | None = None
-    policies: list[Any] | None = None
-
-    class Config:
-        extra = "ignore"
+    id: str
+    label: str | None = None
+    description: str | None = None
+    policy: dict[str, Any] | None = None
 
     @staticmethod
     def list_from_config(config_json: Mapping[str, Any]) -> list[ExtensionPermission]:
@@ -141,83 +136,11 @@ class UserExtensionInfo(BaseModel):
     payment_hash_to_enable: str | None = None
 
 
-class ExtensionBackgroundPaymentDestinationPolicy(str, Enum):
-    OWN_WALLETS_ONLY = "own_wallets_only"
-    EXTERNAL_ALLOWED = "external_allowed"
-
-
-class ExtensionBackgroundPaymentGrant(BaseModel):
-    id: StrictStr = Field(..., min_length=1, max_length=128)
-    wallet_id: str = Field(..., min_length=1, max_length=128)
-    enabled: bool = True
-    max_amount: int = Field(..., gt=0)
-    destination_policy: ExtensionBackgroundPaymentDestinationPolicy
-
-
-class ExtensionBackgroundPaymentGrantRequest(BaseModel):
-    wallet_id: str = Field(..., min_length=1, max_length=128)
-    max_amount: int = Field(..., gt=0)
-    destination_policy: ExtensionBackgroundPaymentDestinationPolicy
-
-    def to_grant(self, grant_id: str | None = None) -> ExtensionBackgroundPaymentGrant:
-        return ExtensionBackgroundPaymentGrant(
-            id=grant_id or str(uuid4()),
-            wallet_id=self.wallet_id,
-            enabled=True,
-            max_amount=self.max_amount,
-            destination_policy=self.destination_policy,
-        )
-
-
-class ExtensionWalletPaymentsWatchGrant(BaseModel):
-    id: StrictStr = Field(..., min_length=1, max_length=128)
-    wallet_id: str = Field(..., min_length=1, max_length=128)
-    enabled: bool = True
-
-
-class ExtensionWalletPaymentsWatchGrantRequest(BaseModel):
-    wallet_id: str = Field(..., min_length=1, max_length=128)
-
-    def to_grant(
-        self, grant_id: str | None = None
-    ) -> ExtensionWalletPaymentsWatchGrant:
-        return ExtensionWalletPaymentsWatchGrant(
-            id=grant_id or str(uuid4()),
-            wallet_id=self.wallet_id,
-            enabled=True,
-        )
-
-
-class ExtensionPermissionCheckItem(BaseModel):
-    id: StrictStr
-    grant: dict[str, Any] = Field(default_factory=dict)
-
-
-class ExtensionPermissionCheckRequest(BaseModel):
-    permissions: list[ExtensionPermissionCheckItem] = Field(default_factory=list)
-
-
-class ExtensionPermissionCheckResult(BaseModel):
-    id: StrictStr
-    approved: bool
-    grant: dict[str, Any] = Field(default_factory=dict)
-
-
-class ExtensionPermissionCheckResponse(BaseModel):
-    permissions: list[ExtensionPermissionCheckResult] = Field(default_factory=list)
-
-
-class ExtensionPermissionsResponse(BaseModel):
-    extension_permissions: list[ExtensionPermission] = Field(default_factory=list)
-    user_permissions: dict[str, list[dict[str, Any]]] = Field(default_factory=dict)
-
-
 class UserExtension(BaseModel):
     user: str
     extension: str
     active: bool
     extra: UserExtensionInfo | None = None
-    permissions: dict = Field(default_factory=dict)
 
     @property
     def is_paid(self) -> bool:
@@ -256,8 +179,6 @@ class Extension(BaseModel):
 
     @property
     def is_upgrade_extension(self) -> bool:
-        if self.is_wasm:
-            return False
         return self.upgrade_hash != ""
 
     @classmethod
@@ -268,66 +189,17 @@ class Extension(BaseModel):
             is_wasm=ext_info.is_wasm,
             name=ext_info.name,
             short_description=ext_info.short_description,
-            tile=_extension_tile(ext_info),
+            tile=(
+                wasm_extension_icon_url(ext_info.id)
+                if ext_info.is_wasm
+                else ext_info.icon
+            ),
             upgrade_hash=ext_info.hash if ext_info.ext_upgrade_dir.is_dir() else "",
         )
 
 
-class WasmInvocation(BaseModel):
-    id: str
-    extension_id: str
-    export_name: str
-    trigger_type: str = "unknown"
-    status: str = "running"
-    started_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
-    finished_at: datetime | None = None
-    duration_ms: int | None = None
-    user_id: str | None = None
-    wallet_id: str | None = None
-    request_id: str | None = None
-    method: str | None = None
-    path: str | None = None
-    event_type: str | None = None
-    payment_hash: str | None = None
-    checking_id: str | None = None
-    memory_peak_bytes: int | None = None
-    request_bytes: int | None = None
-    response_bytes: int | None = None
-    host_call_count: int = 0
-    http_call_count: int = 0
-    storage_call_count: int = 0
-    wallet_call_count: int = 0
-    error_type: str | None = None
-    error_message: str | None = None
-    stop_reason: str | None = None
-    context: dict = Field(default_factory=dict)
-
-
-class WasmInvocationStats(BaseModel):
-    total: int = 0
-    running: int = 0
-    completed: int = 0
-    failed: int = 0
-    stopped: int = 0
-    timeout: int = 0
-    avg_duration_ms: float = 0
-    max_duration_ms: int = 0
-    host_call_count: int = 0
-    http_call_count: int = 0
-    storage_call_count: int = 0
-    wallet_call_count: int = 0
-
-
-class WasmRuntimeLimitsUpdate(BaseModel):
-    limits: dict[str, Any] = Field(default_factory=dict)
-
-
-class WasmRuntimeLimitsInfo(BaseModel):
-    id: str
-    name: str
-    active: bool | None = False
-    wasm_runtime_limits: dict[str, int] = Field(default_factory=dict)
-    effective_wasm_runtime_limits: dict[str, int] = Field(default_factory=dict)
+def wasm_extension_icon_url(ext_id: str) -> str:
+    return f"/ext-assets/{ext_id}/assets/icon.png"
 
 
 class ExtensionRelease(BaseModel):
@@ -505,7 +377,6 @@ class InstallableExtension(BaseModel):
     stars: int = 0
     meta: ExtensionMeta | None = None
     permissions: list[ExtensionPermission] = []
-    wasm_runtime_limits: dict = Field(default_factory=dict, no_database=True)
 
     @property
     def hash(self) -> str:
@@ -608,7 +479,7 @@ class InstallableExtension(BaseModel):
 
         try:
             with zipfile.ZipFile(self.zip_path, "r") as archive:
-                config_name = _archive_config_name(archive.namelist())
+                config_name = self._archive_config_name(archive.namelist())
                 if not config_name:
                     return {}
                 with archive.open(config_name) as config_file:
@@ -618,6 +489,14 @@ class InstallableExtension(BaseModel):
 
         return config if isinstance(config, dict) else {}
 
+    @staticmethod
+    def _archive_config_name(names: list[str]) -> str | None:
+        for name in names:
+            path = PurePosixPath(name)
+            if len(path.parts) == 2 and path.name == "config.json":
+                return name
+        return None
+
     def extract_archive(self):
         logger.info(f"Extracting extension {self.name} ({self.installed_version}).")
         Path(settings.lnbits_extensions_upgrade_path).mkdir(parents=True, exist_ok=True)
@@ -829,10 +708,7 @@ class InstallableExtension(BaseModel):
 
         if cache_value.older_than(10 * 60) or post_refresh_cache:
             # refresh cache in background if older than 10 minutes or requested
-            task_manager.create_task(
-                cls._refresh_installable_extensions_cache(),
-                "refresh_installable_extensions_cache",
-            )
+            create_task(cls._refresh_installable_extensions_cache())
 
         extension_list = cache_value.value  # type: ignore
         return extension_list
@@ -1043,21 +919,3 @@ def icon_to_github_url(source_repo: str, path: str | None) -> str:
     _, _, *rest = path.split("/")
     tail = "/".join(rest)
     return f"https://github.com/{source_repo}/raw/main/{tail}"
-
-
-def wasm_extension_icon_url(ext_id: str) -> str:
-    return f"/ext-assets/{ext_id}/assets/icon.png"
-
-
-def _extension_tile(ext_info: InstallableExtension) -> str | None:
-    if ext_info.is_wasm:
-        return wasm_extension_icon_url(ext_info.id)
-    return ext_info.icon
-
-
-def _archive_config_name(names: list[str]) -> str | None:
-    for name in names:
-        path = PurePosixPath(name)
-        if len(path.parts) == 2 and path.name == "config.json":
-            return name
-    return None

lnbits/core/models/misc.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
-from collections.abc import Callable
-from pathlib import Path
+from collections.abc import Awaitable, Callable
 from typing import Any
 
 from pydantic import BaseModel
@@ -11,10 +10,17 @@ def _do_nothing(*_):
     pass
 
 
+async def _do_nothing_async(_: Any) -> None:
+    pass
+
+
 class CoreAppExtra:
     register_new_ext_routes: Callable = _do_nothing
     register_new_wasm_ext_routes: Callable = _do_nothing
     register_new_ratelimiter: Callable
+    dispatch_extension_invoice_paid: Callable[[Any], Awaitable[None]] = (
+        _do_nothing_async
+    )
 
     def __init__(self) -> None:
         self.wasm_extension_registry = WasmExtensionRegistry()
@@ -25,16 +31,8 @@ class WasmExtensionRegistry:
         self._extensions: dict[str, Any] = {}
 
     def register(self, extension: Any) -> None:
-        self.require_available(extension)
         self._extensions[extension.id] = extension
 
-    def require_available(self, extension: Any) -> None:
-        existing = self._extensions.get(extension.id)
-        if existing and not _same_wasm_extension_registration(existing, extension):
-            raise ValueError(
-                f"WASM extension id '{extension.id}' is already registered."
-            )
-
     def get(self, ext_id: str) -> Any | None:
         return self._extensions.get(ext_id)
 
@@ -42,13 +40,6 @@ class WasmExtensionRegistry:
         return list(self._extensions.values())
 
 
-def _same_wasm_extension_registration(left: Any, right: Any) -> bool:
-    try:
-        return Path(left.root_path).resolve() == Path(right.root_path).resolve()
-    except (AttributeError, TypeError):
-        return left is right
-
-
 class ConversionData(BaseModel):
     from_: str = "sat"
     amount: float

lnbits/core/services/extensions.py

@@ -1,12 +1,5 @@
 import asyncio
 import importlib
-import re
-from collections.abc import Mapping
-from dataclasses import dataclass
-from datetime import datetime, timedelta, timezone
-from threading import RLock
-from typing import Any
-from uuid import uuid4
 
 from loguru import logger
 
@@ -20,168 +13,21 @@ from lnbits.core.crud import (
     update_installed_extension_state,
 )
 from lnbits.core.crud.extensions import (
-    create_wasm_invocation,
-    delete_old_wasm_invocations,
     get_installed_extensions,
-    get_wasm_invocation,
-    mark_stale_wasm_invocations,
     update_installed_extension,
-    update_installed_extension_wasm_runtime_limits,
-    update_wasm_invocation,
-)
-from lnbits.core.crud.extensions import (
-    get_wasm_invocation_stats as get_wasm_invocation_stats_crud,
-)
-from lnbits.core.crud.extensions import (
-    get_wasm_invocations as get_wasm_invocations_crud,
 )
+from lnbits.core.extensions.permissions import validate_wasm_extension_permissions
 from lnbits.core.helpers import migrate_extension_database
-from lnbits.core.wasm_ext.api.permissions import validate_wasm_extension_permissions
-from lnbits.core.wasm_ext.wasm.loader import is_wasm_extension_id
 from lnbits.db import Connection
-from lnbits.settings import WasmRuntimeLimits, settings
+from lnbits.settings import settings
 
 from ..models.extensions import (
     Extension,
     ExtensionMeta,
     ExtensionPermission,
     InstallableExtension,
-    WasmInvocation,
-    WasmInvocationStats,
 )
 
-_WASM_INVOCATION_CLEANUP_INTERVAL = timedelta(hours=1)
-WASM_RUNTIME_LIMIT_FIELDS = tuple(WasmRuntimeLimits.__fields__.keys())
-
-
-@dataclass
-class WasmInvocationHandle:
-    invocation: WasmInvocation
-    engine: Any | None = None
-    store: Any | None = None
-    runtime_limits: dict[str, int] | None = None
-    stop_requested: bool = False
-    stop_reason: str | None = None
-
-
-_wasm_invocation_lock = RLock()
-_wasm_invocation_ready_lock = asyncio.Lock()
-_wasm_invocation_handles: dict[str, WasmInvocationHandle] = {}
-_wasm_invocations_marked_stale = False
-_wasm_invocations_last_cleanup_at: datetime | None = None
-
-
-def wasm_runtime_limit_defaults() -> dict[str, int]:
-    return {field: int(getattr(settings, field)) for field in WASM_RUNTIME_LIMIT_FIELDS}
-
-
-def validate_wasm_runtime_limit_overrides(
-    limits: Mapping[str, Any] | None,
-    *,
-    strict: bool = True,
-) -> dict[str, int]:
-    if not limits:
-        return {}
-
-    validated: dict[str, int] = {}
-    for field, raw_value in limits.items():
-        if field not in WASM_RUNTIME_LIMIT_FIELDS:
-            if strict:
-                raise ValueError(f"Unknown WASM runtime limit field '{field}'.")
-            continue
-
-        value = _validate_wasm_runtime_limit_value(field, raw_value, strict=strict)
-        if value is None:
-            continue
-        validated[field] = value
-
-    return validated
-
-
-def _validate_wasm_runtime_limit_value(
-    field: str,
-    raw_value: Any,
-    *,
-    strict: bool,
-) -> int | None:
-    if raw_value is None or raw_value == "":
-        return None
-    if isinstance(raw_value, bool):
-        return _invalid_wasm_runtime_limit(field, strict, "must be an integer")
-    if isinstance(raw_value, str):
-        raw_value = raw_value.strip()
-        if raw_value == "":
-            return None
-        if not raw_value.isdecimal():
-            return _invalid_wasm_runtime_limit(field, strict, "must be an integer")
-    if isinstance(raw_value, float) and not raw_value.is_integer():
-        return _invalid_wasm_runtime_limit(field, strict, "must be an integer")
-
-    try:
-        value = int(raw_value)
-    except (TypeError, ValueError) as exc:
-        return _invalid_wasm_runtime_limit(
-            field,
-            strict,
-            "must be an integer",
-            exc=exc,
-        )
-    if value < 0:
-        return _invalid_wasm_runtime_limit(field, strict, "cannot be negative")
-    return value
-
-
-def _invalid_wasm_runtime_limit(
-    field: str,
-    strict: bool,
-    message: str,
-    *,
-    exc: Exception | None = None,
-) -> int | None:
-    if not strict:
-        return None
-    error = ValueError(f"WASM runtime limit '{field}' {message}.")
-    if exc:
-        raise error from exc
-    raise error
-
-
-def resolve_wasm_runtime_limits(
-    installed_extension: InstallableExtension | None = None,
-) -> dict[str, int]:
-    limits = wasm_runtime_limit_defaults()
-    if installed_extension:
-        limits.update(
-            validate_wasm_runtime_limit_overrides(
-                installed_extension.wasm_runtime_limits,
-                strict=False,
-            )
-        )
-    return limits
-
-
-async def get_wasm_runtime_limits_for_extension(ext_id: str) -> dict[str, int]:
-    installed_extension = await get_installed_extension(ext_id)
-    return resolve_wasm_runtime_limits(installed_extension)
-
-
-async def update_wasm_extension_runtime_limits(
-    ext_id: str,
-    limits: Mapping[str, Any] | None,
-) -> dict[str, int]:
-    installed_extension = await get_installed_extension(ext_id)
-    if not installed_extension:
-        raise ValueError(f"Extension '{ext_id}' is not installed.")
-    if not installed_extension.is_wasm:
-        raise ValueError(f"Extension '{ext_id}' is not a WASM extension.")
-
-    validated_limits = validate_wasm_runtime_limit_overrides(limits)
-    await update_installed_extension_wasm_runtime_limits(
-        ext_id=ext_id,
-        limits=validated_limits,
-    )
-    return validated_limits
-
 
 async def install_extension(
     ext_info: InstallableExtension,
@@ -200,8 +46,6 @@ async def install_extension(
     installed_ext = await get_installed_extension(ext_info.id)
     if installed_ext and installed_ext.meta:
         ext_info.meta.payments = installed_ext.meta.payments
-    if installed_ext:
-        ext_info.wasm_runtime_limits = installed_ext.wasm_runtime_limits
 
     await check_extensions_limit(installed_ext)
 
@@ -226,7 +70,7 @@ async def install_extension(
         await update_installed_extension(ext_info)
 
     extension = Extension.from_installable_ext(ext_info)
-    if extension.is_upgrade_extension:
+    if extension.is_upgrade_extension and not extension.is_wasm:
         # call stop while the old routes are still active
         await stop_extension_background_work(ext_info.id)
 
@@ -245,394 +89,6 @@ async def check_extensions_limit(installed_ext: InstallableExtension | None = No
         raise ValueError("Max amount of extensions have been installed")
 
 
-async def ensure_wasm_invocation_monitoring_ready() -> None:
-    global _wasm_invocations_last_cleanup_at, _wasm_invocations_marked_stale
-
-    async with _wasm_invocation_ready_lock:
-        now = _now()
-        if not _wasm_invocations_marked_stale:
-            await mark_stale_wasm_invocations()
-            _wasm_invocations_marked_stale = True
-
-        if (
-            _wasm_invocations_last_cleanup_at is None
-            or now - _wasm_invocations_last_cleanup_at
-            >= _WASM_INVOCATION_CLEANUP_INTERVAL
-        ):
-            _wasm_invocations_last_cleanup_at = now
-            await delete_old_wasm_invocations(
-                settings.lnbits_wasm_invocation_retention_days
-            )
-
-
-async def start_wasm_invocation(
-    *,
-    extension_id: str,
-    export_name: str,
-    trigger_type: str = "unknown",
-    user_id: str | None = None,
-    wallet_id: str | None = None,
-    request_id: str | None = None,
-    method: str | None = None,
-    path: str | None = None,
-    event_type: str | None = None,
-    payment_hash: str | None = None,
-    checking_id: str | None = None,
-    request_bytes: int | None = None,
-    context: dict | None = None,
-    runtime_limits: dict[str, int] | None = None,
-) -> WasmInvocation:
-    await ensure_wasm_invocation_monitoring_ready()
-    _check_wasm_invocation_concurrency(
-        extension_id=extension_id,
-        user_id=user_id,
-        limits=runtime_limits,
-    )
-
-    invocation = WasmInvocation(
-        id=uuid4().hex,
-        extension_id=extension_id,
-        export_name=export_name,
-        trigger_type=trigger_type,
-        user_id=user_id,
-        wallet_id=wallet_id,
-        request_id=request_id,
-        method=method,
-        path=path,
-        event_type=event_type,
-        payment_hash=payment_hash,
-        checking_id=checking_id,
-        request_bytes=request_bytes,
-        context=_safe_wasm_invocation_context(context or {}),
-    )
-    await create_wasm_invocation(invocation)
-
-    with _wasm_invocation_lock:
-        _wasm_invocation_handles[invocation.id] = WasmInvocationHandle(
-            invocation,
-            runtime_limits=runtime_limits,
-        )
-
-    return invocation
-
-
-def attach_wasm_invocation_runtime(
-    invocation_id: str,
-    *,
-    engine: Any,
-    store: Any,
-) -> None:
-    with _wasm_invocation_lock:
-        handle = _wasm_invocation_handles.get(invocation_id)
-        if not handle:
-            return
-        handle.engine = engine
-        handle.store = store
-        if handle.stop_requested:
-            _interrupt_wasm_invocation(handle)
-
-
-def record_wasm_invocation_host_call(
-    invocation_id: str | None,
-    method_id: str,
-) -> None:
-    if not invocation_id:
-        return
-
-    with _wasm_invocation_lock:
-        handle = _wasm_invocation_handles.get(invocation_id)
-        if not handle:
-            return
-
-        invocation = handle.invocation
-        invocation.host_call_count += 1
-        category = _wasm_host_call_category(method_id)
-        if category == "http":
-            invocation.http_call_count += 1
-        elif category == "storage":
-            invocation.storage_call_count += 1
-        elif category == "wallet":
-            invocation.wallet_call_count += 1
-
-        _check_wasm_host_call_limit(invocation, category, handle.runtime_limits)
-
-
-async def stop_wasm_invocation(
-    invocation_id: str,
-    *,
-    reason: str = "Stopped by admin.",
-) -> bool:
-    interrupted = False
-    with _wasm_invocation_lock:
-        handle = _wasm_invocation_handles.get(invocation_id)
-        if handle:
-            handle.stop_requested = True
-            handle.stop_reason = reason
-            handle.invocation.stop_reason = reason
-            interrupted = _interrupt_wasm_invocation(handle)
-
-    invocation = await get_wasm_invocation(invocation_id)
-    if invocation and invocation.status == "running":
-        invocation.stop_reason = reason
-        await update_wasm_invocation(invocation)
-
-    return interrupted
-
-
-async def stop_wasm_extension_invocations(
-    extension_id: str,
-    *,
-    reason: str = "Extension deactivated.",
-) -> int:
-    with _wasm_invocation_lock:
-        invocation_ids = [
-            invocation_id
-            for invocation_id, handle in _wasm_invocation_handles.items()
-            if handle.invocation.extension_id == extension_id
-        ]
-
-    for invocation_id in invocation_ids:
-        await stop_wasm_invocation(invocation_id, reason=reason)
-
-    return len(invocation_ids)
-
-
-def wasm_invocation_stop_requested(invocation_id: str) -> bool:
-    with _wasm_invocation_lock:
-        handle = _wasm_invocation_handles.get(invocation_id)
-        return bool(handle and handle.stop_requested)
-
-
-def get_wasm_invocation_stop_reason(invocation_id: str) -> str | None:
-    with _wasm_invocation_lock:
-        handle = _wasm_invocation_handles.get(invocation_id)
-        return handle.stop_reason if handle else None
-
-
-async def finish_wasm_invocation(
-    invocation_id: str,
-    *,
-    status: str,
-    response_bytes: int | None = None,
-    memory_peak_bytes: int | None = None,
-    error_type: str | None = None,
-    error_message: str | None = None,
-    stop_reason: str | None = None,
-) -> None:
-    with _wasm_invocation_lock:
-        handle = _wasm_invocation_handles.pop(invocation_id, None)
-
-    invocation = (
-        handle.invocation if handle else await get_wasm_invocation(invocation_id)
-    )
-    if not invocation:
-        return
-
-    reason = stop_reason or (handle.stop_reason if handle else None)
-    if handle and handle.stop_requested and status == "failed":
-        status = "stopped"
-        reason = reason or "Stopped by admin."
-
-    finished_at = _now()
-    invocation.status = status
-    invocation.finished_at = finished_at
-    invocation.duration_ms = max(
-        0, int((finished_at - invocation.started_at).total_seconds() * 1000)
-    )
-    invocation.response_bytes = response_bytes
-    invocation.memory_peak_bytes = memory_peak_bytes
-    invocation.error_type = error_type
-    invocation.error_message = _safe_wasm_error_message(error_message)
-    invocation.stop_reason = reason
-
-    await update_wasm_invocation(invocation)
-
-
-def get_current_wasm_invocations(
-    extension_id: str | None = None,
-) -> list[WasmInvocation]:
-    with _wasm_invocation_lock:
-        invocations = []
-        for handle in _wasm_invocation_handles.values():
-            if extension_id and handle.invocation.extension_id != extension_id:
-                continue
-            invocation = handle.invocation.copy(deep=True)
-            if handle.stop_requested and invocation.status == "running":
-                invocation.status = "stopping"
-                invocation.stop_reason = handle.stop_reason
-            invocations.append(invocation)
-
-    return sorted(
-        invocations, key=lambda invocation: invocation.started_at, reverse=True
-    )
-
-
-def _check_wasm_invocation_concurrency(
-    *,
-    extension_id: str,
-    user_id: str | None,
-    limits: dict[str, int] | None,
-) -> None:
-    if not limits:
-        return
-
-    with _wasm_invocation_lock:
-        handles = list(_wasm_invocation_handles.values())
-        if _wasm_limit_exceeded(
-            limits["wasm_runtime_max_concurrent_invocations"],
-            len(handles) + 1,
-        ):
-            raise ValueError("WASM runtime has too many active invocations.")
-
-        extension_invocations = sum(
-            1 for handle in handles if handle.invocation.extension_id == extension_id
-        )
-        if _wasm_limit_exceeded(
-            limits["wasm_runtime_max_concurrent_invocations_per_extension"],
-            extension_invocations + 1,
-        ):
-            raise ValueError(
-                f"WASM extension '{extension_id}' has too many active invocations."
-            )
-
-        if not user_id:
-            return
-
-        user_invocations = sum(
-            1 for handle in handles if handle.invocation.user_id == user_id
-        )
-        if _wasm_limit_exceeded(
-            limits["wasm_runtime_max_concurrent_invocations_per_user"],
-            user_invocations + 1,
-        ):
-            raise ValueError("WASM user has too many active invocations.")
-
-
-def _check_wasm_host_call_limit(
-    invocation: WasmInvocation,
-    category: str,
-    limits: dict[str, int] | None,
-) -> None:
-    if not limits:
-        return
-
-    if _wasm_limit_exceeded(
-        limits["wasm_runtime_max_host_calls"],
-        invocation.host_call_count,
-    ):
-        raise ValueError("WASM host call limit exceeded.")
-
-    category_limits = {
-        "http": (
-            limits["wasm_runtime_max_http_calls"],
-            invocation.http_call_count,
-        ),
-        "storage": (
-            limits["wasm_runtime_max_storage_calls"],
-            invocation.storage_call_count,
-        ),
-        "wallet": (
-            limits["wasm_runtime_max_wallet_calls"],
-            invocation.wallet_call_count,
-        ),
-    }
-    category_limit = category_limits.get(category)
-    if category_limit and _wasm_limit_exceeded(*category_limit):
-        raise ValueError(f"WASM {category} host call limit exceeded.")
-
-
-def _wasm_limit_exceeded(limit: int, value: int) -> bool:
-    return limit > 0 and value > limit
-
-
-async def get_wasm_invocation_history(
-    *,
-    extension_id: str | None = None,
-    status: str | None = None,
-    limit: int = 100,
-    offset: int = 0,
-) -> list[WasmInvocation]:
-    await ensure_wasm_invocation_monitoring_ready()
-    return await get_wasm_invocations_crud(
-        extension_id=extension_id,
-        status=status,
-        limit=limit,
-        offset=offset,
-    )
-
-
-async def get_wasm_invocation_summary(
-    *,
-    extension_id: str | None = None,
-    hours: int = 24,
-) -> WasmInvocationStats:
-    await ensure_wasm_invocation_monitoring_ready()
-    since = _now() - timedelta(hours=max(1, min(hours, 24 * 30)))
-    return await get_wasm_invocation_stats_crud(
-        extension_id=extension_id,
-        since=since,
-    )
-
-
-def _interrupt_wasm_invocation(handle: WasmInvocationHandle) -> bool:
-    if not handle.store or not handle.engine:
-        return False
-    try:
-        handle.store.set_epoch_deadline(1)
-        handle.engine.increment_epoch()
-        return True
-    except Exception as exc:
-        logger.warning(
-            f"Failed to interrupt WASM invocation '{handle.invocation.id}': {exc}"
-        )
-        return False
-
-
-def _wasm_host_call_category(method_id: str) -> str:
-    if method_id.startswith("http.") or method_id.startswith("extension.api."):
-        return "http"
-    if method_id.startswith("storage."):
-        return "storage"
-    if method_id.startswith("wallet."):
-        return "wallet"
-    return "host"
-
-
-def _safe_wasm_invocation_context(context: dict) -> dict:
-    safe_context: dict = {}
-    for key, value in context.items():
-        if not isinstance(key, str):
-            continue
-        if value is None or isinstance(value, (bool, int, float)):
-            safe_context[key[:64]] = value
-        elif isinstance(value, str):
-            safe_context[key[:64]] = value[:256]
-    return safe_context
-
-
-def _safe_wasm_error_message(message: str | None) -> str | None:
-    if not message:
-        return None
-
-    safe_message = message[:500]
-    redactions = [
-        (
-            r"(?i)(api[-_ ]?key|token|authorization|password|secret|preimage)"
-            r"\s*[:=]\s*[^\s,;]+",
-            r"\1=[redacted]",
-        ),
-        (r"(?i)bearer\s+[A-Za-z0-9._~+/=-]+", "Bearer [redacted]"),
-        (r"\b[a-fA-F0-9]{64}\b", "[redacted-hex]"),
-    ]
-    for pattern, replacement in redactions:
-        safe_message = re.sub(pattern, replacement, safe_message)
-    return safe_message
-
-
-def _now() -> datetime:
-    return datetime.now(timezone.utc)
-
-
 async def uninstall_extension(ext_id: str):
     await stop_extension_background_work(ext_id)
 
@@ -656,8 +112,6 @@ async def activate_extension(ext: Extension):
 
 
 async def deactivate_extension(ext_id: str):
-    if is_wasm_extension_id(ext_id):
-        await stop_wasm_extension_invocations(ext_id, reason="Extension deactivated.")
     settings.deactivate_extension_paths(ext_id)
     await update_installed_extension_state(ext_id=ext_id, active=False)
     await stop_extension_background_work(ext_id)
@@ -668,9 +122,6 @@ async def stop_extension_background_work(ext_id: str) -> bool:
     Stop background work for extension (like asyncio.Tasks, WebSockets, etc).
     Extension must expose a `myextension_stop()` function if it is starting tasks.
     """
-    if is_wasm_extension_id(ext_id):
-        return True
-
     upgrade_hash = settings.extension_upgrade_hash(ext_id)
     ext = Extension(code=ext_id, is_valid=True, upgrade_hash=upgrade_hash)
 
@@ -703,9 +154,6 @@ async def start_extension_background_work(ext_id: str) -> bool:
     Extension CAN expose a `myextension_start()` function if it is starting tasks.
     Extension MUST expose a `myextension_stop()` in that case.
     """
-    if is_wasm_extension_id(ext_id):
-        return False
-
     upgrade_hash = settings.extension_upgrade_hash(ext_id)
     ext = Extension(code=ext_id, is_valid=True, upgrade_hash=upgrade_hash)
 

lnbits/core/services/fiat_providers.py

@@ -20,7 +20,6 @@ from lnbits.fiat.base import (
     FiatPaymentSuccessStatus,
 )
 from lnbits.settings import settings
-from lnbits.task_manager import task_manager
 
 
 async def handle_fiat_payment_confirmation(
@@ -61,7 +60,11 @@ async def check_fiat_status(payment: Payment) -> FiatPaymentStatus:
         payment.status = PaymentState.SUCCESS.value
         await update_payment(payment)
         await handle_fiat_payment_confirmation(payment)
-        task_manager.internal_invoice_queue.put_nowait(payment)
+
+        # notify receivers asynchronously
+        from lnbits.tasks import internal_invoice_queue
+
+        await internal_invoice_queue.put(payment.checking_id)
 
     return fiat_status
 

lnbits/core/services/funding_source.py

@@ -66,8 +66,6 @@ async def check_server_balance_against_node():
 
 
 async def check_balance_delta_changed():
-    if settings.notification_balance_delta_threshold_sats <= 0:
-        return
     status = await get_balance_delta()
     if settings.latest_balance_delta_sats is None:
         settings.latest_balance_delta_sats = status.delta_sats

lnbits/core/services/notifications.py

@@ -237,15 +237,6 @@ async def send_email(
         return False
 
 
-async def dispatch_payment_notification(payment: Payment) -> None:
-    """
-    This worker dispatches the payment notifications.
-    """
-    wallet = await get_wallet(payment.wallet_id)
-    if wallet:
-        await send_payment_notification(wallet, payment)
-
-
 async def dispatch_webhook(payment: Payment):
     """
     Dispatches the webhook to the webhook url.

lnbits/core/services/payments.py

@@ -17,9 +17,8 @@ from lnbits.db import Connection, Filters
 from lnbits.decorators import check_user_extension_access
 from lnbits.exceptions import InvoiceError, PaymentError, UnsupportedError
 from lnbits.fiat import get_fiat_provider
-from lnbits.helpers import check_callback_url, daystart_timestamp
+from lnbits.helpers import check_callback_url
 from lnbits.settings import settings
-from lnbits.task_manager import task_manager
 from lnbits.utils.crypto import fake_privkey, random_secret_and_hash, verify_preimage
 from lnbits.utils.exchange_rates import fiat_amount_as_satoshis, satoshis_amount_as_fiat
 from lnbits.wallets import fake_wallet, get_funding_source
@@ -374,13 +373,6 @@ async def update_pending_payments(wallet_id: str):
 async def update_pending_payment(
     payment: Payment, conn: Connection | None = None
 ) -> Payment:
-    if payment.is_in and payment.is_expired:
-        payment.status = PaymentState.FAILED
-        payment.labels.append("expired")
-        await update_payment(payment, conn=conn)
-        logger.info(f"invoice {payment.checking_id} expired, marked as failed")
-        return payment
-
     status = await check_payment_status(payment)
     if status.failed:
         payment.status = PaymentState.FAILED
@@ -524,7 +516,9 @@ async def update_wallet_balance(
         )
         payment.status = PaymentState.SUCCESS
         await update_payment(payment, conn=conn)
-        task_manager.internal_invoice_queue.put_nowait(payment)
+        from lnbits.tasks import internal_invoice_queue_put
+
+        await internal_invoice_queue_put(payment.checking_id)
 
 
 async def check_wallet_limits(
@@ -564,9 +558,10 @@ async def check_wallet_daily_withdraw_limit(
         raise ValueError("It is not allowed to spend funds from this server.")
 
     payments = await get_payments(
-        since=daystart_timestamp(),
+        since=int(time.time()) - 60 * 60 * 24,
         outgoing=True,
         wallet_id=wallet_id,
+        limit=1,
         conn=conn,
     )
     if len(payments) == 0:
@@ -794,8 +789,10 @@ async def _pay_internal_invoice(
     )  # notify the receiver
 
     # notify receiver asynchronously (extension listeners)
+    from lnbits.tasks import internal_invoice_queue
+
     logger.debug(f"enqueuing internal invoice {internal_payment.checking_id}")
-    task_manager.internal_invoice_queue.put_nowait(internal_payment)
+    await internal_invoice_queue.put(internal_payment.checking_id)
 
     return payment
 
@@ -832,15 +829,16 @@ async def _pay_external_invoice(
 
     fee_reserve_msat = fee_reserve(amount_msat, internal=False)
 
-    task = task_manager.create_task(
-        _fundingsource_pay_invoice(checking_id, payment.bolt11, fee_reserve_msat),
-        f"fundingsource_pay_invoice_{checking_id}",
+    from lnbits.tasks import create_task
+
+    task = create_task(
+        _fundingsource_pay_invoice(checking_id, payment.bolt11, fee_reserve_msat)
     )
 
     # make sure a hold invoice or deferred payment is not blocking the server
     wait_time = max(1, settings.lnbits_funding_source_pay_invoice_wait_seconds)
     try:
-        payment_response = await asyncio.wait_for(task.task, timeout=wait_time)
+        payment_response = await asyncio.wait_for(task, timeout=wait_time)
     except asyncio.TimeoutError:
         # return pending payment on timeout
         logger.debug(
@@ -1110,18 +1108,3 @@ async def update_invoice_from_paid_invoices_stream(checking_id: str) -> Payment
     payment = await update_payment(payment)
 
     return payment
-
-
-async def fundingsource_invoice_producer() -> None:
-    """
-    will collect all invoices that come directly from the backend wallet.
-
-    Called registered in the app startup sequence and run by taskmanager.
-    """
-    funding_source = get_funding_source()
-    async for checking_id in funding_source.paid_invoices_stream():
-        logger.info(f"got a payment notification {checking_id}")
-        payment = await update_invoice_from_paid_invoices_stream(checking_id)
-        if payment:
-            logger.success(f"fundingsource invoice {checking_id} settled")
-            task_manager.invoice_queue.put_nowait(payment)

lnbits/core/tasks.py

@@ -2,43 +2,78 @@ import asyncio
 
 from loguru import logger
 
-from lnbits.core.crud import create_audit_entry
+from lnbits.core.crud import (
+    create_audit_entry,
+    get_wallet,
+)
+from lnbits.core.crud.audit import delete_expired_audit_entries
 from lnbits.core.crud.payments import get_payments_status_count
 from lnbits.core.crud.users import get_accounts
 from lnbits.core.crud.wallets import get_wallets_count
+from lnbits.core.db import core_app_extra
 from lnbits.core.models.audit import AuditEntry
 from lnbits.core.models.extensions import InstallableExtension
 from lnbits.core.models.notifications import NotificationType
-from lnbits.core.services.funding_source import get_balance_delta
+from lnbits.core.services.funding_source import (
+    check_balance_delta_changed,
+    check_server_balance_against_node,
+    get_balance_delta,
+)
 from lnbits.core.services.notifications import (
     enqueue_admin_notification,
+    process_next_notification,
+    send_payment_notification,
 )
 from lnbits.db import Filters
 from lnbits.settings import settings
 from lnbits.utils.cache import cache
-from lnbits.utils.exchange_rates import btc_price_from_aggregator, btc_rates
+from lnbits.utils.exchange_rates import btc_rates
 
 audit_queue: asyncio.Queue[AuditEntry] = asyncio.Queue()
 
 
-async def process_next_audit_entry() -> None:
-    """
-    Waits for audit entries to be pushed to the queue.
-    Then it inserts the entries into the DB.
-    """
-    data = await audit_queue.get()
-    await create_audit_entry(data)
+async def run_by_the_minute_tasks() -> None:
+    minute_counter = 0
+    while settings.lnbits_running:
+        status_minutes = settings.lnbits_notification_server_status_hours * 60
+
+        if settings.notification_balance_delta_threshold_sats > 0:
+            try:
+                # runs by default every minute, the delta should not change that often
+                await check_balance_delta_changed()
+            except Exception as ex:
+                logger.error(ex)
+
+        if minute_counter % settings.lnbits_watchdog_interval_minutes == 0:
+            try:
+                await check_server_balance_against_node()
+            except Exception as ex:
+                logger.error(ex)
+
+        if minute_counter % status_minutes == 0:
+            try:
+                await _notify_server_status()
+            except Exception as ex:
+                logger.error(ex)
+
+        if minute_counter % 60 == 0:
+            try:
+                # initialize the list of all extensions
+                await InstallableExtension.get_installable_extensions(
+                    post_refresh_cache=True
+                )
+            except Exception as ex:
+                logger.error(ex)
+
+        minute_counter += 1
+        await asyncio.sleep(60)
 
 
-async def refresh_extension_cache() -> None:
-    # only refreshes every 10 minutes
-    await InstallableExtension.get_installable_extensions()
-
-
-async def notify_server_status() -> None:
+async def _notify_server_status() -> None:
     accounts = await get_accounts(filters=Filters(limit=0))
     wallets_count = await get_wallets_count()
     payments = await get_payments_status_count()
+
     status = await get_balance_delta()
     values = {
         "up_time": settings.lnbits_server_up_time,
@@ -55,38 +90,82 @@ async def notify_server_status() -> None:
     enqueue_admin_notification(NotificationType.server_status, values)
 
 
+async def wait_for_paid_invoices(invoice_paid_queue: asyncio.Queue) -> None:
+    """
+    This worker dispatches events to all extensions and dispatches webhooks.
+    """
+    while settings.lnbits_running:
+        payment = await invoice_paid_queue.get()
+        logger.trace("received invoice paid event")
+        # payment notification
+        wallet = await get_wallet(payment.wallet_id)
+        if wallet:
+            await send_payment_notification(wallet, payment)
+        await core_app_extra.dispatch_extension_invoice_paid(payment)
+
+
+async def wait_for_audit_data() -> None:
+    """
+    Waits for audit entries to be pushed to the queue.
+    Then it inserts the entries into the DB.
+    """
+    while settings.lnbits_running:
+        data = await audit_queue.get()
+        try:
+            await create_audit_entry(data)
+        except Exception as ex:
+            logger.warning(ex)
+            await asyncio.sleep(3)
+
+
+async def wait_notification_messages() -> None:
+
+    while settings.lnbits_running:
+        try:
+            await process_next_notification()
+        except Exception as ex:
+            logger.warning("Payment notification error", ex)
+            await asyncio.sleep(3)
+
+
+async def purge_audit_data() -> None:
+    """
+    Remove audit entries which have passed their retention period.
+    """
+    while settings.lnbits_running:
+        try:
+            await delete_expired_audit_entries()
+        except Exception as ex:
+            logger.warning(ex)
+
+        # clean every hour
+        await asyncio.sleep(60 * 60)
+
+
 async def collect_exchange_rates_data() -> None:
     """
     Collect exchange rates data. Used for monitoring only.
     """
-    currency = settings.lnbits_default_accounting_currency or "USD"
-    max_history_size = settings.lnbits_exchange_history_size
-    try:
-        if (
-            settings.lnbits_price_aggregator_enabled
-            and settings.lnbits_price_aggregator_url
-        ):
-            price = await btc_price_from_aggregator(currency)
-            if price:
-                cache.set(
-                    f"btc-price-{currency}",
-                    price,
-                    expiry=settings.lnbits_exchange_rate_cache_seconds,
-                )
-                settings.append_exchange_rate_datapoint(
-                    {"Aggregator": price}, max_history_size
-                )
+    while settings.lnbits_running:
+        currency = settings.lnbits_default_accounting_currency or "USD"
+        max_history_size = settings.lnbits_exchange_history_size
+        sleep_time = settings.lnbits_exchange_history_refresh_interval_seconds
+
+        if sleep_time > 0:
+            try:
+                rates = await btc_rates(currency)
+                if rates:
+                    rates_values = [r[1] for r in rates]
+                    lnbits_rate = sum(rates_values) / len(rates_values)
+                    rates.append(("LNbits", lnbits_rate))
+                    cache.set(
+                        f"btc-price-{currency}",
+                        lnbits_rate,
+                        expiry=settings.lnbits_exchange_rate_cache_seconds,
+                    )
+                settings.append_exchange_rate_datapoint(dict(rates), max_history_size)
+            except Exception as ex:
+                logger.warning(ex)
         else:
-            rates = await btc_rates(currency)
-            if rates:
-                rates_values = [r[1] for r in rates]
-                lnbits_rate = sum(rates_values) / len(rates_values)
-                rates.append(("LNbits", lnbits_rate))
-                cache.set(
-                    f"btc-price-{currency}",
-                    lnbits_rate,
-                    expiry=settings.lnbits_exchange_rate_cache_seconds,
-                )
-            settings.append_exchange_rate_datapoint(dict(rates), max_history_size)
-    except Exception as ex:
-        logger.warning(ex)
+            sleep_time = 60
+        await asyncio.sleep(sleep_time)

lnbits/core/views/admin_api.py

@@ -20,7 +20,7 @@ from lnbits.core.services.settings import dict_to_settings
 from lnbits.decorators import check_admin, check_super_user
 from lnbits.server import server_restart
 from lnbits.settings import AdminSettings, Settings, UpdateSettings, settings
-from lnbits.task_manager import PublicTask, task_manager
+from lnbits.tasks import invoice_listeners
 
 from .. import core_app_extra
 from ..crud import get_admin_settings, reset_core_settings, update_admin_settings
@@ -44,10 +44,11 @@ async def api_auditor():
     name="Monitor",
     description="show the current listeners and other monitoring data",
     dependencies=[Depends(check_admin)],
-    response_model=list[PublicTask],
 )
-async def api_monitor() -> list[PublicTask]:
-    return task_manager.get_public_tasks()
+async def api_monitor():
+    return {
+        "invoice_listeners": list(invoice_listeners.keys()),
+    }
 
 
 @admin_router.get(

lnbits/core/views/extension_api.py

@@ -1,4 +1,3 @@
-import json
 import sys
 import traceback
 from http import HTTPStatus
@@ -10,8 +9,9 @@ from fastapi.requests import Request
 from loguru import logger
 
 from lnbits.core.crud.extensions import get_user_extensions
-from lnbits.core.crud.wallets import get_wallet, get_wallets_ids
+from lnbits.core.crud.wallets import get_wallets_ids
 from lnbits.core.db import db
+from lnbits.core.extensions.permissions import validate_extension_permissions
 from lnbits.core.models import (
     SimpleStatus,
 )
@@ -19,30 +19,17 @@ from lnbits.core.models.extensions import (
     CreateExtension,
     CreateExtensionReview,
     Extension,
-    ExtensionBackgroundPaymentDestinationPolicy,
-    ExtensionBackgroundPaymentGrant,
-    ExtensionBackgroundPaymentGrantRequest,
     ExtensionConfig,
     ExtensionMeta,
-    ExtensionPermissionCheckRequest,
-    ExtensionPermissionCheckResponse,
-    ExtensionPermissionCheckResult,
-    ExtensionPermissionsResponse,
     ExtensionRelease,
     ExtensionReview,
     ExtensionReviewPaymentRequest,
     ExtensionReviewsStatus,
-    ExtensionWalletPaymentsWatchGrant,
-    ExtensionWalletPaymentsWatchGrantRequest,
     InstallableExtension,
     PayToEnableInfo,
     ReleasePaymentInfo,
     UserExtension,
     UserExtensionInfo,
-    WasmInvocation,
-    WasmInvocationStats,
-    WasmRuntimeLimitsInfo,
-    WasmRuntimeLimitsUpdate,
     wasm_extension_icon_url,
 )
 from lnbits.core.models.users import Account, AccountId
@@ -50,19 +37,11 @@ from lnbits.core.services import check_transaction_status, create_invoice
 from lnbits.core.services.extensions import (
     activate_extension,
     deactivate_extension,
-    get_current_wasm_invocations,
     get_valid_extension,
     get_valid_extensions,
-    get_wasm_invocation_history,
-    get_wasm_invocation_summary,
     install_extension,
-    resolve_wasm_runtime_limits,
-    stop_wasm_invocation,
     uninstall_extension,
-    update_wasm_extension_runtime_limits,
-    validate_wasm_runtime_limit_overrides,
 )
-from lnbits.core.wasm_ext.api.permissions import validate_extension_permissions
 from lnbits.db import Page
 from lnbits.decorators import (
     check_account_exists,
@@ -89,9 +68,6 @@ extension_router = APIRouter(
     prefix="/api/v1/extension",
 )
 
-WALLET_PAY_INVOICE_BACKGROUND_PERMISSION = "wallet.pay_invoice_background"
-WALLET_PAYMENTS_WATCH_PERMISSION = "wallet.payments.watch"
-
 
 @extension_router.post("", dependencies=[Depends(check_admin)])
 async def api_install_extension(data: CreateExtension):
@@ -156,106 +132,6 @@ async def api_install_extension(data: CreateExtension):
         ) from exc
 
 
-@extension_router.get(
-    "/wasm/invocations/current",
-    dependencies=[Depends(check_admin)],
-)
-async def api_get_current_wasm_invocations(
-    extension_id: str | None = None,
-) -> list[WasmInvocation]:
-    return get_current_wasm_invocations(extension_id=extension_id)
-
-
-@extension_router.get(
-    "/wasm/invocations",
-    dependencies=[Depends(check_admin)],
-)
-async def api_get_wasm_invocations(
-    extension_id: str | None = None,
-    status: str | None = None,
-    limit: int = 100,
-    offset: int = 0,
-) -> list[WasmInvocation]:
-    return await get_wasm_invocation_history(
-        extension_id=extension_id,
-        status=status,
-        limit=limit,
-        offset=offset,
-    )
-
-
-@extension_router.get(
-    "/wasm/invocations/stats",
-    dependencies=[Depends(check_admin)],
-)
-async def api_get_wasm_invocation_stats(
-    extension_id: str | None = None,
-    hours: int = 24,
-) -> WasmInvocationStats:
-    return await get_wasm_invocation_summary(extension_id=extension_id, hours=hours)
-
-
-@extension_router.post(
-    "/wasm/invocations/{invocation_id}/stop",
-    dependencies=[Depends(check_admin)],
-)
-async def api_stop_wasm_invocation(invocation_id: str) -> SimpleStatus:
-    await stop_wasm_invocation(invocation_id, reason="Stopped by admin.")
-    return SimpleStatus(success=True, message="WASM invocation stop requested.")
-
-
-@extension_router.get(
-    "/wasm/runtime-limits/extensions",
-    dependencies=[Depends(check_admin)],
-)
-async def api_get_wasm_runtime_limit_extensions() -> list[WasmRuntimeLimitsInfo]:
-    installed_extensions = await get_installed_extensions()
-    return [
-        WasmRuntimeLimitsInfo(
-            id=extension.id,
-            name=extension.name,
-            active=extension.active,
-            wasm_runtime_limits=validate_wasm_runtime_limit_overrides(
-                extension.wasm_runtime_limits,
-                strict=False,
-            ),
-            effective_wasm_runtime_limits=resolve_wasm_runtime_limits(extension),
-        )
-        for extension in installed_extensions
-        if extension.is_wasm
-    ]
-
-
-@extension_router.put(
-    "/wasm/runtime-limits/{ext_id}",
-    dependencies=[Depends(check_admin)],
-)
-async def api_update_wasm_runtime_limits(
-    ext_id: str,
-    data: WasmRuntimeLimitsUpdate,
-) -> WasmRuntimeLimitsInfo:
-    try:
-        wasm_runtime_limits = await update_wasm_extension_runtime_limits(
-            ext_id, data.limits
-        )
-        extension = await get_installed_extension(ext_id)
-        if not extension:
-            raise ValueError(f"Extension '{ext_id}' is not installed.")
-        extension.wasm_runtime_limits = wasm_runtime_limits
-        return WasmRuntimeLimitsInfo(
-            id=extension.id,
-            name=extension.name,
-            active=extension.active,
-            wasm_runtime_limits=wasm_runtime_limits,
-            effective_wasm_runtime_limits=resolve_wasm_runtime_limits(extension),
-        )
-    except ValueError as exc:
-        raise HTTPException(
-            status_code=HTTPStatus.BAD_REQUEST,
-            detail=str(exc),
-        ) from exc
-
-
 @extension_router.get("/{ext_id}/details")
 async def api_extension_details(
     ext_id: str,
@@ -379,213 +255,6 @@ async def api_disable_extension(
     return SimpleStatus(success=True, message=f"Extension '{ext_id}' disabled.")
 
 
-@extension_router.post("/{ext_id}/permissions/background-payment")
-async def api_grant_background_payment_permission(
-    ext_id: str,
-    data: ExtensionBackgroundPaymentGrantRequest,
-    account_id: AccountId = Depends(check_account_id_exists),
-) -> dict:
-    installed_ext = await get_installed_extension(ext_id)
-    if not installed_ext or not installed_ext.active:
-        raise HTTPException(
-            HTTPStatus.NOT_FOUND, f"Extension '{ext_id}' is not active."
-        )
-
-    installed_permission_ids = {
-        permission.id for permission in installed_ext.permissions or []
-    }
-    if WALLET_PAY_INVOICE_BACKGROUND_PERMISSION not in installed_permission_ids:
-        raise HTTPException(
-            HTTPStatus.FORBIDDEN,
-            f"Extension '{ext_id}' cannot request background payments.",
-        )
-
-    user_ext = await get_user_extension(account_id.id, ext_id)
-    if not user_ext or not user_ext.active:
-        raise HTTPException(
-            HTTPStatus.FORBIDDEN,
-            f"Extension '{ext_id}' is not enabled for this user.",
-        )
-
-    wallet = await get_wallet(data.wallet_id)
-    if not wallet or wallet.user != account_id.id:
-        raise HTTPException(HTTPStatus.FORBIDDEN, "Not your wallet.")
-    if wallet.is_lightning_shared_wallet:
-        raise HTTPException(
-            HTTPStatus.BAD_REQUEST,
-            "Background payments are not allowed from shared wallets.",
-        )
-    if not wallet.can_send_payments:
-        raise HTTPException(
-            HTTPStatus.BAD_REQUEST,
-            "This wallet cannot send payments.",
-        )
-
-    permissions = user_ext.permissions or {}
-    grant = data.to_grant(
-        _user_permission_grant_id_for_wallet(
-            permissions,
-            WALLET_PAY_INVOICE_BACKGROUND_PERMISSION,
-            data.wallet_id,
-        )
-    )
-    background_grants = [
-        existing
-        for existing in permissions.get(WALLET_PAY_INVOICE_BACKGROUND_PERMISSION, [])
-        if isinstance(existing, dict) and existing.get("wallet_id") != grant.wallet_id
-    ]
-    background_grants.append(json.loads(grant.json()))
-    permissions[WALLET_PAY_INVOICE_BACKGROUND_PERMISSION] = background_grants
-    user_ext.permissions = permissions
-    await update_user_extension(user_ext)
-    return {"permission": WALLET_PAY_INVOICE_BACKGROUND_PERMISSION, "grant": grant}
-
-
-@extension_router.post("/{ext_id}/permissions/wallet-payments-watch")
-async def api_grant_wallet_payments_watch_permission(
-    ext_id: str,
-    data: ExtensionWalletPaymentsWatchGrantRequest,
-    account_id: AccountId = Depends(check_account_id_exists),
-) -> dict:
-    installed_ext = await get_installed_extension(ext_id)
-    if not installed_ext or not installed_ext.active:
-        raise HTTPException(
-            HTTPStatus.NOT_FOUND, f"Extension '{ext_id}' is not active."
-        )
-
-    installed_permission_ids = {
-        permission.id for permission in installed_ext.permissions or []
-    }
-    if WALLET_PAYMENTS_WATCH_PERMISSION not in installed_permission_ids:
-        raise HTTPException(
-            HTTPStatus.FORBIDDEN,
-            f"Extension '{ext_id}' cannot request wallet payment watch access.",
-        )
-
-    user_ext = await get_user_extension(account_id.id, ext_id)
-    if not user_ext or not user_ext.active:
-        raise HTTPException(
-            HTTPStatus.FORBIDDEN,
-            f"Extension '{ext_id}' is not enabled for this user.",
-        )
-
-    wallet = await get_wallet(data.wallet_id)
-    if not wallet or wallet.user != account_id.id:
-        raise HTTPException(HTTPStatus.FORBIDDEN, "Not your wallet.")
-
-    permissions = user_ext.permissions or {}
-    grant = data.to_grant(
-        _user_permission_grant_id_for_wallet(
-            permissions,
-            WALLET_PAYMENTS_WATCH_PERMISSION,
-            data.wallet_id,
-        )
-    )
-    watch_grants = [
-        existing
-        for existing in permissions.get(WALLET_PAYMENTS_WATCH_PERMISSION, [])
-        if isinstance(existing, dict) and existing.get("wallet_id") != grant.wallet_id
-    ]
-    watch_grants.append(json.loads(grant.json()))
-    permissions[WALLET_PAYMENTS_WATCH_PERMISSION] = watch_grants
-    user_ext.permissions = permissions
-    await update_user_extension(user_ext)
-    return {"permission": WALLET_PAYMENTS_WATCH_PERMISSION, "grant": grant}
-
-
-@extension_router.get("/{ext_id}/permissions")
-async def api_get_extension_permissions(
-    ext_id: str,
-    account_id: AccountId = Depends(check_account_id_exists),
-) -> ExtensionPermissionsResponse:
-    installed_ext = await _require_active_wasm_extension(ext_id)
-    extension_permissions = validate_extension_permissions(
-        installed_ext.id, installed_ext.permissions, strict=False
-    )
-    user_ext = await get_user_extension(account_id.id, ext_id)
-    return ExtensionPermissionsResponse(
-        extension_permissions=extension_permissions,
-        user_permissions=_safe_user_extension_permissions(
-            user_ext.permissions if user_ext else {}
-        ),
-    )
-
-
-@extension_router.delete("/{ext_id}/permissions/user/{grant_id}")
-async def api_delete_user_extension_permission(
-    ext_id: str,
-    grant_id: str,
-    account_id: AccountId = Depends(check_account_id_exists),
-) -> SimpleStatus:
-    await _require_active_wasm_extension(ext_id)
-
-    user_ext = await get_user_extension(account_id.id, ext_id)
-    if not user_ext:
-        return SimpleStatus(success=True, message="Permission grant removed.")
-
-    user_ext.permissions = _remove_user_permission_grant(
-        user_ext.permissions or {}, grant_id
-    )
-    await update_user_extension(user_ext)
-    return SimpleStatus(success=True, message="Permission grant removed.")
-
-
-@extension_router.post("/{ext_id}/permissions/check")
-async def api_check_extension_permissions(
-    ext_id: str,
-    data: ExtensionPermissionCheckRequest,
-    account_id: AccountId = Depends(check_account_id_exists),
-) -> ExtensionPermissionCheckResponse:
-    installed_ext = await get_installed_extension(ext_id)
-    if not installed_ext or not installed_ext.active:
-        raise HTTPException(
-            HTTPStatus.NOT_FOUND, f"Extension '{ext_id}' is not active."
-        )
-
-    installed_permission_ids = {
-        permission.id for permission in installed_ext.permissions or []
-    }
-
-    user_ext = await get_user_extension(account_id.id, ext_id)
-    if not user_ext or not user_ext.active:
-        raise HTTPException(
-            HTTPStatus.FORBIDDEN,
-            f"Extension '{ext_id}' is not enabled for this user.",
-        )
-
-    results: list[ExtensionPermissionCheckResult] = []
-    for permission in data.permissions:
-        if permission.id not in installed_permission_ids:
-            raise HTTPException(
-                HTTPStatus.FORBIDDEN,
-                f"Extension '{ext_id}' cannot request '{permission.id}'.",
-            )
-        if permission.id == WALLET_PAY_INVOICE_BACKGROUND_PERMISSION:
-            results.append(
-                await _check_background_payment_permission(
-                    account_id.id,
-                    user_ext.permissions or {},
-                    permission.grant,
-                )
-            )
-            continue
-        if permission.id == WALLET_PAYMENTS_WATCH_PERMISSION:
-            results.append(
-                await _check_wallet_payments_watch_permission(
-                    account_id.id,
-                    user_ext.permissions or {},
-                    permission.grant,
-                )
-            )
-            continue
-        raise HTTPException(
-            HTTPStatus.BAD_REQUEST,
-            f"Unsupported permission check '{permission.id}'.",
-        )
-
-    return ExtensionPermissionCheckResponse(permissions=results)
-
-
 @extension_router.put("/{ext_id}/activate", dependencies=[Depends(check_admin)])
 async def api_activate_extension(ext_id: str) -> SimpleStatus:
     try:
@@ -1003,178 +672,3 @@ async def create_extension_review(
         resp.raise_for_status()
         payment_request = resp.json()
         return ExtensionReviewPaymentRequest(**payment_request)
-
-
-async def _require_active_wasm_extension(ext_id: str) -> InstallableExtension:
-    installed_ext = await get_installed_extension(ext_id)
-    if not installed_ext or not installed_ext.active:
-        raise HTTPException(
-            HTTPStatus.NOT_FOUND, f"Extension '{ext_id}' is not active."
-        )
-    if not installed_ext.is_wasm:
-        raise HTTPException(
-            HTTPStatus.BAD_REQUEST, f"Extension '{ext_id}' is not a WASM extension."
-        )
-    return installed_ext
-
-
-def _safe_user_extension_permissions(permissions: dict | None) -> dict:
-    safe_permissions: dict[str, list[dict]] = {}
-    for permission_id, grants in (permissions or {}).items():
-        if not isinstance(permission_id, str) or not isinstance(grants, list):
-            continue
-        safe_grants = [
-            grant
-            for grant in grants
-            if isinstance(grant, dict) and isinstance(grant.get("id"), str)
-        ]
-        if safe_grants:
-            safe_permissions[permission_id] = safe_grants
-    return safe_permissions
-
-
-def _user_permission_grant_id_for_wallet(
-    permissions: dict, permission_id: str, wallet_id: str
-) -> str | None:
-    grants = permissions.get(permission_id)
-    if not isinstance(grants, list):
-        return None
-
-    for grant in grants:
-        if not isinstance(grant, dict) or grant.get("wallet_id") != wallet_id:
-            continue
-        grant_id = grant.get("id")
-        return grant_id if isinstance(grant_id, str) and grant_id else None
-    return None
-
-
-def _remove_user_permission_grant(permissions: dict, grant_id: str) -> dict:
-    updated_permissions = dict(permissions or {})
-    for permission_id, grants in list(updated_permissions.items()):
-        if not isinstance(grants, list):
-            continue
-
-        remaining_grants = [
-            grant
-            for grant in grants
-            if not isinstance(grant, dict) or grant.get("id") != grant_id
-        ]
-        if remaining_grants:
-            updated_permissions[permission_id] = remaining_grants
-        else:
-            updated_permissions.pop(permission_id, None)
-    return updated_permissions
-
-
-async def _check_background_payment_permission(
-    account_id: str,
-    permissions: dict,
-    grant_data: dict,
-) -> ExtensionPermissionCheckResult:
-    try:
-        data = ExtensionBackgroundPaymentGrantRequest.parse_obj(grant_data)
-    except ValueError as exc:
-        raise HTTPException(HTTPStatus.BAD_REQUEST, str(exc)) from exc
-
-    wallet = await get_wallet(data.wallet_id)
-    if not wallet or wallet.user != account_id:
-        raise HTTPException(HTTPStatus.FORBIDDEN, "Not your wallet.")
-    if wallet.is_lightning_shared_wallet:
-        raise HTTPException(
-            HTTPStatus.BAD_REQUEST,
-            "Background payments are not allowed from shared wallets.",
-        )
-    if not wallet.can_send_payments:
-        raise HTTPException(
-            HTTPStatus.BAD_REQUEST,
-            "This wallet cannot send payments.",
-        )
-
-    requested_grant = data.to_grant()
-    existing_grant = _find_background_payment_grant(
-        permissions, requested_grant.wallet_id
-    )
-    covered = (
-        existing_grant is not None
-        and existing_grant.enabled
-        and existing_grant.max_amount >= requested_grant.max_amount
-        and _background_destination_policy_covers(
-            existing_grant.destination_policy, requested_grant.destination_policy
-        )
-    )
-    grant = existing_grant if covered and existing_grant else requested_grant
-    return ExtensionPermissionCheckResult(
-        id=WALLET_PAY_INVOICE_BACKGROUND_PERMISSION,
-        approved=covered,
-        grant=json.loads(grant.json()),
-    )
-
-
-async def _check_wallet_payments_watch_permission(
-    account_id: str,
-    permissions: dict,
-    grant_data: dict,
-) -> ExtensionPermissionCheckResult:
-    try:
-        data = ExtensionWalletPaymentsWatchGrantRequest.parse_obj(grant_data)
-    except ValueError as exc:
-        raise HTTPException(HTTPStatus.BAD_REQUEST, str(exc)) from exc
-
-    wallet = await get_wallet(data.wallet_id)
-    if not wallet or wallet.user != account_id:
-        raise HTTPException(HTTPStatus.FORBIDDEN, "Not your wallet.")
-
-    existing_grant = _find_wallet_payments_watch_grant(permissions, data.wallet_id)
-    covered = bool(existing_grant and existing_grant.enabled)
-    grant = existing_grant if covered and existing_grant else data.to_grant()
-    return ExtensionPermissionCheckResult(
-        id=WALLET_PAYMENTS_WATCH_PERMISSION,
-        approved=covered,
-        grant=json.loads(grant.json()),
-    )
-
-
-def _find_background_payment_grant(
-    permissions: dict, wallet_id: str
-) -> ExtensionBackgroundPaymentGrant | None:
-    grants = permissions.get(WALLET_PAY_INVOICE_BACKGROUND_PERMISSION)
-    if not isinstance(grants, list):
-        return None
-    for grant_data in grants:
-        if not isinstance(grant_data, dict):
-            continue
-        try:
-            grant = ExtensionBackgroundPaymentGrant.parse_obj(grant_data)
-        except ValueError:
-            continue
-        if grant.wallet_id == wallet_id:
-            return grant
-    return None
-
-
-def _find_wallet_payments_watch_grant(
-    permissions: dict, wallet_id: str
-) -> ExtensionWalletPaymentsWatchGrant | None:
-    grants = permissions.get(WALLET_PAYMENTS_WATCH_PERMISSION)
-    if not isinstance(grants, list):
-        return None
-    for grant_data in grants:
-        if not isinstance(grant_data, dict):
-            continue
-        try:
-            grant = ExtensionWalletPaymentsWatchGrant.parse_obj(grant_data)
-        except ValueError:
-            continue
-        if grant.wallet_id == wallet_id:
-            return grant
-    return None
-
-
-def _background_destination_policy_covers(
-    existing: ExtensionBackgroundPaymentDestinationPolicy,
-    requested: ExtensionBackgroundPaymentDestinationPolicy,
-) -> bool:
-    return (
-        existing == requested
-        or existing == ExtensionBackgroundPaymentDestinationPolicy.EXTERNAL_ALLOWED
-    )

lnbits/core/views/generic.py

@@ -189,9 +189,6 @@ admin_ui_checks = [Depends(check_admin), Depends(check_admin_ui)]
 @generic_router.get("/audit", dependencies=admin_ui_checks)
 @generic_router.get("/node", dependencies=admin_ui_checks)
 @generic_router.get("/admin", dependencies=admin_ui_checks)
-@generic_router.get("/admin/extensions/wasm", dependencies=admin_ui_checks)
-@generic_router.get("/admin/extensions/wasm/limits", dependencies=admin_ui_checks)
-@generic_router.get("/admin/extensions/wasm/{ext_id}", dependencies=admin_ui_checks)
 @generic_router.get(
     "/extensions/builder", dependencies=[Depends(check_extension_builder)]
 )
@@ -199,9 +196,7 @@ admin_ui_checks = [Depends(check_admin), Depends(check_admin_ui)]
     "/extensions/builder/preview", dependencies=[Depends(check_extension_builder)]
 )
 async def index(
-    request: Request,
-    ext_id: str | None = None,
-    user: User = Depends(check_user_exists),
+    request: Request, user: User = Depends(check_user_exists)
 ) -> HTMLResponse:
     return template_renderer().TemplateResponse(
         request,

lnbits/core/views/user_api.py

@@ -158,6 +158,10 @@ async def api_update_user(
 async def api_users_delete_user(
     user_id: str, account: Account = Depends(check_admin)
 ) -> SimpleStatus:
+    wallets = await get_wallets(user_id, deleted=False)
+    for wallet in wallets:
+        await delete_wallet_by_id(wallet.id)
+
     if user_id == settings.super_user:
         raise HTTPException(
             status_code=HTTPStatus.BAD_REQUEST,
@@ -169,11 +173,6 @@ async def api_users_delete_user(
             status_code=HTTPStatus.BAD_REQUEST,
             detail="Only super_user can delete admin user.",
         )
-
-    wallets = await get_wallets(user_id, deleted=False)
-    for wallet in wallets:
-        await delete_wallet_by_id(wallet.id)
-
     await delete_account(user_id)
     return SimpleStatus(success=True, message="User deleted.")
 

lnbits/core/wasm_ext/__init__.py

@@ -1,24 +0,0 @@
-from .api.host import ExtensionHostAPI
-from .api.models import ExtensionAPIMethod, ExtensionAPIMethodExport
-from .api.registry import (
-    extension_api_contract,
-    extension_api_method,
-    extension_api_permission_ids,
-    get_extension_api_method,
-    list_extension_api_methods,
-)
-from .api.runtime import ExtensionAPIHost
-from .wasm.loader import WasmExtension
-
-__all__ = [
-    "ExtensionAPIHost",
-    "ExtensionAPIMethod",
-    "ExtensionAPIMethodExport",
-    "ExtensionHostAPI",
-    "WasmExtension",
-    "extension_api_contract",
-    "extension_api_method",
-    "extension_api_permission_ids",
-    "get_extension_api_method",
-    "list_extension_api_methods",
-]

lnbits/core/wasm_ext/api/__init__.py

@@ -1,22 +0,0 @@
-from .host import ExtensionHostAPI
-from .models import ExtensionAPIMethod, ExtensionAPIMethodExport
-from .registry import (
-    extension_api_contract,
-    extension_api_method,
-    extension_api_permission_ids,
-    get_extension_api_method,
-    list_extension_api_methods,
-)
-from .runtime import ExtensionAPIHost
-
-__all__ = [
-    "ExtensionAPIHost",
-    "ExtensionAPIMethod",
-    "ExtensionAPIMethodExport",
-    "ExtensionHostAPI",
-    "extension_api_contract",
-    "extension_api_method",
-    "extension_api_permission_ids",
-    "get_extension_api_method",
-    "list_extension_api_methods",
-]

lnbits/core/wasm_ext/api/background_payments.py

@@ -1,124 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, NoReturn
-
-from bolt11 import decode as bolt11_decode
-from loguru import logger
-
-from lnbits.core.crud.extensions import get_user_extension
-from lnbits.core.crud.payments import check_internal
-from lnbits.core.crud.wallets import get_wallet
-from lnbits.core.models.extensions import (
-    ExtensionBackgroundPaymentDestinationPolicy,
-    ExtensionBackgroundPaymentGrant,
-)
-from lnbits.core.models.wallets import Wallet
-
-WALLET_PAY_INVOICE_BACKGROUND_PERMISSION = "wallet.pay_invoice_background"
-
-
-async def background_payment_extra(
-    *,
-    extension_id: str,
-    wallet: Wallet,
-    payment_request: str,
-    amount_msat: int,
-) -> dict[str, Any]:
-    grant = await _background_payment_grant(extension_id, wallet, amount_msat)
-    await _check_destination_policy(extension_id, wallet, grant, payment_request)
-
-    return {
-        "tag": extension_id,
-        "extension": extension_id,
-        "background_payment": True,
-        "background_permission": WALLET_PAY_INVOICE_BACKGROUND_PERMISSION,
-        "background_wallet_id": wallet.source_wallet_id,
-        "background_destination_policy": grant.destination_policy.value,
-    }
-
-
-def invoice_amount_msat(payment_request: str) -> int:
-    invoice = bolt11_decode(payment_request)
-    amount_msat = int(invoice.amount_msat or 0)
-    if amount_msat <= 0:
-        raise PermissionError("Background payments require an invoice amount.")
-    return amount_msat
-
-
-async def _background_payment_grant(
-    extension_id: str,
-    wallet: Wallet,
-    amount_msat: int,
-) -> ExtensionBackgroundPaymentGrant:
-    if wallet.is_lightning_shared_wallet:
-        _deny(extension_id, wallet, amount_msat, "shared wallet")
-    if not wallet.can_send_payments:
-        _deny(extension_id, wallet, amount_msat, "wallet cannot send payments")
-
-    user_extension = await get_user_extension(wallet.user, extension_id)
-    if not user_extension or not user_extension.active:
-        _deny(extension_id, wallet, amount_msat, "extension disabled for user")
-
-    permissions = user_extension.permissions or {}
-    grants = permissions.get(WALLET_PAY_INVOICE_BACKGROUND_PERMISSION)
-    if not isinstance(grants, list):
-        _deny(extension_id, wallet, amount_msat, "missing background payment grant")
-
-    grant = _find_wallet_grant(grants, wallet.id)
-    if not grant:
-        _deny(extension_id, wallet, amount_msat, "missing wallet background grant")
-    if not grant.enabled:
-        _deny(extension_id, wallet, amount_msat, "background grant disabled")
-    if amount_msat > grant.max_amount * 1000:
-        _deny(extension_id, wallet, amount_msat, "payment exceeds max amount")
-    return grant
-
-
-def _find_wallet_grant(
-    grants: list[Any], wallet_id: str
-) -> ExtensionBackgroundPaymentGrant | None:
-    for grant_data in grants:
-        if not isinstance(grant_data, dict):
-            continue
-        try:
-            grant = ExtensionBackgroundPaymentGrant.parse_obj(grant_data)
-        except ValueError:
-            continue
-        if grant.wallet_id == wallet_id:
-            return grant
-    return None
-
-
-async def _check_destination_policy(
-    extension_id: str,
-    wallet: Wallet,
-    grant: ExtensionBackgroundPaymentGrant,
-    payment_request: str,
-) -> None:
-    if (
-        grant.destination_policy
-        == ExtensionBackgroundPaymentDestinationPolicy.EXTERNAL_ALLOWED
-    ):
-        return
-
-    payment_hash = bolt11_decode(payment_request).payment_hash
-    internal_payment = await check_internal(payment_hash)
-    if not internal_payment:
-        _deny(extension_id, wallet, 0, "external destination not allowed")
-
-    destination_wallet = await get_wallet(internal_payment.wallet_id)
-    if not destination_wallet or destination_wallet.user != wallet.user:
-        _deny(extension_id, wallet, 0, "destination wallet is not owned by user")
-
-
-def _deny(extension_id: str, wallet: Wallet, amount_msat: int, reason: str) -> NoReturn:
-    logger.warning(
-        "WASM extension '{}' denied background payment from wallet '{}', "
-        "user '{}', amount_msat '{}': {}.",
-        extension_id,
-        wallet.id,
-        wallet.user,
-        amount_msat,
-        reason,
-    )
-    raise PermissionError(reason)

lnbits/core/wasm_ext/api/lnurl.py

@@ -1,70 +0,0 @@
-from __future__ import annotations
-
-import json
-from typing import Any
-
-from lnurl import LnAddress, Lnurl
-
-
-def normalize_lnurl(value: str) -> str:
-    normalized = value.strip()
-    if normalized.lower().startswith("lightning:"):
-        normalized = normalized[len("lightning:") :]
-    if "@" in normalized:
-        normalized = normalized.lower()
-    if not normalized:
-        raise ValueError("LNURL is required.")
-    return normalized
-
-
-def lnurl_for_core(value: str) -> Lnurl | LnAddress:
-    normalized = normalize_lnurl(value)
-    if "@" in normalized:
-        return LnAddress(normalized)
-    return Lnurl(normalized)
-
-
-def lnurl_payment_amount_for_core(amount: float) -> int:
-    if amount <= 0:
-        raise ValueError("Amount must be greater than zero.")
-    return round(amount * 1000)
-
-
-def lnurl_payment_unit_for_core(currency: str) -> str:
-    unit = currency.strip().lower()
-    if not unit:
-        raise ValueError("Currency is required.")
-    if unit in {"sat", "sats"}:
-        return "sat"
-    return unit.upper()
-
-
-def lnurl_pay_response_metadata_json(response: Any) -> str:
-    metadata = getattr(response, "metadata", None)
-    if metadata is None:
-        return "[]"
-
-    metadata_list = getattr(metadata, "list", None)
-    try:
-        if callable(metadata_list):
-            return json.dumps(metadata_list())
-        return json.dumps(metadata)
-    except TypeError:
-        return json.dumps(str(metadata))
-
-
-def lnurl_pay_response_text(response: Any) -> str:
-    description = getattr(response, "description", None)
-    if description is not None:
-        return str(description)
-
-    metadata = getattr(response, "metadata", None)
-    text = getattr(metadata, "text", None)
-    return str(text) if text is not None else ""
-
-
-def lnurl_pay_response_int(response: Any, snake_name: str, camel_name: str) -> int:
-    value = getattr(response, snake_name, None)
-    if value is None:
-        value = getattr(response, camel_name, 0)
-    return int(value or 0)

lnbits/core/wasm_ext/api/permissions.py

@@ -1,250 +0,0 @@
-from collections.abc import Iterable
-from typing import Any
-
-from lnbits.core.models.extensions import ExtensionPermission, InstallableExtension
-from lnbits.core.wasm_ext.api.registry import extension_api_permission_ids
-from lnbits.core.wasm_ext.client.http import _request_origin
-from lnbits.core.wasm_ext.wasm.config import (
-    WasmExtensionConfig,
-    parse_wasm_extension_config,
-)
-
-_POLICY_AWARE_PERMISSION_IDS = {
-    "ext.storage.read_public",
-    "extension.api.request",
-    "http.request",
-    "wallet.create_invoice_public",
-}
-
-
-def validate_extension_permissions(
-    ext_id: str,
-    permissions: Iterable[ExtensionPermission],
-    *,
-    strict: bool = True,
-) -> list[ExtensionPermission]:
-    known_permission_ids = extension_api_permission_ids()
-    normalized_permissions: list[ExtensionPermission] = []
-    unknown_ids: list[str] = []
-
-    for permission in permissions:
-        if permission.id not in known_permission_ids:
-            unknown_ids.append(permission.id)
-            if strict:
-                continue
-        normalized_permissions.append(permission.copy())
-
-    if unknown_ids and strict:
-        raise ValueError(
-            f"Extension '{ext_id}' requests unknown permissions: "
-            + ", ".join(sorted(set(unknown_ids)))
-        )
-
-    return normalized_permissions
-
-
-def validate_wasm_extension_permissions(
-    ext_info: InstallableExtension,
-    granted_permissions: list[ExtensionPermission] | None,
-    extension_config: dict[str, Any] | WasmExtensionConfig,
-) -> list[ExtensionPermission]:
-    if isinstance(extension_config, WasmExtensionConfig):
-        config = extension_config
-    elif extension_config.get("extension_type") != "wasm":
-        return []
-    else:
-        config = parse_wasm_extension_config(ext_info.id, extension_config)
-
-    requested_permissions = validate_extension_permissions(
-        ext_info.id, config.permissions
-    )
-    if not requested_permissions:
-        return []
-
-    if granted_permissions is None:
-        raise ValueError(f"Extension '{ext_info.id}' requires permission approval.")
-
-    granted_permissions = validate_extension_permissions(
-        ext_info.id,
-        granted_permissions,
-    )
-    requested_by_id = _permission_index(ext_info.id, requested_permissions, "requested")
-    granted_by_id = _permission_index(ext_info.id, granted_permissions, "granted")
-
-    extra_granted_ids = sorted(set(granted_by_id) - set(requested_by_id))
-    if extra_granted_ids:
-        raise ValueError(
-            f"Extension '{ext_info.id}' was granted unrequested permissions: "
-            + ", ".join(extra_granted_ids)
-        )
-
-    effective_permissions: list[ExtensionPermission] = []
-    for permission_id, granted_permission in granted_by_id.items():
-        requested_permission = requested_by_id[permission_id]
-        if not _permission_grant_is_subset(requested_permission, granted_permission):
-            raise ValueError(
-                f"Extension '{ext_info.id}' was granted broader policies for "
-                f"permission '{permission_id}'."
-            )
-        effective_permissions.append(
-            requested_permission.copy(update={"policies": granted_permission.policies})
-        )
-
-    return effective_permissions
-
-
-def _permission_index(
-    ext_id: str,
-    permissions: Iterable[ExtensionPermission],
-    source: str,
-) -> dict[str, ExtensionPermission]:
-    indexed: dict[str, ExtensionPermission] = {}
-    duplicate_ids: list[str] = []
-
-    for permission in permissions:
-        if permission.id in indexed:
-            duplicate_ids.append(permission.id)
-            continue
-        indexed[permission.id] = permission
-
-    if duplicate_ids:
-        raise ValueError(
-            f"Extension '{ext_id}' has duplicate {source} permissions: "
-            + ", ".join(sorted(set(duplicate_ids)))
-        )
-    return indexed
-
-
-def _permission_grant_is_subset(
-    requested: ExtensionPermission,
-    granted: ExtensionPermission,
-) -> bool:
-    if requested.id != granted.id:
-        return False
-    if requested.id not in _POLICY_AWARE_PERMISSION_IDS:
-        return True
-    if requested.id == "http.request":
-        return _http_request_grant_is_subset(requested.policies, granted.policies)
-    if requested.id == "extension.api.request":
-        return _extension_api_grant_is_subset(requested.policies, granted.policies)
-    if requested.id == "ext.storage.read_public":
-        return _public_storage_grant_is_subset(requested.policies, granted.policies)
-    if requested.id == "wallet.create_invoice_public":
-        return _public_invoice_grant_is_subset(requested.policies, granted.policies)
-    return False
-
-
-def _policy_list(policies: list[Any] | None) -> list[Any]:
-    return policies if isinstance(policies, list) else []
-
-
-def _http_request_grant_is_subset(
-    requested_policies: list[Any] | None,
-    granted_policies: list[Any] | None,
-) -> bool:
-    return _http_origins(granted_policies).issubset(_http_origins(requested_policies))
-
-
-def _http_origins(policies: list[Any] | None) -> set[str]:
-    origins: set[str] = set()
-    for policy in _policy_list(policies):
-        host = policy.get("host") if isinstance(policy, dict) else policy
-        if not isinstance(host, str) or not host:
-            continue
-        try:
-            origins.add(_request_origin(host))
-        except PermissionError:
-            continue
-    return origins
-
-
-def _extension_api_grant_is_subset(
-    requested_policies: list[Any] | None,
-    granted_policies: list[Any] | None,
-) -> bool:
-    requested_targets = _extension_api_targets(requested_policies)
-    granted_targets = _extension_api_targets(granted_policies)
-    for extension_id, granted_access in granted_targets.items():
-        requested_access = requested_targets.get(extension_id)
-        if requested_access is None or not granted_access.issubset(requested_access):
-            return False
-    return True
-
-
-def _extension_api_targets(policies: list[Any] | None) -> dict[str, set[str]]:
-    targets: dict[str, set[str]] = {}
-    for policy in _policy_list(policies):
-        extension_id: str | None = None
-        access: list[Any] = []
-        if isinstance(policy, str):
-            extension_id = policy
-            access = ["read"]
-        elif isinstance(policy, dict):
-            raw_extension_id = policy.get("id")
-            raw_access = policy.get("access")
-            if isinstance(raw_extension_id, str) and isinstance(raw_access, list):
-                extension_id = raw_extension_id
-                access = raw_access
-        if not extension_id or extension_id in targets:
-            continue
-        clean_access = {
-            item
-            for item in access
-            if isinstance(item, str) and item in {"read", "write"}
-        }
-        if clean_access:
-            targets[extension_id] = clean_access
-    return targets
-
-
-def _public_storage_grant_is_subset(
-    requested_policies: list[Any] | None,
-    granted_policies: list[Any] | None,
-) -> bool:
-    requested_tables = _public_storage_tables(requested_policies)
-    granted_tables = _public_storage_tables(granted_policies)
-    for table_name, granted_fields in granted_tables.items():
-        requested_fields = requested_tables.get(table_name)
-        if requested_fields is None or not granted_fields.issubset(requested_fields):
-            return False
-    return True
-
-
-def _public_storage_tables(policies: list[Any] | None) -> dict[str, set[str]]:
-    tables: dict[str, set[str]] = {}
-    for policy in _policy_list(policies):
-        if not isinstance(policy, dict):
-            continue
-        table_name = policy.get("table_name")
-        public_fields = policy.get("public_fields")
-        if (
-            not isinstance(table_name, str)
-            or table_name in tables
-            or not isinstance(public_fields, list)
-        ):
-            continue
-        fields = {field for field in public_fields if isinstance(field, str) and field}
-        if fields:
-            tables[table_name] = fields
-    return tables
-
-
-def _public_invoice_grant_is_subset(
-    requested_policies: list[Any] | None,
-    granted_policies: list[Any] | None,
-) -> bool:
-    return _public_invoice_sources(granted_policies).issubset(
-        _public_invoice_sources(requested_policies)
-    )
-
-
-def _public_invoice_sources(policies: list[Any] | None) -> set[tuple[str, str]]:
-    sources: set[tuple[str, str]] = set()
-    for policy in _policy_list(policies):
-        if not isinstance(policy, dict):
-            continue
-        table = policy.get("table")
-        wallet_field = policy.get("wallet_field")
-        if isinstance(table, str) and table and isinstance(wallet_field, str):
-            sources.add((table, wallet_field))
-    return sources

lnbits/core/wasm_ext/api/registry.py

@@ -1,204 +0,0 @@
-from __future__ import annotations
-
-import inspect
-from collections.abc import Awaitable, Callable
-from functools import wraps
-from typing import Any, TypeVar, cast, get_type_hints
-
-from pydantic import BaseModel
-
-from .models import ExtensionAPIMethod, ExtensionAPIMethodExport
-
-_EXTENSION_API_METHOD_ATTR = "__lnbits_extension_api_method__"
-_EXTENSION_RUNTIME_PERMISSION_IDS = {
-    "ui.camera.scan_qr",
-    "wallet.pay_invoice",
-    "wallet.pay_invoice_background",
-    "wallet.payments.watch",
-}
-_RequestModel = TypeVar("_RequestModel", bound=BaseModel)
-_ResponseModel = TypeVar("_ResponseModel", bound=BaseModel)
-
-
-def extension_api_method(
-    *,
-    method_id: str,
-    namespace: str,
-    name: str,
-    host_name: str,
-    sdk_name: str,
-    description: str,
-    host_interface: str = "host",
-    required_permission: str | None = None,
-    require_auth: bool = True,
-) -> Callable[
-    [Callable[[Any, _RequestModel], Awaitable[_ResponseModel]]],
-    Callable[[Any, _RequestModel], Awaitable[_ResponseModel]],
-]:
-    export = ExtensionAPIMethodExport(
-        method_id=method_id,
-        namespace=namespace,
-        name=name,
-        host_interface=host_interface,
-        host_name=host_name,
-        sdk_name=sdk_name,
-        description=description,
-        required_permission=required_permission,
-        require_auth=require_auth,
-    )
-
-    def decorator(
-        function: Callable[[Any, _RequestModel], Awaitable[_ResponseModel]],
-    ) -> Callable[[Any, _RequestModel], Awaitable[_ResponseModel]]:
-        @wraps(function)
-        async def wrapper(self: Any, request: _RequestModel) -> _ResponseModel:
-            api = getattr(self, "api", self)
-            if require_auth and not api.has_authenticated_context():
-                raise PermissionError(
-                    f"Extension API method '{method_id}' requires authentication."
-                )
-            api.require_permission(required_permission)
-            return await function(self, request)
-
-        setattr(wrapper, _EXTENSION_API_METHOD_ATTR, export)
-        return wrapper
-
-    return decorator
-
-
-def list_extension_api_methods(
-    api_cls: type[Any] | None = None,
-) -> list[ExtensionAPIMethod]:
-    api_cls = _default_api_cls(api_cls)
-    methods: list[ExtensionAPIMethod] = []
-
-    for prefix, method_cls in _extension_api_method_sources(api_cls):
-        for python_name, function in inspect.getmembers(method_cls, inspect.isfunction):
-            export = getattr(function, _EXTENSION_API_METHOD_ATTR, None)
-            if not export:
-                continue
-
-            request_model, response_model = _get_method_models(function)
-            methods.append(
-                ExtensionAPIMethod(
-                    method_id=export.method_id,
-                    namespace=export.namespace,
-                    name=export.name,
-                    python_name=f"{prefix}.{python_name}" if prefix else python_name,
-                    host_interface=export.host_interface,
-                    host_name=export.host_name,
-                    sdk_name=export.sdk_name,
-                    description=export.description,
-                    request_model=request_model,
-                    response_model=response_model,
-                    required_permission=export.required_permission,
-                    require_auth=export.require_auth,
-                )
-            )
-
-    return sorted(methods, key=lambda method: method.method_id)
-
-
-def extension_api_permission_ids(api_cls: type[Any] | None = None) -> set[str]:
-    permissions = {
-        method.required_permission
-        for method in list_extension_api_methods(api_cls)
-        if method.required_permission
-    }
-    permissions.update(_EXTENSION_RUNTIME_PERMISSION_IDS)
-    return permissions
-
-
-def get_extension_api_method(
-    method_id: str,
-    api_cls: type[Any] | None = None,
-) -> ExtensionAPIMethod:
-    for method in list_extension_api_methods(api_cls):
-        if method.method_id == method_id:
-            return method
-    raise KeyError(f"Unknown extension API method '{method_id}'.")
-
-
-def extension_api_contract(api_cls: type[Any] | None = None) -> dict[str, object]:
-    return {
-        "version": 1,
-        "methods": [
-            {
-                "id": method.method_id,
-                "namespace": method.namespace,
-                "name": method.name,
-                "python_name": method.python_name,
-                "host_interface": method.host_interface,
-                "host_name": method.host_name,
-                "sdk_name": method.sdk_name,
-                "sdk_qualified_name": method.sdk_qualified_name,
-                "description": method.description,
-                "required_permission": method.required_permission,
-                "require_auth": method.require_auth,
-                "request_schema": method.request_model.schema(
-                    ref_template="#/definitions/{model}"
-                ),
-                "response_schema": method.response_model.schema(
-                    ref_template="#/definitions/{model}"
-                ),
-            }
-            for method in list_extension_api_methods(api_cls)
-        ],
-    }
-
-
-def _default_api_cls(api_cls: type[Any] | None) -> type[Any]:
-    if api_cls is not None:
-        return api_cls
-
-    from .host import ExtensionHostAPI
-
-    return ExtensionHostAPI
-
-
-def _extension_api_method_sources(
-    api_cls: type[Any],
-) -> list[tuple[str, type[Any]]]:
-    sources: list[tuple[str, type[Any]]] = [("", api_cls)]
-
-    from .host import ExtensionHostAPI
-
-    if issubclass(api_cls, ExtensionHostAPI):
-        from .utils import extension_api_utils_method_classes
-
-        sources.extend(extension_api_utils_method_classes().items())
-    return sources
-
-
-def _get_method_models(
-    function: Callable[..., object],
-) -> tuple[type[BaseModel], type[BaseModel]]:
-    signature = inspect.signature(function)
-    request_parameters = [
-        parameter
-        for parameter in signature.parameters.values()
-        if parameter.name != "self"
-    ]
-    if len(request_parameters) != 1:
-        raise TypeError(
-            f"Extension API method '{function.__name__}' must accept one request model."
-        )
-
-    hints = get_type_hints(function)
-    request_model = hints.get(request_parameters[0].name)
-    response_model = hints.get("return")
-
-    if not _is_pydantic_model(request_model):
-        raise TypeError(
-            f"Extension API method '{function.__name__}' request must be a BaseModel."
-        )
-    if not _is_pydantic_model(response_model):
-        raise TypeError(
-            f"Extension API method '{function.__name__}' response must be a BaseModel."
-        )
-
-    return cast(type[BaseModel], request_model), cast(type[BaseModel], response_model)
-
-
-def _is_pydantic_model(value: object) -> bool:
-    return isinstance(value, type) and issubclass(value, BaseModel)

lnbits/core/wasm_ext/client/__init__.py

@@ -1,4 +0,0 @@
-from .extensions import send_extension_api_request
-from .http import send_extension_http_request
-
-__all__ = ["send_extension_api_request", "send_extension_http_request"]

lnbits/core/wasm_ext/routes/__init__.py

@@ -1,3 +0,0 @@
-from .register import register_wasm_extension
-
-__all__ = ["register_wasm_extension"]

lnbits/core/wasm_ext/routes/api.py

@@ -1,261 +0,0 @@
-from __future__ import annotations
-
-import json
-import re
-from dataclasses import dataclass
-from typing import Annotated, Any
-
-from fastapi import Depends, FastAPI, HTTPException, Request
-
-from lnbits.core.models import Account
-from lnbits.core.services.extensions import get_wasm_runtime_limits_for_extension
-from lnbits.decorators import check_access_token, check_account_exists
-from lnbits.settings import settings
-
-from ..wasm.config import WasmAPIRouteConfig
-from ..wasm.invoke import invoke_wasm_extension_export
-from ..wasm.loader import WasmExtension
-
-
-class WasmRequestBodyTooLargeError(ValueError):
-    pass
-
-
-@dataclass(frozen=True)
-class WasmRoutePayload:
-    data: dict[str, Any]
-    request_bytes: int | None
-
-
-def register_wasm_extension_api_routes(app: FastAPI, extension: WasmExtension) -> None:
-    for route_config in extension.config.api_routes:
-        _add_wasm_extension_api_route(app, extension, route_config)
-
-
-def _add_wasm_extension_api_route(
-    app: FastAPI,
-    extension: WasmExtension,
-    route_config: WasmAPIRouteConfig,
-) -> None:
-    method = _wasm_extension_api_method(extension, route_config.method)
-    route_path = _wasm_extension_api_path(extension, route_config.path)
-    export_name = _wasm_extension_api_export(extension, route_config.export)
-    path_params = route_config.path_params
-    auth = _wasm_extension_route_auth(extension, route_config.auth)
-
-    if _has_route(app, route_path, method):
-        return
-
-    async def invoke_wasm_api_request(
-        request: Request,
-        account: Account | None = None,
-        access_token: str | None = None,
-    ) -> dict[str, Any]:
-        try:
-            limits = await get_wasm_runtime_limits_for_extension(extension.id)
-            payload = await _read_api_payload(
-                request,
-                path_params,
-                max_body_bytes=limits["wasm_runtime_max_request_bytes"],
-            )
-            return await invoke_wasm_extension_export(
-                extension.id,
-                export_name,
-                payload.data,
-                user=account,
-                access_token=access_token,
-                trigger_type="http",
-                method=request.method,
-                path=request.url.path,
-                request_id=request.headers.get("x-request-id"),
-                request_bytes=payload.request_bytes,
-                context_data={"origin": _request_origin(request)},
-            )
-        except WasmRequestBodyTooLargeError as exc:
-            raise HTTPException(status_code=413, detail=str(exc)) from exc
-        except KeyError as exc:
-            raise HTTPException(status_code=404, detail=str(exc)) from exc
-        except PermissionError as exc:
-            raise HTTPException(status_code=403, detail=str(exc)) from exc
-        except (TypeError, ValueError) as exc:
-            raise HTTPException(status_code=400, detail=str(exc)) from exc
-
-    async def invoke_private_wasm_extension_export(
-        request: Request,
-        access_token: Annotated[str | None, Depends(check_access_token)],
-        account: Account = Depends(check_account_exists),
-    ) -> dict[str, Any]:
-        return await invoke_wasm_api_request(request, account, access_token)
-
-    async def invoke_public_wasm_extension_export(request: Request) -> dict[str, Any]:
-        return await invoke_wasm_api_request(request)
-
-    app.add_api_route(
-        route_path,
-        (
-            invoke_public_wasm_extension_export
-            if auth == "public"
-            else invoke_private_wasm_extension_export
-        ),
-        methods=[method],
-        name=f"{extension.id}:{method}:{route_path}",
-        include_in_schema=False,
-    )
-
-
-async def _read_api_payload(
-    request: Request,
-    path_params: dict[str, str],
-    *,
-    max_body_bytes: int,
-) -> WasmRoutePayload:
-    payload = _read_api_path_params(request, path_params)
-    payload.update(_read_api_query_params(request))
-    request_bytes: int | None = None
-    if request.method in {"POST", "PUT", "PATCH"}:
-        body, request_bytes = await _read_json_object_with_size(
-            request,
-            max_body_bytes=max_body_bytes,
-        )
-        payload.update(body)
-    return WasmRoutePayload(payload, request_bytes)
-
-
-async def _read_json_object(
-    request: Request,
-    *,
-    max_body_bytes: int | None = None,
-) -> dict[str, Any]:
-    body, _ = await _read_json_object_with_size(
-        request,
-        max_body_bytes=(
-            settings.wasm_runtime_max_request_bytes
-            if max_body_bytes is None
-            else max_body_bytes
-        ),
-    )
-    return body
-
-
-async def _read_json_object_with_size(
-    request: Request,
-    *,
-    max_body_bytes: int,
-) -> tuple[dict[str, Any], int]:
-    body = await _read_limited_body(request, max_body_bytes=max_body_bytes)
-    if not body:
-        return {}, 0
-    value = json.loads(body)
-    if not isinstance(value, dict):
-        raise TypeError("WASM extension API payload must be a JSON object.")
-    return value, len(body)
-
-
-async def _read_limited_body(request: Request, *, max_body_bytes: int) -> bytes:
-    content_length = _request_content_length(request)
-    if _wasm_request_too_large(content_length, max_body_bytes):
-        raise WasmRequestBodyTooLargeError(
-            f"WASM extension request is too large: {content_length} bytes."
-        )
-
-    chunks: list[bytes] = []
-    size = 0
-    async for chunk in request.stream():
-        if not chunk:
-            continue
-        size += len(chunk)
-        if _wasm_request_too_large(size, max_body_bytes):
-            raise WasmRequestBodyTooLargeError(
-                f"WASM extension request is too large: {size} bytes."
-            )
-        chunks.append(chunk)
-    return b"".join(chunks)
-
-
-def _read_api_path_params(
-    request: Request,
-    path_params: dict[str, str],
-) -> dict[str, Any]:
-    payload: dict[str, Any] = {}
-    for key, value in request.path_params.items():
-        target = path_params.get(key) or _snake_to_camel(key)
-        payload[target] = value
-    return payload
-
-
-def _read_api_query_params(request: Request) -> dict[str, Any]:
-    return {_snake_to_camel(key): value for key, value in request.query_params.items()}
-
-
-def _request_content_length(request: Request) -> int | None:
-    content_length = request.headers.get("content-length")
-    if content_length and content_length.isdigit():
-        return int(content_length)
-    return None
-
-
-def _wasm_request_too_large(size: int | None, max_body_bytes: int) -> bool:
-    return size is not None and max_body_bytes > 0 and size > max_body_bytes
-
-
-def _request_origin(request: Request) -> str | None:
-    origin = request.headers.get("origin")
-    if not origin:
-        return None
-    return origin[:256]
-
-
-def _wasm_extension_api_export(extension: WasmExtension, export_name: Any) -> str:
-    if not isinstance(export_name, str) or not export_name:
-        raise ValueError(f"Invalid API export for WASM extension '{extension.id}'.")
-
-    for export in extension.exports:
-        if export.name != export_name:
-            continue
-        if export.visibility in {"public", "authenticated"}:
-            return export_name
-        raise PermissionError(f"WASM export '{export_name}' is not callable over HTTP.")
-    raise KeyError(f"WASM extension '{extension.id}' has no export '{export_name}'.")
-
-
-def _wasm_extension_api_method(extension: WasmExtension, method: Any) -> str:
-    if not isinstance(method, str):
-        raise ValueError(f"Invalid API method for WASM extension '{extension.id}'.")
-    method = method.upper()
-    if method not in {"GET", "POST", "PUT", "PATCH", "DELETE"}:
-        raise ValueError(f"Unsupported API method for WASM extension '{extension.id}'.")
-    return method
-
-
-def _wasm_extension_api_path(extension: WasmExtension, path: Any) -> str:
-    if not isinstance(path, str) or not path.startswith("/"):
-        raise ValueError(f"Invalid API path for WASM extension '{extension.id}'.")
-    if path == "/":
-        return f"/api/v1/ext/{extension.id}"
-    return f"/api/v1/ext/{extension.id}{path}"
-
-
-def _wasm_extension_route_auth(extension: WasmExtension, auth: Any) -> str:
-    if auth in {"public", "user"}:
-        return auth
-    raise ValueError(f"Invalid route auth for WASM extension '{extension.id}'.")
-
-
-def _has_route(app: FastAPI, route_path: str, method: str) -> bool:
-    for route in app.routes:
-        if getattr(route, "path", None) != route_path:
-            continue
-        methods = getattr(route, "methods", set()) or set()
-        if method in methods:
-            return True
-    return False
-
-
-def _snake_to_camel(value: str) -> str:
-    head, *tail = value.split("_")
-    return head + "".join(part.capitalize() for part in tail)
-
-
-def _path_template_pattern(path: str) -> str:
-    pattern = re.sub(r"\\{[^/{}]+\\}", r"[^/]+", re.escape(path))
-    return f"^{pattern}$"

lnbits/core/wasm_ext/routes/assets.py

@@ -1,139 +0,0 @@
-from __future__ import annotations
-
-import os
-from pathlib import Path
-
-from fastapi import FastAPI, HTTPException
-from fastapi.responses import FileResponse, Response
-from fastapi.staticfiles import StaticFiles
-from starlette.staticfiles import PathLike as StaticFilesPathLike
-from starlette.types import Scope
-
-from lnbits.settings import settings
-
-from ..wasm.loader import WasmExtension
-
-WASM_EXTENSION_CORE_ASSET_PREFIX = "_lnbits"
-WASM_EXTENSION_CORE_STATIC_ASSETS = {
-    "bundle.min.css": ("static/bundle.min.css", "text/css; charset=utf-8"),
-    "material-icons-v50.woff2": (
-        "static/fonts/material-icons-v50.woff2",
-        "font/woff2",
-    ),
-    "quasar.css": ("static/vendor/quasar.css", "text/css; charset=utf-8"),
-    "quasar.umd.prod.js": (
-        "static/vendor/quasar.umd.prod.js",
-        "text/javascript; charset=utf-8",
-    ),
-    "qrcode.vue.browser.js": (
-        "static/vendor/qrcode.vue.browser.js",
-        "text/javascript; charset=utf-8",
-    ),
-    "vue.global.prod.js": (
-        "static/vendor/vue.global.prod.js",
-        "text/javascript; charset=utf-8",
-    ),
-}
-WASM_EXTENSION_GENERATED_CORE_ASSETS = {
-    "material-icons.css": (
-        """
-        @font-face {
-          font-family: 'Material Icons';
-          font-style: normal;
-          font-weight: 400;
-          src: url('./material-icons-v50.woff2') format('woff2');
-        }
-        """,
-        "text/css; charset=utf-8",
-    )
-}
-WASM_EXTENSION_STATIC_MIME_TYPES = {
-    ".css": "text/css; charset=utf-8",
-    ".gif": "image/gif",
-    ".ico": "image/x-icon",
-    ".jpeg": "image/jpeg",
-    ".jpg": "image/jpeg",
-    ".js": "text/javascript; charset=utf-8",
-    ".png": "image/png",
-    ".webp": "image/webp",
-    ".woff": "font/woff",
-    ".woff2": "font/woff2",
-}
-WASM_EXTENSION_TEXT_STATIC_EXTENSIONS = {".css", ".js"}
-WASM_EXTENSION_HTML_PREFIXES = (b"<!doctype", b"<html", b"<script")
-
-
-class GuardedWasmExtensionStaticFiles(StaticFiles):
-    async def get_response(self, path: str, scope: Scope) -> Response:
-        if path.startswith(f"{WASM_EXTENSION_CORE_ASSET_PREFIX}/"):
-            return _wasm_extension_core_asset_response(path)
-        if Path(path).suffix.lower() not in WASM_EXTENSION_STATIC_MIME_TYPES:
-            raise HTTPException(status_code=404)
-        return await super().get_response(path, scope)
-
-    def file_response(
-        self,
-        full_path: StaticFilesPathLike,
-        stat_result: os.stat_result,
-        scope: Scope,
-        status_code: int = 200,
-    ) -> Response:
-        suffix = Path(full_path).suffix.lower()
-        if suffix in WASM_EXTENSION_TEXT_STATIC_EXTENSIONS:
-            _reject_html_like_wasm_static_asset(Path(full_path))
-
-        response = super().file_response(full_path, stat_result, scope, status_code)
-        response.headers["Content-Type"] = WASM_EXTENSION_STATIC_MIME_TYPES[suffix]
-        response.headers["X-Content-Type-Options"] = "nosniff"
-        response.headers["Cache-Control"] = "no-store"
-        return response
-
-
-def mount_wasm_extension_static(app: FastAPI, extension: WasmExtension) -> None:
-    static_path = extension.root_path / "static"
-
-    mount_path = f"/ext-assets/{extension.id}"
-    if any(getattr(route, "path", None) == mount_path for route in app.routes):
-        return
-
-    app.mount(
-        mount_path,
-        GuardedWasmExtensionStaticFiles(directory=static_path, check_dir=False),
-        name=f"{extension.id}-static",
-    )
-
-
-def _reject_html_like_wasm_static_asset(path: Path) -> None:
-    with path.open("rb") as asset_file:
-        prefix = asset_file.read(512).lstrip().lower()
-    if prefix.startswith(WASM_EXTENSION_HTML_PREFIXES):
-        raise HTTPException(status_code=404)
-
-
-def _wasm_extension_core_asset_response(path: str) -> Response:
-    asset_name = path.removeprefix(f"{WASM_EXTENSION_CORE_ASSET_PREFIX}/")
-    if not asset_name or "/" in asset_name or "\\" in asset_name:
-        raise HTTPException(status_code=404)
-
-    generated_asset = WASM_EXTENSION_GENERATED_CORE_ASSETS.get(asset_name)
-    if generated_asset:
-        content, content_type = generated_asset
-        response = Response(content=content, media_type=content_type)
-        response.headers["X-Content-Type-Options"] = "nosniff"
-        response.headers["Cache-Control"] = "no-store"
-        return response
-
-    asset_config = WASM_EXTENSION_CORE_STATIC_ASSETS.get(asset_name)
-    if not asset_config:
-        raise HTTPException(status_code=404)
-
-    relative_path, content_type = asset_config
-    asset_path = Path(settings.lnbits_path, relative_path)
-    if not asset_path.is_file():
-        raise HTTPException(status_code=404)
-
-    response = FileResponse(asset_path)
-    response.headers["Content-Type"] = content_type
-    response.headers["X-Content-Type-Options"] = "nosniff"
-    response.headers["Cache-Control"] = "no-store"
-    return response

lnbits/core/wasm_ext/routes/register.py

@@ -1,32 +0,0 @@
-from __future__ import annotations
-
-from fastapi import FastAPI
-from loguru import logger
-
-from lnbits.core.db import core_app_extra
-from lnbits.settings import settings
-
-from ..wasm.component import warm_wasm_extension
-from ..wasm.loader import WasmExtension, load_wasm_extension
-from .api import register_wasm_extension_api_routes
-from .assets import mount_wasm_extension_static
-from .ui import register_wasm_extension_ui_routes
-
-
-def register_wasm_extension(app: FastAPI, ext_id: str) -> WasmExtension:
-    loaded = load_wasm_extension(ext_id)
-    core_app_extra.wasm_extension_registry.require_available(loaded)
-
-    warm_wasm_extension(loaded)
-    mount_wasm_extension_static(app, loaded)
-    register_wasm_extension_ui_routes(app, loaded)
-    register_wasm_extension_api_routes(app, loaded)
-
-    core_app_extra.wasm_extension_registry.register(loaded)
-
-    settings.activate_extension_paths(ext_id, "", [])
-    logger.info(
-        f"Loaded WASM extension '{loaded.id}' "
-        f"({loaded.module_path.stat().st_size} bytes)."
-    )
-    return loaded

lnbits/core/wasm_ext/routes/security.py

@@ -1,127 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, NoReturn
-from uuid import uuid4
-
-from fastapi import HTTPException, Request
-from loguru import logger
-
-from lnbits.helpers import template_renderer
-from lnbits.utils.cache import cache
-
-from ..wasm.loader import WasmExtension
-
-WASM_FRAME_TOKEN_EXPIRY_SECONDS = 60
-
-
-def wasm_extension_wrapper_response(
-    request: Request,
-    extension: WasmExtension,
-    auth: str,
-    user_json: str | None,
-) -> Any:
-    public = auth == "public"
-    response = template_renderer().TemplateResponse(
-        request,
-        "wasm_extension.html",
-        {
-            "extension": extension,
-            "public": public,
-            "user": user_json,
-        },
-    )
-    response.headers["Content-Security-Policy"] = "frame-ancestors 'self'"
-    response.headers["X-Frame-Options"] = "SAMEORIGIN"
-    return response
-
-
-def wasm_extension_frame_csp(request: Request, extension: WasmExtension) -> str:
-    origin = str(request.base_url).rstrip("/")
-    extension_assets = f"{origin}/ext-assets/{extension.id}/"
-    return (
-        "sandbox allow-scripts; "
-        "default-src 'none'; "
-        f"script-src {extension_assets}; "
-        "script-src-attr 'none'; "
-        f"style-src {extension_assets}; "
-        "style-src-attr 'none'; "
-        f"img-src {extension_assets} data:; "
-        f"font-src {extension_assets}; "
-        "connect-src 'none'; "
-        "form-action 'none'; "
-        "object-src 'none'; "
-        "base-uri 'none'; "
-        "frame-src 'none'; "
-        "worker-src 'none'; "
-        "media-src 'none'; "
-        "manifest-src 'none'; "
-        "frame-ancestors 'self'"
-    )
-
-
-def wasm_extension_frame_url(
-    extension: WasmExtension, frame_path: str, user_id: str | None
-) -> str:
-    token = _create_wasm_extension_frame_token(extension, frame_path, user_id)
-    return f"{frame_path}?frame_token={token}"
-
-
-def consume_wasm_extension_frame_token(
-    request: Request,
-    extension: WasmExtension,
-    frame_path: str,
-    user_id: str | None,
-) -> None:
-    token = request.query_params.get("frame_token")
-    if not token:
-        _raise_wasm_extension_frame_not_found(extension, frame_path, "missing")
-
-    cache_key = _wasm_extension_frame_token_cache_key(token)
-    token_data = cache.get(cache_key)
-    if (
-        not isinstance(token_data, dict)
-        or token_data.get("extension_id") != extension.id
-        or token_data.get("frame_path") != frame_path
-    ):
-        _raise_wasm_extension_frame_not_found(
-            extension, frame_path, "unknown or expired"
-        )
-
-    token_user_id = token_data.get("user_id")
-    if token_user_id and token_user_id != user_id:
-        _raise_wasm_extension_frame_not_found(extension, frame_path, "wrong user")
-
-    cache.pop(cache_key)
-
-
-def _create_wasm_extension_frame_token(
-    extension: WasmExtension,
-    frame_path: str,
-    user_id: str | None,
-) -> str:
-    token = uuid4().hex
-    cache.set(
-        _wasm_extension_frame_token_cache_key(token),
-        {
-            "extension_id": extension.id,
-            "frame_path": frame_path,
-            "user_id": user_id,
-        },
-        expiry=WASM_FRAME_TOKEN_EXPIRY_SECONDS,
-    )
-    return token
-
-
-def _wasm_extension_frame_token_cache_key(token: str) -> str:
-    return f"wasm-frame-token:{token}"
-
-
-def _raise_wasm_extension_frame_not_found(
-    extension: WasmExtension,
-    frame_path: str,
-    reason: str,
-) -> NoReturn:
-    logger.warning(
-        f"WASM frame token {reason} for extension '{extension.id}' at '{frame_path}'."
-    )
-    raise HTTPException(status_code=404, detail="Not found")

lnbits/core/wasm_ext/routes/ui.py

@@ -1,369 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Annotated, Any
-
-from fastapi import Depends, FastAPI, HTTPException, Request
-from fastapi.responses import FileResponse
-from pydantic import UUID4
-
-from lnbits.core.crud import get_installed_extension, get_user_from_account
-from lnbits.core.models import Account
-from lnbits.decorators import (
-    check_access_token,
-    check_account_exists,
-    optional_user_id,
-)
-
-from ..wasm.loader import WasmExtension
-from .api import (
-    WasmRequestBodyTooLargeError,
-    _has_route,
-    _path_template_pattern,
-    _read_json_object,
-    _snake_to_camel,
-    _wasm_extension_api_export,
-    _wasm_extension_api_method,
-    _wasm_extension_api_path,
-    _wasm_extension_route_auth,
-)
-from .security import (
-    consume_wasm_extension_frame_token,
-    wasm_extension_frame_csp,
-    wasm_extension_frame_url,
-    wasm_extension_wrapper_response,
-)
-
-
-def register_wasm_extension_ui_routes(app: FastAPI, extension: WasmExtension) -> None:
-    _add_wasm_extension_frame_config_route(app, extension)
-
-    for route_index, route_config in enumerate(extension.config.ui_routes):
-        route_path = _wasm_extension_ui_route_path(extension, route_config.path)
-        entrypoint = _wasm_extension_entrypoint(extension, route_config.entrypoint)
-        frame_path = f"/ext-frame/{extension.id}/{route_index}"
-        auth = _wasm_extension_route_auth(extension, route_config.auth)
-        _add_wasm_extension_frame_route(app, extension, frame_path, entrypoint)
-        _add_wasm_extension_wrapper_route(
-            app,
-            extension,
-            route_path,
-            auth,
-        )
-
-
-def _add_wasm_extension_frame_config_route(
-    app: FastAPI,
-    extension: WasmExtension,
-) -> None:
-    route_path = _wasm_extension_frame_config_path(extension)
-    if _has_route(app, route_path, "POST"):
-        return
-
-    async def create_wasm_extension_frame_config(
-        request: Request,
-        access_token: Annotated[str | None, Depends(check_access_token)],
-        usr: UUID4 | None = None,
-    ) -> dict[str, Any]:
-        try:
-            body = await _read_json_object(request)
-        except WasmRequestBodyTooLargeError as exc:
-            raise HTTPException(status_code=413, detail=str(exc)) from exc
-        except (TypeError, ValueError) as exc:
-            raise HTTPException(status_code=400, detail=str(exc)) from exc
-
-        ui_route = _match_wasm_extension_ui_route(extension, body.get("path"))
-        auth = ui_route["auth"]
-
-        if auth == "user":
-            account = await check_account_exists(request, access_token, usr)
-            user_id: str | None = account.id
-        else:
-            user_id = await _optional_wasm_user_id(request, access_token, usr)
-
-        granted_permission_ids = await _wasm_extension_granted_permission_ids(extension)
-
-        return _wasm_extension_frame_config(
-            extension,
-            ui_route["frame_path"],
-            auth,
-            ui_route["path_params"],
-            ui_route["route_params"],
-            _read_wasm_extension_route_query(body.get("query")),
-            user_id,
-            granted_permission_ids,
-        )
-
-    app.add_api_route(
-        route_path,
-        create_wasm_extension_frame_config,
-        methods=["POST"],
-        name=f"{extension.id}:frame-config",
-        include_in_schema=False,
-    )
-
-
-def _add_wasm_extension_wrapper_route(
-    app: FastAPI,
-    extension: WasmExtension,
-    route_path: str,
-    auth: str,
-) -> None:
-    if _has_route(app, route_path, "GET"):
-        return
-
-    async def serve_private_wasm_extension_page(
-        request: Request,
-        account: Account = Depends(check_account_exists),
-    ) -> Any:
-        user = await get_user_from_account(account)
-        return wasm_extension_wrapper_response(
-            request,
-            extension,
-            auth,
-            user.json() if user else None,
-        )
-
-    async def serve_public_wasm_extension_page(request: Request) -> Any:
-        return wasm_extension_wrapper_response(
-            request,
-            extension,
-            auth,
-            None,
-        )
-
-    app.add_api_route(
-        route_path,
-        (
-            serve_public_wasm_extension_page
-            if auth == "public"
-            else serve_private_wasm_extension_page
-        ),
-        methods=["GET"],
-        name=f"{extension.id}:{route_path}",
-        include_in_schema=False,
-    )
-
-
-def _add_wasm_extension_frame_route(
-    app: FastAPI,
-    extension: WasmExtension,
-    frame_path: str,
-    entrypoint: Path,
-) -> None:
-    if _has_route(app, frame_path, "GET"):
-        return
-
-    async def serve_wasm_extension_frame(
-        request: Request,
-        user_id: str | None = Depends(_optional_wasm_user_id),
-    ) -> FileResponse:
-        consume_wasm_extension_frame_token(request, extension, frame_path, user_id)
-        response = FileResponse(entrypoint)
-        response.headers["Content-Security-Policy"] = wasm_extension_frame_csp(
-            request, extension
-        )
-        response.headers["Cache-Control"] = "no-store"
-        response.headers["Cross-Origin-Opener-Policy"] = "same-origin"
-        response.headers["Cross-Origin-Resource-Policy"] = "same-origin"
-        # Extension access goes through the parent bridge.
-        response.headers["Permissions-Policy"] = (
-            "camera=(), microphone=(), geolocation=(), payment=(), "
-            "clipboard-read=(), usb=()"
-        )
-        response.headers["Referrer-Policy"] = "no-referrer"
-        response.headers["X-Content-Type-Options"] = "nosniff"
-        return response
-
-    app.add_api_route(
-        frame_path,
-        serve_wasm_extension_frame,
-        methods=["GET"],
-        name=f"{extension.id}:frame:{frame_path}",
-        include_in_schema=False,
-    )
-
-
-def _wasm_extension_bridge_api_routes(
-    extension: WasmExtension,
-    public: bool,
-) -> list[dict[str, str]]:
-    routes: list[dict[str, str]] = []
-    for route_config in extension.config.api_routes:
-        auth = _wasm_extension_route_auth(extension, route_config.auth)
-        if public and auth != "public":
-            continue
-        method = _wasm_extension_api_method(extension, route_config.method)
-        path = _wasm_extension_api_path(extension, route_config.path)
-        _wasm_extension_api_export(extension, route_config.export)
-        routes.append(
-            {
-                "method": method,
-                "path": path,
-                "pattern": _path_template_pattern(path),
-            }
-        )
-    return routes
-
-
-def _wasm_extension_frame_config_path(extension: WasmExtension) -> str:
-    return f"/api/v1/ext/{extension.id}/_ui/frame"
-
-
-def _match_wasm_extension_ui_route(
-    extension: WasmExtension,
-    path: Any,
-) -> dict[str, Any]:
-    if not isinstance(path, str) or not path.startswith("/"):
-        raise HTTPException(status_code=404, detail="Not found")
-
-    for route_index, route_config in enumerate(extension.config.ui_routes):
-        route_path = _wasm_extension_ui_route_path(extension, route_config.path)
-        route_params = _path_template_params(route_path, path)
-        if route_params is None:
-            continue
-
-        return {
-            "frame_path": f"/ext-frame/{extension.id}/{route_index}",
-            "auth": _wasm_extension_route_auth(extension, route_config.auth),
-            "path_params": route_config.path_params,
-            "route_params": route_params,
-        }
-
-    raise HTTPException(status_code=404, detail="Not found")
-
-
-def _path_template_params(template: str, path: str) -> dict[str, str] | None:
-    template_parts = _path_parts(template)
-    path_parts = _path_parts(path)
-    if len(template_parts) != len(path_parts):
-        return None
-
-    params: dict[str, str] = {}
-    for template_part, path_part in zip(template_parts, path_parts, strict=False):
-        if template_part.startswith("{") and template_part.endswith("}"):
-            param_name = template_part[1:-1]
-            if not param_name:
-                return None
-            params[param_name] = path_part
-            continue
-
-        if template_part != path_part:
-            return None
-
-    return params
-
-
-def _path_parts(path: str) -> list[str]:
-    return [part for part in path.strip("/").split("/") if part]
-
-
-def _wasm_extension_frame_config(
-    extension: WasmExtension,
-    frame_path: str,
-    auth: str,
-    path_params: dict[str, str],
-    route_params: dict[str, str],
-    query: dict[str, Any],
-    user_id: str | None,
-    permissions: set[str],
-) -> dict[str, Any]:
-    public = auth == "public"
-    return {
-        "extension": {
-            "id": extension.id,
-            "name": extension.name,
-        },
-        "frameUrl": wasm_extension_frame_url(extension, frame_path, user_id),
-        "bridge": {
-            "extensionId": extension.id,
-            "public": public,
-            "routeParams": _map_wasm_extension_route_params(route_params, path_params),
-            "query": query,
-            "permissions": sorted(permissions),
-            "apiRoutes": _wasm_extension_bridge_api_routes(extension, public),
-        },
-    }
-
-
-async def _wasm_extension_granted_permission_ids(
-    extension: WasmExtension,
-) -> set[str]:
-    installed_extension = await get_installed_extension(extension.id)
-    if not installed_extension:
-        return set()
-    return {permission.id for permission in installed_extension.permissions}
-
-
-def _map_wasm_extension_route_params(
-    route_params: dict[str, str],
-    path_params: dict[str, str],
-) -> dict[str, str]:
-    payload: dict[str, str] = {}
-    for key, value in route_params.items():
-        target = path_params.get(key) or _snake_to_camel(key)
-        payload[target] = value
-    return payload
-
-
-def _read_wasm_extension_route_query(query: Any) -> dict[str, Any]:
-    if not isinstance(query, dict):
-        return {}
-
-    payload: dict[str, Any] = {}
-    for key, value in query.items():
-        if value is None:
-            continue
-        payload[_snake_to_camel(str(key))] = value
-    return payload
-
-
-async def _optional_wasm_user_id(
-    request: Request,
-    access_token: Annotated[str | None, Depends(check_access_token)],
-    usr: UUID4 | None = None,
-) -> str | None:
-    try:
-        return await optional_user_id(request, access_token, usr)
-    except HTTPException:
-        return None
-
-
-def _wasm_extension_ui_route_path(extension: WasmExtension, path: Any) -> str:
-    if not isinstance(path, str) or not path.startswith("/"):
-        raise ValueError(f"Invalid route path for WASM extension '{extension.id}'.")
-    if path == "/":
-        return "/ext"
-    return f"/ext{path}"
-
-
-def _wasm_extension_entrypoint(extension: WasmExtension, entrypoint: Any) -> Path:
-    if not isinstance(entrypoint, str) or not entrypoint:
-        raise ValueError(
-            f"Invalid route entrypoint for WASM extension '{extension.id}'."
-        )
-    if entrypoint.startswith("/"):
-        raise ValueError(
-            f"Route entrypoint for WASM extension '{extension.id}' must be a "
-            "relative extension path."
-        )
-
-    path = (extension.root_path / entrypoint).resolve()
-    root_path = extension.root_path.resolve()
-    if path != root_path and root_path not in path.parents:
-        raise ValueError(f"Route entrypoint escapes extension root: {entrypoint}")
-
-    static_path = (extension.root_path / "static").resolve()
-    if path == static_path or static_path in path.parents:
-        raise ValueError(
-            f"Route entrypoint for WASM extension '{extension.id}' must not be "
-            "inside the static asset directory."
-        )
-    if path.suffix.lower() != ".html":
-        raise ValueError(
-            f"Route entrypoint for WASM extension '{extension.id}' must be "
-            "an HTML file."
-        )
-    if not path.is_file():
-        raise FileNotFoundError(f"Route entrypoint not found: {path}")
-    return path

lnbits/core/wasm_ext/storage/__init__.py

@@ -1,19 +0,0 @@
-from .crud import (
-    migrate_wasm_extension_database,
-    storage_delete_row,
-    storage_get_paginated_rows,
-    storage_get_public_row,
-    storage_get_row,
-    storage_get_row_owner_id,
-    storage_set_row,
-)
-
-__all__ = [
-    "migrate_wasm_extension_database",
-    "storage_delete_row",
-    "storage_get_paginated_rows",
-    "storage_get_public_row",
-    "storage_get_row",
-    "storage_get_row_owner_id",
-    "storage_set_row",
-]

lnbits/core/wasm_ext/wasm/__init__.py

@@ -1,13 +0,0 @@
-from .component import warm_wasm_extension
-from .events import dispatch_wasm_invoice_paid
-from .invoke import invoke_wasm_extension_export
-from .loader import WasmExtension, is_wasm_extension_dir, is_wasm_extension_id
-
-__all__ = [
-    "WasmExtension",
-    "dispatch_wasm_invoice_paid",
-    "invoke_wasm_extension_export",
-    "is_wasm_extension_dir",
-    "is_wasm_extension_id",
-    "warm_wasm_extension",
-]

lnbits/core/wasm_ext/wasm/component.py

@@ -1,62 +0,0 @@
-from __future__ import annotations
-
-from functools import lru_cache
-from typing import Any
-
-from wasmtime import Config, Engine
-
-from lnbits.settings import settings
-
-from .loader import WasmExtension
-
-
-def warm_wasm_extension(extension: WasmExtension) -> None:
-    _wasm_component(extension)
-
-
-@lru_cache(maxsize=8)
-def _wasm_engine(max_wasm_stack_bytes: int | None = None) -> Any:
-    config = Config()
-    config.wasm_component_model = True
-    config.epoch_interruption = True
-    config.consume_fuel = True
-    stack_limit = (
-        settings.wasm_runtime_max_wasm_stack_bytes
-        if max_wasm_stack_bytes is None
-        else max_wasm_stack_bytes
-    )
-    if stack_limit > 0:
-        config.max_wasm_stack = stack_limit
-    return Engine(config)
-
-
-def _wasm_component(
-    extension: WasmExtension,
-    limits: dict[str, int] | None = None,
-) -> Any:
-    stat = extension.module_path.stat()
-    max_wasm_stack_bytes = (
-        limits["wasm_runtime_max_wasm_stack_bytes"]
-        if limits
-        else settings.wasm_runtime_max_wasm_stack_bytes
-    )
-    return _cached_wasm_component(
-        str(extension.module_path),
-        stat.st_mtime_ns,
-        stat.st_size,
-        max_wasm_stack_bytes,
-    )
-
-
-@lru_cache(maxsize=32)
-def _cached_wasm_component(
-    module_path: str,
-    mtime_ns: int,
-    size: int,
-    max_wasm_stack_bytes: int,
-) -> Any:
-    from wasmtime import component
-
-    return component.Component.from_file(
-        _wasm_engine(max_wasm_stack_bytes), module_path
-    )

lnbits/core/wasm_ext/wasm/config.py

@@ -1,115 +0,0 @@
-from __future__ import annotations
-
-import re
-from typing import Any, Literal
-
-from pydantic import (
-    BaseModel,
-    Field,
-    StrictBool,
-    StrictStr,
-    ValidationError,
-)
-
-from lnbits.core.models.extensions import ExtensionPermission
-
-_EXTENSION_ID_RE = re.compile(r"^[A-Za-z0-9_-]+$")
-
-
-class _StrictWasmModel(BaseModel):
-    class Config:
-        extra = "ignore"
-        allow_population_by_field_name = True
-
-
-class WasmExtensionExport(_StrictWasmModel):
-    name: StrictStr
-    visibility: Literal["authenticated", "event", "public"]
-
-
-class WasmRuntimeConfig(_StrictWasmModel):
-    module: StrictStr
-    wit: StrictStr | None = None
-    world: StrictStr = ""
-    exports: list[WasmExtensionExport] = Field(default_factory=list)
-
-
-class WasmUIConfig(_StrictWasmModel):
-    entrypoint: StrictStr | None = None
-    sandbox: StrictBool | None = None
-
-
-class WasmSDKConfig(_StrictWasmModel):
-    frontend_js: StrictStr | None = None
-
-
-class WasmUIRouteConfig(_StrictWasmModel):
-    path: StrictStr
-    entrypoint: StrictStr
-    auth: Literal["public", "user"]
-    path_params: dict[str, StrictStr] = Field(default_factory=dict)
-
-
-class WasmAPIRouteConfig(_StrictWasmModel):
-    method: Literal["DELETE", "GET", "PATCH", "POST", "PUT"]
-    path: StrictStr
-    export: StrictStr
-    auth: Literal["public", "user"]
-    path_params: dict[str, StrictStr] = Field(default_factory=dict)
-
-
-class WasmEventsConfig(_StrictWasmModel):
-    on_invoice_paid: StrictStr | None = Field(None, alias="onInvoicePaid")
-
-
-class WasmExtensionConfig(_StrictWasmModel):
-    id: StrictStr
-    name: StrictStr
-    short_description: StrictStr
-    tile: StrictStr | None = None
-    version: StrictStr
-    min_lnbits_version: StrictStr | None = None
-    max_lnbits_version: StrictStr | None = None
-    extension_type: Literal["wasm"]
-    wasm: WasmRuntimeConfig
-    events: WasmEventsConfig = Field(
-        default_factory=lambda: WasmEventsConfig.parse_obj({})
-    )
-    ui: WasmUIConfig | None = None
-    sdk: WasmSDKConfig | None = None
-    ui_routes: list[WasmUIRouteConfig] = Field(default_factory=list)
-    api_routes: list[WasmAPIRouteConfig] = Field(default_factory=list)
-    permissions: list[ExtensionPermission] = Field(default_factory=list)
-
-
-def parse_wasm_extension_config(
-    ext_id: str,
-    config: dict[str, Any],
-) -> WasmExtensionConfig:
-    validate_wasm_extension_config_id(ext_id, config)
-    try:
-        return WasmExtensionConfig.parse_obj(config)
-    except ValidationError as exc:
-        raise ValueError(
-            f"Invalid WASM extension config for '{ext_id}': {exc}"
-        ) from exc
-
-
-def validate_wasm_extension_config_id(
-    ext_id: str,
-    config: dict[str, Any] | WasmExtensionConfig,
-) -> str:
-    if not _EXTENSION_ID_RE.fullmatch(ext_id):
-        raise ValueError(f"Invalid WASM extension id '{ext_id}'.")
-
-    config_id = (
-        config.id if isinstance(config, WasmExtensionConfig) else config.get("id")
-    )
-    if not isinstance(config_id, str) or not config_id:
-        raise ValueError(f"WASM extension '{ext_id}' config must define id.")
-    if config_id != ext_id:
-        raise ValueError(
-            f"WASM extension id mismatch: installed as '{ext_id}' "
-            f"but config declares '{config_id}'."
-        )
-    return config_id

lnbits/core/wasm_ext/wasm/events.py

@@ -1,256 +0,0 @@
-import json
-from collections.abc import Iterable
-from typing import Any
-
-from loguru import logger
-
-from lnbits.core.crud.extensions import get_installed_extension, get_user_extensions
-from lnbits.core.crud.wallets import get_wallet
-from lnbits.core.db import core_app_extra
-from lnbits.core.models.extensions import ExtensionWalletPaymentsWatchGrant
-from lnbits.core.wasm_ext.storage.crud import storage_get_row_owner_id
-from lnbits.core.wasm_ext.wasm.invoke import invoke_wasm_extension_export
-from lnbits.helpers import sha256s
-
-WALLET_PAYMENTS_WATCH_PERMISSION = "wallet.payments.watch"
-
-
-async def dispatch_wasm_invoice_paid(payment: Any) -> None:
-    targets: dict[str, tuple[Any, str | None]] = {}
-    extension_id = _payment_extension_id(payment)
-    if extension_id:
-        extension = core_app_extra.wasm_extension_registry.get(extension_id)
-        if extension:
-            targets[extension_id] = (
-                extension,
-                await _wasm_invoice_paid_owner_id(extension, payment),
-            )
-
-    wallet = await _payment_wallet(payment)
-    if wallet:
-        wallet_owner_id = sha256s(wallet.user)
-        for watch_extension_id in await _wallet_watch_extension_ids(
-            wallet.user, wallet.id
-        ):
-            extension = core_app_extra.wasm_extension_registry.get(watch_extension_id)
-            if not extension:
-                continue
-            if watch_extension_id in targets:
-                existing_extension, existing_owner_id = targets[watch_extension_id]
-                targets[watch_extension_id] = (
-                    existing_extension,
-                    existing_owner_id or wallet_owner_id,
-                )
-                continue
-            targets[watch_extension_id] = (extension, wallet_owner_id)
-
-    for extension, owner_id in targets.values():
-        await _dispatch_wasm_invoice_paid_to_extension(extension, payment, owner_id)
-
-
-async def _dispatch_wasm_invoice_paid_to_extension(
-    extension: Any, payment: Any, owner_id: str | None
-) -> None:
-    export_name = _wasm_invoice_paid_export(extension.config)
-    if not export_name:
-        return
-
-    if not _is_wasm_event_export(extension, export_name):
-        logger.warning(
-            f"WASM extension '{extension.id}' declares invalid onInvoicePaid "
-            f"export '{export_name}'."
-        )
-        return
-
-    try:
-        await invoke_wasm_extension_export(
-            extension.id,
-            export_name,
-            _wasm_invoice_paid_payload(payment),
-            context="event",
-            owner_id=owner_id,
-            trigger_type="event",
-            event_type="invoice_paid",
-            wallet_id=payment.wallet_id,
-            payment_hash=payment.payment_hash,
-            checking_id=payment.checking_id,
-        )
-    except Exception as exc:
-        logger.warning(
-            f"WASM extension '{extension.id}' failed to handle paid invoice "
-            f"'{payment.payment_hash}': {exc!s}"
-        )
-
-
-async def _payment_wallet(payment: Any) -> Any | None:
-    wallet_id = getattr(payment, "wallet_id", None)
-    if not isinstance(wallet_id, str) or not wallet_id:
-        return None
-    try:
-        return await get_wallet(wallet_id)
-    except Exception as exc:
-        logger.warning(f"Could not fetch wallet '{wallet_id}' for WASM event: {exc!s}")
-        return None
-
-
-async def _wallet_watch_extension_ids(user_id: str, wallet_id: str) -> list[str]:
-    try:
-        user_extensions = await get_user_extensions(user_id)
-    except Exception as exc:
-        logger.warning(
-            f"Could not fetch extensions for wallet payment watch user "
-            f"'{user_id}': {exc!s}"
-        )
-        return []
-    extension_ids: list[str] = []
-
-    for user_extension in user_extensions:
-        if not user_extension.active:
-            continue
-        if not _has_wallet_watch_grant(user_extension, wallet_id):
-            continue
-        if not core_app_extra.wasm_extension_registry.get(user_extension.extension):
-            continue
-        try:
-            installed_extension = await get_installed_extension(
-                user_extension.extension
-            )
-        except Exception as exc:
-            logger.warning(
-                f"Could not fetch installed extension '{user_extension.extension}' "
-                f"for wallet payment watch: {exc!s}"
-            )
-            continue
-        if not installed_extension or not installed_extension.active:
-            continue
-        if not _extension_has_permission(
-            installed_extension, WALLET_PAYMENTS_WATCH_PERMISSION
-        ):
-            continue
-        extension_ids.append(user_extension.extension)
-
-    return extension_ids
-
-
-def _has_wallet_watch_grant(user_extension: Any, wallet_id: str) -> bool:
-    permissions = user_extension.permissions or {}
-    grants = permissions.get(WALLET_PAYMENTS_WATCH_PERMISSION)
-    if not isinstance(grants, list):
-        return False
-
-    for grant_data in grants:
-        if not isinstance(grant_data, dict):
-            continue
-        try:
-            grant = ExtensionWalletPaymentsWatchGrant.parse_obj(grant_data)
-        except ValueError:
-            continue
-        if grant.enabled and grant.wallet_id == wallet_id:
-            return True
-    return False
-
-
-def _extension_has_permission(extension: Any, permission_id: str) -> bool:
-    return any(
-        (
-            permission.get("id")
-            if isinstance(permission, dict)
-            else getattr(permission, "id", None)
-        )
-        == permission_id
-        for permission in (extension.permissions or [])
-    )
-
-
-def _payment_extension_id(payment: Any) -> str | None:
-    if isinstance(payment.extension, str) and payment.extension:
-        return payment.extension
-
-    extra = payment.extra or {}
-    tag = extra.get("tag") or payment.tag
-    return tag if isinstance(tag, str) and tag else None
-
-
-async def _wasm_invoice_paid_owner_id(extension: Any, payment: Any) -> str | None:
-    source_id = _payment_source_id(payment)
-    source_tables = await _wasm_public_invoice_source_tables(extension.id)
-    if not source_id or not source_tables:
-        return None
-
-    for source_table in source_tables:
-        owner_id = await storage_get_row_owner_id(extension.id, source_table, source_id)
-        if owner_id:
-            return owner_id
-    return None
-
-
-def _payment_source_id(payment: Any) -> str | None:
-    extra = payment.extra or {}
-    source_id = extra.get("source_id")
-    return source_id if isinstance(source_id, str) and source_id else None
-
-
-async def _wasm_public_invoice_source_tables(extension_id: str) -> list[str]:
-    installed_extension = await get_installed_extension(extension_id)
-    if not installed_extension:
-        return []
-    return _wasm_public_invoice_source_tables_from_permissions(
-        installed_extension.permissions
-    )
-
-
-def _wasm_public_invoice_source_tables_from_permissions(
-    permissions: Iterable[Any],
-) -> list[str]:
-    for permission in permissions:
-        permission_id = (
-            permission.get("id")
-            if isinstance(permission, dict)
-            else getattr(permission, "id", None)
-        )
-        if permission_id != "wallet.create_invoice_public":
-            continue
-        policies = (
-            permission.get("policies")
-            if isinstance(permission, dict)
-            else getattr(permission, "policies", None)
-        )
-        if not isinstance(policies, list):
-            return []
-        return [
-            source_policy["table"]
-            for source_policy in policies
-            if isinstance(source_policy, dict)
-            and isinstance(source_policy.get("table"), str)
-            and source_policy["table"]
-        ]
-    return []
-
-
-def _wasm_invoice_paid_export(config: Any) -> str | None:
-    return config.events.on_invoice_paid
-
-
-def _is_wasm_event_export(extension: Any, export_name: str) -> bool:
-    for export in extension.exports:
-        if export.name == export_name:
-            return export.visibility == "event"
-    return False
-
-
-def _wasm_invoice_paid_payload(payment: Any) -> dict[str, Any]:
-    return {
-        "checkingId": payment.checking_id,
-        "paymentHash": payment.payment_hash,
-        "walletId": payment.wallet_id,
-        "amount": payment.amount,
-        "fee": payment.fee,
-        "bolt11": payment.bolt11,
-        "memo": payment.memo,
-        "pending": payment.pending,
-        "status": payment.status,
-        "tag": payment.tag,
-        "extension": payment.extension,
-        "extra": payment.extra or {},
-        "payment": json.loads(payment.json()),
-    }

lnbits/core/wasm_ext/wasm/host.py

@@ -1,94 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import re
-from collections.abc import Mapping
-from typing import Any
-
-from wasmtime import component
-
-from ..api.models import EmptyRequest
-from ..api.registry import list_extension_api_methods
-from ..api.runtime import ExtensionAPIHost
-
-
-def add_extension_host_imports(
-    linker: Any,
-    api_host: ExtensionAPIHost,
-    event_loop: asyncio.AbstractEventLoop,
-) -> None:
-    with linker.root() as root:
-        methods_by_interface: dict[str, list[Any]] = {}
-        for method in list_extension_api_methods():
-            methods_by_interface.setdefault(method.host_interface, []).append(method)
-
-        for host_interface, methods in methods_by_interface.items():
-            with root.add_instance(f"lnbits:extension/{host_interface}") as host:
-                for method in methods:
-                    host.add_func(
-                        method.host_name.replace("_", "-"),
-                        _make_host_import(
-                            api_host,
-                            method.method_id,
-                            method.request_model is EmptyRequest,
-                            event_loop,
-                        ),
-                    )
-
-
-def _make_host_import(
-    api_host: ExtensionAPIHost,
-    host_name: str,
-    empty_request: bool,
-    event_loop: asyncio.AbstractEventLoop,
-) -> Any:
-    if empty_request:
-
-        def empty_host_import(_store: Any) -> Any:
-            future = asyncio.run_coroutine_threadsafe(
-                api_host.invoke(host_name), event_loop
-            )
-            response = future.result()
-            return _dict_to_component_record(response)
-
-        return empty_host_import
-
-    def host_import(_store: Any, request: Any = None) -> Any:
-        payload = _component_payload_to_dict(request)
-        future = asyncio.run_coroutine_threadsafe(
-            api_host.invoke(host_name, payload), event_loop
-        )
-        response = future.result()
-        return _dict_to_component_record(response)
-
-    return host_import
-
-
-def _component_payload_to_dict(value: Any) -> dict[str, Any]:
-    if value is None:
-        return {}
-    if hasattr(value, "__dict__"):
-        return dict(value.__dict__)
-    if isinstance(value, Mapping):
-        return dict(value)
-    raise TypeError("WASM host function payload must be a record.")
-
-
-def _dict_to_component_record(value: Mapping[str, Any]) -> Any:
-
-    record = component.Record()
-    for key, item in value.items():
-        setattr(record, _camel_to_kebab(key), _to_component_value(item))
-    return record
-
-
-def _to_component_value(value: Any) -> Any:
-    if isinstance(value, Mapping):
-        return _dict_to_component_record(value)
-    if isinstance(value, list):
-        return [_to_component_value(item) for item in value]
-    return value
-
-
-def _camel_to_kebab(value: str) -> str:
-    return re.sub(r"([a-z0-9])([A-Z])", r"\1-\2", value).replace("_", "-").lower()

lnbits/core/wasm_ext/wasm/invoke.py

@@ -1,279 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import json
-from collections.abc import Mapping
-from typing import Any
-
-from wasmtime import Store, WasiConfig, component
-
-from lnbits.core.crud.extensions import get_installed_extension
-from lnbits.core.db import core_app_extra
-from lnbits.settings import settings
-
-from ..api.host import ExtensionHostAPI
-from ..api.runtime import ExtensionAPIHost
-from .component import _wasm_component, _wasm_engine
-from .host import add_extension_host_imports
-from .loader import WasmExtension
-
-_WASM_EPOCH_DEADLINE_TICKS = 1_000_000_000
-_WASM_UNLIMITED_FUEL = 2**63 - 1
-
-
-async def invoke_wasm_extension_export(
-    ext_id: str,
-    export_name: str,
-    payload: Mapping[str, Any] | None = None,
-    *,
-    user: Any | None = None,
-    access_token: str | None = None,
-    context: str = "user",
-    owner_id: str | None = None,
-    trigger_type: str = "unknown",
-    request_id: str | None = None,
-    method: str | None = None,
-    path: str | None = None,
-    event_type: str | None = None,
-    wallet_id: str | None = None,
-    payment_hash: str | None = None,
-    checking_id: str | None = None,
-    request_bytes: int | None = None,
-    context_data: dict | None = None,
-) -> dict[str, Any]:
-    from lnbits.core.services.extensions import (
-        finish_wasm_invocation,
-        get_wasm_invocation_stop_reason,
-        resolve_wasm_runtime_limits,
-        start_wasm_invocation,
-        stop_wasm_invocation,
-        wasm_invocation_stop_requested,
-    )
-
-    extension = _get_registered_extension(ext_id)
-    installed_extension = await _active_installed_extension(extension)
-    permissions = installed_extension.permissions
-    limits = resolve_wasm_runtime_limits(installed_extension)
-    payload = payload or {}
-    payload_size = _json_size(payload)
-    effective_request_bytes = (
-        request_bytes if request_bytes is not None else payload_size
-    )
-    _check_wasm_request_size(effective_request_bytes, limits)
-    invocation = await start_wasm_invocation(
-        extension_id=extension.id,
-        export_name=export_name,
-        trigger_type=trigger_type,
-        user_id=_user_id(user) or owner_id,
-        wallet_id=wallet_id,
-        request_id=request_id,
-        method=method,
-        path=path,
-        event_type=event_type,
-        payment_hash=payment_hash,
-        checking_id=checking_id,
-        request_bytes=effective_request_bytes,
-        context={"host_context": context, **(context_data or {})},
-        runtime_limits=limits,
-    )
-    api = ExtensionHostAPI(
-        extension.id,
-        permissions,
-        user_id=_user_id(user),
-        access_token=access_token,
-        context=context,
-        owner_id=owner_id,
-        invocation_id=invocation.id,
-        runtime_limits=limits,
-    )
-    event_loop = asyncio.get_running_loop()
-    thread_task = asyncio.create_task(
-        asyncio.to_thread(
-            _invoke_wasm_extension_export_sync,
-            extension,
-            export_name,
-            payload,
-            api,
-            event_loop,
-            invocation.id,
-            limits,
-        )
-    )
-    max_execution_ms = limits["wasm_runtime_max_execution_ms"]
-    timed_out = False
-    finished = False
-
-    try:
-        try:
-            if max_execution_ms > 0:
-                result = await asyncio.wait_for(
-                    asyncio.shield(thread_task),
-                    timeout=max_execution_ms / 1000,
-                )
-            else:
-                result = await thread_task
-        except asyncio.TimeoutError as exc:
-            timed_out = True
-            stop_reason = "WASM execution time limit exceeded."
-            await stop_wasm_invocation(invocation.id, reason=stop_reason)
-            try:
-                result = await asyncio.wait_for(
-                    asyncio.shield(thread_task),
-                    timeout=2,
-                )
-            except asyncio.TimeoutError:
-                await finish_wasm_invocation(
-                    invocation.id,
-                    status="timeout",
-                    error_type="TimeoutError",
-                    error_message=stop_reason,
-                    stop_reason=stop_reason,
-                )
-                finished = True
-                raise TimeoutError(stop_reason) from exc
-
-        status = (
-            "timeout"
-            if timed_out
-            else (
-                "stopped"
-                if wasm_invocation_stop_requested(invocation.id)
-                else "completed"
-            )
-        )
-        await finish_wasm_invocation(
-            invocation.id,
-            status=status,
-            response_bytes=_json_size(result),
-            stop_reason=get_wasm_invocation_stop_reason(invocation.id),
-        )
-        finished = True
-        return result
-    except Exception as exc:
-        if not finished:
-            await finish_wasm_invocation(
-                invocation.id,
-                status=(
-                    "timeout"
-                    if timed_out
-                    else (
-                        "stopped"
-                        if wasm_invocation_stop_requested(invocation.id)
-                        else "failed"
-                    )
-                ),
-                error_type=exc.__class__.__name__,
-                error_message=str(exc),
-                stop_reason=get_wasm_invocation_stop_reason(invocation.id),
-            )
-        raise
-
-
-def _invoke_wasm_extension_export_sync(
-    extension: WasmExtension,
-    export_name: str,
-    payload: Mapping[str, Any],
-    api: ExtensionHostAPI,
-    event_loop: asyncio.AbstractEventLoop,
-    invocation_id: str,
-    limits: dict[str, int],
-) -> dict[str, Any]:
-    from lnbits.core.services.extensions import attach_wasm_invocation_runtime
-
-    engine = _wasm_engine(limits["wasm_runtime_max_wasm_stack_bytes"])
-    store = Store(engine)
-    _set_store_limits(store, limits)
-    _set_store_fuel(store, limits)
-    store.set_epoch_deadline(_WASM_EPOCH_DEADLINE_TICKS)
-    attach_wasm_invocation_runtime(invocation_id, engine=engine, store=store)
-    store.set_wasi(WasiConfig())
-
-    linker = component.Linker(engine)
-    linker.add_wasip2()
-    add_extension_host_imports(linker, ExtensionAPIHost(api), event_loop)
-
-    wasm_component = _wasm_component(extension, limits)
-    instance = linker.instantiate(store, wasm_component)
-    function = instance.get_func(store, export_name)
-    if not function:
-        raise KeyError(
-            f"WASM extension '{extension.id}' has no export '{export_name}'."
-        )
-
-    result = function(store, json.dumps(payload))
-    function.post_return(store)
-    return _parse_wasm_export_result(result, limits)
-
-
-def _parse_wasm_export_result(value: Any, limits: dict[str, int]) -> dict[str, Any]:
-    if isinstance(value, bytes):
-        value = value.decode()
-    if not isinstance(value, str):
-        return {"ok": True, "data": value}
-
-    max_response_bytes = limits["wasm_runtime_max_response_bytes"]
-    if max_response_bytes > 0:
-        response_size = len(value.encode())
-        if response_size > max_response_bytes:
-            raise ValueError(
-                f"WASM extension response is too large: {response_size} bytes."
-            )
-
-    parsed = json.loads(value)
-    if isinstance(parsed, dict):
-        return parsed
-    return {"ok": True, "data": parsed}
-
-
-def _get_registered_extension(ext_id: str) -> WasmExtension:
-    extension = core_app_extra.wasm_extension_registry.get(ext_id)
-    if extension:
-        return extension
-    raise RuntimeError(f"WASM extension '{ext_id}' is not registered.")
-
-
-async def _active_installed_extension(extension: WasmExtension) -> Any:
-    installed_extension = await get_installed_extension(extension.id)
-    if (
-        not installed_extension
-        or settings.lnbits_extensions_deactivate_all
-        or not installed_extension.active
-    ):
-        raise PermissionError(f"WASM extension '{extension.id}' is deactivated.")
-    return installed_extension
-
-
-def _user_id(user: Any | None) -> str | None:
-    return getattr(user, "id", None) if user else None
-
-
-def _set_store_limits(store: Any, limits: dict[str, int]) -> None:
-    store.set_limits(
-        memory_size=_wasm_limit(limits["wasm_runtime_max_memory_bytes"]),
-        table_elements=_wasm_limit(limits["wasm_runtime_max_table_elements"]),
-        instances=_wasm_limit(limits["wasm_runtime_max_instances"]),
-        tables=_wasm_limit(limits["wasm_runtime_max_tables"]),
-        memories=_wasm_limit(limits["wasm_runtime_max_memories"]),
-    )
-
-
-def _set_store_fuel(store: Any, limits: dict[str, int]) -> None:
-    store.set_fuel(
-        limits["wasm_runtime_max_fuel"]
-        if limits["wasm_runtime_max_fuel"] > 0
-        else _WASM_UNLIMITED_FUEL
-    )
-
-
-def _check_wasm_request_size(request_bytes: int, limits: dict[str, int]) -> None:
-    max_request_bytes = limits["wasm_runtime_max_request_bytes"]
-    if max_request_bytes > 0 and request_bytes > max_request_bytes:
-        raise ValueError(f"WASM extension request is too large: {request_bytes} bytes.")
-
-
-def _wasm_limit(value: int) -> int:
-    return value if value > 0 else -1
-
-
-def _json_size(value: Any) -> int:
-    return len(json.dumps(value, default=str).encode())

lnbits/db.py

@@ -497,7 +497,7 @@ class Filter(BaseModel, Generic[TFilterModel]):
                 validated, errors = compare_field.validate(raw_value, {}, loc="none")
                 if errors:
                     raise ValidationError(errors=[errors], model=model)
-                values[f"{field}__{i}_{index}"] = validated
+                values[f"{field}__{index}"] = validated
         else:
             raise ValueError("Unknown filter field")
 
@@ -510,12 +510,11 @@ class Filter(BaseModel, Generic[TFilterModel]):
         for key in self.values.keys() if self.values else []:
             if self.model and self.model.__fields__[self.field].type_ == datetime:
                 placeholder = compat_timestamp_placeholder(key)
-            else:
-                placeholder = f":{key}"
-            if self.op in {Operator.INCLUDE, Operator.EXCLUDE}:
-                stmt.append(placeholder)
-            else:
                 stmt.append(f"{prefix}{self.field} {self.op.as_sql} {placeholder}")
+            if self.op in {Operator.INCLUDE, Operator.EXCLUDE}:
+                stmt.append(f":{key}")
+            else:
+                stmt.append(f"{prefix}{self.field} {self.op.as_sql} :{key}")
 
         if self.op in {Operator.INCLUDE, Operator.EXCLUDE}:
             statement = f"{prefix}{self.field} {self.op.as_sql} ({', '.join(stmt)})"
@@ -726,20 +725,20 @@ def dict_to_model(_row: dict, model: type[TModel]) -> TModel:  # noqa: C901
         if get_origin(outertype_) is list:
             _items = _safe_load_json(value) if isinstance(value, str) else value
             _dict[key] = [
-                dict_to_submodel(type_, v) if _is_subclass(type_, BaseModel) else v
+                dict_to_submodel(type_, v) if issubclass(type_, BaseModel) else v
                 for v in _items
             ]
             continue
-        if _is_subclass(type_, bool):
+        if issubclass(type_, bool):
             _dict[key] = bool(value)
             continue
-        if _is_subclass(type_, datetime):
+        if issubclass(type_, datetime):
             if DB_TYPE == SQLITE:
                 _dict[key] = datetime.fromtimestamp(value, timezone.utc)
             else:
                 _dict[key] = value.replace(tzinfo=timezone.utc)
             continue
-        if _is_subclass(type_, BaseModel):
+        if issubclass(type_, BaseModel):
             _dict[key] = dict_to_submodel(type_, value)
             continue
         # TODO: remove this when all sub models are migrated to Pydantic
@@ -764,13 +763,6 @@ def _safe_load_json(value: str) -> dict:
         return {}
 
 
-def _is_subclass(type_: Any, class_or_tuple: type | tuple[type, ...]) -> bool:
-    try:
-        return issubclass(type_, class_or_tuple)
-    except TypeError:
-        return False
-
-
 def _valid_sql_name(name: str) -> bool:
     """Check if a SQL name is valid (alphanumeric and underscores only)"""
     return (

lnbits/helpers.py

@@ -372,13 +372,3 @@ def sha256s(value: str) -> str:
     Returns the hex as a string.
     """
     return hashlib.sha256(value.encode("utf-8")).hexdigest()
-
-
-def daystart_timestamp(dt: datetime | None = None) -> int:
-    """
-    Returns the timestamp of the start of the day for the given
-    datetime (or now in UTC if not provided).
-    """
-    dt = dt or datetime.now(timezone.utc)
-    day_start = dt.replace(hour=0, minute=0, second=0, microsecond=0)
-    return int(day_start.timestamp())

lnbits/server.py

@@ -27,8 +27,6 @@ from lnbits.settings import set_cli_settings, settings
 @click.option(
     "--reload", is_flag=True, default=False, help="Enable auto-reload for development"
 )
-@click.option("--ws-max-queue", default=128, help="Websocket max queue size")
-@click.option("--ws-ping-timeout", default=60.0, help="Websocket ping timeout")
 def main(
     port: int,
     host: str,
@@ -36,8 +34,6 @@ def main(
     ssl_keyfile: str,
     ssl_certfile: str,
     reload: bool,
-    ws_max_queue: int,
-    ws_ping_timeout: float,
 ):
     """Launched with `uv run lnbits` at root level"""
 
@@ -62,8 +58,6 @@ def main(
             ssl_keyfile=ssl_keyfile,
             ssl_certfile=ssl_certfile,
             reload=reload or False,
-            ws_ping_timeout=ws_ping_timeout,
-            ws_max_queue=ws_max_queue,
         )
 
         server = uvicorn.Server(config=config)

lnbits/settings.py

@@ -60,7 +60,6 @@ class ExtensionsSettings(LNbitsSettings):
     lnbits_user_default_extensions: list[str] = Field(default=[])
     lnbits_extensions_deactivate_all: bool = Field(default=False)
     lnbits_extensions_builder_activate_non_admins: bool = Field(default=False)
-    lnbits_wasm_invocation_retention_days: int = Field(default=7, ge=0)
     lnbits_extensions_reviews_url: str = Field(
         default="https://demo.lnbits.com/paidreviews/api/v1/AdFzLjzuKFLsdk4Bcnff6r",
         description="""
@@ -82,33 +81,6 @@ class ExtensionsSettings(LNbitsSettings):
         return Path(settings.lnbits_data_folder, "extensions_builder")
 
 
-class WasmRuntimeLimits(LNbitsSettings):
-    # 0 disables the limit. Installed WASM extensions may override these defaults.
-    wasm_runtime_max_memory_bytes: int = Field(default=64 * 1024 * 1024, ge=0)
-    wasm_runtime_max_execution_ms: int = Field(default=5_000, ge=0)
-    wasm_runtime_max_fuel: int = Field(default=100_000_000, ge=0)
-    wasm_runtime_max_response_bytes: int = Field(default=1024 * 1024, ge=0)
-    wasm_runtime_max_request_bytes: int = Field(default=1024 * 1024, ge=0)
-    wasm_runtime_max_wasm_stack_bytes: int = Field(default=1024 * 1024, ge=0)
-
-    wasm_runtime_max_table_elements: int = Field(default=10_000, ge=0)
-    wasm_runtime_max_instances: int = Field(default=8, ge=0)
-    wasm_runtime_max_tables: int = Field(default=10, ge=0)
-    wasm_runtime_max_memories: int = Field(default=1, ge=0)
-
-    wasm_runtime_max_concurrent_invocations: int = Field(default=16, ge=0)
-    wasm_runtime_max_concurrent_invocations_per_extension: int = Field(default=4, ge=0)
-    wasm_runtime_max_concurrent_invocations_per_user: int = Field(default=4, ge=0)
-
-    wasm_runtime_max_host_calls: int = Field(default=1_000, ge=0)
-    wasm_runtime_max_http_calls: int = Field(default=20, ge=0)
-    wasm_runtime_max_storage_calls: int = Field(default=100, ge=0)
-    wasm_runtime_max_wallet_calls: int = Field(default=20, ge=0)
-
-    wasm_runtime_http_timeout_ms: int = Field(default=5_000, ge=0)
-    wasm_runtime_max_http_response_bytes: int = Field(default=1024 * 1024, ge=0)
-
-
 class ExtensionsInstallSettings(LNbitsSettings):
     lnbits_extensions_default_install: list[str] = Field(default=[])
     # required due to GitHUb rate-limit
@@ -390,8 +362,6 @@ class ExchangeProvidersSettings(LNbitsSettings):
     lnbits_exchange_rate_cache_seconds: int = Field(default=60, ge=0)
     lnbits_exchange_history_size: int = Field(default=60, ge=0)
     lnbits_exchange_history_refresh_interval_seconds: int = Field(default=300, ge=0)
-    lnbits_price_aggregator_enabled: bool = Field(default=True)
-    lnbits_price_aggregator_url: str = Field(default="https://price.lnbits.com")
 
     lnbits_exchange_rate_providers: list[ExchangeRateProvider] = Field(
         default=[
@@ -524,11 +494,6 @@ class NotificationsSettings(LNbitsSettings):
             and self.lnbits_telegram_notifications_access_token is not None
         )
 
-    def is_email_notifications_configured(self) -> bool:
-        return self.lnbits_email_notifications_enabled and bool(
-            self.lnbits_email_notifications_email
-        )
-
 
 class FakeWalletFundingSource(LNbitsSettings):
     fake_wallet_secret: str = Field(default="ToTheMoon1")
@@ -622,7 +587,6 @@ class PhoenixdFundingSource(LNbitsSettings):
     phoenixd_api_password: str | None = Field(default=None)
     phoenixd_data_dir: str | None = Field(default=None)
     phoenixd_mnemonic: str | None = Field(default=None)
-    phoenixd_mnemonic_backup_confirmed: bool = Field(default=False)
 
 
 class AlbyFundingSource(LNbitsSettings):
@@ -647,7 +611,6 @@ class SparkL2FundingSource(LNbitsSettings):
     spark_l2_external_endpoint: str | None = Field(default="http://localhost:8765")
     spark_l2_external_api_key: str | None = Field(default=None)
     spark_l2_mnemonic: str | None = Field(default=None)
-    spark_l2_mnemonic_backup_confirmed: bool = Field(default=False)
     spark_l2_pay_wait_ms: int = Field(default=4000, ge=0)
     spark_l2_pay_poll_ms: int = Field(default=500, ge=0)
     spark_l2_stream_keepalive_ms: int = Field(default=15000, ge=0)
@@ -685,7 +648,6 @@ class BoltzFundingSource(LNbitsSettings):
     boltz_client_password: str = Field(default="")
     boltz_client_cert: str | None = Field(default=None)
     boltz_mnemonic: str | None = Field(default=None)
-    boltz_mnemonic_backup_confirmed: bool = Field(default=False)
 
 
 class StrikeFundingSource(LNbitsSettings):
@@ -1039,7 +1001,6 @@ class AuditSettings(LNbitsSettings):
 class EditableSettings(
     UsersSettings,
     ExtensionsSettings,
-    WasmRuntimeLimits,
     ThemesSettings,
     OpsSettings,
     AssetSettings,
@@ -1111,12 +1072,11 @@ class EnvSettings(LNbitsSettings):
     log_rotation: str = Field(default="100 MB")
     log_retention: str = Field(default="3 months")
     first_install_token: str | None = Field(default=None)
+
     cleanup_wallets_days: int = Field(default=90, ge=0)
     funding_source_max_retries: int = Field(default=4, ge=0)
     lnbits_max_users: int = Field(default=0, ge=0)
     lnbits_max_extensions: int = Field(default=0, ge=0)
-    task_heart_beat_verbose: bool = Field(default=False)
-    task_heart_beat_interval: int = Field(default=30)
 
     @property
     def has_default_extension_path(self) -> bool:
@@ -1329,7 +1289,6 @@ class PublicSettings(BaseModel):
     extensions_reviews_url: str = Field(alias="extensionsReviewsUrl")
     ext_builder: bool = Field(alias="extBuilder")
     nostr_configured: bool = Field(alias="nostrConfigured")
-    email_configured: bool = Field(alias="emailConfigured")
     telegram_configured: bool = Field(alias="telegramConfigured")
     wallet_featured_button_label: str | None = Field(alias="walletFeaturedButtonLabel")
     wallet_featured_button_url: str | None = Field(alias="walletFeaturedButtonUrl")
@@ -1394,7 +1353,6 @@ class PublicSettings(BaseModel):
             extensionsReviewsUrl=settings.lnbits_extensions_reviews_url,
             extBuilder=settings.lnbits_extensions_builder_activate_non_admins,
             nostrConfigured=settings.is_nostr_notifications_configured(),
-            emailConfigured=settings.is_email_notifications_configured(),
             telegramConfigured=settings.is_telegram_notifications_configured(),
             walletFeaturedButtonLabel=settings.lnbits_wallet_featured_button_label,
             walletFeaturedButtonUrl=settings.lnbits_wallet_featured_button_url,

lnbits/static/i18n/en.js

@@ -116,7 +116,6 @@ window.localisation.en = {
   read: 'Read',
   write: 'Write',
   pay: 'Pay',
-  sending: 'Sending',
   memo: 'Memo',
   date: 'Date',
   path: 'Path',
@@ -521,49 +520,38 @@ window.localisation.en = {
   extension_cost: 'This release requires a payment of minimum {cost} sats.',
   extension_paid_sats: 'You have already paid {paid_sats} sats.',
   extension_permissions_title: 'Grant extension permissions',
-  extension_permissions_tab: 'Extension Permissions',
-  user_permissions_tab: 'My Grants',
-  extension_permissions_none: 'This extension has no install-time permissions.',
-  user_permissions_none:
-    'You have not granted any permissions for this extension.',
-  user_permissions_max_amount: 'Max payment amount',
-  user_permissions_destination_policy: 'Allowed destinations',
-  user_permissions_no_editable_settings: 'This grant has no editable settings.',
+  extension_permissions_request: 'This extension requests these permissions:',
   extension_permissions_grant_install: 'Grant and install',
-  extension_permissions_high_risk_warning:
-    'This extension requests permissions that can move funds.',
-  extension_permission_risk_low: 'Low risk',
-  extension_permission_risk_medium: 'Medium risk',
-  extension_permission_risk_high: 'High risk',
-  extension_permission_warning_wallet_pay_invoice:
-    'Can spend funds from wallets available to your account.',
-  extension_permission_warning_wallet_pay_invoice_background:
-    'Can spend funds later from approved wallets without an active click.',
-  extension_permission_warning_wallet_payments_watch:
-    'Can read payment metadata for approved wallets.',
-  extension_permission_warning_extension_api_request_write:
-    'Can write data or trigger actions in approved extensions.',
   extension_permission_ext_storage_read: 'Read extension storage',
   extension_permission_ext_storage_read_public: 'Read public extension storage',
   extension_permission_ext_storage_write: 'Write extension storage',
-  extension_permission_ext_storage_read_write: 'Read & Write extension storage',
   extension_permission_extension_api_request: 'Use other extensions',
+  extension_permission_extension_api_request_desc:
+    'Call approved installed extensions using your account permissions.',
   extension_permission_extension_api_request_extensions: 'Allowed extensions',
-  extension_permission_access_read: 'Read',
-  extension_permission_access_write: 'Write',
   extension_permission_http_request: 'Connect to external websites',
+  extension_permission_http_request_desc:
+    'Make HTTP requests to approved external hosts.',
   extension_permission_http_request_hosts: 'Allowed hosts',
   extension_permission_utils_basic: 'Use basic LNbits utilities',
+  extension_permission_utils_basic_desc:
+    'Use public currency conversion, server health, and Lightning invoice helper functions.',
   extension_permission_ui_camera_scan_qr: 'Scan QR codes',
-  extension_permission_wallet_payments_watch: 'Watch wallet payments',
+  extension_permission_ui_camera_scan_qr_desc:
+    'Use the LNbits scanner to read QR codes when you choose to scan.',
+  extension_permission_payments_watch: 'Watch payments',
   extension_permission_wallet_create_invoice: 'Create invoices',
   extension_permission_wallet_create_invoice_public:
     'Create Lightning invoices from public pages',
+  extension_permission_wallet_create_invoice_public_desc:
+    'Create incoming Lightning invoices from public pages.',
   extension_permission_wallet_balance_read: 'View wallet balances',
+  extension_permission_wallet_balance_read_desc:
+    'Read balances of wallets available to your account.',
   extension_permission_wallet_list: 'List wallets',
   extension_permission_wallet_pay_invoice: 'Pay invoices',
-  extension_permission_wallet_pay_invoice_background:
-    'Make background payments',
+  extension_permission_wallet_pay_invoice_desc:
+    'Send Lightning payments from wallets available to your account.',
   create_extension: 'Create Extension',
   release_details_error: 'Cannot get the release details.',
   pay_from_wallet: 'Pay from Wallet',

lnbits/static/js/components/admin/lnbits-admin-exchange-providers.js

@@ -62,6 +62,12 @@ window.app.component('lnbits-admin-exchange-providers', {
   mounted() {
     this.getExchangeRateHistory()
   },
+  created() {
+    const hash = window.location.hash.replace('#', '')
+    if (hash === 'exchange_providers') {
+      this.showExchangeProvidersTab(hash)
+    }
+  },
   methods: {
     getDefaultSetting(fieldName) {
       LNbits.api.getDefaultSetting(fieldName).then(response => {
@@ -121,21 +127,18 @@ window.app.component('lnbits-admin-exchange-providers', {
       this.exchangeData.showTickerConversion = true
     },
     initExchangeChart(data) {
-      if (this.exchangeRatesChart) {
-        this.exchangeRatesChart.destroy()
-        this.exchangeRatesChart = null
-      }
       const xValues = data.map(d =>
         this.utils.formatTimestamp(d.timestamp, 'HH:mm')
       )
-      const exchanges = this.formData.lnbits_price_aggregator_enabled
-        ? [{name: 'Aggregator'}]
-        : [...this.formData.lnbits_exchange_rate_providers, {name: 'LNbits'}]
+      const exchanges = [
+        ...this.formData.lnbits_exchange_rate_providers,
+        {name: 'LNbits'}
+      ]
       const datasets = exchanges.map(exchange => ({
         label: exchange.name,
         data: data.map(d => d.rates[exchange.name]),
         pointStyle: true,
-        borderWidth: exchange.name === 'LNbits' ? 4 : 2,
+        borderWidth: exchange.name === 'LNbits' ? 4 : 1,
         tension: 0.4
       }))
       this.exchangeRatesChart = new Chart(
@@ -145,11 +148,7 @@ window.app.component('lnbits-admin-exchange-providers', {
           options: {
             plugins: {
               legend: {
-                display: true
-              },
-              title: {
-                display: true,
-                text: 'Bitcoin Price History'
+                display: false
               }
             }
           },

lnbits/static/js/components/admin/lnbits-admin-funding-seed-backup.js

@@ -1,151 +0,0 @@
-window.app.component('lnbits-admin-funding-seed-backup', {
-  props: ['active', 'is-super-user', 'form-data', 'settings'],
-  template: '#lnbits-admin-funding-seed-backup',
-  data() {
-    return {
-      dialog: {
-        show: false,
-        step: 1,
-        seed: '',
-        visible: false,
-        challenge: [],
-        answers: {},
-        error: '',
-        confirmField: ''
-      }
-    }
-  },
-  watch: {
-    active(isActive) {
-      if (isActive) {
-        this.openIfRequired()
-      }
-    },
-    'formData.lnbits_backend_wallet_class'(walletClass, previousWalletClass) {
-      const source = this.seedBackupSource(walletClass)
-      if (previousWalletClass && source && this.formData[source.seedField]) {
-        this.formData[source.confirmField] = false
-      }
-      this.openIfRequired()
-    },
-    'formData.boltz_mnemonic'() {
-      this.formData.boltz_mnemonic_backup_confirmed =
-        this.formData.boltz_mnemonic === this.settings.boltz_mnemonic
-          ? this.settings.boltz_mnemonic_backup_confirmed
-          : false
-      this.openIfRequired()
-    },
-    'formData.phoenixd_mnemonic'() {
-      this.formData.phoenixd_mnemonic_backup_confirmed =
-        this.formData.phoenixd_mnemonic === this.settings.phoenixd_mnemonic
-          ? this.settings.phoenixd_mnemonic_backup_confirmed
-          : false
-      this.openIfRequired()
-    },
-    'formData.spark_l2_mnemonic'() {
-      this.formData.spark_l2_mnemonic_backup_confirmed =
-        this.formData.spark_l2_mnemonic === this.settings.spark_l2_mnemonic
-          ? this.settings.spark_l2_mnemonic_backup_confirmed
-          : false
-      this.openIfRequired()
-    }
-  },
-  computed: {
-    seedWords() {
-      return this.dialog.seed
-        .split(/\s+/)
-        .filter(Boolean)
-        .map((word, index) => ({index, word}))
-    }
-  },
-  created() {
-    this.openIfRequired()
-  },
-  methods: {
-    seedBackupSource(walletClass = this.formData.lnbits_backend_wallet_class) {
-      if (walletClass === 'BoltzWallet') {
-        return {
-          seedField: 'boltz_mnemonic',
-          confirmField: 'boltz_mnemonic_backup_confirmed'
-        }
-      }
-      if (walletClass === 'PhoenixdWallet') {
-        return {
-          seedField: 'phoenixd_mnemonic',
-          confirmField: 'phoenixd_mnemonic_backup_confirmed'
-        }
-      }
-      if (walletClass === 'SparkL2Wallet') {
-        return {
-          seedField: 'spark_l2_mnemonic',
-          confirmField: 'spark_l2_mnemonic_backup_confirmed'
-        }
-      }
-    },
-    openIfRequired() {
-      if (!this.active || !this.isSuperUser) return
-
-      const source = this.seedBackupSource()
-      if (!source) return
-
-      const seed = (this.formData[source.seedField] || '').trim()
-      const confirmed = this.formData[source.confirmField]
-      if (!seed || confirmed || this.dialog.show) return
-
-      this.dialog = {
-        show: true,
-        step: 1,
-        seed,
-        visible: false,
-        challenge: [],
-        answers: {},
-        error: '',
-        confirmField: source.confirmField
-      }
-    },
-    prepareChallenge() {
-      const words = this.dialog.seed.split(/\s+/).filter(Boolean)
-      const count = Math.min(4, words.length)
-      const indexes = _.shuffle([...Array(words.length).keys()]).slice(0, count)
-      this.dialog.challenge = indexes
-        .sort((a, b) => a - b)
-        .map(index => ({index, word: words[index]}))
-      this.dialog.answers = {}
-      this.dialog.error = ''
-      this.dialog.step = 2
-    },
-    submitChallenge() {
-      const isValid = this.dialog.challenge.every(({index, word}) => {
-        const answer = this.dialog.answers[index] || ''
-        return answer.trim().toLowerCase() === word.toLowerCase()
-      })
-      if (!isValid) {
-        this.dialog.error =
-          'One or more words are incorrect. Check your backup and try again.'
-        return
-      }
-
-      const field = this.dialog.confirmField
-      LNbits.api
-        .request(
-          'PATCH',
-          '/admin/api/v1/settings',
-          this.g.user.wallets[0].adminkey,
-          {
-            [field]: true
-          }
-        )
-        .then(() => {
-          this.formData[field] = true
-          this.settings[field] = true
-          this.dialog.show = false
-          Quasar.Notify.create({
-            type: 'positive',
-            message: 'Seed backup confirmed',
-            icon: 'check'
-          })
-        })
-        .catch(LNbits.utils.notifyApiError)
-    }
-  }
-})

lnbits/static/js/components/admin/lnbits-admin-funding.js

@@ -1,5 +1,5 @@
 window.app.component('lnbits-admin-funding', {
-  props: ['active', 'is-super-user', 'form-data', 'settings'],
+  props: ['is-super-user', 'form-data', 'settings'],
   template: '#lnbits-admin-funding',
   data() {
     return {

lnbits/static/js/components/admin/lnbits-admin-wasm-limit-config.js

@@ -1,380 +0,0 @@
-window.app.component('lnbits-admin-wasm-limit-config', {
-  props: ['form-data'],
-  template: '#lnbits-admin-wasm-limit-config',
-  data() {
-    return {
-      selectedWasmExtensionId: null,
-      wasmExtensionLimitDraft: {},
-      wasmExtensionLimitsSaving: false,
-      wasmRuntimeLimitExtensions: [],
-      wasmRuntimeLimitExtensionsLoading: false,
-      wasmLimitInfoDialog: {
-        show: false,
-        title: '',
-        details: ''
-      },
-      wasmRuntimeLimitGroups: [
-        {
-          title: 'Execution',
-          fields: [
-            {
-              name: 'wasm_runtime_max_execution_ms',
-              label: 'Max execution time (ms)',
-              description:
-                'Maximum wall-clock time allowed for one WASM invocation.',
-              details:
-                'This is the elapsed time from starting the invocation until the export returns. When the limit is reached LNbits requests an interrupt and records the invocation as timed out if it cannot finish quickly. Use this to stop long sleeps, slow host calls, and CPU loops that run for too long.'
-            },
-            {
-              name: 'wasm_runtime_max_fuel',
-              label: 'Max fuel',
-              description:
-                'Maximum Wasmtime instruction budget for one invocation.',
-              details:
-                'Fuel is Wasmtime instruction budgeting. It is more deterministic than wall-clock time for CPU-heavy loops because each executed instruction consumes budget. Set this low enough to stop busy loops, but high enough for legitimate extension startup and JSON processing.'
-            },
-            {
-              name: 'wasm_runtime_max_wasm_stack_bytes',
-              label: 'Max WASM stack (bytes)',
-              description: 'Maximum stack space for WASM calls and recursion.',
-              details:
-                'This limits stack used by WebAssembly function calls. It protects the server from deep recursion or very large call chains in extension code. If legitimate extensions fail with stack overflow traps, raise this carefully.'
-            }
-          ]
-        },
-        {
-          title: 'Memory and Data Size',
-          fields: [
-            {
-              name: 'wasm_runtime_max_memory_bytes',
-              label: 'Max memory (bytes)',
-              description: 'Maximum WASM linear memory per invocation.',
-              details:
-                'This caps the linear memory visible to the WASM module. It limits memory.grow and can make instantiation fail if the module asks for too much memory up front. This does not include every byte used by the Python process or Wasmtime engine internals.'
-            },
-            {
-              name: 'wasm_runtime_max_request_bytes',
-              label: 'Max request size (bytes)',
-              description:
-                'Maximum serialized input payload accepted before execution.',
-              details:
-                'This caps the serialized payload passed into a WASM export before execution starts. It protects against huge HTTP bodies, oversized event data, and expensive JSON parsing. Requests above this limit should be rejected before invoking the extension.'
-            },
-            {
-              name: 'wasm_runtime_max_response_bytes',
-              label: 'Max response size (bytes)',
-              description:
-                'Maximum serialized response returned by a WASM export.',
-              details:
-                'This caps the JSON or string response returned by the WASM export. It prevents extensions from returning huge responses that consume memory, slow down API calls, or overload the browser. Responses above this limit are treated as invalid.'
-            }
-          ]
-        },
-        {
-          title: 'Wasmtime Objects',
-          fields: [
-            {
-              name: 'wasm_runtime_max_table_elements',
-              label: 'Max table elements',
-              description: 'Maximum total elements allowed in WASM tables.',
-              details:
-                'Tables store references used by WebAssembly, commonly function references. Limiting table elements prevents a module from allocating very large reference tables. Each table element also has host memory overhead.'
-            },
-            {
-              name: 'wasm_runtime_max_instances',
-              label: 'Max instances',
-              description:
-                'Maximum WebAssembly instances allowed inside one store.',
-              details:
-                'This limits how many WebAssembly instances can be created inside one Wasmtime store. LNbits normally needs one instance per invocation, so a low value is expected. Raising it should only be needed if the runtime starts supporting modules that instantiate other modules.'
-            },
-            {
-              name: 'wasm_runtime_max_tables',
-              label: 'Max tables',
-              description:
-                'Maximum WebAssembly tables allowed inside one store.',
-              details:
-                'This limits the number of WebAssembly tables in the store. It is separate from table elements: one setting limits the number of tables, the other limits their total size. Keep this small unless a component model module legitimately needs more tables.'
-            },
-            {
-              name: 'wasm_runtime_max_memories',
-              label: 'Max memories',
-              description:
-                'Maximum WebAssembly linear memories allowed inside one store.',
-              details:
-                'This limits how many separate linear memories a module can create. Most extensions should need only one memory. Keep this small to reduce memory accounting complexity and prevent multi-memory abuse.'
-            }
-          ]
-        },
-        {
-          title: 'Concurrency',
-          fields: [
-            {
-              name: 'wasm_runtime_max_concurrent_invocations',
-              label: 'Max concurrent invocations',
-              description:
-                'Maximum running WASM invocations across the server.',
-              details:
-                'This is the global cap for running WASM invocations across all extensions and users. It protects the LNbits process from thread exhaustion, CPU pressure, and too many simultaneous stores. New invocations should be rejected or queued once this is reached.'
-            },
-            {
-              name: 'wasm_runtime_max_concurrent_invocations_per_extension',
-              label: 'Max concurrent per extension',
-              description:
-                'Maximum running WASM invocations for one extension.',
-              details:
-                'This caps how many invocations a single extension can run at once. It prevents one malicious or buggy extension from consuming the whole global concurrency budget. Set it lower than the global limit.'
-            },
-            {
-              name: 'wasm_runtime_max_concurrent_invocations_per_user',
-              label: 'Max concurrent per user',
-              description: 'Maximum running WASM invocations for one user.',
-              details:
-                'This caps concurrent invocations attributed to one user. It helps protect against a user repeatedly clicking, refreshing, or scripting extension calls. Invocations without a user can still be governed by the global and per-extension limits.'
-            }
-          ]
-        },
-        {
-          title: 'Host Calls',
-          fields: [
-            {
-              name: 'wasm_runtime_max_host_calls',
-              label: 'Max host calls',
-              description:
-                'Maximum total calls from WASM into LNbits host APIs.',
-              details:
-                'This is the total budget for calls from the WASM module into LNbits host APIs during one invocation. It should count all categories together. It limits chatty extensions and prevents tight loops that repeatedly call back into Python.'
-            },
-            {
-              name: 'wasm_runtime_max_http_calls',
-              label: 'Max HTTP calls',
-              description: 'Maximum outbound HTTP host calls per invocation.',
-              details:
-                'This caps outbound HTTP requests made through the host API during one invocation. It reduces SSRF blast radius, protects network resources, and limits slow external dependencies. It should be enforced together with HTTP timeout and response-size limits.'
-            },
-            {
-              name: 'wasm_runtime_max_storage_calls',
-              label: 'Max storage calls',
-              description: 'Maximum storage host calls per invocation.',
-              details:
-                'This caps extension storage operations during one invocation. It protects the database from excessive reads and writes triggered by malicious loops. Use it with storage payload-size limits if those are added later.'
-            },
-            {
-              name: 'wasm_runtime_max_wallet_calls',
-              label: 'Max wallet calls',
-              description: 'Maximum wallet/payment host calls per invocation.',
-              details:
-                'This caps wallet and payment-related host calls during one invocation. These calls are security-sensitive and may touch balances, invoices, or payments. Keep this conservative and rely on explicit permissions for what the extension is allowed to do.'
-            }
-          ]
-        },
-        {
-          title: 'HTTP',
-          fields: [
-            {
-              name: 'wasm_runtime_http_timeout_ms',
-              label: 'HTTP timeout (ms)',
-              description: 'Maximum time allowed for one WASM HTTP request.',
-              details:
-                'This is the per-request timeout for HTTP calls made through the WASM host API. It prevents a slow remote server from holding an invocation open indefinitely. The total invocation timeout still applies across all work.'
-            },
-            {
-              name: 'wasm_runtime_max_http_response_bytes',
-              label: 'Max HTTP response size (bytes)',
-              description:
-                'Maximum response body size accepted from one WASM HTTP request.',
-              details:
-                'This caps the response body accepted from each HTTP call made by an extension. It protects memory and parsing time when a remote server returns a very large body. Responses above the limit should fail the host call.'
-            }
-          ]
-        }
-      ]
-    }
-  },
-  computed: {
-    adminKey() {
-      return this.g.user.wallets[0].adminkey
-    },
-    isExtensionLimitRoute() {
-      return this.$route.path.startsWith('/admin/extensions/wasm/limits/')
-    },
-    routeWasmExtensionId() {
-      return this.isExtensionLimitRoute ? this.$route.params.extId : null
-    },
-    backRoute() {
-      return this.isExtensionLimitRoute
-        ? '/admin/extensions/wasm/limits'
-        : '/admin#extensions'
-    },
-    backTooltip() {
-      return this.isExtensionLimitRoute
-        ? 'Wasm Limit Config'
-        : 'Extensions Settings'
-    },
-    pageDescription() {
-      if (this.isExtensionLimitRoute) {
-        return 'Customize limits for one installed WASM extension.'
-      }
-      return 'These values are global defaults. Use 0 to disable a global limit.'
-    },
-    wasmRuntimeLimitExtensionOptions() {
-      return this.wasmRuntimeLimitExtensions.map(extension => ({
-        label: `${extension.name || extension.id} (${extension.id})`,
-        value: extension.id
-      }))
-    },
-    selectedWasmRuntimeLimitExtension() {
-      return (
-        this.wasmRuntimeLimitExtensions.find(
-          extension => extension.id === this.selectedWasmExtensionId
-        ) || null
-      )
-    },
-    customWasmLimitCount() {
-      const extension = this.selectedWasmRuntimeLimitExtension
-      if (!extension || !extension.wasm_runtime_limits) {
-        return 0
-      }
-      return Object.keys(extension.wasm_runtime_limits).length
-    }
-  },
-  watch: {
-    selectedWasmExtensionId() {
-      this.loadSelectedWasmRuntimeLimitExtension()
-    },
-    routeWasmExtensionId() {
-      this.syncWasmExtensionLimitRoute()
-    }
-  },
-  created() {
-    this.fetchWasmRuntimeLimitExtensions()
-  },
-  methods: {
-    async fetchWasmRuntimeLimitExtensions() {
-      this.wasmRuntimeLimitExtensionsLoading = true
-      try {
-        const {data} = await LNbits.api.request(
-          'GET',
-          '/api/v1/extension/wasm/runtime-limits/extensions',
-          this.adminKey
-        )
-        this.wasmRuntimeLimitExtensions = data || []
-        if (
-          this.selectedWasmExtensionId &&
-          !this.wasmRuntimeLimitExtensions.some(
-            extension => extension.id === this.selectedWasmExtensionId
-          )
-        ) {
-          this.selectedWasmExtensionId = null
-        }
-        this.syncWasmExtensionLimitRoute()
-      } catch (error) {
-        LNbits.utils.notifyApiError(error)
-      } finally {
-        this.wasmRuntimeLimitExtensionsLoading = false
-      }
-    },
-    syncWasmExtensionLimitRoute() {
-      this.selectedWasmExtensionId = this.routeWasmExtensionId
-      this.loadSelectedWasmRuntimeLimitExtension()
-    },
-    openWasmExtensionLimit(extensionId) {
-      this.$router.push(
-        `/admin/extensions/wasm/limits/${encodeURIComponent(extensionId)}`
-      )
-    },
-    loadSelectedWasmRuntimeLimitExtension() {
-      const extension = this.selectedWasmRuntimeLimitExtension
-      this.wasmExtensionLimitDraft = extension
-        ? {...(extension.wasm_runtime_limits || {})}
-        : {}
-    },
-    wasmExtensionLimitHint(field) {
-      const globalValue = this.formData[field.name]
-      return `Inherited global value: ${globalValue}. ${field.description}`
-    },
-    wasmExtensionLimitPlaceholder(field) {
-      const globalValue = this.formData[field.name]
-      return globalValue === undefined || globalValue === null
-        ? ''
-        : String(globalValue)
-    },
-    normalizedWasmExtensionLimitDraft() {
-      const limits = {}
-      this.wasmRuntimeLimitGroups.forEach(group => {
-        group.fields.forEach(field => {
-          const value = this.wasmExtensionLimitDraft[field.name]
-          const cleanValue = typeof value === 'string' ? value.trim() : value
-          if (
-            cleanValue === '' ||
-            cleanValue === null ||
-            cleanValue === undefined
-          ) {
-            return
-          }
-          const numericValue = Number(cleanValue)
-          if (
-            !Number.isFinite(numericValue) ||
-            !Number.isInteger(numericValue) ||
-            numericValue < 0
-          ) {
-            throw new Error(`${field.label} must be a non-negative integer.`)
-          }
-          limits[field.name] = numericValue
-        })
-      })
-      return limits
-    },
-    async clearWasmExtensionLimits() {
-      this.wasmExtensionLimitDraft = {}
-      await this.saveWasmExtensionLimits()
-    },
-    async saveWasmExtensionLimits() {
-      if (!this.selectedWasmExtensionId) {
-        return
-      }
-      this.wasmExtensionLimitsSaving = true
-      try {
-        const {data} = await LNbits.api.request(
-          'PUT',
-          `/api/v1/extension/wasm/runtime-limits/${encodeURIComponent(
-            this.selectedWasmExtensionId
-          )}`,
-          this.adminKey,
-          {
-            limits: this.normalizedWasmExtensionLimitDraft()
-          }
-        )
-        const index = this.wasmRuntimeLimitExtensions.findIndex(
-          extension => extension.id === data.id
-        )
-        if (index >= 0) {
-          this.wasmRuntimeLimitExtensions.splice(index, 1, data)
-        }
-        this.loadSelectedWasmRuntimeLimitExtension()
-        Quasar.Notify.create({
-          type: 'positive',
-          message: 'WASM extension limits saved.'
-        })
-      } catch (error) {
-        if (error instanceof Error && !error.response) {
-          Quasar.Notify.create({
-            type: 'negative',
-            message: error.message
-          })
-        } else {
-          LNbits.utils.notifyApiError(error)
-        }
-      } finally {
-        this.wasmExtensionLimitsSaving = false
-      }
-    },
-    showWasmLimitInfo(field) {
-      this.wasmLimitInfoDialog = {
-        show: true,
-        title: field.label,
-        details: field.details
-      }
-    }
-  }
-})

lnbits/static/js/components/admin/lnbits-admin-wasm-runtime.js

@@ -1,380 +0,0 @@
-window.app.component('lnbits-admin-wasm-runtime', {
-  props: ['form-data'],
-  template: '#lnbits-admin-wasm-runtime',
-  data() {
-    return {
-      wasmRuntimeLoading: false,
-      wasmHistoryLoading: false,
-      wasmRuntimeTimer: null,
-      wasmStats: {},
-      wasmCurrentInvocations: [],
-      wasmInvocationHistory: [],
-      wasmStatItems: [
-        {key: 'total', label: 'Total', icon: 'data_usage', color: 'primary'},
-        {key: 'running', label: 'Running', icon: 'play_circle', color: 'green'},
-        {key: 'completed', label: 'Completed', icon: 'task_alt', color: 'teal'},
-        {key: 'failed', label: 'Failed', icon: 'error', color: 'red'},
-        {
-          key: 'stopped',
-          label: 'Stopped',
-          icon: 'stop_circle',
-          color: 'orange'
-        },
-        {key: 'timeout', label: 'Timeouts', icon: 'timer_off', color: 'purple'}
-      ],
-      wasmCurrentColumns: [
-        {
-          name: 'extension_id',
-          label: 'Extension',
-          field: 'extension_id',
-          align: 'left',
-          sortable: true
-        },
-        {
-          name: 'export_name',
-          label: 'Export',
-          field: 'export_name',
-          align: 'left',
-          sortable: true
-        },
-        {
-          name: 'trigger_type',
-          label: 'Trigger',
-          field: 'trigger_type',
-          align: 'left',
-          sortable: true
-        },
-        {
-          name: 'status',
-          label: 'Status',
-          field: 'status',
-          align: 'left',
-          sortable: true
-        },
-        {
-          name: 'user_id',
-          label: 'User',
-          field: 'user_id',
-          align: 'left',
-          sortable: true
-        },
-        {
-          name: 'started_at',
-          label: 'Started',
-          field: 'started_at',
-          align: 'left',
-          sortable: true
-        },
-        {
-          name: 'duration_ms',
-          label: 'Duration',
-          field: row => row.duration_ms || 0,
-          align: 'right',
-          sortable: true
-        },
-        {
-          name: 'context',
-          label: 'Context',
-          field: row => this.wasmContextValue(row),
-          align: 'left',
-          sortable: true
-        },
-        {name: 'actions', label: '', field: 'actions', align: 'right'}
-      ],
-      wasmHistoryColumns: [
-        {
-          name: 'extension_id',
-          label: 'Extension',
-          field: 'extension_id',
-          align: 'left',
-          sortable: true
-        },
-        {
-          name: 'export_name',
-          label: 'Export',
-          field: 'export_name',
-          align: 'left',
-          sortable: true
-        },
-        {
-          name: 'trigger_type',
-          label: 'Trigger',
-          field: 'trigger_type',
-          align: 'left',
-          sortable: true
-        },
-        {
-          name: 'status',
-          label: 'Status',
-          field: 'status',
-          align: 'left',
-          sortable: true
-        },
-        {
-          name: 'user_id',
-          label: 'User',
-          field: 'user_id',
-          align: 'left',
-          sortable: true
-        },
-        {
-          name: 'started_at',
-          label: 'Started',
-          field: 'started_at',
-          align: 'left',
-          sortable: true
-        },
-        {
-          name: 'duration_ms',
-          label: 'Duration',
-          field: row => row.duration_ms || 0,
-          align: 'right',
-          sortable: true
-        },
-        {
-          name: 'calls',
-          label: 'Calls',
-          field: row => this.wasmCallCount(row),
-          align: 'left',
-          sortable: true
-        },
-        {
-          name: 'context',
-          label: 'Context',
-          field: row => this.wasmContextValue(row),
-          align: 'left',
-          sortable: true
-        },
-        {
-          name: 'error_message',
-          label: 'Error/Stop Reason',
-          field: row => row.error_message || row.stop_reason || '',
-          align: 'left',
-          sortable: true
-        }
-      ]
-    }
-  },
-  computed: {
-    adminKey() {
-      return this.g.user.wallets[0].adminkey
-    },
-    wasmExtensionId() {
-      return this.$route.params.extId || null
-    },
-    wasmExtensionQuery() {
-      if (!this.wasmExtensionId) {
-        return ''
-      }
-      return `extension_id=${encodeURIComponent(this.wasmExtensionId)}`
-    }
-  },
-  watch: {
-    wasmExtensionId() {
-      this.fetchWasmRuntime()
-    }
-  },
-  methods: {
-    async fetchWasmRuntime() {
-      await Promise.all([
-        this.fetchWasmCurrentInvocations(),
-        this.fetchWasmInvocationHistory(),
-        this.fetchWasmInvocationStats()
-      ])
-    },
-    async fetchWasmCurrentInvocations() {
-      this.wasmRuntimeLoading = true
-      try {
-        const query = this.wasmExtensionQuery
-          ? `?${this.wasmExtensionQuery}`
-          : ''
-        const {data} = await LNbits.api.request(
-          'GET',
-          `/api/v1/extension/wasm/invocations/current${query}`,
-          this.adminKey
-        )
-        this.wasmCurrentInvocations = data || []
-      } catch (error) {
-        LNbits.utils.notifyApiError(error)
-      } finally {
-        this.wasmRuntimeLoading = false
-      }
-    },
-    async fetchWasmInvocationHistory() {
-      this.wasmHistoryLoading = true
-      try {
-        const params = ['limit=50']
-        if (this.wasmExtensionQuery) {
-          params.push(this.wasmExtensionQuery)
-        }
-        const {data} = await LNbits.api.request(
-          'GET',
-          `/api/v1/extension/wasm/invocations?${params.join('&')}`,
-          this.adminKey
-        )
-        this.wasmInvocationHistory = data || []
-      } catch (error) {
-        LNbits.utils.notifyApiError(error)
-      } finally {
-        this.wasmHistoryLoading = false
-      }
-    },
-    async fetchWasmInvocationStats() {
-      try {
-        const params = ['hours=24']
-        if (this.wasmExtensionQuery) {
-          params.push(this.wasmExtensionQuery)
-        }
-        const {data} = await LNbits.api.request(
-          'GET',
-          `/api/v1/extension/wasm/invocations/stats?${params.join('&')}`,
-          this.adminKey
-        )
-        this.wasmStats = data || {}
-      } catch (error) {
-        LNbits.utils.notifyApiError(error)
-      }
-    },
-    async stopWasmInvocation(invocationId) {
-      try {
-        await LNbits.api.request(
-          'POST',
-          `/api/v1/extension/wasm/invocations/${encodeURIComponent(invocationId)}/stop`,
-          this.adminKey
-        )
-        Quasar.Notify.create({
-          type: 'positive',
-          message: 'WASM invocation stop requested.'
-        })
-        await this.fetchWasmRuntime()
-      } catch (error) {
-        LNbits.utils.notifyApiError(error)
-      }
-    },
-    deactivateWasmExtension(extensionId) {
-      LNbits.utils
-        .confirmDialog(
-          `Deactivate extension '${extensionId}'?`,
-          'Deactivate Extension'
-        )
-        .onOk(async () => {
-          try {
-            await LNbits.api.request(
-              'PUT',
-              `/api/v1/extension/${encodeURIComponent(extensionId)}/deactivate`,
-              this.adminKey
-            )
-            Quasar.Notify.create({
-              type: 'positive',
-              message: `Extension '${extensionId}' deactivated.`
-            })
-            await this.fetchWasmRuntime()
-          } catch (error) {
-            LNbits.utils.notifyApiError(error)
-          }
-        })
-    },
-    formatWasmStat(key) {
-      const value = this.wasmStats[key]
-      return value === undefined || value === null ? '0' : String(value)
-    },
-    formatWasmDate(value) {
-      return value ? this.utils.formatDate(value) : ''
-    },
-    wasmStatusColor(status) {
-      return (
-        {
-          running: 'green',
-          stopping: 'orange',
-          completed: 'teal',
-          failed: 'red',
-          stopped: 'orange',
-          timeout: 'purple',
-          abandoned: 'grey'
-        }[status] || 'grey'
-      )
-    },
-    wasmTriggerColor(triggerType) {
-      return (
-        {
-          http: 'primary',
-          event: 'purple'
-        }[triggerType] || 'grey'
-      )
-    },
-    formatWasmDuration(row) {
-      let duration = row.duration_ms
-      if (
-        (row.status === 'running' || row.status === 'stopping') &&
-        row.started_at
-      ) {
-        duration = Date.now() - new Date(row.started_at).getTime()
-      }
-      if (duration === undefined || duration === null) {
-        return ''
-      }
-      if (duration >= 1000) {
-        return `${(duration / 1000).toFixed(1)}s`
-      }
-      return `${duration}ms`
-    },
-    formatWasmCalls(row) {
-      return [
-        `host ${row.host_call_count || 0}`,
-        `http ${row.http_call_count || 0}`,
-        `storage ${row.storage_call_count || 0}`,
-        `wallet ${row.wallet_call_count || 0}`
-      ].join(' / ')
-    },
-    wasmCallCount(row) {
-      return (
-        (row.host_call_count || 0) +
-        (row.http_call_count || 0) +
-        (row.storage_call_count || 0) +
-        (row.wallet_call_count || 0)
-      )
-    },
-    wasmContextValue(row) {
-      return [
-        row.method,
-        row.path,
-        row.event_type,
-        row.wallet_id,
-        row.payment_hash
-      ]
-        .filter(Boolean)
-        .join(' ')
-    },
-    formatWasmContext(row) {
-      const items = [
-        row.method,
-        row.path,
-        row.event_type,
-        row.wallet_id ? `wallet ${row.wallet_id}` : '',
-        row.payment_hash ? `payment ${row.payment_hash.slice(0, 12)}...` : ''
-      ].filter(Boolean)
-      return items.join(' | ')
-    },
-    formatWasmUserId(userId) {
-      if (!userId) {
-        return '-'
-      }
-      const value = String(userId)
-      if (value.length <= 12) {
-        return value
-      }
-      return `${value.slice(0, 3)}...${value.slice(-3)}`
-    }
-  },
-  created() {
-    this.fetchWasmRuntime()
-    this.wasmRuntimeTimer = setInterval(() => {
-      this.fetchWasmCurrentInvocations()
-    }, 5000)
-  },
-  unmounted() {
-    if (this.wasmRuntimeTimer) {
-      clearInterval(this.wasmRuntimeTimer)
-    }
-  }
-})

lnbits/static/js/components/lnbits-extension-permissions.js

@@ -1,337 +0,0 @@
-;(function () {
-  function translate(translateFn, key) {
-    return translateFn ? translateFn(key) : key
-  }
-
-  function permissionI18nKey(permission) {
-    return `extension_permission_${permission.id.replace(/[^A-Za-z0-9]/g, '_')}`
-  }
-
-  function permissionLabel(permission, translateFn) {
-    const key = permissionI18nKey(permission)
-    const label = translate(translateFn, key)
-    return label === key ? permission.id : label
-  }
-
-  function permissionManifestDescription(permission) {
-    return typeof permission.description === 'string'
-      ? permission.description
-      : ''
-  }
-
-  function lowRisk(translateFn) {
-    return {
-      level: 'low',
-      color: 'grey-6',
-      label: translate(translateFn, 'extension_permission_risk_low'),
-      warning: ''
-    }
-  }
-
-  function mediumRisk(translateFn, warningKey) {
-    return {
-      level: 'medium',
-      color: 'warning',
-      label: translate(translateFn, 'extension_permission_risk_medium'),
-      warning: warningKey ? translate(translateFn, warningKey) : ''
-    }
-  }
-
-  function highRisk(translateFn, warningKey) {
-    return {
-      level: 'high',
-      color: 'negative',
-      label: translate(translateFn, 'extension_permission_risk_high'),
-      warning: translate(translateFn, warningKey)
-    }
-  }
-
-  function extensionDisplayName(extensions, extensionId) {
-    const extension = (extensions || []).find(
-      extension => extension.id === extensionId
-    )
-    return extension?.name || extensionId
-  }
-
-  function extensionApiPermissionTargets(permission, extensions) {
-    const extensionPolicies = permission.policies
-    if (!Array.isArray(extensionPolicies)) return []
-    return extensionPolicies
-      .map(extension => {
-        const extensionId =
-          typeof extension === 'string' ? extension : extension?.id
-        if (!extensionId) return null
-        const access =
-          typeof extension === 'string'
-            ? ['read']
-            : Array.isArray(extension.access) && extension.access.length
-              ? extension.access
-              : ['read']
-        return {
-          id: extensionId,
-          name: extensionDisplayName(extensions, extensionId),
-          access
-        }
-      })
-      .filter(Boolean)
-  }
-
-  function permissionRiskForPermission(permission, extensions, translateFn) {
-    if (
-      ['wallet.pay_invoice', 'wallet.pay_invoice_background'].includes(
-        permission.id
-      )
-    ) {
-      return highRisk(
-        translateFn,
-        permission.id === 'wallet.pay_invoice_background'
-          ? 'extension_permission_warning_wallet_pay_invoice_background'
-          : 'extension_permission_warning_wallet_pay_invoice'
-      )
-    }
-    if (permission.id === 'extension.api.request') {
-      const hasWriteAccess = extensionApiPermissionTargets(
-        permission,
-        extensions
-      ).some(target => target.access.includes('write'))
-      return hasWriteAccess
-        ? highRisk(
-            translateFn,
-            'extension_permission_warning_extension_api_request_write'
-          )
-        : mediumRisk(translateFn)
-    }
-    if (permission.id === 'http.request') {
-      return mediumRisk(translateFn)
-    }
-    if (permission.id === 'wallet.payments.watch') {
-      return mediumRisk(
-        translateFn,
-        'extension_permission_warning_wallet_payments_watch'
-      )
-    }
-    if (
-      [
-        'wallet.list',
-        'wallet.balance.read',
-        'wallet.create_invoice_public',
-        'ext.storage.read_public'
-      ].includes(permission.id)
-    ) {
-      return mediumRisk(translateFn)
-    }
-    return lowRisk(translateFn)
-  }
-
-  function permissionRisk(permissions, extensions, translateFn) {
-    const risks = permissions.map(permission =>
-      permissionRiskForPermission(permission, extensions, translateFn)
-    )
-    const highestRisk = risks.find(risk => risk.level === 'high')
-    if (highestRisk) return highestRisk
-    return risks.find(risk => risk.level === 'medium') || lowRisk(translateFn)
-  }
-
-  function permissionOrderIndex(permissionId) {
-    const order = [
-      'wallet.pay_invoice',
-      'wallet.pay_invoice_background',
-      'wallet.payments.watch',
-      'wallet.list',
-      'wallet.balance.read',
-      'extension.api.request',
-      'http.request',
-      'ui.camera.scan_qr',
-      'ext.storage.read',
-      'ext.storage.write',
-      'ext.storage.read_public',
-      'wallet.create_invoice_public',
-      'wallet.create_invoice',
-      'utils.basic'
-    ]
-    const index = order.indexOf(permissionId)
-    return index === -1 ? order.length : index
-  }
-
-  function publicStorageFieldGroups(permission) {
-    const tables = permission.policies
-    if (!Array.isArray(tables)) return []
-    return tables
-      .map(table => {
-        const tableName =
-          typeof table === 'string' ? table : table?.table_name || ''
-        const fields =
-          typeof table === 'string' || !Array.isArray(table?.public_fields)
-            ? []
-            : table.public_fields.filter(
-                field => typeof field === 'string' && field
-              )
-        return tableName ? {table: tableName, fields} : null
-      })
-      .filter(Boolean)
-  }
-
-  function httpRequestPermissionHosts(permission) {
-    const hosts = permission.policies
-    if (!Array.isArray(hosts)) return []
-    return hosts
-      .map(host => (typeof host === 'string' ? host : host?.host || ''))
-      .filter(host => typeof host === 'string' && host)
-  }
-
-  function publicInvoicePolicies(permission) {
-    const policies = permission.policies
-    if (!Array.isArray(policies)) return []
-    return policies
-      .map(policy => {
-        if (!policy || typeof policy !== 'object') return null
-        const table = policy.table
-        const walletField = policy.wallet_field
-        if (typeof table !== 'string' || !table) return null
-        if (typeof walletField !== 'string' || !walletField) return null
-        return {table, walletField}
-      })
-      .filter(Boolean)
-  }
-
-  function permissionDisplayItem(permissions, extensions, translateFn) {
-    const permission = permissions[0]
-    const isReadWriteStorage =
-      permissions.length === 2 &&
-      permissions.some(permission => permission.id === 'ext.storage.read') &&
-      permissions.some(permission => permission.id === 'ext.storage.write')
-    const descriptions = permissions
-      .map(permission => permissionManifestDescription(permission))
-      .filter(Boolean)
-    const item = {
-      id: isReadWriteStorage ? 'ext.storage.read_write' : permission.id,
-      label: isReadWriteStorage
-        ? translate(translateFn, 'extension_permission_ext_storage_read_write')
-        : permissionLabel(permission, translateFn),
-      risk: permissionRisk(permissions, extensions, translateFn),
-      badges: [],
-      descriptions,
-      fieldGroups: [],
-      invoicePolicies: [],
-      extensionAccess: [],
-      httpHosts: []
-    }
-
-    if (permission.id === 'ext.storage.read_public') {
-      item.fieldGroups = publicStorageFieldGroups(permission)
-      item.badges = item.fieldGroups.map(group => ({
-        key: group.table,
-        label: group.table
-      }))
-    }
-
-    if (permission.id === 'extension.api.request') {
-      item.extensionAccess = extensionApiPermissionTargets(
-        permission,
-        extensions
-      )
-      item.badges = item.extensionAccess.map(target => ({
-        key: target.id,
-        label: target.name
-      }))
-    }
-
-    if (permission.id === 'http.request') {
-      item.httpHosts = httpRequestPermissionHosts(permission)
-    }
-
-    if (permission.id === 'wallet.create_invoice_public') {
-      item.invoicePolicies = publicInvoicePolicies(permission)
-    }
-
-    return item
-  }
-
-  function displayItems({permissions, extensions, translate}) {
-    const permissionList = permissions || []
-    const permissionsById = new Map(
-      permissionList.map(permission => [permission.id, permission])
-    )
-    const hasReadWriteStorage =
-      permissionsById.has('ext.storage.read') &&
-      permissionsById.has('ext.storage.write')
-    let addedReadWriteStorage = false
-
-    return permissionList
-      .map((permission, index) => {
-        if (
-          hasReadWriteStorage &&
-          ['ext.storage.read', 'ext.storage.write'].includes(permission.id)
-        ) {
-          if (addedReadWriteStorage) return null
-          addedReadWriteStorage = true
-          return {
-            index,
-            orderId: 'ext.storage.read',
-            permissions: [
-              permissionsById.get('ext.storage.read'),
-              permissionsById.get('ext.storage.write')
-            ]
-          }
-        }
-        return {
-          index,
-          orderId: permission.id,
-          permissions: [permission]
-        }
-      })
-      .filter(Boolean)
-      .sort((left, right) => {
-        const leftOrder = permissionOrderIndex(left.orderId)
-        const rightOrder = permissionOrderIndex(right.orderId)
-        return leftOrder === rightOrder
-          ? left.index - right.index
-          : leftOrder - rightOrder
-      })
-      .map(group =>
-        permissionDisplayItem(group.permissions, extensions || [], translate)
-      )
-  }
-
-  window.LNbitsExtensionPermissions = {
-    displayItems,
-    hasHighRisk({permissions, extensions, translate}) {
-      return displayItems({permissions, extensions, translate}).some(
-        permission => permission.risk.level === 'high'
-      )
-    }
-  }
-
-  window.app.component('lnbits-extension-permissions', {
-    template: '#lnbits-extension-permissions',
-    props: {
-      permissions: {
-        type: Array,
-        default: () => []
-      },
-      extensions: {
-        type: Array,
-        default: () => []
-      }
-    },
-    computed: {
-      displayItems() {
-        return window.LNbitsExtensionPermissions.displayItems({
-          permissions: this.permissions,
-          extensions: this.extensions,
-          translate: key => this.$t(key)
-        })
-      }
-    },
-    methods: {
-      publicInvoicePolicySentence(policy) {
-        return `Invoices will be created using ${policy.walletField} from ${policy.table}.`
-      },
-      permissionAccessLabel(access) {
-        const key = `extension_permission_access_${access}`
-        const label = this.$t(key)
-        return label === key ? access : label
-      }
-    }
-  })
-})()

lnbits/static/js/init-app.js

@@ -99,26 +99,6 @@ const routes = [
     name: 'Users',
     component: PageUsers
   },
-  {
-    path: '/admin/extensions/wasm',
-    name: 'AdminWasmRuntime',
-    component: PageAdmin
-  },
-  {
-    path: '/admin/extensions/wasm/limits',
-    name: 'AdminWasmLimitConfig',
-    component: PageAdmin
-  },
-  {
-    path: '/admin/extensions/wasm/limits/:extId',
-    name: 'AdminWasmLimitConfigDetail',
-    component: PageAdmin
-  },
-  {
-    path: '/admin/extensions/wasm/:extId',
-    name: 'AdminWasmRuntimeDetail',
-    component: PageAdmin
-  },
   {
     path: '/admin',
     name: 'Admin',

lnbits/static/js/pages/admin.js

@@ -16,26 +16,18 @@ window.PageAdmin = {
   },
   watch: {
     tab(tab) {
-      if (
-        ['wasm-runtime', 'wasm-limit-config'].includes(tab) &&
-        this.$route.path.startsWith('/admin/extensions/wasm')
-      ) {
-        return
-      }
-      const target = this.adminRouteForTab(tab)
-      if (this.$route.fullPath !== target) {
-        this.$router.push(target)
-      }
+      this.$router.push(`/admin#${tab}`)
     },
     $route(to) {
-      const tab = this.adminTabFromRoute(to)
-      if (this.tab !== tab) {
-        this.tab = tab
+      if (to.hash.length > 1) {
+        this.tab = to.hash.replace('#', '')
       }
     }
   },
   async created() {
-    this.tab = this.adminTabFromRoute(this.$route)
+    if (this.$route.hash.length > 1) {
+      this.tab = this.$route.hash.replace('#', '')
+    }
     await this.getSettings()
   },
   computed: {
@@ -44,27 +36,6 @@ window.PageAdmin = {
     }
   },
   methods: {
-    adminTabFromRoute(route) {
-      if (route.path.startsWith('/admin/extensions/wasm/limits')) {
-        return 'wasm-limit-config'
-      }
-      if (route.path.startsWith('/admin/extensions/wasm')) {
-        return 'wasm-runtime'
-      }
-      if (route.hash.length > 1) {
-        return route.hash.replace('#', '')
-      }
-      return 'funding'
-    },
-    adminRouteForTab(tab) {
-      if (tab === 'wasm-runtime') {
-        return '/admin/extensions/wasm'
-      }
-      if (tab === 'wasm-limit-config') {
-        return '/admin/extensions/wasm/limits'
-      }
-      return `/admin#${tab}`
-    },
     getDefaultSetting(fieldName) {
       LNbits.api.getDefaultSetting(fieldName).then(response => {
         this.formData[fieldName] = response.data.default_value

lnbits/static/js/pages/extensions.js

@@ -29,23 +29,6 @@ window.PageExtensions = {
         permissions: [],
         resolve: null
       },
-      managedExtensionPermissions: {
-        loading: false,
-        extensionPermissions: [],
-        userPermissions: {},
-        savingKey: '',
-        deletingKey: ''
-      },
-      backgroundPaymentDestinationOptions: [
-        {
-          label: 'Only transfers to my wallets',
-          value: 'own_wallets_only'
-        },
-        {
-          label: 'Allow external payments',
-          value: 'external_allowed'
-        }
-      ],
       uninstallAndDropDb: false,
       maxStars: 5,
       paylinkWebsocket: null,
@@ -115,32 +98,6 @@ window.PageExtensions = {
       this.filterExtensions(this.searchTerm, val)
     }
   },
-  computed: {
-    managedUserPermissionRows() {
-      const rows = []
-      const userPermissions =
-        this.managedExtensionPermissions.userPermissions || {}
-      Object.entries(userPermissions).forEach(([permissionId, grants]) => {
-        if (!Array.isArray(grants)) return
-        grants.forEach(grant => {
-          if (!grant || typeof grant !== 'object') return
-          const grantId = String(grant.id || '')
-          const walletId = String(grant.wallet_id || '')
-          if (!grantId || !walletId) return
-          rows.push({
-            key: grantId,
-            permissionId,
-            label: this.permissionLabelById(permissionId),
-            grantId,
-            walletId,
-            walletName: this.walletName(walletId),
-            grant
-          })
-        })
-      })
-      return rows
-    }
-  },
   methods: {
     filterExtensions(term, tab) {
       // Filter the extensions list
@@ -207,11 +164,6 @@ window.PageExtensions = {
           )
           extension.isAvailable = true
           extension.isInstalled = true
-          extension.isWasm =
-            response.data.is_wasm === true ||
-            response.data.isWasm === true ||
-            release.extension_type === 'wasm' ||
-            extension.isWasm === true
           extension.icon = response.data.icon || extension.icon
           extension.installedRelease = release
           this.toggleExtension(extension)
@@ -400,18 +352,8 @@ window.PageExtensions = {
       this.selectedExtension = extension
       this.selectedRelease = null
       this.selectedExtensionRepos = null
-      this.resetManagedExtensionPermissions()
-      this.manageExtensionTab = this.g.user.admin
-        ? 'releases'
-        : 'extension-permissions'
+      this.manageExtensionTab = 'releases'
       this.showManageExtensionDialog = true
-      if (this.canManageExtensionPermissions(extension)) {
-        this.loadManagedExtensionPermissions(extension)
-      }
-
-      if (!this.g.user.admin) {
-        return
-      }
 
       try {
         const {data} = await LNbits.api.request(
@@ -449,61 +391,6 @@ window.PageExtensions = {
         extension.inProgress = false
       }
     },
-    canShowManageExtensionButton(extension) {
-      return (
-        this.g.user.admin ||
-        (extension?.isWasm === true && extension?.isInstalled === true)
-      )
-    },
-    canManageExtensionPermissions(extension = this.selectedExtension) {
-      return extension?.isWasm === true && extension?.isInstalled === true
-    },
-    canShowAdminManageTabs() {
-      return this.g.user.admin === true
-    },
-    resetManagedExtensionPermissions() {
-      this.managedExtensionPermissions = {
-        loading: false,
-        extensionPermissions: [],
-        userPermissions: {},
-        savingKey: '',
-        deletingKey: ''
-      }
-    },
-    async loadManagedExtensionPermissions(extension = this.selectedExtension) {
-      if (!this.canManageExtensionPermissions(extension)) return
-      this.managedExtensionPermissions.loading = true
-      try {
-        const {data} = await LNbits.api.request(
-          'GET',
-          `/api/v1/extension/${extension.id}/permissions`
-        )
-        this.managedExtensionPermissions.extensionPermissions =
-          data.extension_permissions || []
-        this.managedExtensionPermissions.userPermissions =
-          this.cloneUserPermissions(data.user_permissions || {})
-      } catch (error) {
-        console.warn(error)
-        LNbits.utils.notifyApiError(error)
-      } finally {
-        this.managedExtensionPermissions.loading = false
-      }
-    },
-    cloneUserPermissions(userPermissions) {
-      const permissions = {}
-      Object.entries(userPermissions || {}).forEach(
-        ([permissionId, grants]) => {
-          if (!Array.isArray(grants)) return
-          permissions[permissionId] = grants
-            .filter(grant => grant && typeof grant === 'object')
-            .map(grant => ({
-              ...grant,
-              _original: {...grant}
-            }))
-        }
-      )
-      return permissions
-    },
 
     async showExtensionDetails(extId, detailsLink) {
       if (!detailsLink) {
@@ -750,135 +637,6 @@ window.PageExtensions = {
     extensionOpenUrl(extension) {
       return extension.isWasm ? `/ext/${extension.id}` : `/${extension.id}`
     },
-    permissionLabelById(permissionId) {
-      const key = `extension_permission_${String(permissionId).replace(
-        /[^A-Za-z0-9]/g,
-        '_'
-      )}`
-      const label = this.$t(key)
-      return label === key ? permissionId : label
-    },
-    walletName(walletId) {
-      const wallet = (this.g.user.wallets || []).find(
-        wallet => wallet.id === walletId
-      )
-      return wallet ? wallet.name || wallet.id : walletId
-    },
-    userPermissionRowCaption(row) {
-      return `${row.walletName} (${row.walletId.slice(0, 8)}...)`
-    },
-    isBackgroundPaymentPermission(row) {
-      return row.permissionId === 'wallet.pay_invoice_background'
-    },
-    userPermissionGrantPayload(row) {
-      return {
-        wallet_id: row.walletId,
-        max_amount: this.positiveInteger(row.grant.max_amount, 0),
-        destination_policy: this.backgroundPaymentDestinationPolicy(
-          row.grant.destination_policy
-        )
-      }
-    },
-    positiveInteger(value, fallback) {
-      const number = Number(value)
-      if (!Number.isFinite(number) || number <= 0) return fallback
-      return Math.floor(number)
-    },
-    backgroundPaymentDestinationPolicy(value) {
-      return value === 'external_allowed'
-        ? 'external_allowed'
-        : 'own_wallets_only'
-    },
-    backgroundPaymentGrantIncreased(row, payload) {
-      const original = row.grant._original || {}
-      const originalAmount = this.positiveInteger(original.max_amount, 0)
-      const originalPolicy = this.backgroundPaymentDestinationPolicy(
-        original.destination_policy
-      )
-      return (
-        payload.max_amount > originalAmount ||
-        (originalPolicy === 'own_wallets_only' &&
-          payload.destination_policy === 'external_allowed')
-      )
-    },
-    confirmUserPermissionIncrease() {
-      return new Promise(resolve => {
-        let resolved = false
-        const finish = value => {
-          if (resolved) return
-          resolved = true
-          resolve(value)
-        }
-        LNbits.utils
-          .confirmDialog(
-            'This increases what the extension can do with this wallet. Continue?'
-          )
-          .onOk(() => finish(true))
-          .onCancel(() => finish(false))
-          .onDismiss(() => finish(false))
-      })
-    },
-    async saveUserPermissionGrant(row) {
-      if (!this.isBackgroundPaymentPermission(row)) return
-      const payload = this.userPermissionGrantPayload(row)
-      if (!payload.max_amount) {
-        Quasar.Notify.create({
-          type: 'negative',
-          message: 'Max payment amount must be greater than zero.'
-        })
-        return
-      }
-      if (
-        this.backgroundPaymentGrantIncreased(row, payload) &&
-        !(await this.confirmUserPermissionIncrease())
-      ) {
-        return
-      }
-
-      this.managedExtensionPermissions.savingKey = row.key
-      try {
-        await LNbits.api.request(
-          'POST',
-          `/api/v1/extension/${this.selectedExtension.id}/permissions/background-payment`,
-          null,
-          payload
-        )
-        Quasar.Notify.create({
-          type: 'positive',
-          message: 'Permission updated.'
-        })
-        await this.loadManagedExtensionPermissions()
-      } catch (error) {
-        console.warn(error)
-        LNbits.utils.notifyApiError(error)
-      } finally {
-        this.managedExtensionPermissions.savingKey = ''
-      }
-    },
-    deleteUserPermissionGrant(row) {
-      LNbits.utils
-        .confirmDialog('Remove this permission grant?')
-        .onOk(async () => {
-          this.managedExtensionPermissions.deletingKey = row.key
-          try {
-            const grantId = encodeURIComponent(row.grantId)
-            await LNbits.api.request(
-              'DELETE',
-              `/api/v1/extension/${this.selectedExtension.id}/permissions/user/${grantId}`
-            )
-            Quasar.Notify.create({
-              type: 'positive',
-              message: 'Permission removed.'
-            })
-            await this.loadManagedExtensionPermissions()
-          } catch (error) {
-            console.warn(error)
-            LNbits.utils.notifyApiError(error)
-          } finally {
-            this.managedExtensionPermissions.deletingKey = ''
-          }
-        })
-    },
     async getGitHubReleaseDetails(release) {
       if (!release.is_github_release || release.loaded) {
         return
@@ -966,12 +724,42 @@ window.PageExtensions = {
         resolve(grantedPermissions)
       }
     },
-    permissionGrantHasHighRisk() {
-      return window.LNbitsExtensionPermissions.hasHighRisk({
-        permissions: this.permissionGrant.permissions,
-        extensions: this.extensions,
-        translate: key => this.$t(key)
-      })
+    permissionI18nKey(permission) {
+      return `extension_permission_${permission.id.replace(/[^A-Za-z0-9]/g, '_')}`
+    },
+    permissionLabel(permission) {
+      const key = this.permissionI18nKey(permission)
+      const label = this.$t(key)
+      return label === key ? permission.id : label
+    },
+    permissionDescription(permission) {
+      const key = `${this.permissionI18nKey(permission)}_desc`
+      const description = this.$t(key)
+      return description === key ? permission.description : description
+    },
+    permissionPolicyDetails(permission) {
+      if (permission.id === 'http.request') {
+        const hosts = permission.policy?.hosts
+        if (!Array.isArray(hosts) || !hosts.length) return ''
+        return `${this.$t('extension_permission_http_request_hosts')}: ${hosts.join(', ')}`
+      }
+      if (permission.id === 'extension.api.request') {
+        const extensions = permission.policy?.extensions
+        if (!Array.isArray(extensions) || !extensions.length) return ''
+        const targets = extensions
+          .map(extension => {
+            if (typeof extension === 'string') return `${extension} (read)`
+            if (!extension?.id) return null
+            const access = Array.isArray(extension.access)
+              ? extension.access.join(', ')
+              : 'read'
+            return `${extension.id} (${access})`
+          })
+          .filter(Boolean)
+        if (!targets.length) return ''
+        return `${this.$t('extension_permission_extension_api_request_extensions')}: ${targets.join(', ')}`
+      }
+      return ''
     },
     async selectAllUpdatableExtensionss() {
       this.updatableExtensions.forEach(e => (e.selectedForUpdate = true))

lnbits/static/js/pages/wallet.js

@@ -7,7 +7,6 @@ window.PageWallet = {
         invoice: null,
         lnurlpay: null,
         lnurlauth: null,
-        sending: false,
         data: {
           request: '',
           amount: 0,
@@ -132,7 +131,6 @@ window.PageWallet = {
       this.parse.data.request = ''
       this.parse.data.comment = ''
       this.parse.data.internalMemo = null
-      this.parse.sending = false
       this.parse.data.paymentChecker = null
       this.parse.camera.show = false
     },
@@ -364,9 +362,6 @@ window.PageWallet = {
       this.parse.invoice = Object.freeze(cleanInvoice)
     },
     payInvoice() {
-      if (this.parse.sending) return
-
-      this.parse.sending = true
       const dismissPaymentMsg = Quasar.Notify.create({
         timeout: 0,
         message: this.$t('payment_processing')
@@ -379,7 +374,6 @@ window.PageWallet = {
           this.parse.data.internalMemo
         )
         .then(response => {
-          this.parse.sending = false
           dismissPaymentMsg()
           this.g.updatePayments = !this.g.updatePayments
           this.parse.show = false
@@ -397,16 +391,13 @@ window.PageWallet = {
           }
         })
         .catch(err => {
-          this.parse.sending = false
           dismissPaymentMsg()
           LNbits.utils.notifyApiError(err)
           this.g.updatePayments = !this.g.updatePayments
+          this.parse.show = false
         })
     },
     payLnurl() {
-      if (this.parse.sending) return
-
-      this.parse.sending = true
       LNbits.api
         .request('post', '/api/v1/payments/lnurl', this.g.wallet.adminkey, {
           res: this.parse.lnurlpay,
@@ -417,26 +408,18 @@ window.PageWallet = {
           internalMemo: this.parse.data.internalMemo
         })
         .then(response => {
-          this.parse.sending = false
           this.parse.show = false
           if (response.data.extra.success_action) {
             const action = JSON.parse(response.data.extra.success_action)
             switch (action.tag) {
               case 'url':
                 Quasar.Notify.create({
-                  message: action.url,
+                  message: `<a target="_blank" style="color: inherit" href="${action.url}">${action.url}</a>`,
                   caption: action.description,
-                  html: false,
+                  html: true,
                   type: 'positive',
                   timeout: 0,
-                  closeBtn: true,
-                  actions: [
-                    {
-                      label: 'Open link',
-                      color: 'white',
-                      handler: () => this.utils.openUrlInNewTab(action.url)
-                    }
-                  ]
+                  closeBtn: true
                 })
                 break
               case 'message':
@@ -448,36 +431,19 @@ window.PageWallet = {
                 })
                 break
               case 'aes':
-                this.utils
-                  .decryptLnurlPayAES(action, response.data.preimage)
-                  .then(value => {
-                    Quasar.Notify.create({
-                      message: value,
-                      caption: action.description,
-                      html: false,
-                      type: 'positive',
-                      timeout: 0,
-                      closeBtn: true
-                    })
-                  })
-                  .catch(error => {
-                    Quasar.Notify.create({
-                      message: action.description || 'Payment successful.',
-                      caption: 'Could not decrypt success action.',
-                      html: false,
-                      type: 'warning',
-                      timeout: 0,
-                      closeBtn: true
-                    })
-                  })
-                break
+                this.utils.decryptLnurlPayAES(action, response.data.preimage)
+                Quasar.Notify.create({
+                  message: value,
+                  caption: extra.success_action.description,
+                  html: true,
+                  type: 'positive',
+                  timeout: 0,
+                  closeBtn: true
+                })
             }
           }
         })
-        .catch(err => {
-          this.parse.sending = false
-          LNbits.utils.notifyApiError(err)
-        })
+        .catch(LNbits.utils.notifyApiError)
     },
     authLnurl() {
       const dismissAuthMsg = Quasar.Notify.create({

lnbits/static/js/utils.js

@@ -365,27 +365,5 @@ window._lnbitsUtils = {
         let decoder = new TextDecoder('utf-8')
         return decoder.decode(valueb)
       })
-  },
-  validateBrowsableUrl(urlString, allowLoopback = false) {
-    const url = new URL(urlString)
-    if (url.protocol !== 'http:' && url.protocol !== 'https:') {
-      throw new Error('Invalid protocol')
-    }
-    if (!allowLoopback) {
-      const host = url.hostname
-      if (
-        host === 'localhost' ||
-        host === '[::1]' ||
-        host === '::1' ||
-        host.startsWith('127.') ||
-        host.startsWith('::ffff:127.')
-      ) {
-        throw new Error('Loopback addresses are not allowed')
-      }
-    }
-  },
-  openUrlInNewTab(urlString, allowLoopback = false) {
-    this.validateBrowsableUrl(urlString, allowLoopback)
-    window.open(urlString, '_blank', 'noopener,noreferrer')
   }
 }

lnbits/static/js/wasm-extension-component.js

@@ -48,85 +48,6 @@ window.WasmExtensionComponent = {
           </q-card-actions>
         </q-card>
       </q-dialog>
-      <q-dialog v-model="backgroundPaymentPrompt.show" persistent>
-        <q-card style="width: min(560px, calc(100vw - 32px)); max-width: 560px">
-          <q-card-section>
-            <div class="text-h6">Background payments</div>
-          </q-card-section>
-          <q-card-section class="q-pt-none q-gutter-md">
-            <div>
-              {{ backgroundPaymentPrompt.extensionName }} wants permission to make
-              background payments from
-              <strong>{{ backgroundPaymentPrompt.walletName }}</strong>.
-            </div>
-            <q-banner dense rounded class="bg-warning text-dark">
-              This permission can move funds later without an active click.
-            </q-banner>
-            <q-input
-              v-model.number="backgroundPaymentPrompt.form.maxAmount"
-              type="number"
-              label="Max payment amount (sats)"
-              min="1"
-              dense
-              outlined
-            ></q-input>
-            <q-select
-              v-model="backgroundPaymentPrompt.form.destinationPolicy"
-              :options="backgroundPaymentDestinationOptions"
-              emit-value
-              map-options
-              label="Allowed destinations"
-              dense
-              outlined
-            ></q-select>
-          </q-card-section>
-          <q-card-actions align="right">
-            <q-btn
-              flat
-              color="negative"
-              label="Deny"
-              @click="resolveBackgroundPaymentPrompt(false)"
-            ></q-btn>
-            <q-btn
-              unelevated
-              color="primary"
-              label="Allow"
-              @click="resolveBackgroundPaymentPrompt(true)"
-            ></q-btn>
-          </q-card-actions>
-        </q-card>
-      </q-dialog>
-      <q-dialog v-model="walletPaymentWatchPrompt.show" persistent>
-        <q-card style="width: min(520px, calc(100vw - 32px)); max-width: 520px">
-          <q-card-section>
-            <div class="text-h6">Watch wallet payments</div>
-          </q-card-section>
-          <q-card-section class="q-pt-none q-gutter-md">
-            <div>
-              {{ walletPaymentWatchPrompt.extensionName }} wants permission to receive
-              payment notifications for
-              <strong>{{ walletPaymentWatchPrompt.walletName }}</strong>.
-            </div>
-            <q-banner dense rounded class="bg-warning text-dark">
-              This permission exposes payment metadata for this wallet to the extension.
-            </q-banner>
-          </q-card-section>
-          <q-card-actions align="right">
-            <q-btn
-              flat
-              color="negative"
-              label="Deny"
-              @click="resolveWalletPaymentWatchPrompt(false)"
-            ></q-btn>
-            <q-btn
-              unelevated
-              color="primary"
-              label="Allow"
-              @click="resolveWalletPaymentWatchPrompt(true)"
-            ></q-btn>
-          </q-card-actions>
-        </q-card>
-      </q-dialog>
     </div>
   `,
   data() {
@@ -147,36 +68,6 @@ window.WasmExtensionComponent = {
         resolve: null,
         show: false
       },
-      backgroundPaymentDestinationOptions: [
-        {
-          label: 'Only transfers to my wallets',
-          value: 'own_wallets_only'
-        },
-        {
-          label: 'Allow external payments',
-          value: 'external_allowed'
-        }
-      ],
-      backgroundPaymentPrompt: {
-        extensionName: '',
-        form: {
-          destinationPolicy: 'own_wallets_only',
-          maxAmount: 0
-        },
-        reject: null,
-        resolve: null,
-        show: false,
-        walletId: '',
-        walletName: ''
-      },
-      walletPaymentWatchPrompt: {
-        extensionName: '',
-        reject: null,
-        resolve: null,
-        show: false,
-        walletId: '',
-        walletName: ''
-      },
       error: '',
       extensionName: '',
       frameUrl: '',
@@ -193,12 +84,6 @@ window.WasmExtensionComponent = {
   unmounted() {
     window.removeEventListener('message', this.handleWindowMessage)
     this.rejectCameraPrompt('Camera scan cancelled.')
-    this.rejectBackgroundPaymentPrompt(
-      'Background payment permission cancelled.'
-    )
-    this.rejectWalletPaymentWatchPrompt(
-      'Wallet payment watch permission cancelled.'
-    )
     this.closeBridgePort()
   },
   watch: {
@@ -234,20 +119,6 @@ window.WasmExtensionComponent = {
     cameraPromptStorageKey() {
       return `lnbits.ext.permissions.${this.bridge.extensionId}.ui.camera.scan_qr`
     },
-    emptyBackgroundPaymentPrompt() {
-      return {
-        extensionName: '',
-        form: {
-          destinationPolicy: 'own_wallets_only',
-          maxAmount: 0
-        },
-        reject: null,
-        resolve: null,
-        show: false,
-        walletId: '',
-        walletName: ''
-      }
-    },
     emptyCameraPrompt() {
       return {
         extensionName: '',
@@ -256,16 +127,6 @@ window.WasmExtensionComponent = {
         show: false
       }
     },
-    emptyWalletPaymentWatchPrompt() {
-      return {
-        extensionName: '',
-        reject: null,
-        resolve: null,
-        show: false,
-        walletId: '',
-        walletName: ''
-      }
-    },
     plainValue(value) {
       try {
         return JSON.parse(JSON.stringify(value))
@@ -282,12 +143,6 @@ window.WasmExtensionComponent = {
       this.bridge = this.emptyBridge()
       this.allowedPaymentHashes.clear()
       this.rejectCameraPrompt('Camera scan cancelled.')
-      this.rejectBackgroundPaymentPrompt(
-        'Background payment permission cancelled.'
-      )
-      this.rejectWalletPaymentWatchPrompt(
-        'Wallet payment watch permission cancelled.'
-      )
       this.closeBridgePort()
 
       try {
@@ -455,320 +310,6 @@ window.WasmExtensionComponent = {
         this.g.scanner = onScan
       })
     },
-    async requestBackgroundPaymentPermission(message) {
-      const response = await this.requestExtensionPermissions({
-        permissions: [
-          {
-            id: 'wallet.pay_invoice_background',
-            grant: message?.grant || {}
-          }
-        ]
-      })
-      return response.permissions?.[0] || response
-    },
-    async requestWalletPaymentWatchPermission(message) {
-      const response = await this.requestExtensionPermissions({
-        permissions: [
-          {
-            id: 'wallet.payments.watch',
-            grant: message?.grant || {}
-          }
-        ]
-      })
-      return response.permissions?.[0] || response
-    },
-    async requestExtensionPermissions(message) {
-      if (this.bridge.public) {
-        throw new Error('Public pages cannot request permissions.')
-      }
-      const permissions = Array.isArray(message.permissions)
-        ? message.permissions
-        : []
-      if (!permissions.length) {
-        throw new Error('No permissions requested.')
-      }
-
-      const requestedPermissions = permissions.map(permission =>
-        this.normalizePermissionRequest(permission)
-      )
-      const checkResult = await this.checkExtensionPermissions(
-        requestedPermissions.map(permission => ({
-          id: permission.id,
-          grant: permission.grant
-        }))
-      )
-      const checks = Array.isArray(checkResult?.permissions)
-        ? checkResult.permissions
-        : []
-      const approvedLabels = []
-      const results = []
-
-      for (const [index, permission] of requestedPermissions.entries()) {
-        const check = checks[index] || {}
-        if (check.id && check.id !== permission.id) {
-          throw new Error('Permission check response did not match request.')
-        }
-
-        if (check.approved) {
-          approvedLabels.push(permission.label)
-          results.push({
-            id: permission.id,
-            approved: true,
-            grant: check.grant || permission.grant
-          })
-          continue
-        }
-
-        const granted = await this.promptExtensionPermission(permission)
-        results.push({
-          id: permission.id,
-          approved: true,
-          grant: granted?.grant || permission.grant
-        })
-      }
-
-      this.notifyApprovedPermissionUse(approvedLabels)
-      return {permissions: results}
-    },
-    normalizePermissionRequest(permission) {
-      const id = String(permission?.id || '')
-      const grant = permission?.grant || {}
-      if (id === 'wallet.pay_invoice_background') {
-        return this.normalizeBackgroundPaymentPermission(grant)
-      }
-      if (id === 'wallet.payments.watch') {
-        return this.normalizeWalletPaymentWatchPermission(grant)
-      }
-      throw new Error(`Unsupported permission request: ${id}.`)
-    },
-    normalizeBackgroundPaymentPermission(grant) {
-      if (!this.hasBridgePermission('wallet.pay_invoice_background')) {
-        throw new Error('Extension is missing background payment permission.')
-      }
-
-      const walletId = String(grant.walletId || grant.wallet_id || '')
-      const wallet = this.walletById(walletId)
-      if (!wallet) {
-        throw new Error('Selected wallet is not available.')
-      }
-      if (wallet.walletType === 'lightning-shared') {
-        throw new Error(
-          'Background payments are not allowed from shared wallets.'
-        )
-      }
-
-      const requestedGrant = {
-        wallet_id: walletId,
-        max_amount: this.positiveInteger(
-          grant.maxAmount || grant.max_amount,
-          1000
-        ),
-        destination_policy: this.backgroundPaymentDestinationPolicy(
-          grant.destinationPolicy || grant.destination_policy
-        )
-      }
-      if (!requestedGrant.max_amount) {
-        throw new Error('Max payment amount must be greater than zero.')
-      }
-
-      return {
-        id: 'wallet.pay_invoice_background',
-        grant: requestedGrant,
-        label: `Background payments from ${wallet.name || walletId}`,
-        wallet
-      }
-    },
-    normalizeWalletPaymentWatchPermission(grant) {
-      if (!this.hasBridgePermission('wallet.payments.watch')) {
-        throw new Error('Extension is missing wallet payment watch permission.')
-      }
-
-      const walletId = String(grant.walletId || grant.wallet_id || '')
-      const wallet = this.walletById(walletId)
-      if (!wallet) {
-        throw new Error('Selected wallet is not available.')
-      }
-
-      return {
-        id: 'wallet.payments.watch',
-        grant: {wallet_id: walletId},
-        label: `Watch wallet payments for ${wallet.name || walletId}`,
-        wallet
-      }
-    },
-    walletById(walletId) {
-      return (
-        (this.g?.user?.wallets || []).find(wallet => wallet.id === walletId) ||
-        null
-      )
-    },
-    async checkExtensionPermissions(permissions) {
-      return await this.postExtensionPermission(
-        'check',
-        {permissions},
-        'Could not check extension permissions.'
-      )
-    },
-    promptExtensionPermission(permission) {
-      if (permission.id === 'wallet.pay_invoice_background') {
-        return this.promptBackgroundPaymentPermission(permission)
-      }
-      if (permission.id === 'wallet.payments.watch') {
-        return this.promptWalletPaymentWatchPermission(permission)
-      }
-      throw new Error(`Unsupported permission request: ${permission.id}.`)
-    },
-    promptBackgroundPaymentPermission(permission) {
-      if (this.backgroundPaymentPrompt.show) {
-        throw new Error('Background payment prompt is already open.')
-      }
-
-      return new Promise((resolve, reject) => {
-        this.backgroundPaymentPrompt = {
-          extensionName:
-            this.extensionName || this.bridge.extensionId || 'This extension',
-          form: {
-            destinationPolicy: permission.grant.destination_policy,
-            maxAmount: permission.grant.max_amount
-          },
-          reject,
-          resolve,
-          show: true,
-          walletId: permission.grant.wallet_id,
-          walletName: permission.wallet.name || permission.grant.wallet_id
-        }
-      })
-    },
-    async resolveBackgroundPaymentPrompt(approved) {
-      const prompt = this.backgroundPaymentPrompt
-      if (!prompt.show) return
-
-      if (!approved) {
-        this.backgroundPaymentPrompt = this.emptyBackgroundPaymentPrompt()
-        prompt.reject?.(new Error('Background payment permission denied.'))
-        return
-      }
-
-      try {
-        const grant = {
-          wallet_id: prompt.walletId,
-          max_amount: this.positiveInteger(prompt.form.maxAmount, 0),
-          destination_policy: this.backgroundPaymentDestinationPolicy(
-            prompt.form.destinationPolicy
-          )
-        }
-        if (!grant.max_amount) {
-          throw new Error('Max payment amount must be greater than zero.')
-        }
-
-        const data = await this.postExtensionPermission(
-          'background-payment',
-          grant,
-          'Could not save permission.'
-        )
-
-        this.backgroundPaymentPrompt = this.emptyBackgroundPaymentPrompt()
-        prompt.resolve?.(data)
-      } catch (error) {
-        prompt.reject?.(error)
-        this.backgroundPaymentPrompt = this.emptyBackgroundPaymentPrompt()
-      }
-    },
-    rejectBackgroundPaymentPrompt(message) {
-      const reject = this.backgroundPaymentPrompt.reject
-      this.backgroundPaymentPrompt = this.emptyBackgroundPaymentPrompt()
-      reject?.(new Error(message))
-    },
-    promptWalletPaymentWatchPermission(permission) {
-      if (this.walletPaymentWatchPrompt.show) {
-        throw new Error('Wallet payment watch prompt is already open.')
-      }
-
-      return new Promise((resolve, reject) => {
-        this.walletPaymentWatchPrompt = {
-          extensionName:
-            this.extensionName || this.bridge.extensionId || 'This extension',
-          reject,
-          resolve,
-          show: true,
-          walletId: permission.grant.wallet_id,
-          walletName: permission.wallet.name || permission.grant.wallet_id
-        }
-      })
-    },
-    async resolveWalletPaymentWatchPrompt(approved) {
-      const prompt = this.walletPaymentWatchPrompt
-      if (!prompt.show) return
-
-      if (!approved) {
-        this.walletPaymentWatchPrompt = this.emptyWalletPaymentWatchPrompt()
-        prompt.reject?.(new Error('Wallet payment watch permission denied.'))
-        return
-      }
-
-      try {
-        const data = await this.postExtensionPermission(
-          'wallet-payments-watch',
-          {wallet_id: prompt.walletId},
-          'Could not save permission.'
-        )
-
-        this.walletPaymentWatchPrompt = this.emptyWalletPaymentWatchPrompt()
-        prompt.resolve?.(data)
-      } catch (error) {
-        prompt.reject?.(error)
-        this.walletPaymentWatchPrompt = this.emptyWalletPaymentWatchPrompt()
-      }
-    },
-    rejectWalletPaymentWatchPrompt(message) {
-      const reject = this.walletPaymentWatchPrompt.reject
-      this.walletPaymentWatchPrompt = this.emptyWalletPaymentWatchPrompt()
-      reject?.(new Error(message))
-    },
-    positiveInteger(value, fallback) {
-      const number = Number(value)
-      if (!Number.isFinite(number) || number <= 0) return fallback
-      return Math.floor(number)
-    },
-    backgroundPaymentDestinationPolicy(value) {
-      return value === 'external_allowed'
-        ? 'external_allowed'
-        : 'own_wallets_only'
-    },
-    async postExtensionPermission(path, body, fallbackMessage) {
-      const response = await fetch(
-        `/api/v1/extension/${encodeURIComponent(
-          this.bridge.extensionId
-        )}/permissions/${path}`,
-        {
-          method: 'POST',
-          headers: {'content-type': 'application/json'},
-          credentials: 'same-origin',
-          body: JSON.stringify(body)
-        }
-      )
-      const text = await response.text()
-      let data = {}
-      if (text) {
-        try {
-          data = JSON.parse(text)
-        } catch (_error) {
-          data = {detail: text}
-        }
-      }
-      if (!response.ok) {
-        throw new Error(data?.detail || fallbackMessage)
-      }
-      return data
-    },
-    notifyApprovedPermissionUse(permissions) {
-      const permissionList = permissions.filter(Boolean).join(', ')
-      if (!permissionList) return
-      this.notify({
-        level: 'info',
-        message: `Using approved permissions: ${permissionList}.`
-      })
-    },
     requireCameraScanApproval() {
       if (this.isCameraScanRemembered()) return Promise.resolve()
       if (this.cameraPrompt.show) {
@@ -974,30 +515,6 @@ window.WasmExtensionComponent = {
           return
         }
 
-        if (message.action === 'permissions.request') {
-          this.sendResponse(reply, message.id, {
-            ok: true,
-            data: await this.requestExtensionPermissions(message)
-          })
-          return
-        }
-
-        if (message.action === 'permissions.request_background_payment') {
-          this.sendResponse(reply, message.id, {
-            ok: true,
-            data: await this.requestBackgroundPaymentPermission(message)
-          })
-          return
-        }
-
-        if (message.action === 'permissions.request_wallet_payment_watch') {
-          this.sendResponse(reply, message.id, {
-            ok: true,
-            data: await this.requestWalletPaymentWatchPermission(message)
-          })
-          return
-        }
-
         if (message.action === 'payment.subscribe') {
           this.subscribePayment(message)
           this.sendResponse(reply, message.id, {

lnbits/static/vendor.json

@@ -58,7 +58,6 @@
     "js/pages/users.js",
     "js/pages/account.js",
     "js/pages/admin.js",
-    "js/components/admin/lnbits-admin-funding-seed-backup.js",
     "js/components/admin/lnbits-admin-funding.js",
     "js/components/admin/lnbits-admin-funding-sources.js",
     "js/components/admin/lnbits-admin-fiat-providers.js",
@@ -67,8 +66,6 @@
     "js/components/admin/lnbits-admin-users.js",
     "js/components/admin/lnbits-admin-server.js",
     "js/components/admin/lnbits-admin-extensions.js",
-    "js/components/admin/lnbits-admin-wasm-runtime.js",
-    "js/components/admin/lnbits-admin-wasm-limit-config.js",
     "js/components/admin/lnbits-admin-notifications.js",
     "js/components/admin/lnbits-admin-site-customisation.js",
     "js/components/admin/lnbits-admin-assets-config.js",
@@ -92,7 +89,6 @@
     "js/components/lnbits-theme.js",
     "js/components/lnbits-qrcode-scanner.js",
     "js/components/lnbits-manage-extension-list.js",
-    "js/components/lnbits-extension-permissions.js",
     "js/components/lnbits-manage-wallet-list.js",
     "js/components/lnbits-language-dropdown.js",
     "js/components/lnbits-payment-list.js",

lnbits/task_manager.py

@@ -1,200 +0,0 @@
-import asyncio
-import traceback
-import uuid
-from collections.abc import Callable, Coroutine
-from datetime import datetime, timezone
-
-from loguru import logger
-from pydantic import BaseModel
-
-from lnbits.core.models import Payment
-from lnbits.settings import settings
-
-
-class PublicTask(BaseModel):
-    """Public model used to expose task information via the API."""
-
-    name: str
-    created_at: datetime
-
-
-class Task:
-    """Model used on the backend to keep track of background tasks."""
-
-    coro: Coroutine
-    name: str
-    created_at: datetime
-    task: asyncio.Task
-    invoice_queue: asyncio.Queue[Payment] | None = None
-
-    def __init__(
-        self,
-        coro: Coroutine,
-        name: str | None = None,
-        invoice_queue: asyncio.Queue | None = None,
-    ) -> None:
-        self.coro = coro
-        self.name = name or f"task_{uuid.uuid4()}"
-        self.created_at = datetime.now(timezone.utc)
-        self.task = asyncio.create_task(self.coro, name=self.name)
-        self.invoice_queue = invoice_queue
-
-
-class TaskManager:
-    """Singleton class to manage background tasks."""
-
-    tasks: list[Task] = []
-    invoice_queue: asyncio.Queue[Payment] = asyncio.Queue()
-    internal_invoice_queue: asyncio.Queue[Payment] = asyncio.Queue()
-
-    def init(self) -> None:
-        self.create_permanent_task(
-            func=self._heart_beat,
-            interval=settings.task_heart_beat_interval,
-        )
-        self.create_permanent_task(self._invoice_listener_consumer)
-        self.create_permanent_task(self._internal_invoice_listener_consumer)
-
-    def get_task(self, name: str) -> Task | None:
-        """Get a running task by name."""
-        for task in self.tasks:
-            if task.name == name:
-                return task
-        return None
-
-    def get_public_tasks(self) -> list[PublicTask]:
-        """Get a list of public tasks."""
-        return [PublicTask(name=t.name, created_at=t.created_at) for t in self.tasks]
-
-    def cancel_task(self, task: Task) -> None:
-        """Cancel a running task."""
-        self.tasks.remove(task)
-        try:
-            task.task.cancel()
-        except Exception as exc:
-            logger.warning(f"error while cancelling task `{task.name}`: {exc!s}")
-
-    def cancel_all_tasks(self) -> None:
-        """Cancel all running tasks."""
-        for task in list(self.tasks):
-            self.cancel_task(task)
-
-    def create_task(
-        self,
-        coro: Coroutine,
-        name: str | None = None,
-        invoice_queue: asyncio.Queue | None = None,
-    ) -> Task:
-        """Create a task. If a task with the same name exists, it will be cancelled."""
-        if name:
-            task = self.get_task(name)
-            if task:
-                self.cancel_task(task)
-        task = Task(coro=coro, name=name, invoice_queue=invoice_queue)
-        self.tasks.append(task)
-        return task
-
-    def create_permanent_task(
-        self,
-        func: Callable[[], Coroutine],
-        invoice_queue: asyncio.Queue | None = None,
-        name: str | None = None,
-        interval: int = 0,
-    ) -> Task:
-        """Create a task that runs forever and restarts on failure."""
-
-        async def wrapper():
-            while settings.lnbits_running:
-                await self._catch_everything_and_restart(func)
-                if interval > 0:
-                    await asyncio.sleep(interval)
-
-        return self.create_task(
-            coro=wrapper(), name=name or func.__name__, invoice_queue=invoice_queue
-        )
-
-    def register_invoice_listener(
-        self,
-        func: Callable[[Payment], Coroutine],
-        name: str | None = None,
-    ) -> Task:
-        """
-        A method intended for extensions to call when they want to be notified about
-        incoming payments. Will call provided Coroutine with the updated payment.
-        """
-        name = f"{name or uuid.uuid4()}_invoice_listener"
-        queue: asyncio.Queue[Payment] = asyncio.Queue()
-        return self.create_permanent_task(
-            self._invoice_listener_worker(func, queue),
-            name=name,
-            invoice_queue=queue,
-        )
-
-    async def _heart_beat(self) -> None:
-        """A heartbeat that removes done tasks logs the number of tasks."""
-        for task in self.tasks:
-            state = task.task._state if task.task else "NOT RUNNING"
-            if settings.task_heart_beat_verbose:
-                logger.debug(
-                    f"Task Manager: `{task.name}` state: `{state}` "
-                    f"created: {task.created_at.strftime('%Y-%m-%d %H:%M:%S')}`"
-                )
-            if task.task and task.task.done():
-                logger.debug(f"Task Manager: task `{task.name}` is done.")
-                self.cancel_task(task)
-        listeners_count = sum(1 for task in self.tasks if task.invoice_queue)
-        logger.debug(
-            f"Task Manager: {len(self.tasks) - listeners_count} tasks "
-            f"and {listeners_count} invoice listeners."
-        )
-
-    async def _catch_everything_and_restart(
-        self,
-        func: Callable[[], Coroutine],
-        restart_interval: int = 5,
-    ) -> None:
-        """Catches all exceptions from a function and restarts it after 5 seconds."""
-        while settings.lnbits_running:
-            try:
-                return await func()
-            except asyncio.CancelledError:
-                raise  # because we must pass this up
-            except Exception as exc:
-                if not settings.lnbits_running:
-                    return
-                logger.error(f"exception in background task `{func.__name__}`:", exc)
-                logger.error(traceback.format_exc())
-                logger.info(
-                    f"`{func.__name__}` restarts in {restart_interval} seconds."
-                )
-                await asyncio.sleep(restart_interval)
-
-    def _invoice_listener_worker(
-        self, func: Callable[[Payment], Coroutine], queue: asyncio.Queue[Payment]
-    ) -> Callable:
-        async def wrapper() -> None:
-            payment: Payment = await queue.get()
-            await func(payment)
-
-        return wrapper
-
-    def _invoice_dispatcher(self, payment: Payment) -> None:
-        """Dispatches a payment to all registered invoice listeners."""
-        for task in self.tasks:
-            if not task.invoice_queue:
-                continue
-            logger.debug(f"Enqueing payment to task {task.name}")
-            task.invoice_queue.put_nowait(payment)
-
-    async def _invoice_listener_consumer(self) -> None:
-        payment = await self.invoice_queue.get()
-        logger.info(f"got a payment notification {payment.checking_id}")
-        self._invoice_dispatcher(payment)
-
-    async def _internal_invoice_listener_consumer(self) -> None:
-        payment = await self.internal_invoice_queue.get()
-        logger.info(f"got an internal payment notification {payment.checking_id}")
-        self._invoice_dispatcher(payment)
-
-
-task_manager = TaskManager()

lnbits/tasks.py

@@ -1,83 +1,146 @@
 import asyncio
+import traceback
 import uuid
 from collections.abc import Callable, Coroutine
 
 from loguru import logger
 
 from lnbits.core.models import Payment
-from lnbits.core.services.payments import get_standalone_payment
+from lnbits.core.services.payments import (
+    get_standalone_payment,
+    update_invoice_from_paid_invoices_stream,
+)
 from lnbits.settings import settings
-from lnbits.task_manager import task_manager
+from lnbits.wallets import get_funding_source
+
+tasks: list[asyncio.Task] = []
+unique_tasks: dict[str, asyncio.Task] = {}
 
 
-# DEPRECATED: use task_manager.create_task instead.
 def create_task(coro: Coroutine) -> asyncio.Task:
-    logger.debug("DEPRECATED: use task_manager.create_task instead.")
-    return task_manager.create_task(coro).task
+    task = asyncio.create_task(coro)
+    tasks.append(task)
+    return task
 
 
-# DEPRECATED: use task_manager.create_task with `name` kwarg.
 def create_unique_task(name: str, coro: Coroutine) -> asyncio.Task:
-    logger.debug("DEPRECATED: use task_manager.create_task instead.")
-    return task_manager.create_task(coro, name=name).task
+    if unique_tasks.get(name):
+        logger.warning(f"task `{name}` already exists, cancelling it")
+        try:
+            unique_tasks[name].cancel()
+        except Exception as exc:
+            logger.warning(f"error while cancelling task `{name}`: {exc!s}")
+    task = asyncio.create_task(coro)
+    unique_tasks[name] = task
+    return task
 
 
-# DEPRECATED: use task_manager.create_permanent_task instead.
 def create_permanent_task(func: Callable[[], Coroutine]) -> asyncio.Task:
-    logger.debug("DEPRECATED: use task_manager.create_permanent_task instead.")
-    return task_manager.create_permanent_task(func).task
+    return create_task(catch_everything_and_restart(func))
 
 
-# DEPRECATED: use task_manager.create_permanent_task with `name` argument instead.
 def create_permanent_unique_task(
     name: str, coro: Callable[[], Coroutine]
 ) -> asyncio.Task:
     return create_unique_task(name, catch_everything_and_restart(coro, name))
 
 
-# DEPRECATED don't use this, use task_manager.create_permanent_task instead.
+def cancel_all_tasks() -> None:
+    for task in tasks:
+        try:
+            task.cancel()
+        except Exception as exc:
+            logger.warning(f"error while cancelling task: {exc!s}")
+    for name, task in unique_tasks.items():
+        try:
+            task.cancel()
+        except Exception as exc:
+            logger.warning(f"error while cancelling task `{name}`: {exc!s}")
+
+
 async def catch_everything_and_restart(
     func: Callable[[], Coroutine],
     name: str = "unnamed",
-) -> None:
-    _ = name
-    return await task_manager._catch_everything_and_restart(func)
+) -> Coroutine:
+    try:
+        return await func()
+    except asyncio.CancelledError:
+        raise  # because we must pass this up
+    except Exception as exc:
+        logger.error(f"exception in background task `{name}`:", exc)
+        logger.error(traceback.format_exc())
+        logger.error("will restart the task in 5 seconds.")
+        await asyncio.sleep(5)
+        return await catch_everything_and_restart(func, name)
 
 
+invoice_listeners: dict[str, asyncio.Queue] = {}
+
+
+# TODO: name should not be optional
+# some extensions still dont use a name, but they should
 def register_invoice_listener(send_chan: asyncio.Queue, name: str | None = None):
     """
-    DEPRECATED: use task_manager.register_invoice_listener instead,
-    which also allows to pass a callback instead of a queue.
-    This method will still work but it is not recommended for new code.
+    A method intended for extensions (and core/tasks.py) to call when they want to be
+    notified about new invoice payments incoming. Will emit all incoming payments.
     """
-    logger.debug("DEPRECATED: use task_manager.register_invoice_listener instead.")
-    name = f"forward_{name or str(uuid.uuid4())[:8]}"
+    if not name:
+        # fallback to a random name if extension didn't provide one
+        name = f"no_name_{str(uuid.uuid4())[:8]}"
 
-    # here we just forwarding the payments to the provided queue
-    async def forward_queue(payment: Payment):
-        send_chan.put_nowait(payment)
+    if invoice_listeners.get(name):
+        logger.warning(f"invoice listener `{name}` already exists, replacing it")
 
-    task_manager.register_invoice_listener(forward_queue, name=name)
+    logger.trace(f"registering invoice listener `{name}`")
+    invoice_listeners[name] = send_chan
+
+
+internal_invoice_queue: asyncio.Queue = asyncio.Queue(0)
 
 
 async def internal_invoice_queue_put(checking_id: str) -> None:
     """
-    DEPRECATED: use task_manager.internal_invoice_queue instead,
     A method to call when it wants to notify about an internal invoice payment.
     """
-    payment = await get_standalone_payment(checking_id, incoming=True)
-    if not payment:
-        logger.warning(f"internal_invoice_queue_put: payment {checking_id} not found")
-        return
-    await task_manager.internal_invoice_queue.put(payment)
+    await internal_invoice_queue.put(checking_id)
+
+
+async def internal_invoice_listener() -> None:
+    """
+    internal_invoice_queue will be filled directly in core/services.py
+    after the payment was deemed to be settled internally.
+
+    Called by the app startup sequence.
+    """
+    while settings.lnbits_running:
+        checking_id = await internal_invoice_queue.get()
+        logger.info(f"got an internal payment notification {checking_id}")
+        payment = await get_standalone_payment(checking_id, incoming=True)
+        if payment:
+            logger.success(f"internal invoice {checking_id} settled")
+            await invoice_callback_dispatcher(payment)
+
+
+async def invoice_listener() -> None:
+    """
+    invoice_listener will collect all invoices that come directly
+    from the backend wallet.
+
+    Called by the app startup sequence.
+    """
+    funding_source = get_funding_source()
+    async for checking_id in funding_source.paid_invoices_stream():
+        logger.info(f"got a payment notification {checking_id}")
+        payment = await update_invoice_from_paid_invoices_stream(checking_id)
+        if payment:
+            logger.success(f"fundingsource invoice {checking_id} settled")
+            await invoice_callback_dispatcher(payment)
 
 
-# DEPRECATED use task_manager.register_invoice_listener(coro, name="myext")
 def wait_for_paid_invoices(
     invoice_listener_name: str,
     func: Callable[[Payment], Coroutine],
 ) -> Callable[[], Coroutine]:
-    logger.debug("DEPRECATED: use task_manager.register_invoice_listener instead.")
 
     async def wrapper() -> None:
         invoice_queue: asyncio.Queue = asyncio.Queue()
@@ -87,3 +150,27 @@ def wait_for_paid_invoices(
             await func(payment)
 
     return wrapper
+
+
+def run_interval(
+    interval_seconds: int,
+    func: Callable[[], Coroutine],
+) -> Callable[[], Coroutine]:
+    """Run a function at a specified interval in seconds, while the server is running"""
+
+    async def wrapper() -> None:
+        while settings.lnbits_running:
+            try:
+                await func()
+            except Exception as e:
+                logger.error(f"Error occurred in interval task: {e}")
+                logger.warning(traceback.format_exc())
+            await asyncio.sleep(interval_seconds)
+
+    return wrapper
+
+
+async def invoice_callback_dispatcher(payment: Payment):
+    for name, send_chan in invoice_listeners.items():
+        logger.trace(f"invoice listeners: sending to `{name}`")
+        await send_chan.put(payment)

lnbits/templates/components.vue

@@ -1,5 +1,4 @@
-{% include('components/admin/funding_seed_backup.vue') %} {%
-include('components/admin/funding.vue') %} {%
+{% include('components/admin/funding.vue') %} {%
 include('components/admin/funding_sources.vue') %} {%
 include('components/admin/fiat_providers.vue') %} {%
 include('components/admin/exchange_providers.vue') %} {%
@@ -8,8 +7,6 @@ include('components/admin/users.vue') %} {%
 include('components/admin/site_customisation.vue') %} {%
 include('components/admin/audit.vue') %} {%
 include('components/admin/extensions.vue') %} {%
-include('components/admin/wasm-runtime.vue') %} {%
-include('components/admin/wasm-limit-config.vue') %} {%
 include('components/admin/assets-config.vue') %} {%
 include('components/admin/notifications.vue') %} {%
 include('components/admin/server.vue') %} {%
@@ -22,7 +19,6 @@ include('components/lnbits-header-wallets.vue') %} {%
 include('components/lnbits-drawer.vue') %} {%
 include('components/lnbits-home-logos.vue') %} {%
 include('components/lnbits-manage-extension-list.vue') %} {%
-include('components/lnbits-extension-permissions.vue') %} {%
 include('components/lnbits-manage-wallet-list.vue') %} {%
 include('components/lnbits-language-dropdown.vue') %} {%
 include('components/lnbits-payment-list.vue') %} {%

lnbits/templates/components/admin/exchange_providers.vue

@@ -1,46 +1,7 @@
 <template id="lnbits-admin-exchange-providers">
-  <h6 class="q-my-none q-mb-xs">LNbits Price Aggregator</h6>
-  <p class="q-mb-md text-caption text-grey">
-    A privacy-friendly, open-source Bitcoin price aggregator maintained by the
-    LNbits team. Aggregates prices from multiple exchanges and returns a median,
-    no API keys required.
-    <a href="https://price.lnbits.com" target="_blank" rel="noopener"
-      >price.lnbits.com</a
-    >
-    &mdash;
-    <a
-      href="https://github.com/lnbits/lnbits-price-aggregator"
-      target="_blank"
-      rel="noopener"
-      >GitHub</a
-    >
-  </p>
-
-  <div class="row q-mb-md items-start">
-    <div class="col-auto q-mr-md q-mt-sm">
-      <q-toggle
-        v-model="formData.lnbits_price_aggregator_enabled"
-        @update:model-value="formData.touch = null"
-        label="Use Price Aggregator"
-      >
-      </q-toggle>
-    </div>
-    <div class="col-12 col-md-7">
-      <q-input
-        filled
-        v-model="formData.lnbits_price_aggregator_url"
-        type="text"
-        label="Price Aggregator URL"
-        hint="Fetch BTC price from this aggregator instead of individual providers below."
-        :disable="!formData.lnbits_price_aggregator_enabled"
-        @update:model-value="formData.touch = null"
-      >
-      </q-input>
-    </div>
-  </div>
-
-  <q-separator class="q-my-md"></q-separator>
-  <h6 class="q-my-none q-mb-sm">Bitcoin Price History</h6>
+  <h6 class="q-my-none q-mb-sm">
+    <span v-text="$t('exchange_providers')"></span>
+  </h6>
 
   <div class="row">
     <div class="col-12 col-md-8">
@@ -92,11 +53,6 @@
     </div>
   </div>
 
-  <q-separator class="q-my-md"></q-separator>
-  <h6 class="q-my-none q-mb-sm">
-    <span v-text="$t('exchange_providers')"></span>
-  </h6>
-
   <div class="row q-mt-md">
     <div class="col-6">
       <q-btn
@@ -104,7 +60,6 @@
         label="Add Exchange Provider"
         color="primary"
         class="q-mb-md"
-        :disable="formData.lnbits_price_aggregator_enabled"
       >
       </q-btn>
     </div>
@@ -115,20 +70,12 @@
         :label="$t('reset_defaults')"
         color="primary"
         class="float-right"
-        :disable="formData.lnbits_price_aggregator_enabled"
       >
       </q-btn>
     </div>
   </div>
 
-  <div
-    class="overflow-auto"
-    :style="
-      formData.lnbits_price_aggregator_enabled
-        ? 'opacity:0.4;pointer-events:none'
-        : ''
-    "
-  >
+  <div class="overflow-auto">
     <q-table
       row-key="name"
       :rows="formData.lnbits_exchange_rate_providers"

lnbits/templates/components/admin/extensions.vue

@@ -1,11 +1,9 @@
 <template id="lnbits-admin-extensions">
   <q-card-section class="q-pa-none">
     <div>
-      <div class="row items-center justify-between q-mb-md">
-        <h6 class="q-my-none">
-          <span v-text="$t('extensions')"></span>
-        </h6>
-      </div>
+      <h6 class="q-my-none">
+        <span v-text="$t('extensions')"></span>
+      </h6>
       <div class="row q-col-gutter-md">
         <div class="col-12 q-mb-md">
           <p>
@@ -35,27 +33,6 @@
           </div>
         </div>
       </div>
-      <div class="row q-col-gutter-md">
-        <div class="col-12 q-mb-md">
-          <p>Wasm Extension</p>
-          <div class="row q-gutter-sm">
-            <q-btn
-              unelevated
-              color="primary"
-              icon="memory"
-              label="WASM Runtime"
-              to="/admin/extensions/wasm"
-            ></q-btn>
-            <q-btn
-              unelevated
-              color="primary"
-              icon="tune"
-              label="Wasm Limit Config"
-              to="/admin/extensions/wasm/limits"
-            ></q-btn>
-          </div>
-        </div>
-      </div>
       <div class="row q-col-gutter-md">
         <div class="col-12 col-md-6">
           <p>
@@ -147,15 +124,6 @@
               />
             </q-item-section>
           </q-item>
-          <q-input
-            class="q-mt-md"
-            filled
-            v-model.number="formData.lnbits_wasm_invocation_retention_days"
-            type="number"
-            min="0"
-            label="WASM invocation retention days"
-            hint="Set to 0 to disable automatic cleanup."
-          ></q-input>
           <br />
         </div>
         <div class="col-12 col-md-6">

lnbits/templates/components/admin/funding.vue

@@ -301,11 +301,5 @@
         </div>
       </div>
     </div>
-    <lnbits-admin-funding-seed-backup
-      :active="active"
-      :is-super-user="isSuperUser"
-      :form-data="formData"
-      :settings="settings"
-    ></lnbits-admin-funding-seed-backup>
   </q-card-section>
 </template>

lnbits/templates/components/admin/funding_seed_backup.vue

@@ -1,136 +0,0 @@
-<template id="lnbits-admin-funding-seed-backup">
-  <q-dialog v-model="dialog.show">
-    <q-card style="width: 760px; max-width: 95vw; border-radius: 8px">
-      <q-card-section class="q-pb-md">
-        <div class="row q-col-gutter-sm">
-          <div class="col-6">
-            <q-chip
-              square
-              class="full-width"
-              icon="looks_one"
-              :color="dialog.step === 1 ? 'primary' : 'grey-9'"
-              text-color="white"
-              label="Backup"
-            ></q-chip>
-          </div>
-          <div class="col-6">
-            <q-chip
-              square
-              class="full-width"
-              icon="looks_two"
-              :color="dialog.step === 2 ? 'primary' : 'grey-9'"
-              text-color="white"
-              label="Verify"
-            ></q-chip>
-          </div>
-        </div>
-      </q-card-section>
-
-      <q-separator></q-separator>
-
-      <q-card-section v-if="dialog.step === 1">
-        <div class="row items-center justify-between q-mb-md">
-          <div>
-            <div
-              class="text-subtitle1"
-              v-text="`${seedWords.length}-word recovery phrase`"
-            ></div>
-            <div
-              class="text-caption text-grey-5"
-              v-text="'Write these words down in order.'"
-            ></div>
-          </div>
-          <q-btn
-            outline
-            no-caps
-            color="primary"
-            :icon="dialog.visible ? 'visibility_off' : 'visibility'"
-            :label="dialog.visible ? 'Hide words' : 'Show words'"
-            @click="dialog.visible = !dialog.visible"
-          ></q-btn>
-        </div>
-
-        <div class="row q-col-gutter-sm">
-          <div
-            class="col-4 col-md-3"
-            v-for="word in seedWords"
-            :key="word.index"
-          >
-            <div
-              class="row items-center no-wrap rounded-borders"
-              style="
-                min-height: 42px;
-                border: 1px solid rgba(255, 255, 255, 0.14);
-                background: rgba(255, 255, 255, 0.035);
-              "
-            >
-              <div
-                class="text-caption text-grey-5 text-center"
-                style="
-                  width: 42px;
-                  border-right: 1px solid rgba(255, 255, 255, 0.1);
-                "
-                v-text="word.index + 1"
-              ></div>
-              <div
-                class="text-body2 text-weight-medium q-px-sm"
-                style="min-width: 0; overflow-wrap: anywhere"
-                v-text="dialog.visible ? word.word : '••••••'"
-              ></div>
-            </div>
-          </div>
-        </div>
-
-        <div class="row justify-end q-mt-lg">
-          <q-btn
-            color="primary"
-            no-caps
-            label="I have written it down"
-            @click="prepareChallenge"
-          ></q-btn>
-        </div>
-      </q-card-section>
-
-      <q-card-section v-if="dialog.step === 2">
-        <div class="q-mb-md">
-          <div class="text-subtitle1" v-text="'Confirm your backup'"></div>
-          <div
-            class="text-caption text-grey-5"
-            v-text="
-              'Enter the requested words from your written recovery phrase.'
-            "
-          ></div>
-        </div>
-
-        <div class="row q-col-gutter-md">
-          <div
-            class="col-12 col-sm-6"
-            v-for="word in dialog.challenge"
-            :key="word.index"
-          >
-            <q-input
-              v-model.trim="dialog.answers[word.index]"
-              filled
-              :label="`Word ${word.index + 1}`"
-            ></q-input>
-          </div>
-        </div>
-        <div
-          class="text-negative q-mt-sm"
-          v-if="dialog.error"
-          v-text="dialog.error"
-        ></div>
-        <div class="row justify-between q-mt-lg">
-          <q-btn flat no-caps label="Back" @click="dialog.step = 1"></q-btn>
-          <q-btn
-            color="primary"
-            icon="check"
-            no-caps
-            label="Confirm backup"
-            @click="submitChallenge"
-          ></q-btn>
-        </div>
-      </q-card-section>
-    </q-card>
-  </q-dialog>
-</template>

lnbits/templates/components/admin/wasm-limit-config.vue

@@ -1,242 +0,0 @@
-<template id="lnbits-admin-wasm-limit-config">
-  <q-card-section class="q-pa-none">
-    <div>
-      <div class="row items-center justify-between q-mb-md q-col-gutter-sm">
-        <div class="row items-center q-gutter-sm">
-          <q-btn flat dense round icon="arrow_back" :to="backRoute">
-            <q-tooltip v-text="backTooltip"></q-tooltip>
-          </q-btn>
-          <div>
-            <h6 class="q-my-none">Wasm Limit Config</h6>
-            <div
-              class="text-caption text-grey-7"
-              v-text="pageDescription"
-            ></div>
-          </div>
-        </div>
-        <q-btn-dropdown
-          unelevated
-          color="primary"
-          icon="tune"
-          label="Custom Extension Limit"
-          :loading="wasmRuntimeLimitExtensionsLoading"
-        >
-          <q-list style="min-width: 280px; max-width: min(420px, 90vw)">
-            <q-item-label header>
-              Select an extension from the list to customize
-            </q-item-label>
-            <q-item
-              v-if="
-                !wasmRuntimeLimitExtensionsLoading &&
-                wasmRuntimeLimitExtensionOptions.length === 0
-              "
-            >
-              <q-item-section>
-                <q-item-label>No installed WASM extensions found.</q-item-label>
-              </q-item-section>
-            </q-item>
-            <q-item
-              v-for="extension in wasmRuntimeLimitExtensionOptions"
-              :key="extension.value"
-              clickable
-              v-close-popup
-              @click="openWasmExtensionLimit(extension.value)"
-            >
-              <q-item-section>
-                <q-item-label v-text="extension.label"></q-item-label>
-              </q-item-section>
-            </q-item>
-          </q-list>
-        </q-btn-dropdown>
-      </div>
-
-      <template v-if="!isExtensionLimitRoute">
-        <div
-          v-for="(group, index) in wasmRuntimeLimitGroups"
-          :key="group.title"
-          class="q-mb-md"
-        >
-          <q-expansion-item
-            expand-separator
-            :default-opened="group.title === 'Execution'"
-            :label="group.title"
-            header-class="text-subtitle2 text-weight-medium"
-          >
-            <div class="row q-col-gutter-md q-pt-md">
-              <div
-                v-for="field in group.fields"
-                :key="field.name"
-                class="col-12 col-md-6"
-              >
-                <q-input
-                  filled
-                  dense
-                  type="number"
-                  min="0"
-                  v-model.number="formData[field.name]"
-                  :label="field.label"
-                  :hint="field.description"
-                >
-                  <template v-slot:append>
-                    <q-btn
-                      dense
-                      flat
-                      round
-                      icon="info"
-                      color="primary"
-                      @click.stop.prevent="showWasmLimitInfo(field)"
-                    >
-                      <q-tooltip max-width="360px">
-                        <span v-text="field.details"></span>
-                      </q-tooltip>
-                    </q-btn>
-                  </template>
-                </q-input>
-              </div>
-            </div>
-          </q-expansion-item>
-          <q-separator
-            v-if="index < wasmRuntimeLimitGroups.length - 1"
-            class="q-mt-md"
-          ></q-separator>
-        </div>
-      </template>
-
-      <div
-        v-if="isExtensionLimitRoute"
-        class="row items-center justify-between q-mb-md"
-      >
-        <div>
-          <div class="text-subtitle1 text-weight-medium">
-            Extension overrides
-          </div>
-          <div class="text-caption text-grey-7">
-            Empty values inherit the global defaults. A saved 0 disables that
-            limit for the selected extension.
-          </div>
-        </div>
-        <div v-if="selectedWasmRuntimeLimitExtension" class="col-12 col-md-7">
-          <div class="row items-center q-gutter-sm full-height">
-            <q-chip
-              dense
-              :color="
-                selectedWasmRuntimeLimitExtension.active ? 'positive' : 'grey-7'
-              "
-              text-color="white"
-              :label="
-                selectedWasmRuntimeLimitExtension.active ? 'Active' : 'Inactive'
-              "
-            ></q-chip>
-            <q-chip
-              dense
-              outline
-              color="primary"
-              :label="customWasmLimitCount + ' custom overrides'"
-            ></q-chip>
-          </div>
-        </div>
-      </div>
-
-      <q-banner
-        v-if="
-          isExtensionLimitRoute &&
-          !wasmRuntimeLimitExtensionsLoading &&
-          !selectedWasmRuntimeLimitExtension
-        "
-        rounded
-        class="bg-grey-2 text-grey-8 q-mb-lg"
-      >
-        WASM extension not found.
-      </q-banner>
-
-      <div v-if="isExtensionLimitRoute && selectedWasmRuntimeLimitExtension">
-        <div
-          v-for="(group, index) in wasmRuntimeLimitGroups"
-          :key="'extension-' + group.title"
-          class="q-mb-md"
-        >
-          <q-expansion-item
-            expand-separator
-            :default-opened="group.title === 'Execution'"
-            :label="group.title"
-            header-class="text-subtitle2 text-weight-medium"
-          >
-            <div class="row q-col-gutter-md q-pt-md">
-              <div
-                v-for="field in group.fields"
-                :key="'extension-' + field.name"
-                class="col-12 col-md-6"
-              >
-                <q-input
-                  filled
-                  dense
-                  type="number"
-                  min="0"
-                  v-model="wasmExtensionLimitDraft[field.name]"
-                  :label="field.label"
-                  :hint="wasmExtensionLimitHint(field)"
-                  :placeholder="wasmExtensionLimitPlaceholder(field)"
-                >
-                  <template v-slot:append>
-                    <q-btn
-                      dense
-                      flat
-                      round
-                      icon="info"
-                      color="primary"
-                      @click.stop.prevent="showWasmLimitInfo(field)"
-                    >
-                      <q-tooltip max-width="360px">
-                        <span v-text="field.details"></span>
-                      </q-tooltip>
-                    </q-btn>
-                  </template>
-                </q-input>
-              </div>
-            </div>
-          </q-expansion-item>
-          <q-separator
-            v-if="index < wasmRuntimeLimitGroups.length - 1"
-            class="q-mt-md"
-          ></q-separator>
-        </div>
-
-        <div class="row justify-end q-gutter-sm q-mt-md">
-          <q-btn
-            flat
-            color="primary"
-            icon="restart_alt"
-            label="Clear Overrides"
-            :disable="wasmExtensionLimitsSaving"
-            @click="clearWasmExtensionLimits"
-          ></q-btn>
-          <q-btn
-            unelevated
-            color="primary"
-            icon="save"
-            label="Save Extension Limits"
-            :loading="wasmExtensionLimitsSaving"
-            @click="saveWasmExtensionLimits"
-          ></q-btn>
-        </div>
-      </div>
-
-      <q-dialog v-model="wasmLimitInfoDialog.show">
-        <q-card style="width: min(560px, calc(100vw - 32px)); max-width: 560px">
-          <q-card-section class="row items-center q-pb-none">
-            <div class="text-h6" v-text="wasmLimitInfoDialog.title"></div>
-            <q-space></q-space>
-            <q-btn v-close-popup flat round dense icon="close"></q-btn>
-          </q-card-section>
-          <q-card-section>
-            <div
-              class="text-body1"
-              style="line-height: 1.6"
-              v-text="wasmLimitInfoDialog.details"
-            ></div>
-          </q-card-section>
-        </q-card>
-      </q-dialog>
-    </div>
-  </q-card-section>
-</template>

lnbits/templates/components/admin/wasm-runtime.vue

@@ -1,245 +0,0 @@
-<template id="lnbits-admin-wasm-runtime">
-  <q-card-section class="q-pa-none">
-    <div>
-      <div class="row items-center justify-between q-mb-md">
-        <div class="row items-center q-gutter-sm">
-          <q-btn
-            flat
-            dense
-            round
-            icon="arrow_back"
-            :to="
-              wasmExtensionId ? '/admin/extensions/wasm' : '/admin#extensions'
-            "
-          >
-            <q-tooltip
-              v-text="
-                wasmExtensionId ? 'Global WASM Runtime' : 'Extensions Settings'
-              "
-            ></q-tooltip>
-          </q-btn>
-          <div>
-            <h6 class="q-my-none">WASM Runtime</h6>
-            <div
-              v-if="wasmExtensionId"
-              class="text-caption text-grey-7"
-              v-text="`Extension: ${wasmExtensionId}`"
-            ></div>
-          </div>
-        </div>
-        <div>
-          <q-btn
-            flat
-            dense
-            icon="refresh"
-            :loading="wasmRuntimeLoading"
-            @click="fetchWasmRuntime"
-          >
-            <q-tooltip>Refresh runtime data</q-tooltip>
-          </q-btn>
-        </div>
-      </div>
-      <div class="row q-col-gutter-md q-mb-md">
-        <div
-          v-for="item in wasmStatItems"
-          :key="item.key"
-          class="col-6 col-sm-4 col-md-2"
-        >
-          <q-card flat bordered class="full-height">
-            <q-card-section class="q-pa-sm">
-              <div class="row items-center no-wrap q-gutter-sm">
-                <q-avatar
-                  rounded
-                  size="34px"
-                  :color="item.color"
-                  text-color="white"
-                  :icon="item.icon"
-                ></q-avatar>
-                <div class="col">
-                  <div
-                    class="text-caption text-grey-7"
-                    v-text="item.label"
-                  ></div>
-                  <div
-                    class="text-h6 text-weight-bold"
-                    v-text="formatWasmStat(item.key)"
-                  ></div>
-                </div>
-              </div>
-            </q-card-section>
-          </q-card>
-        </div>
-      </div>
-      <q-table
-        class="q-mb-lg"
-        dense
-        flat
-        wrap-cells
-        :rows="wasmCurrentInvocations"
-        :columns="wasmCurrentColumns"
-        row-key="id"
-        :loading="wasmRuntimeLoading"
-        :pagination="{rowsPerPage: 5}"
-        table-style="table-layout: fixed; width: 100%"
-        title="Current Invocations"
-      >
-        <template v-slot:body-cell-extension_id="props">
-          <q-td :props="props">
-            <q-btn
-              dense
-              flat
-              no-caps
-              color="primary"
-              :label="props.row.extension_id"
-              :to="`/admin/extensions/wasm/${encodeURIComponent(props.row.extension_id)}`"
-            ></q-btn>
-          </q-td>
-        </template>
-        <template v-slot:body-cell-trigger_type="props">
-          <q-td :props="props">
-            <q-badge
-              outline
-              :color="wasmTriggerColor(props.row.trigger_type)"
-              v-text="props.row.trigger_type"
-            ></q-badge>
-          </q-td>
-        </template>
-        <template v-slot:body-cell-status="props">
-          <q-td :props="props">
-            <q-badge
-              :color="wasmStatusColor(props.row.status)"
-              v-text="props.row.status"
-            ></q-badge>
-          </q-td>
-        </template>
-        <template v-slot:body-cell-user_id="props">
-          <q-td :props="props">
-            <span v-if="props.row.user_id">
-              <span v-text="formatWasmUserId(props.row.user_id)"></span>
-              <q-tooltip v-text="props.row.user_id"></q-tooltip>
-            </span>
-            <span v-else>-</span>
-          </q-td>
-        </template>
-        <template v-slot:body-cell-started_at="props">
-          <q-td
-            :props="props"
-            v-text="formatWasmDate(props.row.started_at)"
-          ></q-td>
-        </template>
-        <template v-slot:body-cell-duration_ms="props">
-          <q-td :props="props" v-text="formatWasmDuration(props.row)"></q-td>
-        </template>
-        <template v-slot:body-cell-context="props">
-          <q-td :props="props">
-            <div
-              style="white-space: normal; word-break: break-word"
-              v-text="formatWasmContext(props.row)"
-            ></div>
-          </q-td>
-        </template>
-        <template v-slot:body-cell-actions="props">
-          <q-td :props="props">
-            <div class="row justify-end q-gutter-xs">
-              <q-btn
-                dense
-                flat
-                color="negative"
-                icon="stop_circle"
-                @click="stopWasmInvocation(props.row.id)"
-              >
-                <q-tooltip>Stop Invocation</q-tooltip>
-              </q-btn>
-              <q-btn
-                dense
-                unelevated
-                color="negative"
-                label="Deactivate Extension"
-                @click="deactivateWasmExtension(props.row.extension_id)"
-              ></q-btn>
-            </div>
-          </q-td>
-        </template>
-      </q-table>
-      <q-table
-        dense
-        flat
-        wrap-cells
-        :rows="wasmInvocationHistory"
-        :columns="wasmHistoryColumns"
-        row-key="id"
-        :loading="wasmHistoryLoading"
-        :pagination="{rowsPerPage: 10}"
-        table-style="table-layout: fixed; width: 100%"
-        title="Recent Invocations"
-      >
-        <template v-slot:body-cell-extension_id="props">
-          <q-td :props="props">
-            <q-btn
-              dense
-              flat
-              no-caps
-              color="primary"
-              :label="props.row.extension_id"
-              :to="`/admin/extensions/wasm/${encodeURIComponent(props.row.extension_id)}`"
-            ></q-btn>
-          </q-td>
-        </template>
-        <template v-slot:body-cell-trigger_type="props">
-          <q-td :props="props">
-            <q-badge
-              outline
-              :color="wasmTriggerColor(props.row.trigger_type)"
-              v-text="props.row.trigger_type"
-            ></q-badge>
-          </q-td>
-        </template>
-        <template v-slot:body-cell-status="props">
-          <q-td :props="props">
-            <q-badge
-              :color="wasmStatusColor(props.row.status)"
-              v-text="props.row.status"
-            ></q-badge>
-          </q-td>
-        </template>
-        <template v-slot:body-cell-user_id="props">
-          <q-td :props="props">
-            <span v-if="props.row.user_id">
-              <span v-text="formatWasmUserId(props.row.user_id)"></span>
-              <q-tooltip v-text="props.row.user_id"></q-tooltip>
-            </span>
-            <span v-else>-</span>
-          </q-td>
-        </template>
-        <template v-slot:body-cell-started_at="props">
-          <q-td
-            :props="props"
-            v-text="formatWasmDate(props.row.started_at)"
-          ></q-td>
-        </template>
-        <template v-slot:body-cell-duration_ms="props">
-          <q-td :props="props" v-text="formatWasmDuration(props.row)"></q-td>
-        </template>
-        <template v-slot:body-cell-calls="props">
-          <q-td :props="props" v-text="formatWasmCalls(props.row)"></q-td>
-        </template>
-        <template v-slot:body-cell-context="props">
-          <q-td :props="props">
-            <div
-              style="white-space: normal; word-break: break-word"
-              v-text="formatWasmContext(props.row)"
-            ></div>
-          </q-td>
-        </template>
-        <template v-slot:body-cell-error_message="props">
-          <q-td :props="props">
-            <span
-              style="white-space: normal; word-break: break-word"
-              v-text="props.row.error_message || props.row.stop_reason || ''"
-            ></span>
-          </q-td>
-        </template>
-      </q-table>
-    </div>
-  </q-card-section>
-</template>

lnbits/templates/components/lnbits-extension-permissions.vue

@@ -1,105 +0,0 @@
-<template id="lnbits-extension-permissions">
-  <q-list bordered separator>
-    <q-expansion-item
-      v-for="permission of displayItems"
-      :key="permission.id"
-      dense
-      expand-separator
-      class="q-pt-xs"
-    >
-      <template v-slot:header>
-        <q-item-section>
-          <q-item-label class="text-weight-medium">
-            <span v-text="permission.label"></span>
-          </q-item-label>
-        </q-item-section>
-        <q-item-section
-          v-if="permission.risk.level !== 'low' || permission.badges.length"
-          side
-          top
-        >
-          <div class="row items-center justify-end q-gutter-xs">
-            <q-badge
-              v-for="badge of permission.badges"
-              :key="badge.key"
-              outline
-              color="primary"
-              v-text="badge.label"
-            ></q-badge>
-            <q-badge
-              v-if="permission.risk.level !== 'low'"
-              :color="permission.risk.color"
-              v-text="permission.risk.label"
-            ></q-badge>
-          </div>
-        </q-item-section>
-      </template>
-
-      <div class="q-px-md q-pb-sm">
-        <div
-          v-if="permission.risk.warning"
-          class="row items-center text-negative text-caption q-mb-xs"
-        >
-          <q-icon name="warning" size="16px" class="q-mr-xs"></q-icon>
-          <span v-text="permission.risk.warning"></span>
-        </div>
-        <p
-          v-for="description of permission.descriptions"
-          :key="description"
-          class="text-caption q-mb-xs"
-          v-text="description"
-        ></p>
-        <p
-          v-for="policy of permission.invoicePolicies"
-          :key="policy.table + ':' + policy.walletField"
-          class="text-caption q-mb-xs"
-          v-text="publicInvoicePolicySentence(policy)"
-        ></p>
-        <ul v-if="permission.fieldGroups.length" class="q-my-sm q-pl-md">
-          <li v-for="group of permission.fieldGroups" :key="group.table">
-            <span v-text="group.table"></span>
-            <ul v-if="group.fields.length" class="q-pl-md">
-              <li
-                v-for="field of group.fields"
-                :key="group.table + ':' + field"
-                v-text="field"
-              ></li>
-            </ul>
-          </li>
-        </ul>
-        <div v-if="permission.extensionAccess.length" class="q-mt-sm">
-          <div
-            class="text-caption text-grey"
-            v-text="$t('extension_permission_extension_api_request_extensions')"
-          ></div>
-          <div
-            v-for="target of permission.extensionAccess"
-            :key="target.id"
-            class="row items-center q-gutter-xs q-mt-xs"
-          >
-            <span class="text-caption" v-text="target.name"></span>
-            <q-badge
-              v-for="access of target.access"
-              :key="target.id + access"
-              color="grey-7"
-              v-text="permissionAccessLabel(access)"
-            ></q-badge>
-          </div>
-        </div>
-        <div v-if="permission.httpHosts.length" class="q-mt-sm">
-          <div
-            class="text-caption text-grey"
-            v-text="$t('extension_permission_http_request_hosts')"
-          ></div>
-          <ul class="q-my-sm q-pl-md">
-            <li
-              v-for="host of permission.httpHosts"
-              :key="host"
-              v-text="host"
-            ></li>
-          </ul>
-        </div>
-      </div>
-    </q-expansion-item>
-  </q-list>
-</template>

lnbits/templates/components/lnbits-wallet-api-docs.vue

@@ -6,9 +6,6 @@
     :content-inset-level="0.5"
   >
     <q-card-section>
-      <q-banner dense rounded class="bg-warning text-black q-mb-md">
-        These keys should be kept safe, sharing them could risk losing funds.
-      </q-banner>
       <q-list>
         <q-item dense class="q-pa-none">
           <q-item-section>

lnbits/templates/pages/admin.vue

@@ -74,13 +74,7 @@
     <div class="col q-gutter-y-md">
       <q-card>
         <!-- Mobile: Dropdown menu at top -->
-        <div
-          v-if="
-            $q.screen.lt.md &&
-            !['wasm-runtime', 'wasm-limit-config'].includes(tab)
-          "
-          class="q-px-md q-pt-md"
-        >
+        <div v-if="$q.screen.lt.md" class="q-px-md q-pt-md">
           <q-select
             v-model="tab"
             :options="[
@@ -205,7 +199,6 @@
                 >
                   <q-tab-panel name="funding">
                     <lnbits-admin-funding
-                      :active="tab === 'funding'"
                       :is-super-user="isSuperUser"
                       :settings="settings"
                       :form-data="formData"
@@ -226,12 +219,6 @@
                   <q-tab-panel name="extensions">
                     <lnbits-admin-extensions :form-data="formData" />
                   </q-tab-panel>
-                  <q-tab-panel name="wasm-runtime">
-                    <lnbits-admin-wasm-runtime :form-data="formData" />
-                  </q-tab-panel>
-                  <q-tab-panel name="wasm-limit-config">
-                    <lnbits-admin-wasm-limit-config :form-data="formData" />
-                  </q-tab-panel>
                   <q-tab-panel name="notifications">
                     <lnbits-admin-notifications :form-data="formData" />
                   </q-tab-panel>

lnbits/templates/pages/extensions.vue

@@ -356,7 +356,7 @@
                 @click="showManageExtension(extension)"
                 flat
                 color="primary"
-                v-if="canShowManageExtensionButton(extension)"
+                v-if="g.user.admin"
                 :label="$t('manage')"
                 ><q-tooltip
                   ><span v-text="$t('manage_extension_details')"></span
@@ -460,26 +460,37 @@
     position="top"
     @hide="onManageExtensionDialogHide"
   >
-    <q-card v-if="permissionGrant.show" class="q-pa-md lnbits__dialog-card">
+    <q-card v-if="permissionGrant.show" class="q-pa-lg lnbits__dialog-card">
       <q-card-section>
         <div class="text-h6" v-text="$t('extension_permissions_title')"></div>
-        <q-banner
-          v-if="permissionGrantHasHighRisk()"
-          dense
-          class="bg-red-1 text-red-10 q-mt-md"
-        >
-          <template v-slot:avatar>
-            <q-icon name="warning" color="negative"></q-icon>
-          </template>
-          <span v-text="$t('extension_permissions_high_risk_warning')"></span>
-        </q-banner>
+        <div
+          class="text-body2 q-mt-sm"
+          v-text="$t('extension_permissions_request')"
+        ></div>
       </q-card-section>
 
-      <lnbits-extension-permissions
-        class="q-mt-md"
-        :permissions="permissionGrant.permissions"
-        :extensions="extensions"
-      ></lnbits-extension-permissions>
+      <q-list bordered separator class="q-mt-md">
+        <q-item
+          v-for="permission of permissionGrant.permissions"
+          :key="permission.id"
+        >
+          <q-item-section>
+            <q-item-label>
+              <li><strong v-text="permissionLabel(permission)"></strong></li>
+            </q-item-label>
+            <q-item-label
+              v-if="permissionDescription(permission)"
+              caption
+              v-text="permissionDescription(permission)"
+            ></q-item-label>
+            <q-item-label
+              v-if="permissionPolicyDetails(permission)"
+              caption
+              v-text="permissionPolicyDetails(permission)"
+            ></q-item-label>
+          </q-item-section>
+        </q-item>
+      </q-list>
 
       <div class="row q-mt-lg">
         <q-btn
@@ -531,43 +542,20 @@
         </div>
       </div>
     </q-card>
-    <q-card
-      v-else
-      class="q-pa-lg lnbits__dialog-card"
-      style="width: min(95vw, 920px); max-width: 95vw"
-    >
+    <q-card v-else class="q-pa-lg lnbits__dialog-card">
       <q-tabs
         v-model="manageExtensionTab"
         active-color="primary"
         align="justify"
       >
         <q-tab
-          v-if="canShowAdminManageTabs()"
           name="releases"
           :label="$t('releases')"
           @update="val => (manageExtensionTab = val.name)"
         ></q-tab>
 
         <q-tab
-          v-if="canManageExtensionPermissions()"
-          name="extension-permissions"
-          :label="$t('extension_permissions_tab')"
-          @update="val => (manageExtensionTab = val.name)"
-        ></q-tab>
-
-        <q-tab
-          v-if="canManageExtensionPermissions()"
-          name="user-permissions"
-          :label="$t('user_permissions_tab')"
-          @update="val => (manageExtensionTab = val.name)"
-        ></q-tab>
-
-        <q-tab
-          v-if="
-            canShowAdminManageTabs() &&
-            selectedExtension &&
-            selectedExtension.isInstalled
-          "
+          v-if="selectedExtension && selectedExtension.isInstalled"
           name="sell"
           :label="$t('sell')"
           @update="val => (manageExtensionTab = val.name)"
@@ -577,7 +565,7 @@
       <div
         v-show="manageExtensionTab === 'releases'"
         class="col-12 col-md-5 q-gutter-y-md q-mt-md"
-        v-if="canShowAdminManageTabs() && selectedExtensionRepos"
+        v-if="selectedExtensionRepos"
       >
         <q-card
           flat
@@ -838,147 +826,9 @@
           ></q-btn>
         </div>
       </div>
-      <q-spinner-bars
-        v-else-if="
-          canShowAdminManageTabs() && manageExtensionTab === 'releases'
-        "
-        color="primary"
-        size="2.55em"
-      ></q-spinner-bars>
+      <q-spinner-bars v-else color="primary" size="2.55em"></q-spinner-bars>
       <div
-        v-if="canManageExtensionPermissions()"
-        v-show="manageExtensionTab === 'extension-permissions'"
-        class="col-12 col-md-5 q-gutter-y-md q-mt-md"
-      >
-        <q-spinner-bars
-          v-if="managedExtensionPermissions.loading"
-          color="primary"
-          size="2.55em"
-        ></q-spinner-bars>
-        <lnbits-extension-permissions
-          v-else-if="managedExtensionPermissions.extensionPermissions.length"
-          :permissions="managedExtensionPermissions.extensionPermissions"
-          :extensions="extensions"
-        ></lnbits-extension-permissions>
-        <q-banner v-else rounded class="bg-grey-2 text-grey-8">
-          <span v-text="$t('extension_permissions_none')"></span>
-        </q-banner>
-        <div class="row q-mt-lg">
-          <q-btn
-            v-close-popup
-            flat
-            color="grey"
-            class="q-ml-auto"
-            v-text="$t('close')"
-          ></q-btn>
-        </div>
-      </div>
-      <div
-        v-if="canManageExtensionPermissions()"
-        v-show="manageExtensionTab === 'user-permissions'"
-        class="col-12 col-md-5 q-gutter-y-md q-mt-md"
-      >
-        <q-spinner-bars
-          v-if="managedExtensionPermissions.loading"
-          color="primary"
-          size="2.55em"
-        ></q-spinner-bars>
-        <q-banner
-          v-else-if="!managedUserPermissionRows.length"
-          rounded
-          class="bg-grey-2 text-grey-8"
-        >
-          <span v-text="$t('user_permissions_none')"></span>
-        </q-banner>
-        <q-list v-else bordered separator>
-          <q-expansion-item
-            v-for="row in managedUserPermissionRows"
-            :key="row.key"
-          >
-            <template v-slot:header>
-              <q-item-section>
-                <q-item-label class="text-weight-medium">
-                  <span v-text="row.label"></span>
-                </q-item-label>
-                <q-item-label caption>
-                  <span v-text="userPermissionRowCaption(row)"></span>
-                </q-item-label>
-              </q-item-section>
-              <q-item-section side>
-                <q-btn
-                  flat
-                  dense
-                  round
-                  color="negative"
-                  icon="delete"
-                  :loading="managedExtensionPermissions.deletingKey === row.key"
-                  @click.stop="deleteUserPermissionGrant(row)"
-                >
-                  <q-tooltip>
-                    <span v-text="$t('delete')"></span>
-                  </q-tooltip>
-                </q-btn>
-              </q-item-section>
-            </template>
-            <div class="q-pa-md">
-              <div
-                v-if="isBackgroundPaymentPermission(row)"
-                class="row q-col-gutter-sm"
-              >
-                <div class="col-12 col-sm-5">
-                  <q-input
-                    dense
-                    outlined
-                    type="number"
-                    min="1"
-                    v-model.number="row.grant.max_amount"
-                    :label="$t('user_permissions_max_amount')"
-                    suffix="sat"
-                  ></q-input>
-                </div>
-                <div class="col-12 col-sm-7">
-                  <q-select
-                    dense
-                    outlined
-                    emit-value
-                    map-options
-                    v-model="row.grant.destination_policy"
-                    :options="backgroundPaymentDestinationOptions"
-                    :label="$t('user_permissions_destination_policy')"
-                  ></q-select>
-                </div>
-                <div class="col-12">
-                  <q-btn
-                    unelevated
-                    color="primary"
-                    icon="save"
-                    :loading="managedExtensionPermissions.savingKey === row.key"
-                    @click="saveUserPermissionGrant(row)"
-                  >
-                    <span v-text="$t('save')"></span>
-                  </q-btn>
-                </div>
-              </div>
-              <q-item-label v-else caption>
-                <span
-                  v-text="$t('user_permissions_no_editable_settings')"
-                ></span>
-              </q-item-label>
-            </div>
-          </q-expansion-item>
-        </q-list>
-        <div class="row q-mt-lg">
-          <q-btn
-            v-close-popup
-            flat
-            color="grey"
-            class="q-ml-auto"
-            v-text="$t('close')"
-          ></q-btn>
-        </div>
-      </div>
-      <div
-        v-if="canShowAdminManageTabs() && selectedExtension"
+        v-if="selectedExtension"
         v-show="manageExtensionTab === 'sell'"
         class="col-12 col-md-5 q-gutter-y-md q-mt-md"
       >

lnbits/templates/pages/wallet.vue

@@ -664,8 +664,7 @@
             unelevated
             color="primary"
             @click="payInvoice"
-            :disable="parse.sending"
-            :label="parse.sending ? $t('sending') + '...' : $t('pay')"
+            :label="$t('pay')"
           ></q-btn>
           <q-btn
             v-close-popup
@@ -837,13 +836,7 @@
             </div>
           </div>
           <div class="row q-mt-lg">
-            <q-btn
-              unelevated
-              color="primary"
-              type="submit"
-              :disable="parse.sending"
-              :label="parse.sending ? $t('sending') + '...' : $t('send')"
-            ></q-btn>
+            <q-btn unelevated color="primary" type="submit">Send</q-btn>
             <q-btn
               :label="$t('cancel')"
               v-close-popup

lnbits/utils/cache.py

@@ -1,8 +1,13 @@
 from __future__ import annotations
 
+import asyncio
 from time import time
 from typing import Any, NamedTuple
 
+from loguru import logger
+
+from lnbits.settings import settings
+
 
 class Cached(NamedTuple):
     value: Any
@@ -17,7 +22,8 @@ class Cache:
     Small caching utility providing simple get/set interface (very much like redis)
     """
 
-    def __init__(self) -> None:
+    def __init__(self, interval: float = 10) -> None:
+        self.interval = interval
         self._values: dict[Any, Cached] = {}
 
     def value(self, key: str) -> Cached | None:
@@ -53,11 +59,16 @@ class Cache:
             self.set(key, value, expiry=expiry)
             return value
 
-    async def invalidate_cache(self):
-        ts = time()
-        expired = [k for k, v in self._values.items() if v.expiry < ts]
-        for k in expired:
-            self._values.pop(k)
+    async def invalidate_forever(self):
+        while settings.lnbits_running:
+            try:
+                await asyncio.sleep(self.interval)
+                ts = time()
+                expired = [k for k, v in self._values.items() if v.expiry < ts]
+                for k in expired:
+                    self._values.pop(k)
+            except Exception:
+                logger.error("Error invalidating cache")
 
 
 cache = Cache()

lnbits/utils/exchange_rates.py

@@ -289,32 +289,7 @@ async def btc_rates(currency: str) -> list[tuple[str, float]]:
     return apply_trimmed_mean_filter(all_rates)
 
 
-async def btc_price_from_aggregator(currency: str) -> float | None:
-    url = settings.lnbits_price_aggregator_url.rstrip("/")
-    try:
-        headers = {"User-Agent": settings.user_agent}
-        async with httpx.AsyncClient(headers=headers) as client:
-            r = await client.get(f"{url}/rate/{currency.upper()}", timeout=3)
-            r.raise_for_status()
-            data = r.json()
-            median = data.get("rates", {}).get("median")
-            if median:
-                return float(median)
-    except Exception as e:
-        logger.warning(f"Failed to fetch price from aggregator {url}: {e}")
-    return None
-
-
 async def btc_price(currency: str) -> float:
-    if (
-        settings.lnbits_price_aggregator_enabled
-        and settings.lnbits_price_aggregator_url
-    ):
-        price = await btc_price_from_aggregator(currency)
-        if price:
-            return price
-        logger.warning("Price aggregator failed, falling back to exchange providers.")
-
     rates = await btc_rates(currency)
     if not rates:
         logger.warning("Could not fetch any Bitcoin price.")

lnbits/utils/logger.py

@@ -41,16 +41,19 @@ def log_server_info():
 
 def initialize_server_websocket_logger() -> Callable:
     super_user_hash = sha256(settings.super_user.encode("utf-8")).hexdigest()
+
     serverlog_queue: asyncio.Queue = asyncio.Queue()
+
+    async def update_websocket_serverlog():
+        while settings.lnbits_running:
+            msg = await serverlog_queue.get()
+            await websocket_updater(super_user_hash, msg)
+
     logger.add(
         lambda msg: serverlog_queue.put_nowait(msg),
         format=Formatter().format,
     )
 
-    async def update_websocket_serverlog():
-        msg = await serverlog_queue.get()
-        await websocket_updater(super_user_hash, msg)
-
     return update_websocket_serverlog
 
 

lnbits/wallets/void.py

@@ -1,3 +1,5 @@
+from collections.abc import AsyncGenerator
+
 from loguru import logger
 
 from .base import (
@@ -38,3 +40,6 @@ class VoidWallet(Wallet):
 
     async def get_payment_status(self, *_, **__) -> PaymentStatus:
         return PaymentPendingStatus()
+
+    async def paid_invoices_stream(self) -> AsyncGenerator[str, None]:
+        yield ""

package.json

@@ -111,7 +111,6 @@
       "js/pages/users.js",
       "js/pages/account.js",
       "js/pages/admin.js",
-      "js/components/admin/lnbits-admin-funding-seed-backup.js",
       "js/components/admin/lnbits-admin-funding.js",
       "js/components/admin/lnbits-admin-funding-sources.js",
       "js/components/admin/lnbits-admin-fiat-providers.js",
@@ -120,8 +119,6 @@
       "js/components/admin/lnbits-admin-users.js",
       "js/components/admin/lnbits-admin-server.js",
       "js/components/admin/lnbits-admin-extensions.js",
-      "js/components/admin/lnbits-admin-wasm-runtime.js",
-      "js/components/admin/lnbits-admin-wasm-limit-config.js",
       "js/components/admin/lnbits-admin-notifications.js",
       "js/components/admin/lnbits-admin-site-customisation.js",
       "js/components/admin/lnbits-admin-assets-config.js",
@@ -145,7 +142,6 @@
       "js/components/lnbits-theme.js",
       "js/components/lnbits-qrcode-scanner.js",
       "js/components/lnbits-manage-extension-list.js",
-      "js/components/lnbits-extension-permissions.js",
       "js/components/lnbits-manage-wallet-list.js",
       "js/components/lnbits-language-dropdown.js",
       "js/components/lnbits-payment-list.js",

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lnbits"
-version = "1.5.6"
+version = "1.5.5"
 requires-python = ">=3.10,<3.13"
 description = "LNbits, free and open-source Lightning wallet and accounts system."
 authors = [{ name = "Alan Bits", email = "alan@lnbits.com" }]

tests/api/test_admin_api.py

@@ -3,7 +3,6 @@ from pathlib import Path
 import pytest
 from httpx import AsyncClient
 
-from lnbits.core.crud.settings import get_settings_field, set_settings_field
 from lnbits.server import server_restart
 from lnbits.settings import Settings
 
@@ -82,9 +81,7 @@ async def test_admin_audit_monitor_and_test_email(
         headers={"Authorization": f"Bearer {superuser_token}"},
     )
     assert monitor.status_code == 200
-    task_names = [t["name"] for t in monitor.json()]
-    assert "core_invoice_listener" in task_names
-    assert "core_wasm_invoice_listener" in task_names
+    assert "invoice_listeners" in monitor.json()
 
     test_email = await client.get(
         "/admin/api/v1/testemail",
@@ -153,15 +150,6 @@ async def test_admin_partial_reset_restart_and_backup(
 async def test_admin_delete_settings_requires_superuser(
     client: AsyncClient, superuser_token: str
 ):
-    await set_settings_field("lnbits_site_title", "Reset me")
-    await set_settings_field("lnbits_backend_wallet_class", "BoltzWallet")
-    await set_settings_field("boltz_mnemonic", "keep boltz seed")
-    await set_settings_field("boltz_mnemonic_backup_confirmed", True)
-    await set_settings_field("phoenixd_mnemonic", "keep phoenixd seed")
-    await set_settings_field("phoenixd_mnemonic_backup_confirmed", True)
-    await set_settings_field("spark_l2_mnemonic", "keep spark seed")
-    await set_settings_field("spark_l2_mnemonic_backup_confirmed", True)
-
     server_restart.clear()
     response = await client.delete(
         "/admin/api/v1/settings",
@@ -169,21 +157,4 @@ async def test_admin_delete_settings_requires_superuser(
     )
     assert response.status_code == 200
     assert server_restart.is_set() is True
-    assert await get_settings_field("lnbits_site_title") is None
-
-    backend_wallet = await get_settings_field("lnbits_backend_wallet_class")
-    boltz_seed = await get_settings_field("boltz_mnemonic")
-    boltz_confirmed = await get_settings_field("boltz_mnemonic_backup_confirmed")
-    phoenixd_seed = await get_settings_field("phoenixd_mnemonic")
-    phoenixd_confirmed = await get_settings_field("phoenixd_mnemonic_backup_confirmed")
-    spark_l2_seed = await get_settings_field("spark_l2_mnemonic")
-    spark_l2_confirmed = await get_settings_field("spark_l2_mnemonic_backup_confirmed")
-    assert backend_wallet and backend_wallet.value == "BoltzWallet"
-    assert boltz_seed and boltz_seed.value == "keep boltz seed"
-    assert boltz_confirmed and boltz_confirmed.value is True
-    assert phoenixd_seed and phoenixd_seed.value == "keep phoenixd seed"
-    assert phoenixd_confirmed and phoenixd_confirmed.value is True
-    assert spark_l2_seed and spark_l2_seed.value == "keep spark seed"
-    assert spark_l2_confirmed and spark_l2_confirmed.value is True
-
     server_restart.clear()

tests/api/test_extension_api.py

@@ -1,6 +1,3 @@
-import json
-import zipfile
-from pathlib import Path
 from types import SimpleNamespace
 from uuid import uuid4
 
@@ -11,7 +8,6 @@ from starlette.requests import Request
 from lnbits.core.crud.db_versions import get_db_version, update_migration_version
 from lnbits.core.crud.extensions import (
     create_installed_extension,
-    delete_installed_extension,
     get_installed_extension,
     get_user_extension,
 )
@@ -23,14 +19,11 @@ from lnbits.core.models.extensions import (
     CreateExtensionReview,
     Extension,
     ExtensionConfig,
-    ExtensionPermission,
     ExtensionRelease,
     InstallableExtension,
     PayToEnableInfo,
     ReleasePaymentInfo,
     UserExtensionInfo,
-    WasmRuntimeLimitsUpdate,
-    wasm_extension_icon_url,
 )
 from lnbits.core.models.users import AccountId
 from lnbits.core.services.payments import create_wallet_invoice
@@ -42,11 +35,9 @@ from lnbits.core.views.extension_api import (
     api_enable_extension,
     api_extension_details,
     api_get_user_extensions,
-    api_get_wasm_runtime_limit_extensions,
     api_install_extension,
     api_uninstall_extension,
     api_update_pay_to_enable,
-    api_update_wasm_runtime_limits,
     create_extension_review,
     delete_extension_db,
     extensions,
@@ -171,147 +162,6 @@ async def test_extension_api_install_details_and_release_endpoints(mocker):
     assert release_info["is_version_compatible"] is True
 
 
-@pytest.mark.anyio
-async def test_extension_api_installs_wasm_with_granted_permissions(
-    tmp_path,
-    settings,
-    mocker,
-):
-    ext_id = f"wasm_{uuid4().hex[:8]}"
-    release = make_extension_release(ext_id)
-    granted_permissions = [
-        ExtensionPermission(
-            id="http.request",
-            policies=[{"host": "https://api.example.com"}],
-        )
-    ]
-    create_data = CreateExtension(
-        ext_id=ext_id,
-        archive=release.archive,
-        source_repo=release.source_repo,
-        version=release.version,
-        permissions=granted_permissions,
-    )
-    original_data_folder = settings.lnbits_data_folder
-    original_extensions_path = settings.lnbits_extensions_path
-    register_wasm_routes_mock = mocker.patch(
-        "lnbits.core.services.extensions.core_app_extra.register_new_wasm_ext_routes"
-    )
-    mocker.patch.object(
-        InstallableExtension,
-        "get_extension_release",
-        mocker.AsyncMock(return_value=release),
-    )
-    mocker.patch.object(
-        InstallableExtension,
-        "download_archive",
-        mocker.AsyncMock(),
-    )
-
-    try:
-        settings.lnbits_data_folder = str(tmp_path / "data")
-        settings.lnbits_extensions_path = str(tmp_path / "code")
-        _write_wasm_extension_archive(ext_id, release.version, settings)
-
-        installed = await api_install_extension(create_data)
-        stored = await get_installed_extension(ext_id)
-    finally:
-        await delete_installed_extension(ext_id=ext_id)
-        settings.lnbits_data_folder = original_data_folder
-        settings.lnbits_extensions_path = original_extensions_path
-
-    assert installed.code == ext_id
-    assert installed.is_wasm is True
-    assert stored is not None
-    assert stored.permissions == [
-        ExtensionPermission(
-            id="http.request",
-            description="Call example API.",
-            policies=[{"host": "https://api.example.com"}],
-        )
-    ]
-    register_wasm_routes_mock.assert_called_once_with(ext_id)
-
-
-@pytest.mark.anyio
-async def test_extension_api_wasm_runtime_limits_and_catalog_use_installed_metadata(
-    tmp_path,
-    settings,
-    mocker,
-):
-    ext_id = f"wasm_{uuid4().hex[:8]}"
-    py_ext_id = f"py_{uuid4().hex[:8]}"
-    granted_permissions = [
-        ExtensionPermission(
-            id="http.request",
-            description="Call example API.",
-            policies=[{"host": "https://api.example.com"}],
-        )
-    ]
-    original_extensions_path = settings.lnbits_extensions_path
-
-    try:
-        settings.lnbits_extensions_path = str(tmp_path)
-        _write_installed_wasm_config(ext_id, tmp_path)
-        await create_installed_extension(
-            InstallableExtension(
-                id=ext_id,
-                name="WASM Demo",
-                version="1.0.0",
-                active=True,
-                permissions=granted_permissions,
-                wasm_runtime_limits={"wasm_runtime_max_execution_ms": 1234},
-            )
-        )
-        await create_installed_extension(make_installable_extension(py_ext_id))
-
-        runtime_extensions = await api_get_wasm_runtime_limit_extensions()
-        wasm_info = next(info for info in runtime_extensions if info.id == ext_id)
-
-        updated_info = await api_update_wasm_runtime_limits(
-            ext_id,
-            WasmRuntimeLimitsUpdate(
-                limits={
-                    "wasm_runtime_max_execution_ms": "2345",
-                    "wasm_runtime_max_fuel": 0,
-                }
-            ),
-        )
-        stored = await get_installed_extension(ext_id)
-
-        mocker.patch.object(
-            InstallableExtension,
-            "get_installable_extensions",
-            mocker.AsyncMock(
-                return_value=[
-                    make_installable_extension(ext_id),
-                    make_installable_extension(py_ext_id),
-                ]
-            ),
-        )
-        catalog = await extensions(AccountId(id=uuid4().hex))
-    finally:
-        await delete_installed_extension(ext_id=ext_id)
-        await delete_installed_extension(ext_id=py_ext_id)
-        settings.lnbits_extensions_path = original_extensions_path
-
-    assert wasm_info.wasm_runtime_limits == {"wasm_runtime_max_execution_ms": 1234}
-    assert py_ext_id not in {info.id for info in runtime_extensions}
-    assert updated_info.wasm_runtime_limits == {
-        "wasm_runtime_max_execution_ms": 2345,
-        "wasm_runtime_max_fuel": 0,
-    }
-    assert stored is not None
-    assert stored.wasm_runtime_limits == updated_info.wasm_runtime_limits
-
-    catalog_item = next(item for item in catalog if item["id"] == ext_id)
-    assert catalog_item["isWasm"] is True
-    assert catalog_item["icon"] == wasm_extension_icon_url(ext_id)
-    assert catalog_item["permissions"] == [
-        dict(permission) for permission in granted_permissions
-    ]
-
-
 @pytest.mark.anyio
 async def test_extension_api_pay_to_enable_and_catalog_views(mocker, admin_user):
     regular_user = await create_user_account(
@@ -578,40 +428,3 @@ async def test_extension_api_review_endpoints(mocker):
         CreateExtensionReview(tag=ext_id, name="Alice", rating=900, comment="Great")
     )
     assert payment_request.payment_hash.startswith("hash_")
-
-
-def _write_wasm_extension_archive(ext_id: str, version: str, settings) -> None:
-    zip_path = Path(settings.lnbits_data_folder, "zips", f"{ext_id}.zip")
-    zip_path.parent.mkdir(parents=True, exist_ok=True)
-    config = _wasm_config(ext_id)
-    root = f"{ext_id}-{version}"
-    with zipfile.ZipFile(zip_path, "w") as archive:
-        archive.writestr(f"{root}/config.json", json.dumps(config))
-        archive.writestr(f"{root}/{config['wasm']['module']}", b"\0asm")
-
-
-def _write_installed_wasm_config(ext_id: str, extensions_path) -> None:
-    config_dir = extensions_path / "extensions" / ext_id
-    config_dir.mkdir(parents=True)
-    (config_dir / "config.json").write_text(
-        json.dumps(_wasm_config(ext_id)),
-        encoding="utf-8",
-    )
-
-
-def _wasm_config(ext_id: str) -> dict:
-    return {
-        "id": ext_id,
-        "name": "WASM Demo",
-        "short_description": "WASM extension",
-        "version": "1.0.0",
-        "extension_type": "wasm",
-        "wasm": {"module": "extension.wasm"},
-        "permissions": [
-            {
-                "id": "http.request",
-                "description": "Call example API.",
-                "policies": [{"host": "https://api.example.com"}],
-            }
-        ],
-    }

tests/conftest.py

@@ -89,7 +89,7 @@ def run_before_and_after_tests(settings: Settings):
 @pytest.fixture(scope="session")
 async def app(settings: Settings):
     app = create_app()
-    async with LifespanManager(app, startup_timeout=30) as manager:
+    async with LifespanManager(app) as manager:
         settings.first_install = True
         await first_install(
             UpdateSuperuserPassword(