refactor: extract functions

lnbits/core/extensions/api.py

@@ -26,6 +26,8 @@ from .models import (
     LogRequest,
     LogResponse,
     NowResponse,
+    PayInvoiceRequest,
+    PayInvoiceResponse,
     RandomIdRequest,
     RandomIdResponse,
     StorageDeleteRequest,
@@ -37,6 +39,8 @@ from .models import (
     StorageSetRequest,
     StorageSetResponse,
     UserWalletSummary,
+    WalletBalanceRequest,
+    WalletBalanceResponse,
 )
 from .storage import (
     storage_delete_row,
@@ -49,6 +53,7 @@ from .storage import (
 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)
 
@@ -58,6 +63,7 @@ class ExtensionAPIMethodExport:
     method_id: str
     namespace: str
     name: str
+    host_interface: str
     host_name: str
     sdk_name: str
     description: str
@@ -71,6 +77,7 @@ class ExtensionAPIMethod:
     namespace: str
     name: str
     python_name: str
+    host_interface: str
     host_name: str
     sdk_name: str
     description: str
@@ -92,16 +99,18 @@ def extension_api_method(
     host_name: str,
     sdk_name: str,
     description: str,
+    host_interface: str = "host",
     required_permission: str | None = None,
     require_auth: bool = True,
 ) -> Callable[
-    [Callable[[ExtensionAPI, _RequestModel], Awaitable[_ResponseModel]]],
-    Callable[[ExtensionAPI, _RequestModel], Awaitable[_ResponseModel]],
+    [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,
@@ -110,15 +119,16 @@ def extension_api_method(
     )
 
     def decorator(
-        function: Callable[[ExtensionAPI, _RequestModel], Awaitable[_ResponseModel]],
-    ) -> Callable[[ExtensionAPI, _RequestModel], Awaitable[_ResponseModel]]:
+        function: Callable[[Any, _RequestModel], Awaitable[_ResponseModel]],
+    ) -> Callable[[Any, _RequestModel], Awaitable[_ResponseModel]]:
         @wraps(function)
-        async def wrapper(self: ExtensionAPI, request: _RequestModel) -> _ResponseModel:
-            if require_auth and not self.has_authenticated_context():
+        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."
                 )
-            self.require_permission(required_permission)
+            api.require_permission(required_permission)
             return await function(self, request)
 
         setattr(wrapper, _EXTENSION_API_METHOD_ATTR, export)
@@ -134,15 +144,20 @@ class ExtensionAPI:
         permissions: Iterable[Any],
         *,
         user_id: str | None = None,
+        access_token: str | None = None,
         context: str = "user",
         owner_id: str | None = None,
     ) -> None:
         self.extension_id = extension_id
         self.permissions, self.permission_policies = self._permission_data(permissions)
         self.user_id = user_id
+        self.access_token = access_token
         self.context = context
         self.owner_id = sha256s(user_id) if user_id else owner_id
         self._uuid = secrets.token_urlsafe(12).replace("-", "_")
+        from .api_utils import ExtensionAPIUtils
+
+        self.utils = ExtensionAPIUtils(self)
 
     def __repr__(self) -> str:
         return (
@@ -311,8 +326,8 @@ class ExtensionAPI:
         payment = await create_payment_request(
             request.wallet_id,
             CreateInvoice(
-                amount=request.amount_sat,
-                unit=request.currency or "sat",
+                amount=request.amount,
+                unit=request.currency,
                 memo=request.memo,
                 extra=request.extra,
                 extension=self.extension_id,
@@ -400,6 +415,92 @@ class ExtensionAPI:
             ]
         )
 
+    @extension_api_method(
+        method_id="wallet.balance",
+        namespace="wallet",
+        name="Read wallet balance",
+        host_name="wallet_balance",
+        sdk_name="balance",
+        description="Read the balance of a wallet available to the user.",
+        required_permission="wallet.balance.read",
+    )
+    async def wallet_balance(
+        self, request: WalletBalanceRequest
+    ) -> WalletBalanceResponse:
+        from lnbits.core.crud.wallets import get_wallet
+
+        if not self.user_id:
+            raise PermissionError(
+                "Reading a wallet balance requires an authenticated user context."
+            )
+
+        wallet = await get_wallet(request.wallet_id)
+        if wallet is None or wallet.user != self.user_id:
+            raise PermissionError("Reading this wallet balance is not allowed.")
+
+        withdrawable_msat = max(wallet.withdrawable_balance, 0)
+        fee_reserve_msat = max(wallet.balance_msat - withdrawable_msat, 0)
+        return WalletBalanceResponse(
+            wallet_id=wallet.id,
+            name=wallet.name,
+            currency=wallet.currency,
+            balance_msat=wallet.balance_msat,
+            balance_sat=wallet.balance,
+            withdrawable_msat=withdrawable_msat,
+            withdrawable_sat=withdrawable_msat // 1000,
+            fee_reserve_msat=fee_reserve_msat,
+            fee_reserve_sat=fee_reserve_msat // 1000,
+            can_send_payments=wallet.can_send_payments,
+        )
+
+    @extension_api_method(
+        method_id="wallet.pay_invoice",
+        namespace="wallet",
+        name="Pay invoice",
+        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
+    ) -> PayInvoiceResponse:
+        from lnbits.core.crud.wallets import get_wallet
+        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 or wallet.user != self.user_id:
+            raise PermissionError("Paying invoices from this wallet is not allowed.")
+
+        try:
+            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,
+            )
+        except (PaymentError, ValueError) as exc:
+            return PayInvoiceResponse(ok=False, error=str(exc))
+
+        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",
         namespace="http",
@@ -434,6 +535,7 @@ class ExtensionAPI:
             self.extension_id,
             policy,
             self.user_id,
+            self.access_token,
             request,
         )
 
@@ -551,39 +653,54 @@ def list_extension_api_methods(
 ) -> list[ExtensionAPIMethod]:
     methods: list[ExtensionAPIMethod] = []
 
