refactor: purge Quart from the codebase

Most functionality is still broken

lnbits/core/models.py

@@ -1,7 +1,7 @@
 import json
 import hmac
 import hashlib
-from quart import url_for
+from lnbits.helpers import url_for
 from ecdsa import SECP256k1, SigningKey  # type: ignore
 from lnurl import encode as lnurl_encode  # type: ignore
 from typing import List, NamedTuple, Optional, Dict
@@ -30,11 +30,12 @@ class Wallet(BaseModel):
 
     @property
     def lnurlwithdraw_full(self) -> str:
+        
         url = url_for(
-            "core.lnurl_full_withdraw",
+            "/withdraw",
+            external=True,
             usr=self.user,
             wal=self.id,
-            _external=True,
         )
         try:
             return lnurl_encode(url)

lnbits/core/services.py

@@ -5,7 +5,6 @@ from io import BytesIO
 from binascii import unhexlify
 from typing import Optional, Tuple, Dict
 from urllib.parse import urlparse, parse_qs
-from quart import g, url_for
 from lnurl import LnurlErrorResponse, decode as decode_lnurl  # type: ignore
 
 try:
@@ -15,9 +14,10 @@ except ImportError:  # pragma: nocover
 
 from lnbits import bolt11
 from lnbits.db import Connection
-from lnbits.helpers import urlsafe_short_hash
+from lnbits.helpers import url_for, urlsafe_short_hash
 from lnbits.settings import WALLET
 from lnbits.wallets.base import PaymentStatus, PaymentResponse
+from lnbits.requestvars import g
 
 from . import db
 from .crud import (
@@ -220,10 +220,9 @@ async def redeem_lnurl_withdraw(
 
     try:
         params["balanceNotify"] = url_for(
-            "core.lnurl_balance_notify",
-            service=urlparse(lnurl_request).netloc,
+            f"/withdraw/notify/{urlparse(lnurl_request).netloc}",
+            external=True,
             wal=wallet_id,
-            _external=True,
         )
     except Exception:
         pass
@@ -242,7 +241,7 @@ async def perform_lnurlauth(
     cb = urlparse(callback)
 
     k1 = unhexlify(parse_qs(cb.query)["k1"][0])
-    key = g.wallet.lnurlauth_key(cb.netloc)
+    key = g().wallet.lnurlauth_key(cb.netloc)
 
     def int_to_bytes_suitable_der(x: int) -> bytes:
         """for strict DER we need to encode the integer with some quirks"""

lnbits/core/views/api.py

@@ -1,3 +1,4 @@
+from lnbits.helpers import url_for
 from fastapi.param_functions import Depends
 from lnbits.auth_bearer import AuthBearer
 from pydantic import BaseModel
@@ -6,7 +7,6 @@ import json
 import httpx
 import hashlib
 from urllib.parse import urlparse, urlunparse, urlencode, parse_qs, ParseResult
-from quart import current_app, make_response, url_for
 
 from fastapi import Query
 
@@ -121,10 +121,9 @@ async def api_payments_create_invoice(data: CreateInvoiceData):
                     params={
                         "pr": payment_request,
                         "balanceNotify": url_for(
-                            "core.lnurl_balance_notify",
-                            service=urlparse(data.lnurl_callback).netloc,
+                            f"/withdraw/notify/{urlparse(data.lnurl_callback).netloc}",
+                            external=True,
                             wal=g().wallet.id,
-                            _external=True,
                         ),
                     },
                     timeout=10,

lnbits/core/views/generic.py

@@ -1,32 +1,24 @@
-from lnbits.core.models import Wallet
-from fastapi.params import Query
-from fastapi.routing import APIRouter
-from fastapi.responses import RedirectResponse
-from fastapi import status
-from lnbits.requestvars import g
-from os import path
 from http import HTTPStatus
 from typing import Optional
-import jinja2
 
+from fastapi import Request, status
+from fastapi.param_functions import Body
+from fastapi.params import Depends, Query
+from fastapi.responses import FileResponse, RedirectResponse
+from fastapi.routing import APIRouter
+from pydantic.types import UUID4
 from starlette.responses import HTMLResponse
 
-from lnbits.core import core_app, db
-from lnbits.decorators import check_user_exists, validate_uuids
-from lnbits.settings import LNBITS_ALLOWED_USERS, SERVICE_FEE, LNBITS_SITE_TITLE
+from lnbits.core import db
+from lnbits.helpers import template_renderer, url_for
+from lnbits.requestvars import g
+from lnbits.settings import (LNBITS_ALLOWED_USERS, LNBITS_SITE_TITLE,
+                             SERVICE_FEE)
 
-from ..crud import (
-    create_account,
-    get_user,
-    update_user_extension,
-    create_wallet,
-    delete_wallet,
-    get_balance_check,
-    save_balance_notify,
-)
-from ..services import redeem_lnurl_withdraw, pay_invoice
-from fastapi import FastAPI, Request
-from fastapi.responses import FileResponse
+from ..crud import (create_account, create_wallet, delete_wallet,
+                    get_balance_check, get_user, save_balance_notify,
+                    update_user_extension)
+from ..services import pay_invoice, redeem_lnurl_withdraw
 
 core_html_routes: APIRouter = APIRouter(tags=["Core NON-API Website Routes"])
 
@@ -37,13 +29,13 @@ async def favicon():
 
 @core_html_routes.get("/", response_class=HTMLResponse)
 async def home(request: Request, lightning: str = None):
-    return g().templates.TemplateResponse("core/index.html", {"request": request, "lnurl": lightning})
+    return template_renderer().TemplateResponse("core/index.html", {"request": request, "lnurl": lightning})
 
 
 @core_html_routes.get("/extensions")
-@validate_uuids(["usr"], required=True)
-@check_user_exists()
-async def extensions(enable: str, disable: str):
+# @validate_uuids(["usr"], required=True)
+# @check_user_exists()
+async def extensions(request: Request, enable: str, disable: str):
     extension_to_enable = enable
     extension_to_disable = disable
 
@@ -60,20 +52,16 @@ async def extensions(enable: str, disable: str):
         await update_user_extension(
             user_id=g.user.id, extension=extension_to_disable, active=False
         )
-    return await templates.TemplateResponse("core/extensions.html", {"request": request, "user": get_user(g.user.id)})
+    return template_renderer().TemplateResponse("core/extensions.html", {"request": request, "user": get_user(g.user.id)})
 
 
 @core_html_routes.get("/wallet", response_class=HTMLResponse)
 #Not sure how to validate
-@validate_uuids(["usr", "wal"])
-async def wallet(request: Request,
-    usr: Optional[str] = Query(None),
-    wal: Optional[str] = Query(None),
-    nme: Optional[str] = Query(None),
-    ):
-                    
-    user_id = usr
-    wallet_id = wal
+# @validate_uuids(["usr", "nme"])
+async def wallet(request: Request = Query(None), nme: Optional[str] = Query(None), 
+                 usr: Optional[UUID4] = Query(None), wal: Optional[UUID4] = Query(None)):
+    user_id = usr.hex if usr else None
+    wallet_id = wal.hex if wal else None
     wallet_name = nme
     service_fee = int(SERVICE_FEE) if int(SERVICE_FEE) == SERVICE_FEE else SERVICE_FEE
 
@@ -84,33 +72,33 @@ async def wallet(request: Request,
     # nothing: create everything
 
     if not user_id:
-        usr = await get_user((await create_account()).id)
+        user = await get_user((await create_account()).id)
     else:
-        usr = await get_user(user_id)
-        if not usr:
-            return g().templates.TemplateResponse("error.html", {"request": request, "err": "User does not exist."})
+        user = await get_user(user_id)
+        if not user:
+            return template_renderer().TemplateResponse("error.html", {"request": request, "err": "User does not exist."})
         if LNBITS_ALLOWED_USERS and user_id not in LNBITS_ALLOWED_USERS:
-            return g().templates.TemplateResponse("error.html", {"request": request, "err": "User not authorized."})
+            return template_renderer().TemplateResponse("error.html", {"request": request, "err": "User not authorized."})
     if not wallet_id:
-        if usr.wallets and not wallet_name:
-            wal = usr.wallets[0]
+        if user.wallets and not wallet_name:
+            wallet = user.wallets[0]
         else:
-            wal = await create_wallet(user_id=usr.id, wallet_name=wallet_name)
+            wallet = await create_wallet(user_id=user.id, wallet_name=wallet_name)
 
-        return RedirectResponse(f"/wallet?usr={usr.id}&wal={wal.id}", status_code=status.HTTP_307_TEMPORARY_REDIRECT)
+        return RedirectResponse(f"/wallet?usr={user.id}&wal={wallet.id}", status_code=status.HTTP_307_TEMPORARY_REDIRECT)
 
-    wal = usr.get_wallet(wallet_id)
-    if not wal:
-        return g().templates.TemplateResponse("error.html", {"request": request, ...})
+    wallet = user.get_wallet(wallet_id)
+    if not wallet:
+        return template_renderer().TemplateResponse("error.html", {"request": request, "err": "Wallet not found"})
 
-    return g().templates.TemplateResponse(
-        "core/wallet.html", {"request":request,"user":usr, "wallet":wal, "service_fee":service_fee}
+    return template_renderer().TemplateResponse(
+        "core/wallet.html", {"request":request,"user":user.dict(), "wallet":wallet.dict(), "service_fee":service_fee}
     )
 
 
 @core_html_routes.get("/withdraw")
-@validate_uuids(["usr", "wal"], required=True)
-async def lnurl_full_withdraw():
+# @validate_uuids(["usr", "wal"], required=True)
+async def lnurl_full_withdraw(request: Request):
     user = await get_user(request.args.get("usr"))
     if not user:
         return {"status": "ERROR", "reason": "User does not exist."}
@@ -122,24 +110,22 @@ async def lnurl_full_withdraw():
     return {
             "tag": "withdrawRequest",
             "callback": url_for(
-                "core.lnurl_full_withdraw_callback",
+                "/withdraw/cb",
+                external=True,
                 usr=user.id,
                 wal=wallet.id,
-                _external=True,
             ),
             "k1": "0",
             "minWithdrawable": 1000 if wallet.withdrawable_balance else 0,
             "maxWithdrawable": wallet.withdrawable_balance,
             "defaultDescription": f"{LNBITS_SITE_TITLE} balance withdraw from {wallet.id[0:5]}",
-            "balanceCheck": url_for(
-                "core.lnurl_full_withdraw", usr=user.id, wal=wallet.id, _external=True
-            ),
+            "balanceCheck": url_for("/withdraw", external=True, usr=user.id, wal=wallet.id),
         }
 
 
 @core_html_routes.get("/withdraw/cb")
-@validate_uuids(["usr", "wal"], required=True)
-async def lnurl_full_withdraw_callback():
+# @validate_uuids(["usr", "wal"], required=True)
+async def lnurl_full_withdraw_callback(request: Request):
     user = await get_user(request.args.get("usr"))
     if not user:
         return {"status": "ERROR", "reason": "User does not exist."}
@@ -166,34 +152,35 @@ async def lnurl_full_withdraw_callback():
 
 
 @core_html_routes.get("/deletewallet")
-@validate_uuids(["usr", "wal"], required=True)
-@check_user_exists()
-async def deletewallet():
-    wallet_id = request.args.get("wal", type=str)
-    user_wallet_ids = g.user.wallet_ids
+# @validate_uuids(["usr", "wal"], required=True)
+# @check_user_exists()
+async def deletewallet(request: Request):
+    wallet_id = request.path_params.get("wal", type=str)
+    user_wallet_ids = g().user.wallet_ids
 
     if wallet_id not in user_wallet_ids:
         abort(HTTPStatus.FORBIDDEN, "Not your wallet.")
     else:
-        await delete_wallet(user_id=g.user.id, wallet_id=wallet_id)
+        await delete_wallet(user_id=g().user.id, wallet_id=wallet_id)
         user_wallet_ids.remove(wallet_id)
 
     if user_wallet_ids:
-        return redirect(url_for("core.wallet", usr=g.user.id, wal=user_wallet_ids[0]))
+        return RedirectResponse(url_for("/wallet", usr=g().user.id, wal=user_wallet_ids[0]), 
+                                status_code=status.HTTP_307_TEMPORARY_REDIRECT)        
 
-    return redirect(url_for("core.home"))
+    return RedirectResponse(url_for("/"), status_code=status.HTTP_307_TEMPORARY_REDIRECT)        
 
 
 @core_html_routes.get("/withdraw/notify/{service}")
-@validate_uuids(["wal"], required=True)
-async def lnurl_balance_notify(service: str):
+# @validate_uuids(["wal"], required=True)
+async def lnurl_balance_notify(request: Request, service: str):
     bc = await get_balance_check(request.args.get("wal"), service)
     if bc:
         redeem_lnurl_withdraw(bc.wallet, bc.url)
 
 
 @core_html_routes.get("/lnurlwallet")
-async def lnurlwallet():
+async def lnurlwallet(request: Request):
     async with db.connect() as conn:
         account = await create_account(conn=conn)
         user = await get_user(account.id, conn=conn)

lnbits/core/views/public_api.py

@@ -1,7 +1,6 @@
 import trio
 import datetime
 from http import HTTPStatus
-from quart import jsonify
 
 from lnbits import bolt11