-    for python_name, function in inspect.getmembers(api_cls, inspect.isfunction):
-        export = getattr(function, _EXTENSION_API_METHOD_ATTR, None)
-        if not export:
-            continue
+    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=python_name,
-                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,
+            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_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]:
-    return {
+    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(
@@ -607,6 +724,7 @@ def extension_api_contract(
                 "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,

lnbits/core/extensions/api_utils.py

@@ -0,0 +1,381 @@
+from __future__ import annotations
+
+import time
+from datetime import datetime
+from typing import TYPE_CHECKING, Any
+
+from .api import extension_api_method
+from .models import (
+    Bolt11Request,
+    CurrencyConvertRequest,
+    CurrencyConvertResponse,
+    CurrencyListResponse,
+    CurrencyRateRequest,
+    CurrencyRateResponse,
+    DecodeInvoiceResponse,
+    EmptyRequest,
+    FiatToSatsRequest,
+    FiatToSatsResponse,
+    InvoiceAmountMsatResponse,
+    InvoiceExpiryResponse,
+    InvoiceMemoResponse,
+    InvoicePaymentHashResponse,
+    RandomSecretAndHashRequest,
+    RandomSecretAndHashResponse,
+    SatsToFiatRequest,
+    SatsToFiatResponse,
+    ServerHealthResponse,
+    ValidateInvoiceResponse,
+    VerifyPreimageRequest,
+    VerifyPreimageResponse,
+)
+
+if TYPE_CHECKING:
+    from .api import ExtensionAPI
+
+
+class ExtensionAPIUtils:
+    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, api: ExtensionAPI) -> None:
+        self.api = api
+
+
+class ExtensionCurrencyUtils(_ExtensionAPIUtilsGroup):
+    @extension_api_method(
+        method_id="utils.currencies.list",
+        namespace="utils.currencies",
+        name="List currencies",
+        host_interface="utils-currencies",
+        host_name="list_currencies",
+        sdk_name="list",
+        description="List currencies supported by LNbits exchange-rate conversion.",
+        required_permission="utils.basic",
+        require_auth=False,
+    )
+    async def list(self, request: EmptyRequest) -> CurrencyListResponse:
+        from lnbits.utils.exchange_rates import allowed_currencies
+
+        return CurrencyListResponse(currencies=allowed_currencies())
+
+    @extension_api_method(
+        method_id="utils.currencies.rate",
+        namespace="utils.currencies",
+        name="Get currency rate",
+        host_interface="utils-currencies",
+        host_name="rate",
+        sdk_name="rate",
+        description="Get sats-per-fiat and BTC price for a currency.",
+        required_permission="utils.basic",
+        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)
+
+    @extension_api_method(
+        method_id="utils.currencies.convert",
+        namespace="utils.currencies",
+        name="Convert currency amount",
+        host_interface="utils-currencies",
+        host_name="convert",
+        sdk_name="convert",
+        description="Convert between sats, BTC, and supported fiat currencies.",
+        required_permission="utils.basic",
+        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":
+            from_currency = "sat"
+
+        amounts: list[tuple[str, float]] = []
+        if from_currency == "sat":
+            sats = int(request.amount)
+            amounts.append(("BTC", sats / 100_000_000))
+            amounts.append(("sats", sats))
+            for currency in request.to.split(","):
+                currency = currency.strip()
+                if currency:
+                    amounts.append(
+                        (
+                            currency.upper(),
+                            await satoshis_amount_as_fiat(sats, currency),
+                        )
+                    )
+        else:
+            sats = await fiat_amount_as_satoshis(request.amount, from_currency)
+            amounts.append((from_currency.upper(), request.amount))
+            amounts.append(("sats", sats))
+            amounts.append(("BTC", sats / 100_000_000))
+        return CurrencyConvertResponse(amounts=amounts)
+
+    @extension_api_method(
+        method_id="utils.currencies.fiat_to_sats",
+        namespace="utils.currencies",
+        name="Convert fiat to sats",
+        host_interface="utils-currencies",
+        host_name="fiat_to_sats",
+        sdk_name="fiatToSats",
+        description="Convert a fiat amount to sats.",
+        required_permission="utils.basic",
+        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(
+                request.amount,
+                request.currency,
+            )
+        )
+
+    @extension_api_method(
+        method_id="utils.currencies.sats_to_fiat",
+        namespace="utils.currencies",
+        name="Convert sats to fiat",
+        host_interface="utils-currencies",
+        host_name="sats_to_fiat",
+        sdk_name="satsToFiat",
+        description="Convert a sats amount to fiat.",
+        required_permission="utils.basic",
+        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)
+        )
+
+
+class ExtensionServerUtils(_ExtensionAPIUtilsGroup):
+    @extension_api_method(
+        method_id="utils.server.health",
+        namespace="utils.server",
+        name="Server health",
+        host_interface="utils-server",
+        host_name="health",
+        sdk_name="health",
+        description="Return basic public LNbits server health data.",
+        required_permission="utils.basic",
+        require_auth=False,
+    )
+    async def health(self, request: EmptyRequest) -> ServerHealthResponse:
+        from lnbits.settings import settings
+
+        return ServerHealthResponse(
+            server_time=int(time.time()),
+            up_time=settings.lnbits_server_up_time,
+        )
+
+
+class ExtensionLightningUtils(_ExtensionAPIUtilsGroup):
+    @extension_api_method(
+        method_id="utils.lightning.decode_invoice",
+        namespace="utils.lightning",
+        name="Decode Lightning invoice",
+        host_interface="utils-lightning",
+        host_name="decode_invoice",
+        sdk_name="decodeInvoice",
+        description="Decode a BOLT11 Lightning invoice.",
+        required_permission="utils.basic",
+        require_auth=False,
+    )
+    async def decode_invoice(self, request: Bolt11Request) -> DecodeInvoiceResponse:
+        invoice = _decode_bolt11(request.bolt11)
+        return _decoded_invoice_response(invoice)
+
+    @extension_api_method(
+        method_id="utils.lightning.validate_invoice",
+        namespace="utils.lightning",
+        name="Validate Lightning invoice",
+        host_interface="utils-lightning",
+        host_name="validate_invoice",
+        sdk_name="validateInvoice",
+        description="Validate whether a string is a BOLT11 Lightning invoice.",
+        required_permission="utils.basic",
+        require_auth=False,
+    )
+    async def validate_invoice(self, request: Bolt11Request) -> ValidateInvoiceResponse:
+        try:
+            _decode_bolt11(request.bolt11)
+            return ValidateInvoiceResponse(valid=True)
+        except Exception as exc:
+            return ValidateInvoiceResponse(valid=False, error=str(exc))
+
+    @extension_api_method(
+        method_id="utils.lightning.invoice_payment_hash",
+        namespace="utils.lightning",
+        name="Get Lightning invoice payment hash",
+        host_interface="utils-lightning",
+        host_name="invoice_payment_hash",
+        sdk_name="invoicePaymentHash",
+        description="Get the payment hash from a BOLT11 Lightning invoice.",
+        required_permission="utils.basic",
+        require_auth=False,
+    )
+    async def invoice_payment_hash(
+        self, request: Bolt11Request
+    ) -> InvoicePaymentHashResponse:
+        return InvoicePaymentHashResponse(
+            payment_hash=str(_decode_bolt11(request.bolt11).payment_hash)
+        )
+
+    @extension_api_method(
+        method_id="utils.lightning.invoice_amount_msat",
+        namespace="utils.lightning",
+        name="Get Lightning invoice amount",
+        host_interface="utils-lightning",
+        host_name="invoice_amount_msat",
+        sdk_name="invoiceAmountMsat",
+        description="Get the amount in msat from a BOLT11 Lightning invoice.",
+        required_permission="utils.basic",
+        require_auth=False,
+    )
+    async def invoice_amount_msat(
+        self, request: Bolt11Request
+    ) -> InvoiceAmountMsatResponse:
+        return InvoiceAmountMsatResponse(
+            amount_msat=_invoice_amount_msat(_decode_bolt11(request.bolt11))
+        )
+
+    @extension_api_method(
+        method_id="utils.lightning.invoice_expiry",
+        namespace="utils.lightning",
+        name="Get Lightning invoice expiry",
+        host_interface="utils-lightning",
+        host_name="invoice_expiry",
+        sdk_name="invoiceExpiry",
+        description="Get the expiry timestamp from a BOLT11 Lightning invoice.",
+        required_permission="utils.basic",
+        require_auth=False,
+    )
+    async def invoice_expiry(self, request: Bolt11Request) -> InvoiceExpiryResponse:
+        return InvoiceExpiryResponse(
+            expires_at=_invoice_expires_at(_decode_bolt11(request.bolt11))
+        )
+
+    @extension_api_method(
+        method_id="utils.lightning.invoice_memo",
+        namespace="utils.lightning",
+        name="Get Lightning invoice memo",
+        host_interface="utils-lightning",
+        host_name="invoice_memo",
+        sdk_name="invoiceMemo",
+        description="Get the memo from a BOLT11 Lightning invoice.",
+        required_permission="utils.basic",
+        require_auth=False,
+    )
+    async def invoice_memo(self, request: Bolt11Request) -> InvoiceMemoResponse:
+        return InvoiceMemoResponse(memo=_invoice_memo(_decode_bolt11(request.bolt11)))
+
+    @extension_api_method(
+        method_id="utils.lightning.verify_preimage",
+        namespace="utils.lightning",
+        name="Verify Lightning preimage",
+        host_interface="utils-lightning",
+        host_name="verify_preimage",
+        sdk_name="verifyPreimage",
+        description="Verify that a preimage matches a payment hash.",
+        required_permission="utils.basic",
+        require_auth=False,
+    )
+    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)
+        )
+
+    @extension_api_method(
+        method_id="utils.lightning.random_secret_and_hash",
+        namespace="utils.lightning",
+        name="Random Lightning secret and hash",
+        host_interface="utils-lightning",
+        host_name="random_secret_and_hash",
+        sdk_name="randomSecretAndHash",
+        description="Create a random secret and matching SHA256 hash.",
+        required_permission="utils.basic",
+        require_auth=False,
+    )
+    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)
+
+
+def extension_api_utils_method_classes() -> dict[str, type[_ExtensionAPIUtilsGroup]]:
+    return {
+        "utils.currencies": ExtensionCurrencyUtils,
+        "utils.server": ExtensionServerUtils,
+        "utils.lightning": ExtensionLightningUtils,
+    }
+
+
+def _decode_bolt11(payment_request: str) -> Any:
+    from lnbits import bolt11
+
+    return bolt11.decode(payment_request)
+
+
+def _decoded_invoice_response(invoice: Any) -> DecodeInvoiceResponse:
+    return DecodeInvoiceResponse(
+        payment_hash=str(getattr(invoice, "payment_hash", "")) or None,
+        amount_msat=_invoice_amount_msat(invoice),
+        expiry=_invoice_expiry(invoice),
+        expires_at=_invoice_expires_at(invoice),
+        memo=_invoice_memo(invoice),
+    )
+
+
+def _invoice_amount_msat(invoice: Any) -> int | None:
+    amount_msat = getattr(invoice, "amount_msat", None)
+    if amount_msat is None:
+        return None
+    return int(amount_msat)
+
+
+def _invoice_expiry(invoice: Any) -> int | None:
+    expiry = getattr(invoice, "expiry", None)
+    if expiry is None:
+        return None
+    return int(expiry)
+
+
+def _invoice_expires_at(invoice: Any) -> int | None:
+    expiry_date = getattr(invoice, "expiry_date", None)
+    if isinstance(expiry_date, datetime):
+        return int(expiry_date.timestamp())
+
+    date = getattr(invoice, "date", None)
+    expiry = getattr(invoice, "expiry", None)
+    if isinstance(date, datetime) and expiry is not None:
+        return int(date.timestamp() + int(expiry))
+    if isinstance(date, (int, float)) and expiry is not None:
+        return int(date + int(expiry))
+    return None
+
+
+def _invoice_memo(invoice: Any) -> str | None:
+    memo = getattr(invoice, "description", None)
+    return str(memo) if memo is not None else None

lnbits/core/extensions/extension_client.py

@@ -11,7 +11,6 @@ from lnbits.core.crud.extensions import (
     get_installed_extension,
     get_user_active_extensions_ids,
 )
-from lnbits.core.crud.wallets import get_wallets
 from lnbits.settings import settings
 
 from .models import ExtensionApiRequest, HttpResponse
@@ -34,17 +33,19 @@ async def send_extension_api_request(
     caller_extension_id: str,
     policy: dict[str, Any],
     user_id: str | None,
+    access_token: str | None,
     request: ExtensionApiRequest,
 ) -> HttpResponse:
     if not user_id:
         raise PermissionError("Extension API requests require authentication.")
+    if not access_token:
+        raise PermissionError("Extension API requests require an account access token.")
 
     target_extension_id = _target_extension_id(request.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)
 
-    api_key = await _user_api_key(user_id, request.method)
     path = _extension_api_path(request.path)
     body = request.body.encode() if request.body is not None else b""
     if len(body) > 65_536:
@@ -60,7 +61,7 @@ async def send_extension_api_request(
             async with client.stream(
                 request.method,
                 url,
-                headers={"X-API-KEY": api_key},
+                headers={"Authorization": f"Bearer {access_token}"},
                 content=body,
             ) as response:
                 response_body = await _read_limited_response(response)
@@ -94,17 +95,22 @@ def _target_extension_access(
             extension_id = extension
             access = ["read"]
         elif isinstance(extension, dict):
-            extension_id = extension.get("id")
-            access = extension.get("access")
+            raw_extension_id = extension.get("id")
+            raw_access = extension.get("access")
+            if not isinstance(raw_extension_id, str):
+                continue
+            if not isinstance(raw_access, list):
+                raise PermissionError(
+                    f"Extension API target '{target_extension_id}' "
+                    "has no access policy."
+                )
+            extension_id = raw_extension_id
+            access = raw_access
         else:
             continue
 
         if extension_id != target_extension_id:
             continue
-        if not isinstance(access, list):
-            raise PermissionError(
-                f"Extension API target '{target_extension_id}' has no access policy."
-            )
         clean_access = {
             item
             for item in access
@@ -153,14 +159,6 @@ async def _require_enabled_extension(target_extension_id: str, user_id: str) ->
         )
 
 
-async def _user_api_key(user_id: str, method: str) -> str:
-    wallets = await get_wallets(user_id)
-    if not wallets:
-        raise PermissionError("Extension API request requires a user wallet.")
-    wallet = wallets[0]
-    return wallet.inkey if method in _READ_METHODS else wallet.adminkey
-
-
 def _extension_api_path(path: str) -> str:
     parts = urlsplit(path)
     if parts.scheme or parts.netloc:

lnbits/core/extensions/models.py

@@ -74,9 +74,8 @@ class StorageDeleteResponse(BaseModel):
 
 class CreateInvoiceRequest(BaseModel):
     wallet_id: str = Field(..., min_length=1, max_length=128)
-    amount_sat: int = Field(..., gt=0)
-    # todo: bridge for extensions to select currencies
-    currency: str | None = Field(..., min_length=1, max_length=8)
+    amount: float = Field(..., gt=0)
+    currency: str = Field("sat", min_length=1, max_length=8)
     memo: str = Field(..., max_length=512)
     tag: str = Field(..., min_length=1, max_length=64)
     extra: dict[str, str] = Field(default_factory=dict)
@@ -118,6 +117,43 @@ class ListUserWalletsResponse(BaseModel):
     wallets: list[UserWalletSummary] = Field(default_factory=list)
 
 
+class WalletBalanceRequest(BaseModel):
+    wallet_id: str = Field(..., min_length=1, max_length=128)
+
+
+class WalletBalanceResponse(BaseModel):
+    wallet_id: str
+    name: str
+    currency: str | None = None
+    balance_msat: int
+    balance_sat: int
+    withdrawable_msat: int
+    withdrawable_sat: int
+    fee_reserve_msat: int
+    fee_reserve_sat: int
+    can_send_payments: bool
+
+
+class PayInvoiceRequest(BaseModel):
+    wallet_id: str = Field(..., min_length=1, max_length=128)
+    payment_request: str = Field(..., min_length=1, max_length=8192)
+    max_sat: int | None = Field(None, gt=0)
+    description: str = Field("", max_length=512)
+    extra: dict[str, str] = Field(default_factory=dict)
+
+
+class PayInvoiceResponse(BaseModel):
+    ok: bool = True
+    error: str | None = None
+    checking_id: str | None = None
+    payment_hash: str | None = None
+    status: str | None = None
+    amount_msat: int = 0
+    fee_msat: int = 0
+    pending: bool = False
+    success: bool = False
+
+
 class HttpRequest(BaseModel):
     method: Literal["DELETE", "GET", "HEAD", "PATCH", "POST", "PUT"] = "GET"
     url: str = Field(..., min_length=1, max_length=2048)
@@ -163,6 +199,107 @@ class ExtensionApiRequest(BaseModel):
         return values
 
 
+class CurrencyListResponse(BaseModel):
+    currencies: list[str] = Field(default_factory=list)
+
+
+class CurrencyRateRequest(BaseModel):
+    currency: str = Field(..., min_length=1, max_length=8)
+
+
+class CurrencyRateResponse(BaseModel):
+    rate: float
+    price: float
+
+
+class CurrencyConvertRequest(BaseModel):
+    amount: float = Field(..., gt=0)
+    from_currency: str = Field(..., alias="from", min_length=1, max_length=8)
+    to: str = Field(..., min_length=1, max_length=256)
+
+    class Config:
+        allow_population_by_field_name = True
+
+
+class CurrencyConvertResponse(BaseModel):
+    amounts: list[tuple[str, float]] = Field(default_factory=list)
+
+
+class FiatToSatsRequest(BaseModel):
+    amount: float = Field(..., gt=0)
+    currency: str = Field(..., min_length=1, max_length=8)
+
+
+class FiatToSatsResponse(BaseModel):
+    amount_sat: int
+
+
+class SatsToFiatRequest(BaseModel):
+    amount: float = Field(..., gt=0)
+    currency: str = Field(..., min_length=1, max_length=8)
+
+
+class SatsToFiatResponse(BaseModel):
+    amount: float
+
+
+class ServerHealthResponse(BaseModel):
+    server_time: int
+    up_time: str
+
+
+class Bolt11Request(BaseModel):
+    bolt11: str = Field(..., min_length=1, max_length=8192)
+
+
+class DecodeInvoiceResponse(BaseModel):
+    valid: bool = True
+    payment_hash: str | None = None
+    amount_msat: int | None = None
+    expiry: int | None = None
+    expires_at: int | None = None
+    memo: str | None = None
+
+
+class ValidateInvoiceResponse(BaseModel):
+    valid: bool
+    error: str | None = None
+
+
+class InvoicePaymentHashResponse(BaseModel):
+    payment_hash: str
+
+
+class InvoiceAmountMsatResponse(BaseModel):
+    amount_msat: int | None = None
+
+
+class InvoiceExpiryResponse(BaseModel):
+    expires_at: int | None = None
+
+
+class InvoiceMemoResponse(BaseModel):
+    memo: str | None = None
+
+
+class VerifyPreimageRequest(BaseModel):
+    preimage: str = Field(..., min_length=64, max_length=64)
+    payment_hash: str = Field(..., min_length=64, max_length=64)
+
+
+class VerifyPreimageResponse(BaseModel):
+    valid: bool
+
+
+class RandomSecretAndHashRequest(BaseModel):
+    length: int = Field(32, ge=16, le=64)
+
+
+class RandomSecretAndHashResponse(BaseModel):
+    secret: str
+    hash: str
+
+
 class RandomIdRequest(BaseModel):
     prefix: str = Field(..., min_length=1, max_length=32)
 

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

@@ -15,7 +15,7 @@ from pydantic import UUID4
 from starlette.staticfiles import PathLike as StaticFilesPathLike
 from starlette.types import Scope
 
-from lnbits.core.crud import get_user_from_account
+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 (
@@ -140,6 +140,8 @@ def _mount_wasm_extension_static(app: FastAPI, extension: WasmExtension) -> None
 
 
 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(
@@ -147,15 +149,12 @@ def _register_wasm_extension_ui_routes(app: FastAPI, extension: WasmExtension) -
         )
         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 {}
         _add_wasm_extension_frame_route(app, extension, frame_path, entrypoint)
         _add_wasm_extension_wrapper_route(
             app,
             extension,
             route_path,
-            frame_path,
             auth,
-            path_params,
         )
 
 
@@ -179,7 +178,9 @@ def _add_wasm_extension_api_route(
         return
 
     async def invoke_wasm_api_request(
-        request: Request, account: Account | None = None
+        request: Request,
+        account: Account | None = None,
+        access_token: str | None = None,
     ) -> dict[str, Any]:
         try:
             payload = await _read_api_payload(request, path_params)
@@ -188,6 +189,7 @@ def _add_wasm_extension_api_route(
                 export_name,
                 payload,
                 user=account,
+                access_token=access_token,
             )
         except KeyError as exc:
             raise HTTPException(status_code=404, detail=str(exc)) from exc
@@ -198,9 +200,10 @@ def _add_wasm_extension_api_route(
 
     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)
+        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)
@@ -218,6 +221,55 @@ def _add_wasm_extension_api_route(
     )
 
 
+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],
@@ -303,9 +355,7 @@ def _add_wasm_extension_wrapper_route(
     app: FastAPI,
     extension: WasmExtension,
     route_path: str,
-    frame_path: str,
     auth: str,
-    path_params: dict[str, str],
 ) -> None:
     if _has_route(app, route_path, "GET"):
         return
@@ -318,25 +368,16 @@ def _add_wasm_extension_wrapper_route(
         return _wasm_extension_wrapper_response(
             request,
             extension,
-            frame_path,
             auth,
-            path_params,
             user.json() if user else None,
-            account.id,
         )
 
-    async def serve_public_wasm_extension_page(
-        request: Request,
-        user_id: str | None = Depends(_optional_wasm_user_id),
-    ) -> Any:
+    async def serve_public_wasm_extension_page(request: Request) -> Any:
         return _wasm_extension_wrapper_response(
             request,
             extension,
-            frame_path,
             auth,
-            path_params,
             None,
-            user_id,
         )
 
     app.add_api_route(
@@ -394,11 +435,8 @@ def _add_wasm_extension_frame_route(
 def _wasm_extension_wrapper_response(
     request: Request,
     extension: WasmExtension,
-    frame_path: str,
     auth: str,
-    path_params: dict[str, str],
     user_json: str | None,
-    user_id: str | None,
 ) -> Any:
     public = auth == "public"
     response = template_renderer().TemplateResponse(
@@ -406,14 +444,6 @@ def _wasm_extension_wrapper_response(
         "wasm_extension.html",
         {
             "extension": extension,
-            "frame_url": _wasm_extension_frame_url(extension, frame_path, user_id),
-            "bridge": {
-                "extensionId": extension.id,
-                "public": public,
-                "routeParams": _read_api_path_params(request, path_params),
-                "query": _read_api_query_params(request),
-                "apiRoutes": _wasm_extension_bridge_api_routes(extension, public),
-            },
             "public": public,
             "user": user_json,
         },
@@ -537,6 +567,118 @@ def _wasm_extension_bridge_api_routes(
     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}$"

lnbits/core/extensions/runtime.py

@@ -30,26 +30,34 @@ class ExtensionAPIHost:
     ) -> dict[str, Any]:
         method = self._require_method(host_name)
         request = self._request_model(method, payload)
-        handler = getattr(self.api, method.python_name)
+        handler = _resolve_attr_path(self.api, method.python_name)
         response = handler(request)
         if inspect.isawaitable(response):
             response = await response
         return self._response_payload(method, response)
 
     def imports(self) -> dict[str, HostImport]:
+        return self.imports_for_interface("host")
+
+    def import_object(self) -> dict[str, dict[str, HostImport]]:
+        interfaces = sorted({method.host_interface for method in self.methods})
+        return {
+            f"lnbits:extension/{interface}": self.imports_for_interface(interface)
+            for interface in interfaces
+        }
+
+    def imports_for_interface(self, host_interface: str) -> dict[str, HostImport]:
         return {
             _snake_to_camel(method.host_name): self._make_import(method)
             for method in self.methods
+            if method.host_interface == host_interface
         }
 
-    def import_object(self) -> dict[str, dict[str, HostImport]]:
-        return {"lnbits:extension/host": self.imports()}
-
     def _make_import(self, method: ExtensionAPIMethod) -> HostImport:
         async def host_import(
             payload: Mapping[str, Any] | BaseModel | None = None,
         ) -> dict[str, Any]:
-            return await self.invoke(method.host_name, payload)
+            return await self.invoke(method.method_id, payload)
 
         return host_import
 
@@ -66,6 +74,8 @@ class ExtensionAPIHost:
         index: dict[str, ExtensionAPIMethod] = {}
         for method in methods:
             for host_name in {
+                method.method_id,
+                f"{method.host_interface}:{method.host_name}",
                 method.host_name,
                 _snake_to_camel(method.host_name),
                 method.host_name.replace("_", "-"),
@@ -118,3 +128,9 @@ def _snake_to_camel(value: str) -> str:
 def _to_snake(value: str) -> str:
     value = value.replace("-", "_")
     return re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", value).lower()
+
+
+def _resolve_attr_path(value: Any, path: str) -> Any:
+    for part in path.split("."):
+        value = getattr(value, part)
+    return value

lnbits/core/extensions/wasm.py

@@ -21,6 +21,7 @@ async def invoke_wasm_extension_export(
     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]:
@@ -30,6 +31,7 @@ async def invoke_wasm_extension_export(
         extension.id,
         permissions,
         user_id=_user_id(user),
+        access_token=access_token,
         context=context,
         owner_id=owner_id,
     )
@@ -126,12 +128,17 @@ def _add_extension_host_imports(
     event_loop: asyncio.AbstractEventLoop,
 ) -> None:
     with linker.root() as root:
-        with root.add_instance("lnbits:extension/host") as host:
-            for method in list_extension_api_methods():
-                host.add_func(
-                    method.host_name.replace("_", "-"),
-                    _make_host_import(api_host, method.host_name, event_loop),
-                )
+        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(

lnbits/core/models/__init__.py

@@ -7,7 +7,6 @@ from .misc import (
     CoreAppExtra,
     DbVersion,
     SimpleStatus,
-    WasmExtensionRegistry,
 )
 from .payments import (
     CancelInvoice,
@@ -103,6 +102,5 @@ __all__ = [
     "Wallet",
     "WalletInfo",
     "WalletTypeInfo",
-    "WasmExtensionRegistry",
     "WebPushSubscription",
 ]

lnbits/core/models/extensions.py

@@ -7,7 +7,8 @@ import os
 import shutil
 import zipfile
 from asyncio.tasks import create_task
-from pathlib import Path
+from collections.abc import Mapping
+from pathlib import Path, PurePosixPath
 from typing import Any
 
 import httpx
@@ -83,6 +84,14 @@ class ExtensionPermission(BaseModel):
     description: str | None = None
     policy: dict[str, Any] | None = None
 
+    @staticmethod
+    def list_from_config(config_json: Mapping[str, Any]) -> list[ExtensionPermission]:
+        return [
+            ExtensionPermission.parse_obj(permission)
+            for permission in config_json.get("permissions") or []
+            if isinstance(permission, dict) and permission.get("id")
+        ]
+
 
 class ExtensionConfig(BaseModel):
     name: str
@@ -180,11 +189,19 @@ class Extension(BaseModel):
             is_wasm=ext_info.is_wasm,
             name=ext_info.name,
             short_description=ext_info.short_description,
-            tile=ext_info.icon,
+            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 "",
         )
 
 
+def wasm_extension_icon_url(ext_id: str) -> str:
+    return f"/ext-assets/{ext_id}/assets/icon.png"
+
+
 class ExtensionRelease(BaseModel):
     name: str
     version: str
@@ -456,6 +473,30 @@ class InstallableExtension(BaseModel):
                 os.remove(ext_zip_file)
             raise AssertionError("File hash missmatch. Will not install.")
 
+    def load_archive_config(self) -> dict[str, Any]:
+        if not self.zip_path.is_file():
+            return {}
+
+        try:
+            with zipfile.ZipFile(self.zip_path, "r") as archive:
+                config_name = self._archive_config_name(archive.namelist())
+                if not config_name:
+                    return {}
+                with archive.open(config_name) as config_file:
+                    config = json.load(config_file)
+        except Exception as exc:
+            raise ValueError(f"Cannot read extension config for '{self.id}'.") from exc
+
+        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)
@@ -634,11 +675,7 @@ class InstallableExtension(BaseModel):
                     version=version,
                     short_description=config_json.get("short_description"),
                     icon=config_json.get("tile"),
-                    permissions=[
-                        ExtensionPermission.parse_obj(permission)
-                        for permission in config_json.get("permissions") or []
-                        if isinstance(permission, dict) and permission.get("id")
-                    ],
+                    permissions=ExtensionPermission.list_from_config(config_json),
                     meta=ExtensionMeta(
                         installed_release=ExtensionRelease(
                             name=ext_id,

lnbits/core/services/extensions.py

@@ -1,10 +1,5 @@
 import asyncio
 import importlib
-import json
-import zipfile
-from collections.abc import Iterable
-from pathlib import PurePosixPath
-from typing import Any
 
 from loguru import logger
 
@@ -21,7 +16,7 @@ from lnbits.core.crud.extensions import (
     get_installed_extensions,
     update_installed_extension,
 )
-from lnbits.core.extensions.api import extension_api_permission_ids
+from lnbits.core.extensions.permissions import validate_wasm_extension_permissions
 from lnbits.core.helpers import migrate_extension_database
 from lnbits.db import Connection
 from lnbits.settings import settings
@@ -57,8 +52,8 @@ async def install_extension(
     if not skip_download:
         await ext_info.download_archive()
 
-    extension_config = _load_extension_archive_config(ext_info)
-    ext_info.permissions = _validate_extension_permissions(
+    extension_config = ext_info.load_archive_config()
+    ext_info.permissions = validate_wasm_extension_permissions(
         ext_info, granted_permissions, extension_config
     )
 
@@ -85,89 +80,6 @@ async def install_extension(
     return extension
 
 
-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_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.parse_obj(permission)
-            for permission in extension_config.get("permissions") or []
-            if isinstance(permission, dict) and permission.get("id")
-        ],
-    )
-    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
-
-
-def _load_extension_archive_config(ext_info: InstallableExtension) -> dict[str, Any]:
-    if not ext_info.zip_path.is_file():
-        return {}
-
-    try:
-        with zipfile.ZipFile(ext_info.zip_path, "r") as archive:
-            config_name = _archive_config_name(archive.namelist())
-            if not config_name:
-                return {}
-            with archive.open(config_name) as config_file:
-                config = json.load(config_file)
-    except Exception as exc:
-        raise ValueError(f"Cannot read extension config for '{ext_info.id}'.") from exc
-
-    return config if isinstance(config, dict) else {}
-
-
-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
-
-
 async def check_extensions_limit(installed_ext: InstallableExtension | None = None):
     if settings.lnbits_max_extensions == 0 or installed_ext:
         return

lnbits/core/views/extension_api.py

@@ -11,6 +11,7 @@ from loguru import logger
 from lnbits.core.crud.extensions import get_user_extensions
 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,
 )
@@ -29,6 +30,7 @@ from lnbits.core.models.extensions import (
     ReleasePaymentInfo,
     UserExtension,
     UserExtensionInfo,
+    wasm_extension_icon_url,
 )
 from lnbits.core.models.users import Account, AccountId
 from lnbits.core.services import check_transaction_status, create_invoice
@@ -39,7 +41,6 @@ from lnbits.core.services.extensions import (
     get_valid_extensions,
     install_extension,
     uninstall_extension,
-    validate_extension_permissions,
 )
 from lnbits.db import Page
 from lnbits.decorators import (
@@ -573,6 +574,8 @@ async def extensions(account_id: AccountId = Depends(check_account_id_exists)):
     extension_data = []
     for ext in installable_exts:
         installed_ext = installed_exts_by_id.get(ext.id)
+        is_wasm = installed_ext.is_wasm if installed_ext else ext.is_wasm
+        icon = wasm_extension_icon_url(ext.id) if is_wasm else ext.icon
         permissions = (
             validate_extension_permissions(
                 installed_ext.id, installed_ext.permissions, strict=False
@@ -584,7 +587,7 @@ async def extensions(account_id: AccountId = Depends(check_account_id_exists)):
             {
                 "id": ext.id,
                 "name": ext.name,
-                "icon": ext.icon,
+                "icon": icon,
                 "shortDescription": ext.short_description,
                 "stars": ext.stars,
                 "isFeatured": ext.meta.featured if ext.meta else False,
@@ -616,7 +619,7 @@ async def extensions(account_id: AccountId = Depends(check_account_id_exists)):
                     else {}
                 ),
                 "isPaymentRequired": ext.requires_payment,
-                "isWasm": installed_ext.is_wasm if installed_ext else ext.is_wasm,
+                "isWasm": is_wasm,
                 "permissions": [dict(permission) for permission in permissions],
                 "inProgress": False,
                 "selectedForUpdate": False,

lnbits/static/i18n/en.js

@@ -533,13 +533,25 @@ window.localisation.en = {
   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_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_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/init-app.js

@@ -139,6 +139,16 @@ const routes = [
     name: 'PageError',
     component: PageError
   },
+  {
+    path: '/ext/:extId',
+    name: 'WasmExtensionRoot',
+    component: window.WasmExtensionComponent
+  },
+  {
+    path: '/ext/:extId/:pathMatch(.*)*',
+    name: 'WasmExtension',
+    component: window.WasmExtensionComponent
+  },
   {
     path: '/:pathMatch(.*)*',
     name: 'DynamicComponent',

lnbits/static/js/pages/extensions.js

@@ -164,6 +164,7 @@ window.PageExtensions = {
           )
           extension.isAvailable = true
           extension.isInstalled = true
+          extension.icon = response.data.icon || extension.icon
           extension.installedRelease = release
           this.toggleExtension(extension)
           extension.inProgress = false

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

@@ -0,0 +1,566 @@
+window.WasmExtensionComponent = {
+  template: `
+    <div class="wasm-extension-page relative-position">
+      <q-inner-loading :showing="loading && !frameUrl">
+        <q-spinner-dots size="40px"></q-spinner-dots>
+      </q-inner-loading>
+      <q-banner v-if="error" class="q-ma-md bg-negative text-white">
+        {{ error }}
+      </q-banner>
+      <iframe
+        v-else-if="frameUrl"
+        ref="frame"
+        :key="frameUrl"
+        class="wasm-extension-frame"
+        :src="frameUrl"
+        :title="extensionName || 'Extension'"
+        sandbox="allow-scripts"
+        allow="clipboard-write"
+        referrerpolicy="no-referrer"
+      ></iframe>
+      <q-dialog v-model="cameraPrompt.show" persistent>
+        <q-card style="width: min(520px, calc(100vw - 32px)); max-width: 520px">
+          <q-card-section>
+            <div class="text-h6">Camera access</div>
+          </q-card-section>
+          <q-card-section class="q-pt-none">
+            {{ cameraPrompt.extensionName }} wants to access the camera to scan a QR code.
+          </q-card-section>
+          <q-card-actions align="right">
+            <q-btn
+              flat
+              color="negative"
+              label="Deny"
+              @click="resolveCameraPrompt('deny')"
+            ></q-btn>
+            <q-btn
+              flat
+              color="primary"
+              label="Allow"
+              @click="resolveCameraPrompt('allow')"
+            ></q-btn>
+            <q-btn
+              unelevated
+              color="primary"
+              label="Allow and Remember"
+              @click="resolveCameraPrompt('allow_remember')"
+            ></q-btn>
+          </q-card-actions>
+        </q-card>
+      </q-dialog>
+    </div>
+  `,
+  data() {
+    return {
+      allowedPaymentHashes: new Set(),
+      bridge: {
+        apiRoutes: [],
+        extensionId: '',
+        permissions: [],
+        public: false,
+        query: {},
+        routeParams: {}
+      },
+      bridgePort: null,
+      cameraPrompt: {
+        extensionName: '',
+        reject: null,
+        resolve: null,
+        show: false
+      },
+      error: '',
+      extensionName: '',
+      frameUrl: '',
+      handleWindowMessage: null,
+      loading: false,
+      loadId: 0,
+      paymentSubscriptions: new Map()
+    }
+  },
+  created() {
+    this.handleWindowMessage = event => this.onWindowMessage(event)
+    window.addEventListener('message', this.handleWindowMessage)
+  },
+  unmounted() {
+    window.removeEventListener('message', this.handleWindowMessage)
+    this.rejectCameraPrompt('Camera scan cancelled.')
+    this.closeBridgePort()
+  },
+  watch: {
+    '$route.fullPath': {
+      immediate: true,
+      handler() {
+        this.loadFrameConfig()
+      }
+    }
+  },
+  methods: {
+    emptyBridge() {
+      return {
+        apiRoutes: [],
+        extensionId: '',
+        permissions: [],
+        public: false,
+        query: {},
+        routeParams: {}
+      }
+    },
+    plainBridgeContext() {
+      return {
+        extensionId: String(this.bridge.extensionId || ''),
+        public: Boolean(this.bridge.public),
+        routeParams: this.plainValue(this.bridge.routeParams || {}),
+        query: this.plainValue(this.bridge.query || {})
+      }
+    },
+    hasBridgePermission(permission) {
+      return (this.bridge.permissions || []).includes(permission)
+    },
+    cameraPromptStorageKey() {
+      return `lnbits.ext.permissions.${this.bridge.extensionId}.ui.camera.scan_qr`
+    },
+    emptyCameraPrompt() {
+      return {
+        extensionName: '',
+        reject: null,
+        resolve: null,
+        show: false
+      }
+    },
+    plainValue(value) {
+      try {
+        return JSON.parse(JSON.stringify(value))
+      } catch (_error) {
+        return {}
+      }
+    },
+    async loadFrameConfig() {
+      const extId = String(this.$route.params.extId || '')
+      const loadId = ++this.loadId
+      this.loading = true
+      this.error = ''
+      this.frameUrl = ''
+      this.bridge = this.emptyBridge()
+      this.allowedPaymentHashes.clear()
+      this.rejectCameraPrompt('Camera scan cancelled.')
+      this.closeBridgePort()
+
+      try {
+        const response = await fetch(
+          `/api/v1/ext/${encodeURIComponent(extId)}/_ui/frame`,
+          {
+            method: 'POST',
+            headers: {'content-type': 'application/json'},
+            credentials: 'same-origin',
+            body: JSON.stringify({
+              path: this.$route.path,
+              query: this.$route.query || {}
+            })
+          }
+        )
+        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 || 'Failed to load extension page.')
+        }
+        if (loadId !== this.loadId) return
+
+        this.bridge = data.bridge || this.emptyBridge()
+        this.extensionName = data.extension?.name || extId
+        this.frameUrl = data.frameUrl
+      } catch (error) {
+        if (loadId !== this.loadId) return
+        console.error('[lnbits wasm extension] Failed to load frame.', error)
+        this.error = error instanceof Error ? error.message : String(error)
+      } finally {
+        if (loadId === this.loadId) {
+          this.loading = false
+        }
+      }
+    },
+    extensionFrameWindow() {
+      return this.$refs.frame?.contentWindow
+    },
+    sendResponse(reply, id, payload) {
+      reply({
+        type: 'lnbits-extension:response',
+        id,
+        ...payload
+      })
+    },
+    allowedApiRoute(method, path) {
+      let url
+      try {
+        url = new URL(path, window.location.origin)
+      } catch (_error) {
+        return false
+      }
+      if (url.origin !== window.location.origin) return false
+
+      method = String(method || 'GET').toUpperCase()
+      return (this.bridge.apiRoutes || []).some(route => {
+        return (
+          route.method === method &&
+          new RegExp(route.pattern).test(url.pathname)
+        )
+      })
+    },
+    async callApi(message) {
+      const method = String(message.method || 'GET').toUpperCase()
+      const path = String(message.path || '')
+      if (!this.allowedApiRoute(method, path)) {
+        throw new Error('Extension API route is not allowed.')
+      }
+
+      const options = {
+        method,
+        headers: {},
+        credentials: 'same-origin'
+      }
+      if (message.body !== undefined && message.body !== null) {
+        options.headers['content-type'] = 'application/json'
+        options.body = JSON.stringify(message.body)
+      }
+
+      const response = await fetch(path, options)
+      const text = await response.text()
+      let data = text
+      if (text) {
+        try {
+          data = JSON.parse(text)
+        } catch (_error) {
+          data = text
+        }
+      }
+      if (!response.ok) {
+        throw new Error(
+          typeof data === 'object' && data.detail ? data.detail : text
+        )
+      }
+      this.rememberPaymentHashes(data)
+      return data
+    },
+    notify(message) {
+      const level = ['positive', 'negative', 'warning', 'info'].includes(
+        message.level
+      )
+        ? message.level
+        : 'info'
+      if (window.Quasar?.Notify) {
+        window.Quasar.Notify.create({
+          color: level,
+          message: String(message.message || '')
+        })
+      }
+    },
+    async scanQrCode() {
+      if (!this.hasBridgePermission('ui.camera.scan_qr')) {
+        throw new Error('Extension is missing scanner permission.')
+      }
+      if (!this.g) {
+        throw new Error('LNbits scanner is not available.')
+      }
+      if (this.g.scanner) {
+        throw new Error('A scanner is already active.')
+      }
+      await this.requireCameraScanApproval()
+      if (this.g.scanner) {
+        throw new Error('A scanner is already active.')
+      }
+
+      return new Promise((resolve, reject) => {
+        let completed = false
+
+        const cleanup = () => {
+          window.clearTimeout(timeout)
+          window.clearInterval(cancelPoll)
+          if (this.g.scanner === onScan) {
+            this.g.scanner = null
+          }
+        }
+
+        const complete = callback => value => {
+          if (completed) return
+          completed = true
+          cleanup()
+          callback(value)
+        }
+
+        const onScan = value => {
+          complete(resolve)({value: String(value || '')})
+        }
+
+        const timeout = window.setTimeout(() => {
+          complete(reject)(new Error('QR scan timed out.'))
+        }, 120000)
+
+        const cancelPoll = window.setInterval(() => {
+          if (!completed && this.g.scanner !== onScan) {
+            complete(reject)(new Error('QR scan cancelled.'))
+          }
+        }, 250)
+
+        this.g.scanner = onScan
+      })
+    },
+    requireCameraScanApproval() {
+      if (this.isCameraScanRemembered()) return Promise.resolve()
+      if (this.cameraPrompt.show) {
+        return Promise.reject(
+          new Error('Camera access prompt is already open.')
+        )
+      }
+
+      return new Promise((resolve, reject) => {
+        this.cameraPrompt = {
+          extensionName:
+            this.extensionName || this.bridge.extensionId || 'This extension',
+          reject,
+          resolve,
+          show: true
+        }
+      })
+    },
+    isCameraScanRemembered() {
+      try {
+        return (
+          this.$q.localStorage.getItem(this.cameraPromptStorageKey()) ===
+          'allow'
+        )
+      } catch (_error) {
+        return false
+      }
+    },
+    rememberCameraScanApproval() {
+      try {
+        this.$q.localStorage.set(this.cameraPromptStorageKey(), 'allow')
+      } catch (_error) {}
+    },
+    resolveCameraPrompt(decision) {
+      const resolve = this.cameraPrompt.resolve
+      const reject = this.cameraPrompt.reject
+      this.cameraPrompt = this.emptyCameraPrompt()
+
+      if (decision === 'allow_remember') {
+        this.rememberCameraScanApproval()
+        resolve?.()
+        return
+      }
+      if (decision === 'allow') {
+        resolve?.()
+        return
+      }
+      reject?.(new Error('Camera scan denied by user.'))
+    },
+    rejectCameraPrompt(message) {
+      const reject = this.cameraPrompt.reject
+      this.cameraPrompt = this.emptyCameraPrompt()
+      reject?.(new Error(message))
+    },
+    rememberPaymentHashes(value) {
+      if (!value || typeof value !== 'object') return
+
+      if (Array.isArray(value)) {
+        value.forEach(item => this.rememberPaymentHashes(item))
+        return
+      }
+
+      for (const [key, item] of Object.entries(value)) {
+        if (
+          ['paymentHash', 'payment_hash'].includes(key) &&
+          this.isPaymentHash(item)
+        ) {
+          this.allowedPaymentHashes.add(item)
+        }
+        this.rememberPaymentHashes(item)
+      }
+    },
+    isPaymentHash(value) {
+      return typeof value === 'string' && /^[a-f0-9]{64}$/i.test(value)
+    },
+    websocketUrl(path) {
+      const url = new URL(window.location.href)
+      url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:'
+      url.pathname = path
+      url.search = ''
+      url.hash = ''
+      return url.toString()
+    },
+    sendBridgeEvent(message) {
+      if (!this.bridgePort) return
+      this.bridgePort.postMessage({
+        type: 'lnbits-extension:event',
+        ...message
+      })
+    },
+    closePaymentSubscription(subscriptionId) {
+      const subscription = this.paymentSubscriptions.get(subscriptionId)
+      if (!subscription) return
+      this.paymentSubscriptions.delete(subscriptionId)
+      try {
+        subscription.socket.close()
+      } catch (_error) {}
+    },
+    closePaymentSubscriptions() {
+      for (const subscriptionId of Array.from(
+        this.paymentSubscriptions.keys()
+      )) {
+        this.closePaymentSubscription(subscriptionId)
+      }
+    },
+    closeBridgePort() {
+      this.closePaymentSubscriptions()
+      this.bridgePort?.close()
+      this.bridgePort = null
+    },
+    subscribePayment(message) {
+      const subscriptionId = String(message.subscriptionId || '')
+      const paymentHash = String(message.paymentHash || '')
+
+      if (!subscriptionId || !this.isPaymentHash(paymentHash)) {
+        throw new Error('Invalid payment subscription.')
+      }
+      if (!this.allowedPaymentHashes.has(paymentHash)) {
+        throw new Error('Payment subscription is not allowed.')
+      }
+
+      this.closePaymentSubscription(subscriptionId)
+
+      const socket = new WebSocket(
+        this.websocketUrl(`/api/v1/ws/${encodeURIComponent(paymentHash)}`)
+      )
+      this.paymentSubscriptions.set(subscriptionId, {paymentHash, socket})
+
+      socket.addEventListener('message', event => {
+        let data = event.data
+        try {
+          data = JSON.parse(event.data)
+        } catch (_error) {}
+
+        this.sendBridgeEvent({
+          event: 'payment.update',
+          subscriptionId,
+          paymentHash,
+          data
+        })
+
+        if (
+          data &&
+          typeof data === 'object' &&
+          (data.pending === false ||
+            ['success', 'settled', 'paid'].includes(String(data.status || '')))
+        ) {
+          this.sendBridgeEvent({
+            event: 'payment.settled',
+            subscriptionId,
+            paymentHash,
+            data
+          })
+          this.closePaymentSubscription(subscriptionId)
+        }
+      })
+      socket.addEventListener('error', () => {
+        this.sendBridgeEvent({
+          event: 'payment.error',
+          subscriptionId,
+          paymentHash
+        })
+        this.closePaymentSubscription(subscriptionId)
+      })
+      socket.addEventListener('close', () => {
+        this.paymentSubscriptions.delete(subscriptionId)
+      })
+    },
+    async handleBridgeRequest(message, reply) {
+      if (!message || message.type !== 'lnbits-extension:request') return
+
+      try {
+        if (message.action === 'context') {
+          this.sendResponse(reply, message.id, {
+            ok: true,
+            data: this.plainBridgeContext()
+          })
+          return
+        }
+
+        if (message.action === 'api') {
+          this.sendResponse(reply, message.id, {
+            ok: true,
+            data: await this.callApi(message)
+          })
+          return
+        }
+
+        if (message.action === 'ui.notify') {
+          this.notify(message)
+          this.sendResponse(reply, message.id, {
+            ok: true,
+            data: {ok: true}
+          })
+          return
+        }
+
+        if (message.action === 'ui.scan_qr') {
+          this.sendResponse(reply, message.id, {
+            ok: true,
+            data: await this.scanQrCode()
+          })
+          return
+        }
+
+        if (message.action === 'payment.subscribe') {
+          this.subscribePayment(message)
+          this.sendResponse(reply, message.id, {
+            ok: true,
+            data: {ok: true}
+          })
+          return
+        }
+
+        if (message.action === 'payment.unsubscribe') {
+          this.closePaymentSubscription(String(message.subscriptionId || ''))
+          this.sendResponse(reply, message.id, {
+            ok: true,
+            data: {ok: true}
+          })
+          return
+        }
+
+        throw new Error('Unknown extension bridge action.')
+      } catch (error) {
+        this.sendResponse(reply, message.id, {
+          ok: false,
+          error: error instanceof Error ? error.message : String(error)
+        })
+      }
+    },
+    onWindowMessage(event) {
+      if (event.source !== this.extensionFrameWindow()) return
+      const message = event.data
+      if (!message || message.type !== 'lnbits-extension:connect') return
+
+      const port = event.ports?.[0]
+      if (!port) return
+
+      this.closeBridgePort()
+      this.bridgePort = port
+      this.bridgePort.addEventListener('message', portEvent => {
+        this.handleBridgeRequest(portEvent.data, response => {
+          port.postMessage(response)
+        })
+      })
+      this.bridgePort.start()
+      this.bridgePort.postMessage({
+        type: 'lnbits-extension:connected',
+        id: message.id
+      })
+    }
+  }
+}

lnbits/static/vendor.json

@@ -96,6 +96,7 @@
     "js/components/extension-settings.js",
     "js/components/data-fields.js",
     "js/components.js",
+    "js/wasm-extension-component.js",
     "js/init-app.js"
   ],
   "css": ["vendor/quasar.css", "css/base.css"]

lnbits/templates/base.html

@@ -16,6 +16,18 @@
         src: url("{{ static_url_for('static', 'fonts/material-icons-v50.woff2') }}")
           format('woff2');
       }
+
+      .wasm-extension-page,
+      .wasm-extension-frame {
+        height: calc(100vh - 56px);
+        min-height: calc(100vh - 56px);
+        width: 100%;
+      }
+
+      .wasm-extension-frame {
+        border: 0;
+        display: block;
+      }
     </style>
     <title>{% block title %}{{ SITE_TITLE }}{% endblock %}</title>
     <meta charset="utf-8" />
@@ -44,12 +56,14 @@
         <lnbits-drawer v-if="g.user && !g.isPublicPage"></lnbits-drawer>
         {% block page_container %}
         <q-page-container>
-          <q-page class="q-px-md q-py-lg" :class="{'q-px-lg': $q.screen.gt.xs}">
+          <q-page
+            :class="$route.path.startsWith('/ext/') ? 'q-pa-none' : ['q-px-md', 'q-py-lg', {'q-px-lg': $q.screen.gt.xs}]"
+          >
             <lnbits-wallet-new
-              v-if="g.user && !g.isPublicPage"
+              v-if="g.user && !g.isPublicPage && !$route.path.startsWith('/ext/')"
             ></lnbits-wallet-new>
             <lnbits-header-wallets
-              v-if="g.user && !g.isPublicPage"
+              v-if="g.user && !g.isPublicPage && !$route.path.startsWith('/ext/')"
             ></lnbits-header-wallets>
             <!-- block page content from static extensions -->
             <div

lnbits/templates/wasm_extension.html

@@ -1,351 +1 @@
-{% extends "base.html" %} {% block styles %}
-<style>
-  .wasm-extension-frame {
-    border: 0;
-    display: block;
-    height: calc(100vh - 56px);
-    min-height: calc(100vh - 56px);
-    width: 100%;
-  }
-</style>
-{% endblock %} {% block page_container %}
-<q-page-container>
-  <!-- # todo:revisit this -->
-  <q-page
-    v-if="$route.path.startsWith('{{ normalize_path(request.path) }}')"
-    class="q-pa-none"
-  >
-    <iframe
-      id="lnbits-wasm-extension-frame"
-      class="wasm-extension-frame"
-      data-frame-url="{{ frame_url }}"
-      title="{{ extension.name }}"
-      sandbox="allow-scripts"
-      allow="clipboard-write"
-      referrerpolicy="no-referrer"
-    ></iframe>
-  </q-page>
-  <q-page v-else class="q-px-md q-py-lg" :class="{'q-px-lg': $q.screen.gt.xs}">
-    <lnbits-wallet-new v-if="g.user && !g.isPublicPage"></lnbits-wallet-new>
-    <lnbits-header-wallets
-      v-if="g.user && !g.isPublicPage"
-    ></lnbits-header-wallets>
-    <router-view :key="$route.path"></router-view>
-  </q-page>
-</q-page-container>
-{% endblock %} {% block scripts %}
-<script>
-  ;(() => {
-    const bridge = {{ bridge | tojson | safe }}
-    let bridgePort = null
-    const allowedPaymentHashes = new Set()
-    const paymentSubscriptions = new Map()
-
-    function extensionFrameWindow() {
-      return extensionFrame()?.contentWindow
-    }
-
-    function extensionFrame() {
-      return document.getElementById('lnbits-wasm-extension-frame')
-    }
-
-    function loadExtensionFrame() {
-      const frame = extensionFrame()
-      if (!frame) {
-        closeBridgePort()
-        return
-      }
-      if (frame.dataset.loaded === 'true') return
-      frame.dataset.loaded = 'true'
-      frame.src = frame.dataset.frameUrl
-    }
-
-    function startExtensionFrameLoader() {
-      loadExtensionFrame()
-      window.router?.afterEach(() => {
-        window.setTimeout(loadExtensionFrame)
-      })
-    }
-
-    function sendResponse(reply, id, payload) {
-      reply({
-        type: 'lnbits-extension:response',
-        id,
-        ...payload
-      })
-    }
-
-    function allowedApiRoute(method, path) {
-      let url
-      try {
-        url = new URL(path, window.location.origin)
-      } catch (_error) {
-        return false
-      }
-      if (url.origin !== window.location.origin) return false
-
-      method = String(method || 'GET').toUpperCase()
-      return bridge.apiRoutes.some(route => {
-        return (
-          route.method === method &&
-          new RegExp(route.pattern).test(url.pathname)
-        )
-      })
-    }
-
-    async function callApi(message) {
-      const method = String(message.method || 'GET').toUpperCase()
-      const path = String(message.path || '')
-      if (!allowedApiRoute(method, path)) {
-        throw new Error('Extension API route is not allowed.')
-      }
-
-      const options = {
-        method,
-        headers: {},
-        credentials: 'same-origin'
-      }
-      if (message.body !== undefined && message.body !== null) {
-        options.headers['content-type'] = 'application/json'
-        options.body = JSON.stringify(message.body)
-      }
-
-      const response = await fetch(path, options)
-      const text = await response.text()
-      let data = text
-      if (text) {
-        try {
-          data = JSON.parse(text)
-        } catch (_error) {
-          data = text
-        }
-      }
-      if (!response.ok) {
-        throw new Error(
-          typeof data === 'object' && data.detail ? data.detail : text
-        )
-      }
-      rememberPaymentHashes(data)
-      return data
-    }
-
-    function notify(message) {
-      const level = ['positive', 'negative', 'warning', 'info'].includes(
-        message.level
-      )
-        ? message.level
-        : 'info'
-      if (window.Quasar?.Notify) {
-        window.Quasar.Notify.create({
-          color: level,
-          message: String(message.message || '')
-        })
-      }
-    }
-
-    function rememberPaymentHashes(value) {
-      if (!value || typeof value !== 'object') return
-
-      if (Array.isArray(value)) {
-        value.forEach(rememberPaymentHashes)
-        return
-      }
-
-      for (const [key, item] of Object.entries(value)) {
-        if (
-          ['paymentHash', 'payment_hash'].includes(key) &&
-          isPaymentHash(item)
-        ) {
-          allowedPaymentHashes.add(item)
-        }
-        rememberPaymentHashes(item)
-      }
-    }
-
-    function isPaymentHash(value) {
-      return typeof value === 'string' && /^[a-f0-9]{64}$/i.test(value)
-    }
-
-    function websocketUrl(path) {
-      const url = new URL(window.location.href)
-      url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:'
-      url.pathname = path
-      url.search = ''
-      url.hash = ''
-      return url.toString()
-    }
-
-    function sendBridgeEvent(message) {
-      if (!bridgePort) return
-      bridgePort.postMessage({
-        type: 'lnbits-extension:event',
-        ...message
-      })
-    }
-
-    function closePaymentSubscription(subscriptionId) {
-      const subscription = paymentSubscriptions.get(subscriptionId)
-      if (!subscription) return
-      paymentSubscriptions.delete(subscriptionId)
-      try {
-        subscription.socket.close()
-      } catch (_error) {}
-    }
-
-    function closePaymentSubscriptions() {
-      for (const subscriptionId of Array.from(paymentSubscriptions.keys())) {
-        closePaymentSubscription(subscriptionId)
-      }
-    }
-
-    function closeBridgePort() {
-      closePaymentSubscriptions()
-      bridgePort?.close()
-      bridgePort = null
-    }
-
-    function subscribePayment(message) {
-      const subscriptionId = String(message.subscriptionId || '')
-      const paymentHash = String(message.paymentHash || '')
-
-      if (!subscriptionId || !isPaymentHash(paymentHash)) {
-        throw new Error('Invalid payment subscription.')
-      }
-      if (!allowedPaymentHashes.has(paymentHash)) {
-        throw new Error('Payment subscription is not allowed.')
-      }
-
-      closePaymentSubscription(subscriptionId)
-
-      const socket = new WebSocket(
-        websocketUrl(`/api/v1/ws/${encodeURIComponent(paymentHash)}`)
-      )
-      paymentSubscriptions.set(subscriptionId, {paymentHash, socket})
-
-      socket.addEventListener('message', event => {
-        let data = event.data
-        try {
-          data = JSON.parse(event.data)
-        } catch (_error) {}
-
-        sendBridgeEvent({
-          event: 'payment.update',
-          subscriptionId,
-          paymentHash,
-          data
-        })
-
-        if (
-          data &&
-          typeof data === 'object' &&
-          (data.pending === false ||
-            ['success', 'settled', 'paid'].includes(String(data.status || '')))
-        ) {
-          sendBridgeEvent({
-            event: 'payment.settled',
-            subscriptionId,
-            paymentHash,
-            data
-          })
-          closePaymentSubscription(subscriptionId)
-        }
-      })
-      socket.addEventListener('error', () => {
-        sendBridgeEvent({
-          event: 'payment.error',
-          subscriptionId,
-          paymentHash
-        })
-        closePaymentSubscription(subscriptionId)
-      })
-      socket.addEventListener('close', () => {
-        paymentSubscriptions.delete(subscriptionId)
-      })
-    }
-
-    async function handleBridgeRequest(message, reply) {
-      if (!message || message.type !== 'lnbits-extension:request') return
-
-      try {
-        if (message.action === 'context') {
-          sendResponse(reply, message.id, {
-            ok: true,
-            data: {
-              extensionId: bridge.extensionId,
-              public: bridge.public,
-              routeParams: bridge.routeParams,
-              query: bridge.query
-            }
-          })
-          return
-        }
-
-        if (message.action === 'api') {
-          sendResponse(reply, message.id, {
-            ok: true,
-            data: await callApi(message)
-          })
-          return
-        }
-
-        if (message.action === 'ui.notify') {
-          notify(message)
-          sendResponse(reply, message.id, {
-            ok: true,
-            data: {ok: true}
-          })
-          return
-        }
-
-        if (message.action === 'payment.subscribe') {
-          subscribePayment(message)
-          sendResponse(reply, message.id, {
-            ok: true,
-            data: {ok: true}
-          })
-          return
-        }
-
-        if (message.action === 'payment.unsubscribe') {
-          closePaymentSubscription(String(message.subscriptionId || ''))
-          sendResponse(reply, message.id, {
-            ok: true,
-            data: {ok: true}
-          })
-          return
-        }
-
-        throw new Error('Unknown extension bridge action.')
-      } catch (error) {
-        sendResponse(reply, message.id, {
-          ok: false,
-          error: error instanceof Error ? error.message : String(error)
-        })
-      }
-    }
-
-    window.addEventListener('message', event => {
-      if (event.source !== extensionFrameWindow()) return
-      const message = event.data
-      if (!message || message.type !== 'lnbits-extension:connect') return
-
-      const port = event.ports?.[0]
-      if (!port) return
-
-      closeBridgePort()
-      bridgePort = port
-      bridgePort.addEventListener('message', portEvent => {
-        handleBridgeRequest(portEvent.data, response => {
-          port.postMessage(response)
-        })
-      })
-      bridgePort.start()
-      bridgePort.postMessage({
-        type: 'lnbits-extension:connected',
-        id: message.id
-      })
-    })
-    window.addEventListener('load', startExtensionFrameLoader)
-  })()
-</script>
-{% endblock %}
+{% extends "base.html" %}

package.json

@@ -149,6 +149,7 @@
       "js/components/extension-settings.js",
       "js/components/data-fields.js",
       "js/components.js",
+      "js/wasm-extension-component.js",
       "js/init-app.js"
     ],
     "css": [

tools/codegen/extension_sdk_typescript.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import argparse
+import re
 from collections import defaultdict
 from collections.abc import Sequence
 from pathlib import Path
@@ -185,6 +186,7 @@ def _render_method_metadata(
                 f'    namespace: "{method.namespace}",',
                 f'    sdkName: "{method.sdk_name}",',
                 f'    pythonName: "{method.python_name}",',
+                f'    hostInterface: "{method.host_interface}",',
                 f'    hostName: "{method.host_name}",',
                 f'    hostJsName: "{_camel(method.host_name)}",',
                 f"    requiredPermission: {permission},",
@@ -197,76 +199,120 @@ def _render_method_metadata(
 
 def _render_host_type(methods: Sequence[ExtensionAPIMethod]) -> list[str]:
     lines = ["export type ExtensionHost = {"]
-    for method in sorted(methods, key=lambda item: item.host_name):
-        request = _model_name(method.request_model)
-        response = _model_name(method.response_model)
-        if _is_empty_model(method.request_model):
-            lines.append(f"  {_camel(method.host_name)}(): MaybePromise<{response}>")
-        else:
-            lines.append(
-                f"  {_camel(method.host_name)}"
-                f"(input: {request}): MaybePromise<{response}>"
-            )
-    lines.append("}")
-    return lines
-
-
-def _render_sdk_type(methods: Sequence[ExtensionAPIMethod]) -> list[str]:
-    namespaces = _methods_by_namespace(methods)
-    lines = ["export type ExtensionSdk = {"]
-    for namespace, namespace_methods in namespaces.items():
-        lines.append(f"  {namespace}: {{")
-        for method in namespace_methods:
+    for host_interface, interface_methods in _methods_by_host_interface(
+        methods
+    ).items():
+        lines.append(f"  {_ts_property(host_interface)}: {{")
+        for method in sorted(interface_methods, key=lambda item: item.host_name):
             request = _model_name(method.request_model)
             response = _model_name(method.response_model)
             if _is_empty_model(method.request_model):
-                lines.append(f"    {method.sdk_name}(): Promise<{response}>")
+                lines.append(
+                    f"    {_camel(method.host_name)}(): MaybePromise<{response}>"
+                )
             else:
                 lines.append(
-                    f"    {method.sdk_name}(input: {request}): Promise<{response}>"
+                    f"    {_camel(method.host_name)}"
+                    f"(input: {request}): MaybePromise<{response}>"
                 )
         lines.append("  }")
     lines.append("}")
     return lines
 
 
+def _render_sdk_type(methods: Sequence[ExtensionAPIMethod]) -> list[str]:
+    lines = ["export type ExtensionSdk = {"]
+    _render_sdk_type_node(lines, _namespace_tree(methods), 1)
+    lines.append("}")
+    return lines
+
+
 def _render_create_sdk(methods: Sequence[ExtensionAPIMethod]) -> list[str]:
-    namespaces = _methods_by_namespace(methods)
     lines = [
         "export function createExtensionSdk(",
         "  host: ExtensionHost",
         "): ExtensionSdk {",
         "  return {",
     ]
-    for namespace, namespace_methods in namespaces.items():
-        lines.append(f"    {namespace}: {{")
-        for method in namespace_methods:
-            host_name = _camel(method.host_name)
-            if _is_empty_model(method.request_model):
-                signature = f"{method.sdk_name}()"
-                host_call = f"host.{host_name}()"
-            else:
-                signature = f"{method.sdk_name}(input)"
-                host_call = f"host.{host_name}(input)"
-            lines.extend(
-                [
-                    f"      async {signature} {{",
-                    f"        return {host_call}",
-                    "      },",
-                ]
-            )
-        lines.append("    },")
+    _render_create_sdk_node(lines, _namespace_tree(methods), 2)
     lines.extend(["  }", "}"])
     return lines
 
 
-def _methods_by_namespace(
+def _render_sdk_type_node(lines: list[str], node: dict[str, Any], level: int) -> None:
+    indent = "  " * level
+    for namespace, child in _iter_child_namespaces(node):
+        lines.append(f"{indent}{namespace}: {{")
+        _render_sdk_type_node(lines, child, level + 1)
+        lines.append(f"{indent}}}")
+
+    for method in node.get("__methods__", []):
+        request = _model_name(method.request_model)
+        response = _model_name(method.response_model)
+        if _is_empty_model(method.request_model):
+            lines.append(f"{indent}{method.sdk_name}(): Promise<{response}>")
+        else:
+            lines.append(
+                f"{indent}{method.sdk_name}(input: {request}): Promise<{response}>"
+            )
+
+
+def _render_create_sdk_node(lines: list[str], node: dict[str, Any], level: int) -> None:
+    indent = "  " * level
+    for namespace, child in _iter_child_namespaces(node):
+        lines.append(f"{indent}{namespace}: {{")
+        _render_create_sdk_node(lines, child, level + 1)
+        lines.append(f"{indent}}},")
+
+    for method in node.get("__methods__", []):
+        host_call_target = (
+            f"host{_ts_access(method.host_interface)}"
+            f"{_ts_access(_camel(method.host_name))}"
+        )
+        if _is_empty_model(method.request_model):
+            signature = f"{method.sdk_name}()"
+            host_call = f"{host_call_target}()"
+        else:
+            signature = f"{method.sdk_name}(input)"
+            host_call = f"{host_call_target}(input)"
+        lines.extend(
+            [
+                f"{indent}async {signature} {{",
+                f"{indent}  return {host_call}",
+                f"{indent}}},",
+            ]
+        )
+
+
+def _methods_by_host_interface(
     methods: Sequence[ExtensionAPIMethod],
 ) -> dict[str, list[ExtensionAPIMethod]]:
-    namespaces: dict[str, list[ExtensionAPIMethod]] = defaultdict(list)
+    interfaces: dict[str, list[ExtensionAPIMethod]] = defaultdict(list)
+    for method in sorted(
+        methods, key=lambda item: (item.host_interface, item.host_name)
+    ):
+        interfaces[method.host_interface].append(method)
+    return dict(sorted(interfaces.items()))
+
+
+def _namespace_tree(methods: Sequence[ExtensionAPIMethod]) -> dict[str, Any]:
+    tree: dict[str, Any] = {}
     for method in sorted(methods, key=lambda item: (item.namespace, item.sdk_name)):
-        namespaces[method.namespace].append(method)
-    return dict(sorted(namespaces.items()))
+        node = tree
+        for part in method.namespace.split("."):
+            node = node.setdefault(part, {})
+        node.setdefault("__methods__", []).append(method)
+    return tree
+
+
+def _iter_child_namespaces(
+    node: dict[str, Any],
+) -> list[tuple[str, dict[str, Any]]]:
+    return [
+        (key, value)
+        for key, value in sorted(node.items())
+        if key != "__methods__" and isinstance(value, dict)
+    ]
 
 
 def _model_name(model: type[BaseModel]) -> str:
@@ -278,6 +324,18 @@ def _camel(value: str) -> str:
     return head + "".join(part.capitalize() for part in tail)
 
 
+def _ts_property(value: str) -> str:
+    if re.match(r"^[A-Za-z_$][A-Za-z0-9_$]*$", value):
+        return value
+    return f'"{value}"'
+
+
+def _ts_access(value: str) -> str:
+    if re.match(r"^[A-Za-z_$][A-Za-z0-9_$]*$", value):
+        return f".{value}"
+    return f'["{value}"]'
+
+
 def _is_empty_model(model: type[BaseModel]) -> bool:
     return not model.__fields__