Merge remote-tracking branch 'origin/main' into qrcodemaker

2022-07-28 10:48:12 +01:00 · 2022-07-28 10:48:12 +01:00 · 4c8641fe00
commit 4c8641fe00
parent 829e220096 9a9f3ae809
231 changed files with 7526 additions and 1859 deletions
--- a/.dockerignore
+++ b/.dockerignore
@ -0,0 +1,21 @@
+.git
+data
+docker
+docs
+tests
+venv
+tools
+
+*.md
+*.log
+
+.env
+
+.gitignore
+.prettierrc
+LICENSE
+Makefile
+mypy.ini
+package-lock.json
+package.json
+pytest.ini
--- a/.editorconfig
+++ b/.editorconfig
@ -1,16 +0,0 @@
-root = true
-
-[*]
-charset = utf-8
-end_of_line = lf
-insert_final_newline = true
-trim_trailing_whitespace = true
-indent_size = 2
-indent_style = space
-
-[*.md]
-trim_trailing_whitespace = false
-
-[*.py]
-indent_size = 4
-indent_style = space
--- a/.env.example
+++ b/.env.example
@ -1,10 +1,8 @@
-QUART_APP=lnbits.app:create_app()
-QUART_ENV=development
-QUART_DEBUG=true
-
 HOST=127.0.0.1
 PORT=5000

+DEBUG=false
+
 LNBITS_ALLOWED_USERS=""
 LNBITS_ADMIN_USERS=""
 # Extensions only admin can access
@ -32,11 +30,12 @@ LNBITS_SERVICE_FEE="0.0"
 LNBITS_SITE_TITLE="LNbits"
 LNBITS_SITE_TAGLINE="free and open-source lightning wallet"
 LNBITS_SITE_DESCRIPTION="Some description about your service, will display if title is not 'LNbits'"
-# Choose from mint, flamingo, salvador, autumn, monochrome, classic
-LNBITS_THEME_OPTIONS="classic, bitcoin, flamingo, mint, autumn, monochrome, salvador"
+# Choose from mint, flamingo, freedom, salvador, autumn, monochrome, classic
+LNBITS_THEME_OPTIONS="classic, bitcoin, freedom, mint, autumn, monochrome, salvador"
+# LNBITS_CUSTOM_LOGO="https://lnbits.com/assets/images/logo/logo.svg"

 # Choose from LNPayWallet, OpenNodeWallet, LntxbotWallet,
-#             LndRestWallet, CLightningWallet, LNbitsWallet, SparkWallet, FakeWallet
+#             LndRestWallet, CLightningWallet, LNbitsWallet, SparkWallet, FakeWallet, EclairWallet
 LNBITS_BACKEND_WALLET_CLASS=VoidWallet
 # VoidWallet is just a fallback that works without any actual Lightning capabilities,
 # just so you can see the UI before dealing with this file.
@ -77,4 +76,8 @@ OPENNODE_KEY=OPENNODE_ADMIN_KEY

 # FakeWallet
 FAKE_WALLET_SECRET="ToTheMoon1"
-LNBITS_DENOMINATION=sats
+LNBITS_DENOMINATION=sats
+
+# EclairWallet
+ECLAIR_URL=http://127.0.0.1:8283
+ECLAIR_PASS=eclairpw
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@ -1 +1 @@
-custom: https://lnbits.com/paywall/GAqKguK5S8f6w5VNjS9DfK
+custom: https://legend.lnbits.com/paywall/GAqKguK5S8f6w5VNjS9DfK
--- a/.github/workflows/codeql.yml
+++ b/.github/workflows/codeql.yml
@ -2,9 +2,9 @@ name: codeql

 on:
  push:
-    branches: [master, ]
+    branches: [main, ]
  pull_request:
-    branches: [master]
+    branches: [main]
  schedule:
    - cron: '0 12 * * 5'

@ -19,10 +19,10 @@ jobs:
      - run: git checkout HEAD^2
        if: ${{ github.event_name == 'pull_request' }}
      - name: Initialize CodeQL
-        uses: github/codeql-action/init@v1
+        uses: github/codeql-action/init@v2
        with:
          languages: javascript, python
      - name: Autobuild
-        uses: github/codeql-action/autobuild@v1
+        uses: github/codeql-action/autobuild@v2
      - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v1
+        uses: github/codeql-action/analyze@v2
--- a/.github/workflows/formatting.yml
+++ b/.github/workflows/formatting.yml
@ -2,9 +2,9 @@ name: formatting

 on:
  push:
-    branches: [ master ]
+    branches: [ main ]
  pull_request:
-    branches: [ master ]
+    branches: [ main ]

 jobs:
  black:
@ -15,9 +15,22 @@ jobs:
      - run: python3 -m venv venv
      - run: ./venv/bin/pip install black
      - run: make checkblack
+  isort:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+      - run: sudo apt-get install python3-venv
+      - run: python3 -m venv venv
+      - run: ./venv/bin/pip install isort
+      - run: make checkisort
+            
  prettier:
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v2
-      - run: npm install
-      - run: make checkprettier
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+      - run: sudo apt-get install python3-venv
+      - run: python3 -m venv venv
+      - run: npm install prettier
+      - run: ./node_modules/.bin/prettier --check lnbits/static/js/*.js lnbits/core/static/js/*.js lnbits/extensions/*/templates/*/*.html ./lnbits/core/templates/core/*.html lnbits/templates/*.html lnbits/extensions/*/static/js/*.js
--- a/.github/workflows/migrations.yml
+++ b/.github/workflows/migrations.yml
@ -0,0 +1,51 @@
+name: migrations
+
+on: [pull_request]
+
+jobs:
+  sqlite-to-postgres:
+    runs-on: ubuntu-latest
+    services:
+      postgres:
+        image: postgres:latest
+        env:
+          POSTGRES_USER: postgres
+          POSTGRES_PASSWORD: postgres
+          POSTGRES_DB: postgres
+        ports:
+          # maps tcp port 5432 on service container to the host
+          - 5432:5432
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+    strategy:
+      matrix:
+        python-version: [3.8]
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v2
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install dependencies
+        env: 
+          VIRTUAL_ENV: ./venv
+          PATH: ${{ env.VIRTUAL_ENV }}/bin:${{ env.PATH }}
+        run: |
+          python -m venv ${{ env.VIRTUAL_ENV }}
+          ./venv/bin/python -m pip install --upgrade pip
+          ./venv/bin/pip install -r requirements.txt
+          ./venv/bin/pip install pytest pytest-asyncio pytest-cov requests mock
+          sudo apt install unzip
+      - name: Run migrations
+        run: |
+          rm -rf ./data
+          mkdir -p ./data
+          export LNBITS_DATA_FOLDER="./data"
+          unzip tests/data/mock_data.zip -d ./data
+          timeout 5s ./venv/bin/uvicorn lnbits.__main__:app --host 0.0.0.0 --port 5001 || code=$?; if [[ $code -ne 124 && $code -ne 0 ]]; then exit $code; fi
+          export LNBITS_DATABASE_URL="postgres://postgres:postgres@0.0.0.0:5432/postgres"
+          timeout 5s ./venv/bin/uvicorn lnbits.__main__:app --host 0.0.0.0 --port 5001 || code=$?; if [[ $code -ne 124 && $code -ne 0 ]]; then exit $code; fi
+          ./venv/bin/python tools/conv.py
--- a/.github/workflows/mypy.yml
+++ b/.github/workflows/mypy.yml
@ -10,4 +10,4 @@ jobs:
      - uses: jpetrucciani/mypy-check@master
        with:
          mypy_flags: '--install-types --non-interactive'
-          path: lnbits
+          path: 'lnbits'
--- a/.github/workflows/regtest.yml
+++ b/.github/workflows/regtest.yml
@ -0,0 +1,83 @@
+name: regtest
+
+on: [push, pull_request]
+
+jobs:
+  LndRestWallet:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: [3.8]
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v2
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Setup Regtest
+        run: |
+          git clone https://github.com/lnbits/legend-regtest-enviroment.git docker
+          cd docker
+          chmod +x ./tests
+          ./tests
+          sudo chmod -R a+rwx .
+      - name: Install dependencies
+        env:
+          VIRTUAL_ENV: ./venv
+          PATH: ${{ env.VIRTUAL_ENV }}/bin:${{ env.PATH }}
+        run: |
+          python -m venv ${{ env.VIRTUAL_ENV }}
+          ./venv/bin/python -m pip install --upgrade pip
+          ./venv/bin/pip install -r requirements.txt
+          ./venv/bin/pip install pylightning
+          ./venv/bin/pip install pytest pytest-asyncio pytest-cov requests mock
+      - name: Run tests
+        env:
+          PYTHONUNBUFFERED: 1
+          PORT: 5123
+          LNBITS_DATA_FOLDER: ./data
+          LNBITS_BACKEND_WALLET_CLASS: LndRestWallet
+          LND_REST_ENDPOINT: https://localhost:8081/
+          LND_REST_CERT: ./docker/data/lnd-1/tls.cert
+          LND_REST_MACAROON: ./docker/data/lnd-1/data/chain/bitcoin/regtest/admin.macaroon
+        run: |
+          sudo chmod -R a+rwx . && rm -rf ./data && mkdir -p ./data
+          make test-real-wallet
+  CLightningWallet:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: [3.8]
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v2
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Setup Regtest
+        run: |
+          git clone https://github.com/lnbits/legend-regtest-enviroment.git docker
+          cd docker
+          chmod +x ./tests
+          ./tests
+          sudo chmod -R a+rwx .
+      - name: Install dependencies
+        env:
+          VIRTUAL_ENV: ./venv
+          PATH: ${{ env.VIRTUAL_ENV }}/bin:${{ env.PATH }}
+        run: |
+          python -m venv ${{ env.VIRTUAL_ENV }}
+          ./venv/bin/python -m pip install --upgrade pip
+          ./venv/bin/pip install -r requirements.txt
+          ./venv/bin/pip install pylightning
+          ./venv/bin/pip install pytest pytest-asyncio pytest-cov requests mock
+      - name: Run tests
+        env:
+          PYTHONUNBUFFERED: 1
+          PORT: 5123
+          LNBITS_DATA_FOLDER: ./data
+          LNBITS_BACKEND_WALLET_CLASS: CLightningWallet
+          CLIGHTNING_RPC: ./docker/data/clightning-1/regtest/lightning-rpc
+        run: |
+          sudo chmod -R a+rwx . && rm -rf ./data && mkdir -p ./data
+          make test-real-wallet
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@ -3,15 +3,15 @@ name: tests
 on: [push, pull_request]

 jobs:
-  unit:
+  venv-sqlite:
    runs-on: ubuntu-latest
    strategy:
      matrix:
-        python-version: [3.8]
+        python-version: [3.7, 3.8, 3.9]
    steps:
      - uses: actions/checkout@v2
      - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v1
+        uses: actions/setup-python@v2
        with:
          python-version: ${{ matrix.python-version }}
      - name: Install dependencies
@ -22,37 +22,67 @@ jobs:
          python -m venv ${{ env.VIRTUAL_ENV }}
          ./venv/bin/python -m pip install --upgrade pip
          ./venv/bin/pip install -r requirements.txt
-          ./venv/bin/pip install pytest pytest-asyncio requests trio mock
+          ./venv/bin/pip install pytest pytest-asyncio pytest-cov requests mock
      - name: Run tests
        run: make test
-  # build:
-  #   runs-on: ubuntu-latest
-  #   strategy:
-  #     matrix:
-  #       python-version: [3.7, 3.8]
-  #   steps:
-  #     - uses: actions/checkout@v2
-  #     - name: Set up Python ${{ matrix.python-version }}
-  #       uses: actions/setup-python@v1
-  #       with:
-  #         python-version: ${{ matrix.python-version }}
-  #     - name: Install dependencies
-  #       run: |
-  #         python -m pip install --upgrade pip
-  #         pip install -r requirements.txt
-  #     - name: Test with pytest
-  #       env:
-  #         LNBITS_BACKEND_WALLET_CLASS: LNPayWallet
-  #         LNBITS_FORCE_HTTPS: 0
-  #         LNPAY_API_ENDPOINT: https://api.lnpay.co/v1/
-  #         LNPAY_API_KEY: sak_gG5pSFZhFgOLHm26a8hcWvXKt98yd
-  #         LNPAY_ADMIN_KEY: waka_HqWfOoNE0TPqmQHSYErbF4n9
-  #         LNPAY_INVOICE_KEY: waki_ZqFEbhrTyopuPlOZButZUw
-  #         LNPAY_READ_KEY: wakr_6IyTaNrvSeu3jbojSWt4ou6h
-  #       run: |
-  #         pip install pytest pytest-cov
-  #         pytest --cov=lnbits --cov-report=xml
-  #     - name: Upload coverage to Codecov
-  #       uses: codecov/codecov-action@v1
-  #       with:
-  #         file: ./coverage.xml
+  venv-postgres:
+    runs-on: ubuntu-latest
+    services:
+      postgres:
+        image: postgres:latest
+        env:
+          POSTGRES_USER: postgres
+          POSTGRES_PASSWORD: postgres
+          POSTGRES_DB: postgres
+        ports:
+          # maps tcp port 5432 on service container to the host
+          - 5432:5432
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+    strategy:
+      matrix:
+        python-version: [3.8]
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v2
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install dependencies
+        env: 
+          VIRTUAL_ENV: ./venv
+          PATH: ${{ env.VIRTUAL_ENV }}/bin:${{ env.PATH }}
+        run: |
+          python -m venv ${{ env.VIRTUAL_ENV }}
+          ./venv/bin/python -m pip install --upgrade pip
+          ./venv/bin/pip install -r requirements.txt
+          ./venv/bin/pip install pytest pytest-asyncio pytest-cov requests mock
+      - name: Run tests
+        env:
+          LNBITS_DATABASE_URL: postgres://postgres:postgres@0.0.0.0:5432/postgres
+        run: make test
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v3
+        with:
+          file: ./coverage.xml
+  pipenv-sqlite:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: [3.7, 3.8, 3.9]
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v2
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install dependencies
+        run: |
+          pip install pipenv
+          pipenv install --dev
+          pipenv install importlib-metadata
+      - name: Run tests
+        run: make test-pipenv
--- a/.gitignore
+++ b/.gitignore
@ -15,7 +15,7 @@ __pycache__
 .webassets-cache
 htmlcov
 test-reports
-tests/data
+tests/data/*.sqlite3

 *.swo
 *.swp
@ -31,5 +31,10 @@ venv

 __bundle__

+coverage.xml
 node_modules
 lnbits/static/bundle.*
+docker
+
+# Nix
+*result*
--- a/2
+++ b/2
@ -8,7 +8,7 @@ ENV PATH="$VIRTUAL_ENV/bin:$PATH"

 # Install build deps
 RUN apt-get update
-RUN apt-get install -y --no-install-recommends build-essential pkg-config
+RUN apt-get install -y --no-install-recommends build-essential pkg-config libpq-dev
 RUN python -m pip install --upgrade pip
 RUN pip install wheel

--- a/30
+++ b/30
@ -2,7 +2,7 @@

 all: format check requirements.txt

-format: prettier black
+format: prettier isort black

 check: mypy checkprettier checkblack

@ -17,12 +17,18 @@ mypy: $(shell find lnbits -name "*.py")
 	./venv/bin/mypy lnbits/core
 	./venv/bin/mypy lnbits/extensions/*

+isort: $(shell find lnbits -name "*.py")
+	./venv/bin/isort --profile black lnbits
+
 checkprettier: $(shell find lnbits -name "*.js" -name ".html")
 	./node_modules/.bin/prettier --check lnbits/static/js/*.js lnbits/core/static/js/*.js lnbits/extensions/*/templates/*/*.html ./lnbits/core/templates/core/*.html lnbits/templates/*.html lnbits/extensions/*/static/js/*.js

 checkblack: $(shell find lnbits -name "*.py")
 	./venv/bin/black --check lnbits

+checkisort: $(shell find lnbits -name "*.py")
+	./venv/bin/isort --profile black --check-only lnbits
+
 Pipfile.lock: Pipfile
 	./venv/bin/pipenv lock

@ -30,8 +36,26 @@ requirements.txt: Pipfile.lock
 	cat Pipfile.lock | jq -r '.default | map_values(.version) | to_entries | map("\(.key)\(.value)") | join("\n")' > requirements.txt

 test:
-	rm -rf ./tests/data
+	mkdir -p ./tests/data
+	LNBITS_BACKEND_WALLET_CLASS="FakeWallet" \
+	FAKE_WALLET_SECRET="ToTheMoon1" \
+	LNBITS_DATA_FOLDER="./tests/data" \
+	PYTHONUNBUFFERED=1 \
+	./venv/bin/pytest --durations=1 -s --cov=lnbits --cov-report=xml tests
+
+test-real-wallet:
 	mkdir -p ./tests/data
 	LNBITS_DATA_FOLDER="./tests/data" \
 	PYTHONUNBUFFERED=1 \
-	./venv/bin/pytest -s
+	./venv/bin/pytest --durations=1 -s --cov=lnbits --cov-report=xml tests
+
+test-pipenv:
+	mkdir -p ./tests/data
+	LNBITS_BACKEND_WALLET_CLASS="FakeWallet" \
+	FAKE_WALLET_SECRET="ToTheMoon1" \
+	LNBITS_DATA_FOLDER="./tests/data" \
+	PYTHONUNBUFFERED=1 \
+	pipenv run pytest --durations=1 -s --cov=lnbits --cov-report=xml tests
+
+bak:
+	# LNBITS_DATABASE_URL=postgres://postgres:postgres@0.0.0.0:5432/postgres
--- a/15
+++ b/15
@ -4,7 +4,7 @@ url = "https://pypi.org/simple"
 verify_ssl = true

 [requires]
-python_version = "3.7"
+python_version = "3.8"

 [packages]
 bitstring = "*"
@ -12,6 +12,7 @@ cerberus = "*"
 ecdsa = "*"
 environs = "*"
 lnurl = "==0.3.6"
+loguru = "*"
 pyscss = "*"
 shortuuid = "*"
 typing-extensions = "*"
@ -27,13 +28,19 @@ asyncio = "*"
 fastapi = "*"
 uvicorn = {extras = ["standard"], version = "*"}
 sse-starlette = "*"
-jinja2 = "3.0.1"
+jinja2 = "==3.0.1"
 pyngrok = "*"
-secp256k1 = "*"
+secp256k1 = "==0.14.0"
+cffi = "==1.15.0"
 pycryptodomex = "*"

 [dev-packages]
 black = "==20.8b1"
+mock = "*"
+mypy = "*"
 pytest = "*"
+pytest-asyncio = "*"
 pytest-cov = "*"
-mypy = "latest"
+requests = "*"
+types-mock = "*"
+types-protobuf = "*"
--- a/Pipfile.lock
+++ b/Pipfile.lock
--- a/1
+++ b/1
@ -1 +0,0 @@
-web: hypercorn -k trio --bind 0.0.0.0:5000 'lnbits.app:create_app()'
--- a/README.md
+++ b/README.md
@ -7,13 +7,13 @@ LNbits

 ![Lightning network wallet](https://i.imgur.com/EHvK6Lq.png)

-# LNbits v0.3 BETA, free and open-source lightning-network wallet/accounts system
+# LNbits v0.9 BETA, free and open-source lightning-network wallet/accounts system

 (Join us on [https://t.me/lnbits](https://t.me/lnbits))

 (LNbits is beta, for responsible disclosure of any concerns please contact lnbits@pm.me)

-Use [lnbits.com](https://lnbits.com), or run your own LNbits server!
+Use [legend.lnbits.com](https://legend.lnbits.com), or run your own LNbits server!

 LNbits is a very simple Python server that sits on top of any funding source, and can be used as:

@ -33,7 +33,7 @@ LNbits is inspired by all the great work of [opennode.com](https://www.opennode.

 ## Running LNbits

-See the [install guide](docs/devs/installation.md) for details on installation and setup.
+See the [install guide](docs/guide/installation.md) for details on installation and setup.

 ## LNbits as an account system

@ -67,7 +67,7 @@ Wallets can be easily generated and given out to people at events (one click mul

 ## Tip us

-If you like this project and might even use or extend it, why not [send some tip love](https://lnbits.com/paywall/GAqKguK5S8f6w5VNjS9DfK)!
+If you like this project and might even use or extend it, why not [send some tip love](https://legend.lnbits.com/paywall/GAqKguK5S8f6w5VNjS9DfK)!


 [docs]: https://lnbits.org/
--- a/app.json
+++ b/app.json
@ -1,7 +0,0 @@
-{
-  "scripts": {
-    "dokku": {
-      "predeploy": "quart migrate && quart assets"
-    }
-  }
-}
--- a/build.py
+++ b/build.py
@ -0,0 +1,110 @@
+import warnings
+import subprocess
+import glob
+import os
+from os import path
+from typing import Any, List, NamedTuple, Optional
+from pathlib import Path
+
+LNBITS_PATH = path.dirname(path.realpath(__file__)) + "/lnbits"
+
+def get_js_vendored(prefer_minified: bool = False) -> List[str]:
+    paths = get_vendored(".js", prefer_minified)
+
+    def sorter(key: str):
+        if "moment@" in key:
+            return 1
+        if "vue@" in key:
+            return 2
+        if "vue-router@" in key:
+            return 3
+        if "polyfills" in key:
+            return 4
+        return 9
+
+    return sorted(paths, key=sorter)
+
+
+def get_css_vendored(prefer_minified: bool = False) -> List[str]:
+    paths = get_vendored(".css", prefer_minified)
+
+    def sorter(key: str):
+        if "quasar@" in key:
+            return 1
+        if "vue@" in key:
+            return 2
+        if "chart.js@" in key:
+            return 100
+        return 9
+
+    return sorted(paths, key=sorter)
+
+
+def get_vendored(ext: str, prefer_minified: bool = False) -> List[str]:
+    paths: List[str] = []
+    for path in glob.glob(
+        os.path.join(LNBITS_PATH, "static/vendor/**"), recursive=True
+    ):
+        if path.endswith(".min" + ext):
+            # path is minified
+            unminified = path.replace(".min" + ext, ext)
+            if prefer_minified:
+                paths.append(path)
+                if unminified in paths:
+                    paths.remove(unminified)
+            elif unminified not in paths:
+                paths.append(path)
+
+        elif path.endswith(ext):
+            # path is not minified
+            minified = path.replace(ext, ".min" + ext)
+            if not prefer_minified:
+                paths.append(path)
+                if minified in paths:
+                    paths.remove(minified)
+            elif minified not in paths:
+                paths.append(path)
+
+    return sorted(paths)
+
+
+def url_for_vendored(abspath: str) -> str:
+    return "/" + os.path.relpath(abspath, LNBITS_PATH)
+
+def transpile_scss():
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        from scss.compiler import compile_string  # type: ignore
+
+        with open(os.path.join(LNBITS_PATH, "static/scss/base.scss")) as scss:
+            with open(os.path.join(LNBITS_PATH, "static/css/base.css"), "w") as css:
+                css.write(compile_string(scss.read()))
+
+def bundle_vendored():
+    for getfiles, outputpath in [
+        (get_js_vendored, os.path.join(LNBITS_PATH, "static/bundle.js")),
+        (get_css_vendored, os.path.join(LNBITS_PATH, "static/bundle.css")),
+    ]:
+        output = ""
+        for path in getfiles():
+            with open(path) as f:
+                output += "/* " + url_for_vendored(path) + " */\n" + f.read() + ";\n"
+        with open(outputpath, "w") as f:
+            f.write(output)
+
+
+def build():
+    transpile_scss()
+    bundle_vendored()
+#    root = Path("lnbits/static/foo")
+#    root.mkdir(parents=True)
+#    root.joinpath("example.css").write_text("")
+
+if __name__ == "__main__":
+   build()
+
+#def build(setup_kwargs):
+#    """Build """
+#    transpile_scss()
+#    bundle_vendored()
+#    subprocess.run(["ls", "-la", "./lnbits/static"])
--- a/docs/devs/development.md
+++ b/docs/devs/development.md
@ -17,7 +17,7 @@ Tests

 This project has unit tests that help prevent regressions. Before you can run the tests, you must install a few dependencies:
 ```bash
-./venv/bin/pip install pytest pytest-asyncio requests trio mock
+./venv/bin/pip install pytest pytest-asyncio pytest-cov requests mock
 ```

 Then to run the tests:
--- a/docs/devs/extensions.md
+++ b/docs/devs/extensions.md
@ -15,6 +15,7 @@ cp lnbits/extensions/example lnbits/extensions/mysuperplugin -r # Let's not use
 cd lnbits/extensions/mysuperplugin
 find . -type f -print0 | xargs -0 sed -i 's/example/mysuperplugin/g' # Change all occurrences of 'example' to your plugin name 'mysuperplugin'.
 ```
+- if you are on macOS and having difficulty with 'sed', consider `brew install gnu-sed` and use 'gsed', without -0 option after xargs.

 Going over the example extension's structure:
 * views_api.py: This is where your public API would go. It will be exposed at "$DOMAIN/$PLUGIN/$ROUTE". For example: https://lnbits.com/mysuperplugin/api/v1/tools.
--- a/docs/devs/installation.md
+++ b/docs/devs/installation.md
@ -7,46 +7,10 @@ nav_order: 1

 # Installation

-LNbits uses [Pipenv][pipenv] to manage Python packages.
+This guide has been moved to the [installation guide](../guide/installation.md). 
+To install the developer packages, use `pipenv install --dev`.

-```sh
-git clone https://github.com/lnbits/lnbits-legend.git
-cd lnbits-legend/
+## Notes:

-sudo apt-get install pipenv
-pipenv shell
-# pipenv --python 3.9 shell (if you wish to use a version of Python higher than 3.7)
-pipenv install --dev
-# pipenv --python 3.9 install --dev (if you wish to use a version of Python higher than 3.7)
-
-# If any of the modules fails to install, try checking and upgrading your setupTool module
-# pip install -U setuptools
-
-# install libffi/libpq in case "pipenv install" fails
-# sudo apt-get install -y libffi-dev libpq-dev
-``` 
-## Running the server
-
-Create the data folder and edit the .env file:
-
-    mkdir data
-    cp .env.example .env
-    sudo nano .env
-
-To then run the server for development purposes (includes hot-reload), use:
-
-    pipenv run python -m uvicorn lnbits.__main__:app --host 0.0.0.0  --reload
-    
-For production, use:
-
-    pipenv run python -m uvicorn lnbits.__main__:app --host 0.0.0.0
-
-You might also need to install additional packages, depending on the [backend wallet](../guide/wallets.md) you use.
-E.g. when you want to use LND you have to `pipenv run pip install lndgrpc` and `pipenv run pip install purerpc`.
-
-Take a look at [Polar][polar] for an excellent way of spinning up a Lightning Network dev environment.
-
-**Notes**: 
-
-* We reccomend using <a href="https://caddyserver.com/docs/install#debian-ubuntu-raspbian">Caddy</a> for a reverse-proxy if you want to serve your install through a domain, alternatively you can use [ngrok](https://ngrok.com/).
+* We recommend using <a href="https://caddyserver.com/docs/install#debian-ubuntu-raspbian">Caddy</a> for a reverse-proxy if you want to serve your install through a domain, alternatively you can use [ngrok](https://ngrok.com/).
 * <a href="https://linuxize.com/post/how-to-use-linux-screen/#starting-linux-screen">Screen</a> works well if you want LNbits to continue running when you close your terminal session.
--- a/docs/guide/installation.md
+++ b/docs/guide/installation.md
@ -4,8 +4,125 @@ title: Basic installation
 nav_order: 2
 ---

+
+
 # Basic installation
-Install Postgres and setup a database for LNbits:
+
+You can choose between four package managers, `poetry`, `pipenv`, `venv` and `nix`.
+
+By default, LNbits will use SQLite as its database. You can also use PostgreSQL which is recommended for applications with a high load (see guide below).
+
+## Option 1: poetry
+
+```sh
+git clone https://github.com/lnbits/lnbits-legend.git
+cd lnbits-legend/
+
+curl -sSL https://install.python-poetry.org | python3 -
+poetry install 
+
+# You may need to install python 3.9, update your python following this guide https://linuxize.com/post/how-to-install-python-3-9-on-ubuntu-20-04/
+
+ mkdir data && cp .env.example .env
+``` 
+
+#### Running the server
+    
+```sh
+poetry run lnbits
+# To change port/host pass 'poetry run lnbits --port 9000 --host 0.0.0.0'
+```
+
+## Option 2: pipenv
+
+```sh
+git clone https://github.com/lnbits/lnbits-legend.git
+cd lnbits-legend/
+
+sudo apt update && sudo apt install -y pipenv
+pipenv install --dev
+# pipenv --python 3.9 install --dev (if you wish to use a version of Python higher than 3.7)
+pipenv shell
+# pipenv --python 3.9 shell (if you wish to use a version of Python higher than 3.7)
+
+# If any of the modules fails to install, try checking and upgrading your setupTool module
+# pip install -U setuptools wheel
+
+# install libffi/libpq in case "pipenv install" fails
+# sudo apt-get install -y libffi-dev libpq-dev
+
+ mkdir data && cp .env.example .env
+``` 
+
+#### Running the server
+    
+```sh
+pipenv run python -m uvicorn lnbits.__main__:app --port 5000 --host 0.0.0.0
+```
+
+Add the flag `--reload` for development (includes hot-reload).
+
+
+## Option 3: venv
+
+```sh
+git clone https://github.com/lnbits/lnbits-legend.git
+cd lnbits-legend/
+# ensure you have virtualenv installed, on debian/ubuntu 'apt install python3-venv'
+python3 -m venv venv
+# If you have problems here, try `sudo apt install -y pkg-config libpq-dev`
+./venv/bin/pip install -r requirements.txt
+# create the data folder and the .env file
+mkdir data && cp .env.example .env
+```
+
+#### Running the server
+
+```sh
+./venv/bin/uvicorn lnbits.__main__:app --port 5000
+```
+
+If you want to host LNbits on the internet, run with the option `--host 0.0.0.0`. 
+
+## Option 4: Nix
+
+```sh
+git clone https://github.com/lnbits/lnbits-legend.git
+cd lnbits-legend/
+# Install nix, modern debian distros usually already include
+sh <(curl -L https://nixos.org/nix/install) --daemon
+
+nix build .#lnbits 
+mkdir data
+
+```
+
+#### Running the server
+
+```sh
+# .env variables are currently passed when running
+LNBITS_DATA_FOLDER=data LNBITS_BACKEND_WALLET_CLASS=LNbitsWallet LNBITS_ENDPOINT=https://legend.lnbits.com LNBITS_KEY=7b1a78d6c78f48b09a202f2dcb2d22eb ./result/bin/lnbits --port 9000
+```
+
+### Troubleshooting
+
+Problems installing? These commands have helped us install LNbits. 
+
+```sh
+sudo apt install pkg-config libffi-dev libpq-dev
+
+# if the secp256k1 build fails:
+# if you used pipenv (option 1)
+pipenv install setuptools wheel 
+# if you used venv (option 2)
+./venv/bin/pip install setuptools wheel 
+# build essentials for debian/ubuntu
+sudo apt install python3-dev gcc build-essential
+```
+
+### Optional: PostgreSQL database
+
+If you want to use LNbits at scale, we recommend using PostgreSQL as the backend database. Install Postgres and setup a database for LNbits:

 ```sh
 # on debian/ubuntu 'sudo apt-get -y install postgresql'
@ -22,53 +139,54 @@ createdb lnbits
 exit
 ```

-Download this repo and install the dependencies:
+You need to edit the `.env` file.

 ```sh
-git clone https://github.com/lnbits/lnbits-legend.git
-cd lnbits-legend/
-# ensure you have virtualenv installed, on debian/ubuntu 'apt install python3-venv' should work
-python3 -m venv venv
-./venv/bin/pip install -r requirements.txt
-cp .env.example .env
 # add the database connection string to .env 'nano .env' LNBITS_DATABASE_URL=
 # postgres://<user>:<myPassword>@<host>/<lnbits> - alter line bellow with your user, password and db name
 LNBITS_DATABASE_URL="postgres://postgres:postgres@localhost/lnbits"
 # save and exit
-./venv/bin/uvicorn lnbits.__main__:app --port 5000
 ```

+# Using LNbits
+
 Now you can visit your LNbits at http://localhost:5000/. 

-Now modify the `.env` file with any settings you prefer and add a proper [funding source](./wallets.md) by modifying the value of `LNBITS_BACKEND_WALLET_CLASS` and providing the extra information and credentials related to the chosen funding source.
+Now modify the `.env` file with any settings you prefer and add a proper [funding source](./wallets.md) by modifying the value of `LNBITS_BACKEND_WALLET_CLASS` and providing the extra information and credentials related to the chosen funding source. 

 Then you can restart it and it will be using the new settings.

-You might also need to install additional packages or perform additional setup steps, depending on the chosen backend. See [the short guide](./wallets.md) on each different funding source.
+You might also need to install additional packages or perform additional setup steps, depending on the chosen backend. See [the short guide](./wallets.md) on each different funding source. 

-## Important note
-If you already have LNbits installed and running, on an SQLite database, we **HIGHLY** recommend you migrate to postgres!
-
-There's a script included that can do the migration easy. You should have Postgres already installed and there should be a password for the user, check the guide above.
-
-```sh
-# STOP LNbits
-# on the LNBits folder, locate and edit 'conv.py' with the relevant credentials
-python3 conv.py
-
-# add the database connection string to .env 'nano .env' LNBITS_DATABASE_URL=
-# postgres://<user>:<password>@<host>/<database> - alter line bellow with your user, password and db name
-LNBITS_DATABASE_URL="postgres://postgres:postgres@localhost/lnbits"
-# save and exit
-```
-
-Hopefully, everything works and get migrated... Launch LNbits again and check if everything is working properly.
+Take a look at [Polar](https://lightningpolar.com/) for an excellent way of spinning up a Lightning Network dev environment.



 # Additional guides

-### LNbits as a systemd service
+## SQLite to PostgreSQL migration
+If you already have LNbits installed and running, on an SQLite database, we **highly** recommend you migrate to postgres if you are planning to run LNbits on scale.
+
+There's a script included that can do the migration easy. You should have Postgres already installed and there should be a password for the user (see Postgres install guide above). Additionally, your LNbits instance should run once on postgres to implement the database schema before the migration works:
+
+```sh
+# STOP LNbits
+
+# add the database connection string to .env 'nano .env' LNBITS_DATABASE_URL=
+# postgres://<user>:<password>@<host>/<database> - alter line bellow with your user, password and db name
+LNBITS_DATABASE_URL="postgres://postgres:postgres@localhost/lnbits"
+# save and exit
+
+# START LNbits
+# STOP LNbits
+# on the LNBits folder, locate and edit 'tools/conv.py' with the relevant credentials
+python3 tools/conv.py
+```
+
+Hopefully, everything works and get migrated... Launch LNbits again and check if everything is working properly.
+
+
+## LNbits as a systemd service

 Systemd is great for taking care of your LNbits instance. It will start it on boot and restart it in case it crashes. If you want to run LNbits as a systemd service on your Debian/Ubuntu/Raspbian server, create a file at `/etc/systemd/system/lnbits.service` with the following content:

@ -78,17 +196,23 @@ Systemd is great for taking care of your LNbits instance. It will start it on bo

 [Unit]
 Description=LNbits
-#Wants=lnd.service # you can uncomment these lines if you know what you're doing
-#After=lnd.service # it will make sure that lnbits starts after lnd (replace with your own backend service)
+# you can uncomment these lines if you know what you're doing
+# it will make sure that lnbits starts after lnd (replace with your own backend service)
+#Wants=lnd.service 
+#After=lnd.service 

 [Service]
-WorkingDirectory=/home/bitcoin/lnbits # replace with the absolute path of your lnbits installation
-ExecStart=/home/bitcoin/lnbits/venv/bin/uvicorn lnbits.__main__:app --port 5000 # same here
-User=bitcoin # replace with the user that you're running lnbits on
+# replace with the absolute path of your lnbits installation
+WorkingDirectory=/home/bitcoin/lnbits 
+# same here
+ExecStart=/home/bitcoin/lnbits/venv/bin/uvicorn lnbits.__main__:app --port 5000 
+# replace with the user that you're running lnbits on
+User=bitcoin 
 Restart=always
 TimeoutSec=120
 RestartSec=30
-Environment=PYTHONUNBUFFERED=1 # this makes sure that you receive logs in real time
+# this makes sure that you receive logs in real time
+Environment=PYTHONUNBUFFERED=1 

 [Install]
 WantedBy=multi-user.target
@ -101,11 +225,40 @@ sudo systemctl enable lnbits.service
 sudo systemctl start lnbits.service
 ```

-### LNbits running on Umbrel behind Tor
+## Using https without reverse proxy
+The most common way of using LNbits via https is to use a reverse proxy such as Caddy, nginx, or ngriok. However, you can also run LNbits via https without additional software. This is useful for development purposes or if you want to use LNbits in your local network. 
+
+We have to create a self-signed certificate using `mkcert`. Note that this certiciate is not "trusted" by most browsers but that's fine (since you know that you have created it) and encryption is always better than clear text.
+
+#### Install mkcert
+You can find the install instructions for `mkcert` [here](https://github.com/FiloSottile/mkcert). 
+
+Install mkcert on Ubuntu:
+```sh
+sudo apt install libnss3-tools
+curl -JLO "https://dl.filippo.io/mkcert/latest?for=linux/amd64"
+chmod +x mkcert-v*-linux-amd64
+sudo cp mkcert-v*-linux-amd64 /usr/local/bin/mkcert
+```
+#### Create certificate
+To create a certificate, first `cd` into your lnbits folder and execute the following command ([more info](https://kifarunix.com/how-to-create-self-signed-ssl-certificate-with-mkcert-on-ubuntu-18-04/))
+```sh
+# add your local IP (192.x.x.x) as well if you want to use it in your local network
+mkcert localhost 127.0.0.1 ::1 
+```
+
+This will create two new files (`localhost-key.pem` and `localhost.pem `) which you can then pass to uvicorn when you start LNbits:
+
+```sh
+./venv/bin/uvicorn lnbits.__main__:app --host 0.0.0.0 --port 5000 --ssl-keyfile ./localhost-key.pem --ssl-certfile ./localhost.pem 
+```
+
+
+## LNbits running on Umbrel behind Tor

 If you want to run LNbits on your Umbrel but want it to be reached through clearnet, _Uxellodunum_ made an extensive [guide](https://community.getumbrel.com/t/guide-lnbits-without-tor/604) on how to do it.

-### Docker installation
+## Docker installation

 To install using docker you first need to build the docker image as:

@ -137,9 +290,3 @@ docker run --detach --publish 5000:5000 --name lnbits --volume ${PWD}/.env:/app/
 ```

 Finally you can access your lnbits on your machine at port 5000.
-
-# Additional guides
-
-## LNbits running on Umbrel behind Tor
-
-If you want to run LNbits on your Umbrel but want it to be reached through clearnet, _Uxellodunum_ made an extensive [guide](https://community.getumbrel.com/t/guide-lnbits-without-tor/604) on how to do it.
--- a/docs/guide/wallets.md
+++ b/docs/guide/wallets.md
@ -17,7 +17,6 @@ A backend wallet can be configured using the following LNbits environment variab
 ### CLightning

 Using this wallet requires the installation of the `pylightning` Python package.
-If you want to use LNURLp you should use SparkWallet because of an issue with description_hash and CLightning.

 - `LNBITS_BACKEND_WALLET_CLASS`: **CLightningWallet**
 - `CLIGHTNING_RPC`: /file/path/lightning-rpc
--- a/flake.lock
+++ b/flake.lock
@ -0,0 +1,77 @@
+{
+  "nodes": {
+    "flake-utils": {
+      "locked": {
+        "lastModified": 1656928814,
+        "narHash": "sha256-RIFfgBuKz6Hp89yRr7+NR5tzIAbn52h8vT6vXkYjZoM=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "7e2a3b3dfd9af950a856d66b0a7d01e3c18aa249",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1657114324,
+        "narHash": "sha256-fWuaUNXrHcz/ciHRHlcSO92dvV3EVS0GJQUSBO5JIB4=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "a5c867d9fe9e4380452628e8f171c26b69fa9d3d",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs_2": {
+      "locked": {
+        "lastModified": 1657261001,
+        "narHash": "sha256-sUZeuRYfhG59uD6xafM07bc7bAIkpcGq84Vj4B+cyms=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "0be91cefefde5701f8fa957904618a13e3bb51d8",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "poetry2nix": {
+      "inputs": {
+        "flake-utils": "flake-utils",
+        "nixpkgs": "nixpkgs_2"
+      },
+      "locked": {
+        "lastModified": 1657149754,
+        "narHash": "sha256-iSnZoqwNDDVoO175whSuvl4sS9lAb/2zZ3Sa4ywo970=",
+        "owner": "nix-community",
+        "repo": "poetry2nix",
+        "rev": "fc1930e011dea149db81863aac22fe701f36f1b5",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-community",
+        "repo": "poetry2nix",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "nixpkgs": "nixpkgs",
+        "poetry2nix": "poetry2nix"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}
--- a/flake.nix
+++ b/flake.nix
@ -0,0 +1,55 @@
+{
+  inputs = {
+    nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
+    poetry2nix.url = "github:nix-community/poetry2nix";
+  };
+  outputs = { self, nixpkgs, poetry2nix }@inputs:
+    let
+      supportedSystems = [ "x86_64-linux" "aarch64-linux" ];
+      forSystems = systems: f:
+        nixpkgs.lib.genAttrs systems
+        (system: f system (import nixpkgs { inherit system; overlays = [ poetry2nix.overlay self.overlays.default ]; }));
+      forAllSystems = forSystems supportedSystems;
+      projectName = "lnbits";
+    in
+    {
+      devShells = forAllSystems (system: pkgs: {
+        default = pkgs.mkShell {
+          buildInputs = with pkgs; [
+            nodePackages.prettier
+          ];
+        };
+      });
+      overlays = {
+        default = final: prev: {
+          ${projectName} = self.packages.${final.hostPlatform.system}.${projectName};
+        };
+      };
+      packages = forAllSystems (system: pkgs: {
+        default = self.packages.${system}.${projectName};
+        ${projectName} = pkgs.poetry2nix.mkPoetryApplication {
+          projectDir = ./.;
+          python = pkgs.python39;
+        };
+      });
+      nixosModules = {
+        default = { pkgs, lib, config, ... }: {
+          imports = [ "${./nix/modules/${projectName}-service.nix}" ];
+          nixpkgs.overlays = [ self.overlays.default ];
+        };
+      };
+      checks = forAllSystems (system: pkgs:
+        let
+          vmTests = import ./nix/tests {
+            makeTest = (import (nixpkgs + "/nixos/lib/testing-python.nix") { inherit system; }).makeTest;
+            inherit inputs pkgs;
+          };
+        in
+        pkgs.lib.optionalAttrs pkgs.stdenv.isLinux vmTests # vmTests can only be ran on Linux, so append them only if on Linux.
+        //
+        {
+          # Other checks here...
+        }
+      );
+    };
+}
--- a/lnbits/main.py
+++ b/lnbits/main.py
@ -1,36 +1,38 @@
 import asyncio

 import uvloop
+from loguru import logger
 from starlette.requests import Request

-from .commands import bundle_vendored, migrate_databases, transpile_scss
+from .commands import migrate_databases
 from .settings import (
    DEBUG,
+    HOST,
    LNBITS_COMMIT,
    LNBITS_DATA_FOLDER,
+    LNBITS_DATABASE_URL,
    LNBITS_SITE_TITLE,
    PORT,
-    SERVICE_FEE,
    WALLET,
 )

 uvloop.install()

 asyncio.create_task(migrate_databases())
-transpile_scss()
-bundle_vendored()

 from .app import create_app

 app = create_app()

-print(
-    f"""Starting LNbits with
-  - git version: {LNBITS_COMMIT}
-  - site title: {LNBITS_SITE_TITLE}
-  - debug: {DEBUG}
-  - data folder: {LNBITS_DATA_FOLDER}
-  - funding source: {WALLET.__class__.__name__}
-  - service fee: {SERVICE_FEE}
-"""
+logger.info("Starting LNbits")
+logger.info(f"Host: {HOST}")
+logger.info(f"Port: {PORT}")
+logger.info(f"Debug: {DEBUG}")
+logger.info(f"Site title: {LNBITS_SITE_TITLE}")
+logger.info(f"Funding source: {WALLET.__class__.__name__}")
+logger.info(
+    f"Database: {'PostgreSQL' if LNBITS_DATABASE_URL and LNBITS_DATABASE_URL.startswith('postgres://') else 'CockroachDB' if LNBITS_DATABASE_URL and LNBITS_DATABASE_URL.startswith('cockroachdb://') else 'SQLite'}"
 )
+logger.info(f"Data folder: {LNBITS_DATA_FOLDER}")
+logger.info(f"Git version: {LNBITS_COMMIT}")
+# logger.info(f"Service fee: {SERVICE_FEE}")
--- a/lnbits/app.py
+++ b/lnbits/app.py
@ -1,19 +1,22 @@
 import asyncio
 import importlib
+import logging
 import sys
 import traceback
 import warnings
+from http import HTTPStatus

 from fastapi import FastAPI, Request
 from fastapi.exceptions import RequestValidationError
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.middleware.gzip import GZipMiddleware
+from fastapi.responses import JSONResponse
 from fastapi.staticfiles import StaticFiles
+from loguru import logger

 import lnbits.settings
 from lnbits.core.tasks import register_task_listeners

-from .commands import db_migrate, handle_assets
 from .core import core_app
 from .core.views.generic import core_html_routes
 from .helpers import (
@ -39,10 +42,21 @@ def create_app(config_object="lnbits.settings") -> FastAPI:
    """Create application factory.
    :param config_object: The configuration object to use.
    """
-    app = FastAPI()
-    app.mount("/static", StaticFiles(directory="lnbits/static"), name="static")
+    configure_logger()
+
+    app = FastAPI(
+        title="LNbits API",
+        description="API for LNbits, the free and open source bitcoin wallet and accounts system with plugins.",
+        license_info={
+            "name": "MIT License",
+            "url": "https://raw.githubusercontent.com/lnbits/lnbits-legend/main/LICENSE",
+        },
+    )
+    app.mount("/static", StaticFiles(packages=[("lnbits", "static")]), name="static")
    app.mount(
-        "/core/static", StaticFiles(directory="lnbits/core/static"), name="core_static"
+        "/core/static",
+        StaticFiles(packages=[("lnbits.core", "static")]),
+        name="core_static",
    )

    origins = ["*"]
@ -58,15 +72,19 @@ def create_app(config_object="lnbits.settings") -> FastAPI:
    async def validation_exception_handler(
        request: Request, exc: RequestValidationError
    ):
-        return template_renderer().TemplateResponse(
-            "error.html",
-            {"request": request, "err": f"`{exc.errors()}` is not a valid UUID."},
-        )
+        # Only the browser sends "text/html" request
+        # not fail proof, but everything else get's a JSON response

-        # return HTMLResponse(
-        #     status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-        #     content=jsonable_encoder({"detail": exc.errors(), "body": exc.body}),
-        # )
+        if "text/html" in request.headers["accept"]:
+            return template_renderer().TemplateResponse(
+                "error.html",
+                {"request": request, "err": f"{exc.errors()} is not a valid UUID."},
+            )
+
+        return JSONResponse(
+            status_code=HTTPStatus.NO_CONTENT,
+            content={"detail": exc.errors()},
+        )

    app.add_middleware(GZipMiddleware, minimum_size=1000)
    # app.add_middleware(ASGIProxyFix)
@ -74,7 +92,6 @@ def create_app(config_object="lnbits.settings") -> FastAPI:
    check_funding_source(app)
    register_assets(app)
    register_routes(app)
-    # register_commands(app)
    register_async_tasks(app)
    register_exception_handlers(app)

@ -88,14 +105,14 @@ def check_funding_source(app: FastAPI) -> None:
            error_message, balance = await WALLET.status()
            if not error_message:
                break
-            warnings.warn(
-                f"  × The backend for {WALLET.__class__.__name__} isn't working properly: '{error_message}'",
+            logger.error(
+                f"The backend for {WALLET.__class__.__name__} isn't working properly: '{error_message}'",
                RuntimeWarning,
            )
-            print("Retrying connection to backend in 5 seconds...")
+            logger.info("Retrying connection to backend in 5 seconds...")
            await asyncio.sleep(5)
-        print(
-            f"  ✔️ {WALLET.__class__.__name__} seems to be connected and with a balance of {balance} msat."
+        logger.info(
+            f"✔️ Backend {WALLET.__class__.__name__} connected and with a balance of {balance} msat."
        )


@ -118,20 +135,15 @@ def register_routes(app: FastAPI) -> None:
                for s in ext_statics:
                    app.mount(s["path"], s["app"], s["name"])

+            logger.trace(f"adding route for extension {ext_module}")
            app.include_router(ext_route)
        except Exception as e:
-            print(str(e))
+            logger.error(str(e))
            raise ImportError(
                f"Please make sure that the extension `{ext.code}` follows conventions."
            )


-def register_commands(app: FastAPI):
-    """Register Click commands."""
-    app.cli.add_command(db_migrate)
-    app.cli.add_command(handle_assets)
-
-
 def register_assets(app: FastAPI):
    """Serve each vendored asset separately or a bundle."""

@ -167,10 +179,53 @@ def register_async_tasks(app):
 def register_exception_handlers(app: FastAPI):
    @app.exception_handler(Exception)
    async def basic_error(request: Request, err):
-        print("handled error", traceback.format_exc())
+        logger.error("handled error", traceback.format_exc())
+        logger.error("ERROR:", err)
        etype, _, tb = sys.exc_info()
        traceback.print_exception(etype, err, tb)
        exc = traceback.format_exc()
-        return template_renderer().TemplateResponse(
-            "error.html", {"request": request, "err": err}
+
+        if "text/html" in request.headers["accept"]:
+            return template_renderer().TemplateResponse(
+                "error.html", {"request": request, "err": err}
+            )
+
+        return JSONResponse(
+            status_code=HTTPStatus.NO_CONTENT,
+            content={"detail": err},
        )
+
+
+def configure_logger() -> None:
+    logger.remove()
+    log_level: str = "DEBUG" if lnbits.settings.DEBUG else "INFO"
+    formatter = Formatter()
+    logger.add(sys.stderr, level=log_level, format=formatter.format)
+
+    logging.getLogger("uvicorn").handlers = [InterceptHandler()]
+    logging.getLogger("uvicorn.access").handlers = [InterceptHandler()]
+
+
+class Formatter:
+    def __init__(self):
+        self.padding = 0
+        self.minimal_fmt: str = "<green>{time:YYYY-MM-DD HH:mm:ss.SS}</green> | <level>{level}</level> | <level>{message}</level>\n"
+        if lnbits.settings.DEBUG:
+            self.fmt: str = "<green>{time:YYYY-MM-DD HH:mm:ss.SS}</green> | <level>{level: <4}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> | <level>{message}</level>\n"
+        else:
+            self.fmt: str = self.minimal_fmt
+
+    def format(self, record):
+        function = "{function}".format(**record)
+        if function == "emit":  # uvicorn logs
+            return self.minimal_fmt
+        return self.fmt
+
+
+class InterceptHandler(logging.Handler):
+    def emit(self, record):
+        try:
+            level = logger.level(record.levelname).name
+        except ValueError:
+            level = record.levelno
+        logger.log(level, record.getMessage())
--- a/lnbits/bolt11.py
+++ b/lnbits/bolt11.py
@ -1,15 +1,16 @@
-import bitstring  # type: ignore
-import re
 import hashlib
-from typing import List, NamedTuple, Optional
-from bech32 import bech32_encode, bech32_decode, CHARSET
-from ecdsa import SECP256k1, VerifyingKey  # type: ignore
-from ecdsa.util import sigdecode_string  # type: ignore
-from binascii import unhexlify
+import re
 import time
+from binascii import unhexlify
 from decimal import Decimal
+from typing import List, NamedTuple, Optional
+
+import bitstring  # type: ignore
 import embit
 import secp256k1
+from bech32 import CHARSET, bech32_decode, bech32_encode
+from ecdsa import SECP256k1, VerifyingKey  # type: ignore
+from ecdsa.util import sigdecode_string  # type: ignore


 class Route(NamedTuple):
@ -165,7 +166,7 @@ def lnencode(addr, privkey):
    if addr.amount:
        amount = Decimal(str(addr.amount))
        # We can only send down to millisatoshi.
-        if amount * 10 ** 12 % 10:
+        if amount * 10**12 % 10:
            raise ValueError(
                "Cannot encode {}: too many decimal places".format(addr.amount)
            )
@ -270,7 +271,7 @@ class LnAddr(object):
 def shorten_amount(amount):
    """Given an amount in bitcoin, shorten it"""
    # Convert to pico initially
-    amount = int(amount * 10 ** 12)
+    amount = int(amount * 10**12)
    units = ["p", "n", "u", "m", ""]
    for unit in units:
        if amount % 1000 == 0:
@ -289,7 +290,7 @@ def _unshorten_amount(amount: str) -> int:
    # * `u` (micro): multiply by 0.000001
    # * `n` (nano): multiply by 0.000000001
    # * `p` (pico): multiply by 0.000000000001
-    units = {"p": 10 ** 12, "n": 10 ** 9, "u": 10 ** 6, "m": 10 ** 3}
+    units = {"p": 10**12, "n": 10**9, "u": 10**6, "m": 10**3}
    unit = str(amount)[-1]

    # BOLT #11:
@ -348,9 +349,9 @@ def _trim_to_bytes(barr):

 def _readable_scid(short_channel_id: int) -> str:
    return "{blockheight}x{transactionindex}x{outputindex}".format(
-        blockheight=((short_channel_id >> 40) & 0xffffff),
-        transactionindex=((short_channel_id >> 16) & 0xffffff),
-        outputindex=(short_channel_id & 0xffff),
+        blockheight=((short_channel_id >> 40) & 0xFFFFFF),
+        transactionindex=((short_channel_id >> 16) & 0xFFFFFF),
+        outputindex=(short_channel_id & 0xFFFF),
    )


--- a/lnbits/commands.py
+++ b/lnbits/commands.py
@ -1,16 +1,19 @@
 import asyncio
-import warnings
-import click
 import importlib
-import re
 import os
+import re
+import warnings

-from .db import SQLITE, POSTGRES, COCKROACH
-from .core import db as core_db, migrations as core_migrations
+import click
+from loguru import logger
+
+from .core import db as core_db
+from .core import migrations as core_migrations
+from .db import COCKROACH, POSTGRES, SQLITE
 from .helpers import (
-    get_valid_extensions,
    get_css_vendored,
    get_js_vendored,
+    get_valid_extensions,
    url_for_vendored,
 )
 from .settings import LNBITS_PATH
@ -69,7 +72,7 @@ async def migrate_databases():
            if match:
                version = int(match.group(1))
                if version > current_versions.get(db_name, 0):
-                    print(f"running migration {db_name}.{version}")
+                    logger.debug(f"running migration {db_name}.{version}")
                    await migrate(db)

                    if db.schema == None:
@ -110,4 +113,4 @@ async def migrate_databases():
        async with ext_db.connect() as ext_conn:
            await run_migration(ext_conn, ext_migrations)

-    print("  ✔️ All migrations done.")
+    logger.info("✔️ All migrations done.")
--- a/lnbits/core/crud.py
+++ b/lnbits/core/crud.py
@ -1,15 +1,15 @@
-import json
 import datetime
-from uuid import uuid4
-from typing import List, Optional, Dict, Any
+import json
+from typing import Any, Dict, List, Optional
 from urllib.parse import urlparse
+from uuid import uuid4

 from lnbits import bolt11
-from lnbits.db import Connection, POSTGRES, COCKROACH
+from lnbits.db import COCKROACH, POSTGRES, Connection
 from lnbits.settings import DEFAULT_WALLET_NAME, LNBITS_ADMIN_USERS

 from . import db
-from .models import User, Wallet, Payment, BalanceCheck
+from .models import BalanceCheck, Payment, User, Wallet

 # accounts
 # --------
@ -113,7 +113,7 @@ async def create_wallet(
 async def update_wallet(
    wallet_id: str, new_name: str, conn: Optional[Connection] = None
 ) -> Optional[Wallet]:
-    await (conn or db).execute(
+    return await (conn or db).execute(
        """
        UPDATE wallets SET
            name = ?
@ -180,16 +180,28 @@ async def get_wallet_for_key(


 async def get_standalone_payment(
-    checking_id_or_hash: str, conn: Optional[Connection] = None
+    checking_id_or_hash: str,
+    conn: Optional[Connection] = None,
+    incoming: Optional[bool] = False,
+    wallet_id: Optional[str] = None,
 ) -> Optional[Payment]:
+    clause: str = "checking_id = ? OR hash = ?"
+    values = [checking_id_or_hash, checking_id_or_hash]
+    if incoming:
+        clause = f"({clause}) AND amount > 0"
+
+    if wallet_id:
+        clause = f"({clause}) AND wallet = ?"
+        values.append(wallet_id)
+
    row = await (conn or db).fetchone(
-        """
+        f"""
        SELECT *
        FROM apipayments
-        WHERE checking_id = ? OR hash = ?
+        WHERE {clause}
        LIMIT 1
        """,
-        (checking_id_or_hash, checking_id_or_hash),
+        tuple(values),
    )

    return Payment.from_row(row) if row else None
--- a/lnbits/core/models.py
+++ b/lnbits/core/models.py
@ -1,12 +1,15 @@
-import json
-import hmac
 import hashlib
-from lnbits.helpers import url_for
+import hmac
+import json
+from sqlite3 import Row
+from typing import Dict, List, NamedTuple, Optional
+
 from ecdsa import SECP256k1, SigningKey  # type: ignore
 from lnurl import encode as lnurl_encode  # type: ignore
-from typing import List, NamedTuple, Optional, Dict
-from sqlite3 import Row
+from loguru import logger
 from pydantic import BaseModel
+
+from lnbits.helpers import url_for
 from lnbits.settings import WALLET


@ -103,6 +106,8 @@ class Payment(BaseModel):

    @property
    def tag(self) -> Optional[str]:
+        if self.extra is None:
+            return ""
        return self.extra.get("tag")

    @property
@ -142,10 +147,12 @@ class Payment(BaseModel):
            status = await WALLET.get_invoice_status(self.checking_id)

        if self.is_out and status.failed:
-            print(f" - deleting outgoing failed payment {self.checking_id}: {status}")
+            logger.info(
+                f" - deleting outgoing failed payment {self.checking_id}: {status}"
+            )
            await self.delete()
        elif not status.pending:
-            print(
+            logger.info(
                f" - marking '{'in' if self.is_in else 'out'}' {self.checking_id} as not pending anymore: {status}"
            )
            await self.set_pending(status.pending)
--- a/lnbits/core/services.py
+++ b/lnbits/core/services.py
@ -6,14 +6,22 @@ from typing import Dict, Optional, Tuple
 from urllib.parse import parse_qs, urlparse

 import httpx
+from fastapi import Depends
 from lnurl import LnurlErrorResponse
 from lnurl import decode as decode_lnurl  # type: ignore
+from loguru import logger

 from lnbits import bolt11
 from lnbits.db import Connection
+from lnbits.decorators import (
+    WalletTypeInfo,
+    get_key_type,
+    require_admin_key,
+    require_invoice_key,
+)
 from lnbits.helpers import url_for, urlsafe_short_hash
 from lnbits.requestvars import g
-from lnbits.settings import WALLET
+from lnbits.settings import FAKE_WALLET, WALLET
 from lnbits.wallets.base import PaymentResponse, PaymentStatus

 from . import db
@ -48,15 +56,19 @@ async def create_invoice(
    description_hash: Optional[bytes] = None,
    extra: Optional[Dict] = None,
    webhook: Optional[str] = None,
+    internal: Optional[bool] = False,
    conn: Optional[Connection] = None,
 ) -> Tuple[str, str]:
    invoice_memo = None if description_hash else memo

-    ok, checking_id, payment_request, error_message = await WALLET.create_invoice(
+    # use the fake wallet if the invoice is for internal use only
+    wallet = FAKE_WALLET if internal else WALLET
+
+    ok, checking_id, payment_request, error_message = await wallet.create_invoice(
        amount=amount, memo=invoice_memo, description_hash=description_hash
    )
    if not ok:
-        raise InvoiceFailure(error_message or "Unexpected backend error.")
+        raise InvoiceFailure(error_message or "unexpected backend error.")

    invoice = bolt11.decode(payment_request)

@ -97,18 +109,15 @@ async def pay_invoice(
            raise ValueError("Amount in invoice is too high.")

        # put all parameters that don't change here
-        PaymentKwargs = TypedDict(
-            "PaymentKwargs",
-            {
-                "wallet_id": str,
-                "payment_request": str,
-                "payment_hash": str,
-                "amount": int,
-                "memo": str,
-                "extra": Optional[Dict],
-            },
-        )
-        payment_kwargs: PaymentKwargs = dict(
+        class PaymentKwargs(TypedDict):
+            wallet_id: str
+            payment_request: str
+            payment_hash: str
+            amount: int
+            memo: str
+            extra: Optional[Dict]
+
+        payment_kwargs: PaymentKwargs = PaymentKwargs(
            wallet_id=wallet_id,
            payment_request=payment_request,
            payment_hash=invoice.payment_hash,
@ -120,6 +129,7 @@ async def pay_invoice(
        # check_internal() returns the checking_id of the invoice we're waiting for
        internal_checking_id = await check_internal(invoice.payment_hash, conn=conn)
        if internal_checking_id:
+            logger.debug(f"creating temporary internal payment with id {internal_id}")
            # create a new payment from this wallet
            await create_payment(
                checking_id=internal_id,
@ -129,6 +139,7 @@ async def pay_invoice(
                **payment_kwargs,
            )
        else:
+            logger.debug(f"creating temporary payment with id {temp_id}")
            # create a temporary payment here so we can check if
            # the balance is enough in the next step
            await create_payment(
@ -142,6 +153,7 @@ async def pay_invoice(
        wallet = await get_wallet(wallet_id, conn=conn)
        assert wallet
        if wallet.balance_msat < 0:
+            logger.debug("balance is too low, deleting temporary payment")
            if not internal_checking_id and wallet.balance_msat > -fee_reserve_msat:
                raise PaymentFailure(
                    f"You must reserve at least 1% ({round(fee_reserve_msat/1000)} sat) to cover potential routing fees."
@ -149,6 +161,7 @@ async def pay_invoice(
            raise PermissionError("Insufficient balance.")

    if internal_checking_id:
+        logger.debug(f"marking temporary payment as not pending {internal_checking_id}")
        # mark the invoice from the other side as not pending anymore
        # so the other side only has access to his new money when we are sure
        # the payer has enough to deduct from
@ -163,11 +176,14 @@ async def pay_invoice(

        await internal_invoice_queue.put(internal_checking_id)
    else:
+        logger.debug(f"backend: sending payment {temp_id}")
        # actually pay the external invoice
        payment: PaymentResponse = await WALLET.pay_invoice(
            payment_request, fee_reserve_msat
        )
+        logger.debug(f"backend: pay_invoice finished {temp_id}")
        if payment.checking_id:
+            logger.debug(f"creating final payment {payment.checking_id}")
            async with db.connect() as conn:
                await create_payment(
                    checking_id=payment.checking_id,
@ -177,15 +193,18 @@ async def pay_invoice(
                    conn=conn,
                    **payment_kwargs,
                )
+                logger.debug(f"deleting temporary payment {temp_id}")
                await delete_payment(temp_id, conn=conn)
        else:
+            logger.debug(f"backend payment failed, no checking_id {temp_id}")
            async with db.connect() as conn:
+                logger.debug(f"deleting temporary payment {temp_id}")
                await delete_payment(temp_id, conn=conn)
            raise PaymentFailure(
                payment.error_message
                or "Payment failed, but backend didn't give us an error message."
            )
-
+        logger.debug(f"payment successful {payment.checking_id}")
    return invoice.payment_hash


@ -216,7 +235,7 @@ async def redeem_lnurl_withdraw(
            conn=conn,
        )
    except:
-        print(
+        logger.warning(
            f"failed to create invoice on redeem_lnurl_withdraw from {lnurl}. params: {res}"
        )
        return None
@ -243,12 +262,15 @@ async def redeem_lnurl_withdraw(


 async def perform_lnurlauth(
-    callback: str, conn: Optional[Connection] = None
+    callback: str,
+    wallet: WalletTypeInfo = Depends(require_admin_key),
+    conn: Optional[Connection] = None,
 ) -> Optional[LnurlErrorResponse]:
    cb = urlparse(callback)

    k1 = unhexlify(parse_qs(cb.query)["k1"][0])
-    key = g().wallet.lnurlauth_key(cb.netloc)
+
+    key = wallet.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"""
@ -325,11 +347,11 @@ async def check_invoice_status(
    if not payment.pending:
        return status
    if payment.is_out and status.failed:
-        print(f" - deleting outgoing failed payment {payment.checking_id}: {status}")
+        logger.info(f"deleting outgoing failed payment {payment.checking_id}: {status}")
        await payment.delete()
    elif not status.pending:
-        print(
-            f" - marking '{'in' if payment.is_in else 'out'}' {payment.checking_id} as not pending anymore: {status}"
+        logger.info(
+            f"marking '{'in' if payment.is_in else 'out'}' {payment.checking_id} as not pending anymore: {status}"
        )
        await payment.set_pending(status.pending)
    return status
--- a/lnbits/core/static/js/extensions.js
+++ b/lnbits/core/static/js/extensions.js
@ -1,4 +1,36 @@
 new Vue({
  el: '#vue',
+  data: function () {
+    return {
+      searchTerm: '',
+      filteredExtensions: null
+    }
+  },
+  mounted() {
+    this.filteredExtensions = this.g.extensions
+  },
+  watch: {
+    searchTerm(term) {
+      // Reset the filter
+      this.filteredExtensions = this.g.extensions
+      if (term !== '') {
+        // Filter the extensions list
+        function extensionNameContains(searchTerm) {
+          return function (extension) {
+            return (
+              extension.name.toLowerCase().includes(searchTerm.toLowerCase()) ||
+              extension.shortDescription
+                .toLowerCase()
+                .includes(searchTerm.toLowerCase())
+            )
+          }
+        }
+
+        this.filteredExtensions = this.filteredExtensions.filter(
+          extensionNameContains(term)
+        )
+      }
+    }
+  },
  mixins: [windowMixin]
 })
--- a/lnbits/core/static/js/service-worker.js
+++ b/lnbits/core/static/js/service-worker.js
@ -0,0 +1,51 @@
+// the cache version gets updated every time there is a new deployment
+const CACHE_VERSION = 1
+const CURRENT_CACHE = `lnbits-${CACHE_VERSION}-`
+
+const getApiKey = request => {
+  return request.headers.get('X-Api-Key') || 'none'
+}
+
+// on activation we clean up the previously registered service workers
+self.addEventListener('activate', evt =>
+  evt.waitUntil(
+    caches.keys().then(cacheNames => {
+      return Promise.all(
+        cacheNames.map(cacheName => {
+          const currentCacheVersion = cacheName.split('-').slice(-2, 2)
+          if (currentCacheVersion !== CACHE_VERSION) {
+            return caches.delete(cacheName)
+          }
+        })
+      )
+    })
+  )
+)
+
+// The fetch handler serves responses for same-origin resources from a cache.
+// If no response is found, it populates the runtime cache with the response
+// from the network before returning it to the page.
+self.addEventListener('fetch', event => {
+  // Skip cross-origin requests, like those for Google Analytics.
+  if (
+    event.request.url.startsWith(self.location.origin) &&
+    event.request.method == 'GET'
+  ) {
+    // Open the cache
+    event.respondWith(
+      caches.open(CURRENT_CACHE + getApiKey(event.request)).then(cache => {
+        // Go to the network first
+        return fetch(event.request)
+          .then(fetchedResponse => {
+            cache.put(event.request, fetchedResponse.clone())
+
+            return fetchedResponse
+          })
+          .catch(() => {
+            // If the network is unavailable, get
+            return cache.match(event.request.url)
+          })
+      })
+    )
+  }
+})
--- a/lnbits/core/static/js/wallet.js
+++ b/lnbits/core/static/js/wallet.js
@ -618,10 +618,10 @@ new Vue({
    },
    updateWalletName: function () {
      let newName = this.newName
+      let adminkey = this.g.wallet.adminkey
      if (!newName || !newName.length) return
-      // let data = {name: newName}
      LNbits.api
-        .request('PUT', '/api/v1/wallet/' + newName, this.g.wallet.adminkey, {})
+        .request('PUT', '/api/v1/wallet/' + newName, adminkey, {})
        .then(res => {
          this.newName = ''
          this.$q.notify({
@ -691,10 +691,7 @@ new Vue({
  },
  mounted: function () {
    // show disclaimer
-    if (
-      this.$refs.disclaimer &&
-      !this.$q.localStorage.getItem('lnbits.disclaimerShown')
-    ) {
+    if (!this.$q.localStorage.getItem('lnbits.disclaimerShown')) {
      this.disclaimerDialog.show = true
      this.$q.localStorage.set('lnbits.disclaimerShown', true)
    }
@ -705,3 +702,11 @@ new Vue({
    )
  }
 })
+
+if (navigator.serviceWorker != null) {
+  navigator.serviceWorker
+    .register('/service-worker.js')
+    .then(function (registration) {
+      console.log('Registered events at scope: ', registration.scope)
+    })
+}
--- a/lnbits/core/tasks.py
+++ b/lnbits/core/tasks.py
@ -1,7 +1,9 @@
 import asyncio
-import httpx
 from typing import List

+import httpx
+from loguru import logger
+
 from lnbits.tasks import register_invoice_listener

 from . import db
@ -20,7 +22,7 @@ async def register_task_listeners():
 async def wait_for_paid_invoices(invoice_paid_queue: asyncio.Queue):
    while True:
        payment = await invoice_paid_queue.get()
-
+        logger.debug("received invoice paid event")
        # send information to sse channel
        await dispatch_invoice_listener(payment)

@ -44,7 +46,7 @@ async def dispatch_invoice_listener(payment: Payment):
        try:
            send_channel.put_nowait(payment)
        except asyncio.QueueFull:
-            print("removing sse listener", send_channel)
+            logger.debug("removing sse listener", send_channel)
            api_invoice_listeners.remove(send_channel)


@ -52,7 +54,8 @@ async def dispatch_webhook(payment: Payment):
    async with httpx.AsyncClient() as client:
        data = payment.dict()
        try:
-            r = await client.post(payment.webhook, json=data, timeout=40)
+            logger.debug("sending webhook", payment.webhook)
+            r = await client.post(payment.webhook, json=data, timeout=40)  # type: ignore
            await mark_webhook_sent(payment, r.status_code)
        except (httpx.ConnectError, httpx.RequestError):
            await mark_webhook_sent(payment, -1)
--- a/lnbits/core/templates/core/_api_docs.html
+++ b/lnbits/core/templates/core/_api_docs.html
@ -48,7 +48,9 @@
        <code>{"X-Api-Key": "<i>{{ wallet.inkey }}</i>"}</code><br />
        <h5 class="text-caption q-mt-sm q-mb-none">Body (application/json)</h5>
        <code
-          >{"out": false, "amount": &lt;int&gt;, "memo": &lt;string&gt;}</code
+          >{"out": false, "amount": &lt;int&gt;, "memo": &lt;string&gt;, "unit":
+          &lt;string&gt;, "webhook": &lt;url:string&gt;, "internal":
+          &lt;bool&gt;}</code
        >
        <h5 class="text-caption q-mt-sm q-mb-none">
          Returns 201 CREATED (application/json)
@ -61,8 +63,8 @@
        <code
          >curl -X POST {{ request.base_url }}api/v1/payments -d '{"out": false,
          "amount": &lt;int&gt;, "memo": &lt;string&gt;, "webhook":
-          &lt;url:string&gt;, "unit": &lt;string&gt;}' -H "X-Api-Key: <i>{{ wallet.inkey }}</i>" -H
-          "Content-type: application/json"</code
+          &lt;url:string&gt;, "unit": &lt;string&gt;}' -H "X-Api-Key:
+          <i>{{ wallet.inkey }}</i>" -H "Content-type: application/json"</code
        >
      </q-card-section>
    </q-card>
--- a/lnbits/core/templates/core/extensions.html
+++ b/lnbits/core/templates/core/extensions.html
@ -2,10 +2,23 @@
 %} {% block scripts %} {{ window_vars(user) }}
 <script src="/core/static/js/extensions.js"></script>
 {% endblock %} {% block page %}
+<div class="row q-col-gutter-md q-mb-md">
+  <div class="col-sm-3 col-xs-8 q-ml-auto">
+    <q-input v-model="searchTerm" label="Search extensions">
+      <q-icon
+        v-if="searchTerm !== ''"
+        name="close"
+        @click="searchTerm = ''"
+        class="cursor-pointer q-mt-lg"
+      />
+    </q-input>
+  </div>
+</div>
+
 <div class="row q-col-gutter-md">
  <div
    class="col-6 col-md-4 col-lg-3"
-    v-for="extension in g.extensions"
+    v-for="extension in filteredExtensions"
    :key="extension.code"
  >
    <q-card>
--- a/lnbits/core/templates/core/wallet.html
+++ b/lnbits/core/templates/core/wallet.html
@ -4,7 +4,6 @@
 <!---->
 {% block scripts %} {{ window_vars(user, wallet) }}
 <script src="/core/static/js/wallet.js"></script>
-<link rel="manifest" href="/manifest/{{ user.id }}.webmanifest" />
 {% endblock %}
 <!---->
 {% block title %} {{ wallet.name }} - {{ SITE_TITLE }} {% endblock %}
@ -706,11 +705,10 @@

    <q-tab icon="photo_camera" label="Scan" @click="showCamera"> </q-tab>
  </q-tabs>
-  {% if service_fee > 0 %}
-  <div ref="disclaimer"></div>
+
  <q-dialog v-model="disclaimerDialog.show">
    <q-card class="q-pa-lg">
-      <h6 class="q-my-md text-deep-purple">Warning</h6>
+      <h6 class="q-my-md text-primary">Warning</h6>
      <p>
        Login functionality to be released in v0.2, for now,
        <strong
@ -720,10 +718,10 @@
      </p>
      <p>
        This service is in BETA, and we hold no responsibility for people losing
-        access to funds. To encourage you to run your own LNbits installation,
-        any balance on {% raw %}{{ disclaimerDialog.location.host }}{% endraw %}
-        will incur a charge of
-        <strong>{{ service_fee }}% service fee</strong> per week.
+        access to funds. {% if service_fee > 0 %} To encourage you to run your
+        own LNbits installation, any balance on {% raw %}{{
+        disclaimerDialog.location.host }}{% endraw %} will incur a charge of
+        <strong>{{ service_fee }}% service fee</strong> per week. {% endif %}
      </p>
      <div class="row q-mt-lg">
        <q-btn
@ -738,5 +736,5 @@
      </div>
    </q-card>
  </q-dialog>
-  {% endif %} {% endblock %}
+  {% endblock %}
 </div>
--- a/lnbits/core/views/api.py
+++ b/lnbits/core/views/api.py
@ -3,33 +3,30 @@ import hashlib
 import json
 from binascii import unhexlify
 from http import HTTPStatus
-from typing import Dict, List, Optional, Union
+from typing import Dict, List, Optional, Tuple, Union
 from urllib.parse import ParseResult, parse_qs, urlencode, urlparse, urlunparse

 import httpx
+from fastapi import Depends, Header, Query, Request
 import pyqrcode
 from io import BytesIO
 from starlette.responses import HTMLResponse, StreamingResponse
-from fastapi import Query, Request, Header
 from fastapi.exceptions import HTTPException
-from fastapi.param_functions import Depends
 from fastapi.params import Body
+from loguru import logger
 from pydantic import BaseModel
 from pydantic.fields import Field
 from sse_starlette.sse import EventSourceResponse

 from lnbits import bolt11, lnurl
-from lnbits.bolt11 import Invoice
 from lnbits.core.models import Payment, Wallet
 from lnbits.decorators import (
-    WalletAdminKeyChecker,
-    WalletInvoiceKeyChecker,
    WalletTypeInfo,
    get_key_type,
-    require_admin_key
+    require_admin_key,
+    require_invoice_key,
 )
 from lnbits.helpers import url_for, urlsafe_short_hash
-from lnbits.requestvars import g
 from lnbits.settings import LNBITS_ADMIN_USERS, LNBITS_SITE_TITLE
 from lnbits.utils.exchange_rates import (
    currencies,
@ -102,7 +99,7 @@ async def api_update_balance(

@core_app.put("/api/v1/wallet/{new_name}")
 async def api_update_wallet(
-    new_name: str, wallet: WalletTypeInfo = Depends(WalletAdminKeyChecker())
+    new_name: str, wallet: WalletTypeInfo = Depends(require_admin_key)
 ):
    await update_wallet(wallet.wallet.id, new_name)
    return {
@ -113,16 +110,29 @@ async def api_update_wallet(


@core_app.get("/api/v1/payments")
-async def api_payments(wallet: WalletTypeInfo = Depends(get_key_type)):
-    await get_payments(wallet_id=wallet.wallet.id, pending=True, complete=True)
+async def api_payments(
+    limit: Optional[int] = None,
+    offset: Optional[int] = None,
+    wallet: WalletTypeInfo = Depends(get_key_type),
+):
    pendingPayments = await get_payments(
-        wallet_id=wallet.wallet.id, pending=True, exclude_uncheckable=True
+        wallet_id=wallet.wallet.id,
+        pending=True,
+        exclude_uncheckable=True,
+        limit=limit,
+        offset=offset,
    )
    for payment in pendingPayments:
        await check_invoice_status(
            wallet_id=payment.wallet_id, payment_hash=payment.payment_hash
        )
-    return await get_payments(wallet_id=wallet.wallet.id, pending=True, complete=True)
+    return await get_payments(
+        wallet_id=wallet.wallet.id,
+        pending=True,
+        complete=True,
+        limit=limit,
+        offset=offset,
+    )


 class CreateInvoiceData(BaseModel):
@ -135,6 +145,7 @@ class CreateInvoiceData(BaseModel):
    lnurl_balance_check: Optional[str] = None
    extra: Optional[dict] = None
    webhook: Optional[str] = None
+    internal: Optional[bool] = False
    bolt11: Optional[str] = None


@ -148,6 +159,7 @@ async def api_payments_create_invoice(data: CreateInvoiceData, wallet: Wallet):
    if data.unit == "sat":
        amount = int(data.amount)
    else:
+        assert data.unit is not None, "unit not set"
        price_in_sats = await fiat_amount_as_satoshis(data.amount, data.unit)
        amount = price_in_sats

@ -160,6 +172,7 @@ async def api_payments_create_invoice(data: CreateInvoiceData, wallet: Wallet):
                description_hash=description_hash,
                extra=data.extra,
                webhook=data.webhook,
+                internal=data.internal,
                conn=conn,
            )
        except InvoiceFailure as e:
@ -172,7 +185,10 @@ async def api_payments_create_invoice(data: CreateInvoiceData, wallet: Wallet):
    lnurl_response: Union[None, bool, str] = None
    if data.lnurl_callback:
        if "lnurl_balance_check" in data:
-            save_balance_check(wallet.id, data.lnurl_balance_check)
+            assert (
+                data.lnurl_balance_check is not None
+            ), "lnurl_balance_check is required"
+            await save_balance_check(wallet.id, data.lnurl_balance_check)

        async with httpx.AsyncClient() as client:
            try:
@ -234,12 +250,9 @@ async def api_payments_pay_invoice(bolt11: str, wallet: Wallet):
    status_code=HTTPStatus.CREATED,
 )
 async def api_payments_create(
-    wallet: WalletTypeInfo = Depends(get_key_type),
-    invoiceData: CreateInvoiceData = Body(...),
+    wallet: WalletTypeInfo = Depends(require_invoice_key),
+    invoiceData: CreateInvoiceData = Body(...),  # type: ignore
 ):
-    if wallet.wallet_type < 0 or wallet.wallet_type > 2:
-        raise HTTPException(status_code=HTTPStatus.BAD_REQUEST, detail="Key is invalid")
-
    if invoiceData.out is True and wallet.wallet_type == 0:
        if not invoiceData.bolt11:
            raise HTTPException(
@ -249,8 +262,14 @@ async def api_payments_create(
        return await api_payments_pay_invoice(
            invoiceData.bolt11, wallet.wallet
        )  # admin key
-    # invoice key
-    return await api_payments_create_invoice(invoiceData, wallet.wallet)
+    elif not invoiceData.out:
+        # invoice key
+        return await api_payments_create_invoice(invoiceData, wallet.wallet)
+    else:
+        raise HTTPException(
+            status_code=HTTPStatus.BAD_REQUEST,
+            detail="Invoice (or Admin) key required.",
+        )


 class CreateLNURLData(BaseModel):
@ -263,7 +282,7 @@ class CreateLNURLData(BaseModel):

@core_app.post("/api/v1/payments/lnurl")
 async def api_payments_pay_lnurl(
-    data: CreateLNURLData, wallet: WalletTypeInfo = Depends(get_key_type)
+    data: CreateLNURLData, wallet: WalletTypeInfo = Depends(require_admin_key)
 ):
    domain = urlparse(data.callback).netloc

@ -275,7 +294,7 @@ async def api_payments_pay_lnurl(
                timeout=40,
            )
            if r.is_error:
-                raise httpx.ConnectError
+                raise httpx.ConnectError("LNURL callback connection error")
        except (httpx.ConnectError, httpx.RequestError):
            raise HTTPException(
                status_code=HTTPStatus.BAD_REQUEST,
@ -289,6 +308,12 @@ async def api_payments_pay_lnurl(
            detail=f"{domain} said: '{params.get('reason', '')}'",
        )

+    if not params.get("pr"):
+        raise HTTPException(
+            status_code=HTTPStatus.BAD_REQUEST,
+            detail=f"{domain} did not return a payment request.",
+        )
+
    invoice = bolt11.decode(params["pr"])
    if invoice.amount_msat != data.amount:
        raise HTTPException(
@ -296,11 +321,11 @@ async def api_payments_pay_lnurl(
            detail=f"{domain} returned an invalid invoice. Expected {data.amount} msat, got {invoice.amount_msat}.",
        )

-    #  if invoice.description_hash != data.description_hash:
-    #      raise HTTPException(
-    #          status_code=HTTPStatus.BAD_REQUEST,
-    #          detail=f"{domain} returned an invalid invoice. Expected description_hash == {data.description_hash}, got {invoice.description_hash}.",
-    #      )
+    if invoice.description_hash != data.description_hash:
+        raise HTTPException(
+            status_code=HTTPStatus.BAD_REQUEST,
+            detail=f"{domain} returned an invalid invoice. Expected description_hash == {data.description_hash}, got {invoice.description_hash}.",
+        )

    extra = {}

@ -308,7 +333,7 @@ async def api_payments_pay_lnurl(
        extra["success_action"] = params["successAction"]
    if data.comment:
        extra["comment"] = data.comment
-
+    assert data.description is not None, "description is required"
    payment_hash = await pay_invoice(
        wallet_id=wallet.wallet.id,
        payment_request=params["pr"],
@ -325,19 +350,20 @@ async def api_payments_pay_lnurl(


 async def subscribe(request: Request, wallet: Wallet):
-    this_wallet_id = wallet.wallet.id
+    this_wallet_id = wallet.id

-    payment_queue = asyncio.Queue(0)
+    payment_queue: asyncio.Queue[Payment] = asyncio.Queue(0)

-    print("adding sse listener", payment_queue)
+    logger.debug("adding sse listener", payment_queue)
    api_invoice_listeners.append(payment_queue)

-    send_queue = asyncio.Queue(0)
+    send_queue: asyncio.Queue[Tuple[str, Payment]] = asyncio.Queue(0)

    async def payment_received() -> None:
        while True:
            payment: Payment = await payment_queue.get()
            if payment.wallet_id == this_wallet_id:
+                logger.debug("payment receieved", payment)
                await send_queue.put(("payment-received", payment))

    asyncio.create_task(payment_received())
@ -362,21 +388,29 @@ async def api_payments_sse(
    request: Request, wallet: WalletTypeInfo = Depends(get_key_type)
 ):
    return EventSourceResponse(
-        subscribe(request, wallet), ping=20, media_type="text/event-stream"
+        subscribe(request, wallet.wallet), ping=20, media_type="text/event-stream"
    )


@core_app.get("/api/v1/payments/{payment_hash}")
 async def api_payment(payment_hash, X_Api_Key: Optional[str] = Header(None)):
-    wallet = None
-    try:
-        if X_Api_Key.extra:
-            print("No key")
-    except:
-        wallet = await get_wallet_for_key(X_Api_Key)
-    payment = await get_standalone_payment(payment_hash)
+    # We use X_Api_Key here because we want this call to work with and without keys
+    # If a valid key is given, we also return the field "details", otherwise not
+    wallet = await get_wallet_for_key(X_Api_Key) if type(X_Api_Key) == str else None
+
+    # we have to specify the wallet id here, because postgres and sqlite return internal payments in different order
+    # and get_standalone_payment otherwise just fetches the first one, causing unpredictable results
+    payment = await get_standalone_payment(
+        payment_hash, wallet_id=wallet.id if wallet else None
+    )
+    if payment is None:
+        raise HTTPException(
+            status_code=HTTPStatus.NOT_FOUND, detail="Payment does not exist."
+        )
    await check_invoice_status(payment.wallet_id, payment_hash)
-    payment = await get_standalone_payment(payment_hash)
+    payment = await get_standalone_payment(
+        payment_hash, wallet_id=wallet.id if wallet else None
+    )
    if not payment:
        raise HTTPException(
            status_code=HTTPStatus.NOT_FOUND, detail="Payment does not exist."
@ -394,14 +428,16 @@ async def api_payment(payment_hash, X_Api_Key: Optional[str] = Header(None)):
        return {"paid": False}

    if wallet and wallet.id == payment.wallet_id:
-            return {"paid": not payment.pending, "preimage": payment.preimage, "details": payment}
+        return {
+            "paid": not payment.pending,
+            "preimage": payment.preimage,
+            "details": payment,
+        }
    return {"paid": not payment.pending, "preimage": payment.preimage}


-@core_app.get(
-    "/api/v1/lnurlscan/{code}", dependencies=[Depends(WalletInvoiceKeyChecker())]
-)
-async def api_lnurlscan(code: str):
+@core_app.get("/api/v1/lnurlscan/{code}")
+async def api_lnurlscan(code: str, wallet: WalletTypeInfo = Depends(get_key_type)):
    try:
        url = lnurl.decode(code)
        domain = urlparse(url).netloc
@ -429,7 +465,7 @@ async def api_lnurlscan(code: str):
        params.update(kind="auth")
        params.update(callback=url)  # with k1 already in it

-        lnurlauth_key = g().wallet.lnurlauth_key(domain)
+        lnurlauth_key = wallet.wallet.lnurlauth_key(domain)
        params.update(pubkey=lnurlauth_key.verifying_key.to_string("compressed").hex())
    else:
        async with httpx.AsyncClient() as client:
@ -545,14 +581,19 @@ async def api_payments_decode(data: DecodePayment):
        return {"message": "Failed to decode"}


-@core_app.post("/api/v1/lnurlauth", dependencies=[Depends(WalletAdminKeyChecker())])
-async def api_perform_lnurlauth(callback: str):
-    err = await perform_lnurlauth(callback)
+class Callback(BaseModel):
+    callback: str = Query(...)
+
+
+@core_app.post("/api/v1/lnurlauth")
+async def api_perform_lnurlauth(
+    callback: Callback, wallet: WalletTypeInfo = Depends(require_admin_key)
+):
+    err = await perform_lnurlauth(callback.callback, wallet=wallet)
    if err:
        raise HTTPException(
            status_code=HTTPStatus.SERVICE_UNAVAILABLE, detail=err.reason
        )
-
    return ""


@ -571,8 +612,8 @@ class ConversionData(BaseModel):
 async def api_fiat_as_sats(data: ConversionData):
    output = {}
    if data.from_ == "sat":
-        output["sats"] = int(data.amount)
        output["BTC"] = data.amount / 100000000
+        output["sats"] = int(data.amount)
        for currency in data.to.split(","):
            output[currency.strip().upper()] = await satoshis_amount_as_fiat(
                data.amount, currency.strip()
--- a/lnbits/core/views/generic.py
+++ b/lnbits/core/views/generic.py
@ -7,6 +7,7 @@ from fastapi.exceptions import HTTPException
 from fastapi.params import Depends, Query
 from fastapi.responses import FileResponse, RedirectResponse
 from fastapi.routing import APIRouter
+from loguru import logger
 from pydantic.types import UUID4
 from starlette.responses import HTMLResponse, JSONResponse

@ -17,10 +18,12 @@ from lnbits.helpers import template_renderer, url_for
 from lnbits.settings import (
    LNBITS_ADMIN_USERS,
    LNBITS_ALLOWED_USERS,
+    LNBITS_CUSTOM_LOGO,
    LNBITS_SITE_TITLE,
    SERVICE_FEE,
 )

+from ...helpers import get_valid_extensions
 from ..crud import (
    create_account,
    create_wallet,
@ -52,9 +55,9 @@ async def home(request: Request, lightning: str = None):
 )
 async def extensions(
    request: Request,
-    user: User = Depends(check_user_exists),
-    enable: str = Query(None),
-    disable: str = Query(None),
+    user: User = Depends(check_user_exists),  # type: ignore
+    enable: str = Query(None),  # type: ignore
+    disable: str = Query(None),  # type: ignore
 ):
    extension_to_enable = enable
    extension_to_disable = disable
@ -64,18 +67,28 @@ async def extensions(
            HTTPStatus.BAD_REQUEST, "You can either `enable` or `disable` an extension."
        )

+    # check if extension exists
+    if extension_to_enable or extension_to_disable:
+        ext = extension_to_enable or extension_to_disable
+        if ext not in [e.code for e in get_valid_extensions()]:
+            raise HTTPException(
+                HTTPStatus.BAD_REQUEST, f"Extension '{ext}' doesn't exist."
+            )
+
    if extension_to_enable:
+        logger.info(f"Enabling extension: {extension_to_enable} for user {user.id}")
        await update_user_extension(
            user_id=user.id, extension=extension_to_enable, active=True
        )
    elif extension_to_disable:
+        logger.info(f"Disabling extension: {extension_to_disable} for user {user.id}")
        await update_user_extension(
            user_id=user.id, extension=extension_to_disable, active=False
        )

    # Update user as his extensions have been updated
    if extension_to_enable or extension_to_disable:
-        user = await get_user(user.id)
+        user = await get_user(user.id)  # type: ignore

    return template_renderer().TemplateResponse(
        "core/extensions.html", {"request": request, "user": user.dict()}
@ -96,10 +109,10 @@ nothing: create everything<br>
 """,
 )
 async def wallet(
-    request: Request = Query(None),
-    nme: Optional[str] = Query(None),
-    usr: Optional[UUID4] = Query(None),
-    wal: Optional[UUID4] = Query(None),
+    request: Request = Query(None),  # type: ignore
+    nme: Optional[str] = Query(None),  # type: ignore
+    usr: Optional[UUID4] = Query(None),  # type: ignore
+    wal: Optional[UUID4] = Query(None),  # type: ignore
 ):
    user_id = usr.hex if usr else None
    wallet_id = wal.hex if wal else None
@ -108,6 +121,7 @@ async def wallet(

    if not user_id:
        user = await get_user((await create_account()).id)
+        logger.info(f"Create user {user.id}")  # type: ignore
    else:
        user = await get_user(user_id)
        if not user:
@ -121,18 +135,22 @@ async def wallet(
        if LNBITS_ADMIN_USERS and user_id in LNBITS_ADMIN_USERS:
            user.admin = True
    if not wallet_id:
-        if user.wallets and not wallet_name:
-            wallet = user.wallets[0]
+        if user.wallets and not wallet_name:  # type: ignore
+            wallet = user.wallets[0]  # type: ignore
        else:
-            wallet = await create_wallet(user_id=user.id, wallet_name=wallet_name)
+            wallet = await create_wallet(user_id=user.id, wallet_name=wallet_name)  # type: ignore
+            logger.info(
+                f"Created new wallet {wallet_name if wallet_name else '(no name)'} for user {user.id}"  # type: ignore
+            )

        return RedirectResponse(
-            f"/wallet?usr={user.id}&wal={wallet.id}",
+            f"/wallet?usr={user.id}&wal={wallet.id}",  # type: ignore
            status_code=status.HTTP_307_TEMPORARY_REDIRECT,
        )

-    wallet = user.get_wallet(wallet_id)
-    if not wallet:
+    logger.debug(f"Access wallet {wallet_name}{'of user '+ user.id if user else ''}")
+    userwallet = user.get_wallet(wallet_id)  # type: ignore
+    if not userwallet:
        return template_renderer().TemplateResponse(
            "error.html", {"request": request, "err": "Wallet not found"}
        )
@ -141,9 +159,10 @@ async def wallet(
        "core/wallet.html",
        {
            "request": request,
-            "user": user.dict(),
-            "wallet": wallet.dict(),
+            "user": user.dict(),  # type: ignore
+            "wallet": userwallet.dict(),
            "service_fee": service_fee,
+            "web_manifest": f"/manifest/{user.id}.webmanifest",  # type: ignore
        },
    )

@ -197,20 +216,20 @@ async def lnurl_full_withdraw_callback(request: Request):


@core_html_routes.get("/deletewallet", response_class=RedirectResponse)
-async def deletewallet(request: Request, wal: str = Query(...), usr: str = Query(...)):
+async def deletewallet(request: Request, wal: str = Query(...), usr: str = Query(...)):  # type: ignore
    user = await get_user(usr)
-    user_wallet_ids = [u.id for u in user.wallets]
-    print("USR", user_wallet_ids)
+    user_wallet_ids = [u.id for u in user.wallets]  # type: ignore

    if wal not in user_wallet_ids:
        raise HTTPException(HTTPStatus.FORBIDDEN, "Not your wallet.")
    else:
-        await delete_wallet(user_id=user.id, wallet_id=wal)
+        await delete_wallet(user_id=user.id, wallet_id=wal)  # type: ignore
        user_wallet_ids.remove(wal)
+        logger.debug("Deleted wallet {wal} of user {user.id}")

    if user_wallet_ids:
        return RedirectResponse(
-            url_for("/wallet", usr=user.id, wal=user_wallet_ids[0]),
+            url_for("/wallet", usr=user.id, wal=user_wallet_ids[0]),  # type: ignore
            status_code=status.HTTP_307_TEMPORARY_REDIRECT,
        )

@ -223,15 +242,17 @@ async def deletewallet(request: Request, wal: str = Query(...), usr: str = Query
 async def lnurl_balance_notify(request: Request, service: str):
    bc = await get_balance_check(request.query_params.get("wal"), service)
    if bc:
-        redeem_lnurl_withdraw(bc.wallet, bc.url)
+        await redeem_lnurl_withdraw(bc.wallet, bc.url)


-@core_html_routes.get("/lnurlwallet", response_class=RedirectResponse, name="core.lnurlwallet")
+@core_html_routes.get(
+    "/lnurlwallet", response_class=RedirectResponse, name="core.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)
-        wallet = await create_wallet(user_id=user.id, conn=conn)
+        wallet = await create_wallet(user_id=user.id, conn=conn)  # type: ignore

    asyncio.create_task(
        redeem_lnurl_withdraw(
@ -244,11 +265,16 @@ async def lnurlwallet(request: Request):
    )

    return RedirectResponse(
-        f"/wallet?usr={user.id}&wal={wallet.id}",
+        f"/wallet?usr={user.id}&wal={wallet.id}",  # type: ignore
        status_code=status.HTTP_307_TEMPORARY_REDIRECT,
    )


+@core_html_routes.get("/service-worker.js", response_class=FileResponse)
+async def service_worker():
+    return FileResponse("lnbits/core/static/js/service-worker.js")
+
+
@core_html_routes.get("/manifest/{usr}.webmanifest")
 async def manifest(usr: str):
    user = await get_user(usr)
@ -256,21 +282,23 @@ async def manifest(usr: str):
        raise HTTPException(status_code=HTTPStatus.NOT_FOUND)

    return {
-        "short_name": "LNbits",
-        "name": "LNbits Wallet",
+        "short_name": LNBITS_SITE_TITLE,
+        "name": LNBITS_SITE_TITLE + " Wallet",
        "icons": [
            {
-                "src": "https://cdn.jsdelivr.net/gh/lnbits/lnbits@0.3.0/docs/logos/lnbits.png",
+                "src": LNBITS_CUSTOM_LOGO
+                if LNBITS_CUSTOM_LOGO
+                else "https://cdn.jsdelivr.net/gh/lnbits/lnbits@0.3.0/docs/logos/lnbits.png",
                "type": "image/png",
                "sizes": "900x900",
            }
        ],
-        "start_url": "/wallet?usr=" + usr,
-        "background_color": "#3367D6",
-        "description": "Weather forecast information",
+        "start_url": "/wallet?usr=" + usr + "&wal=" + user.wallets[0].id,
+        "background_color": "#1F2234",
+        "description": "Bitcoin Lightning Wallet",
        "display": "standalone",
        "scope": "/",
-        "theme_color": "#3367D6",
+        "theme_color": "#1F2234",
        "shortcuts": [
            {
                "name": wallet.name,
--- a/lnbits/core/views/public_api.py
+++ b/lnbits/core/views/public_api.py
@ -4,6 +4,7 @@ from http import HTTPStatus
 from urllib.parse import urlparse

 from fastapi import HTTPException
+from loguru import logger
 from starlette.requests import Request
 from starlette.responses import HTMLResponse

@ -45,7 +46,7 @@ async def api_public_payment_longpolling(payment_hash):

    payment_queue = asyncio.Queue(0)

-    print("adding standalone invoice listener", payment_hash, payment_queue)
+    logger.debug("adding standalone invoice listener", payment_hash, payment_queue)
    api_invoice_listeners.append(payment_queue)

    response = None
--- a/lnbits/db.py
+++ b/lnbits/db.py
@ -5,6 +5,7 @@ import time
 from contextlib import asynccontextmanager
 from typing import Optional

+from loguru import logger
 from sqlalchemy import create_engine
 from sqlalchemy_aio.base import AsyncConnection
 from sqlalchemy_aio.strategy import ASYNCIO_STRATEGY  # type: ignore
@ -139,7 +140,7 @@ class Database(Compat):
                    f"LNBITS_DATA_FOLDER named {LNBITS_DATA_FOLDER} was not created"
                    f" - please 'mkdir {LNBITS_DATA_FOLDER}' and try again"
                )
-
+        logger.trace(f"database {self.type} added for {self.name}")
        self.schema = self.name
        if self.name.startswith("ext_"):
            self.schema = self.name[4:]
--- a/lnbits/decorators.py
+++ b/lnbits/decorators.py
@ -1,4 +1,5 @@
 from http import HTTPStatus
+from typing import Union

 from cerberus import Validator  # type: ignore
 from fastapi import status
@ -13,7 +14,11 @@ from starlette.requests import Request
 from lnbits.core.crud import get_user, get_wallet_for_key
 from lnbits.core.models import User, Wallet
 from lnbits.requestvars import g
-from lnbits.settings import LNBITS_ALLOWED_USERS, LNBITS_ADMIN_USERS, LNBITS_ADMIN_EXTENSIONS
+from lnbits.settings import (
+    LNBITS_ADMIN_EXTENSIONS,
+    LNBITS_ADMIN_USERS,
+    LNBITS_ALLOWED_USERS,
+)


 class KeyChecker(SecurityBase):
@ -25,20 +30,21 @@ class KeyChecker(SecurityBase):
        self._key_type = "invoice"
        self._api_key = api_key
        if api_key:
-            self.model: APIKey = APIKey(
+            key = APIKey(
                **{"in": APIKeyIn.query},
                name="X-API-KEY",
                description="Wallet API Key - QUERY",
            )
        else:
-            self.model: APIKey = APIKey(
+            key = APIKey(
                **{"in": APIKeyIn.header},
                name="X-API-KEY",
                description="Wallet API Key - HEADER",
            )
-        self.wallet = None
+        self.wallet = None  # type: ignore
+        self.model: APIKey = key

-    async def __call__(self, request: Request) -> Wallet:
+    async def __call__(self, request: Request):
        try:
            key_value = (
                self._api_key
@ -48,7 +54,7 @@ class KeyChecker(SecurityBase):
            # FIXME: Find another way to validate the key. A fetch from DB should be avoided here.
            #        Also, we should not return the wallet here - thats silly.
            #        Possibly store it in a Redis DB
-            self.wallet = await get_wallet_for_key(key_value, self._key_type)
+            self.wallet = await get_wallet_for_key(key_value, self._key_type)  # type: ignore
            if not self.wallet:
                raise HTTPException(
                    status_code=HTTPStatus.UNAUTHORIZED,
@ -116,13 +122,13 @@ api_key_query = APIKeyQuery(

 async def get_key_type(
    r: Request,
-    api_key_header: str = Security(api_key_header),
-    api_key_query: str = Security(api_key_query),
+    api_key_header: str = Security(api_key_header),  # type: ignore
+    api_key_query: str = Security(api_key_query),  # type: ignore
 ) -> WalletTypeInfo:
    # 0: admin
    # 1: invoice
    # 2: invalid
-    pathname = r['path'].split('/')[1]
+    pathname = r["path"].split("/")[1]

    if not api_key_header and not api_key_query:
        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST)
@ -130,11 +136,15 @@ async def get_key_type(
    token = api_key_header if api_key_header else api_key_query

    try:
-        checker = WalletAdminKeyChecker(api_key=token)
-        await checker.__call__(r)
-        wallet = WalletTypeInfo(0, checker.wallet)
-        if (LNBITS_ADMIN_USERS and wallet.wallet.user not in LNBITS_ADMIN_USERS) and (LNBITS_ADMIN_EXTENSIONS and pathname in LNBITS_ADMIN_EXTENSIONS):
-            raise HTTPException(status_code=HTTPStatus.UNAUTHORIZED, detail="User not authorized.")
+        admin_checker = WalletAdminKeyChecker(api_key=token)
+        await admin_checker.__call__(r)
+        wallet = WalletTypeInfo(0, admin_checker.wallet)  # type: ignore
+        if (LNBITS_ADMIN_USERS and wallet.wallet.user not in LNBITS_ADMIN_USERS) and (
+            LNBITS_ADMIN_EXTENSIONS and pathname in LNBITS_ADMIN_EXTENSIONS
+        ):
+            raise HTTPException(
+                status_code=HTTPStatus.UNAUTHORIZED, detail="User not authorized."
+            )
        return wallet
    except HTTPException as e:
        if e.status_code == HTTPStatus.BAD_REQUEST:
@ -145,25 +155,30 @@ async def get_key_type(
        raise

    try:
-        checker = WalletInvoiceKeyChecker(api_key=token)
-        await checker.__call__(r)
-        wallet = WalletTypeInfo(1, checker.wallet)
-        if (LNBITS_ADMIN_USERS and wallet.wallet.user not in LNBITS_ADMIN_USERS) and (LNBITS_ADMIN_EXTENSIONS and pathname in LNBITS_ADMIN_EXTENSIONS):
-           raise HTTPException(status_code=HTTPStatus.UNAUTHORIZED, detail="User not authorized.")
+        invoice_checker = WalletInvoiceKeyChecker(api_key=token)
+        await invoice_checker.__call__(r)
+        wallet = WalletTypeInfo(1, invoice_checker.wallet)  # type: ignore
+        if (LNBITS_ADMIN_USERS and wallet.wallet.user not in LNBITS_ADMIN_USERS) and (
+            LNBITS_ADMIN_EXTENSIONS and pathname in LNBITS_ADMIN_EXTENSIONS
+        ):
+            raise HTTPException(
+                status_code=HTTPStatus.UNAUTHORIZED, detail="User not authorized."
+            )
        return wallet
    except HTTPException as e:
        if e.status_code == HTTPStatus.BAD_REQUEST:
            raise
        if e.status_code == HTTPStatus.UNAUTHORIZED:
-            return WalletTypeInfo(2, None)
+            return WalletTypeInfo(2, None)  # type: ignore
    except:
        raise
+    return wallet


 async def require_admin_key(
    r: Request,
-    api_key_header: str = Security(api_key_header),
-    api_key_query: str = Security(api_key_query),
+    api_key_header: str = Security(api_key_header),  # type: ignore
+    api_key_query: str = Security(api_key_query),  # type: ignore
 ):
    token = api_key_header if api_key_header else api_key_query

@ -181,8 +196,8 @@ async def require_admin_key(

 async def require_invoice_key(
    r: Request,
-    api_key_header: str = Security(api_key_header),
-    api_key_query: str = Security(api_key_query),
+    api_key_header: str = Security(api_key_header),  # type: ignore
+    api_key_query: str = Security(api_key_query),  # type: ignore
 ):
    token = api_key_header if api_key_header else api_key_query

--- a/lnbits/extensions/bleskomat/init.py
+++ b/lnbits/extensions/bleskomat/init.py
@ -9,7 +9,7 @@ db = Database("ext_bleskomat")
 bleskomat_static_files = [
    {
        "path": "/bleskomat/static",
-        "app": StaticFiles(directory="lnbits/extensions/bleskomat/static"),
+        "app": StaticFiles(packages=[("lnbits", "extensions/bleskomat/static")]),
        "name": "bleskomat_static",
    }
 ]
--- a/lnbits/extensions/bleskomat/exchange_rates.py
+++ b/lnbits/extensions/bleskomat/exchange_rates.py
@ -1,7 +1,8 @@
-import httpx
 import json
 import os

+import httpx
+
 fiat_currencies = json.load(
    open(
        os.path.join(
--- a/lnbits/extensions/bleskomat/lnurl_api.py
+++ b/lnbits/extensions/bleskomat/lnurl_api.py
@ -3,6 +3,7 @@ import math
 import traceback
 from http import HTTPStatus

+from loguru import logger
 from starlette.requests import Request

 from . import bleskomat_ext
@ -122,7 +123,7 @@ async def api_bleskomat_lnurl(req: Request):
    except LnurlHttpError as e:
        return {"status": "ERROR", "reason": str(e)}
    except Exception as e:
-        print(str(e))
+        logger.error(str(e))
        return {"status": "ERROR", "reason": "Unexpected error"}

    return {"status": "OK"}
--- a/lnbits/extensions/bleskomat/models.py
+++ b/lnbits/extensions/bleskomat/models.py
@ -3,11 +3,12 @@ import time
 from typing import Dict

 from fastapi.params import Query
+from loguru import logger
 from pydantic import BaseModel, validator
 from starlette.requests import Request

 from lnbits import bolt11
-from lnbits.core.services import pay_invoice, PaymentFailure
+from lnbits.core.services import PaymentFailure, pay_invoice

 from . import db
 from .exchange_rates import exchange_rate_providers, fiat_currencies
@ -125,7 +126,7 @@ class BleskomatLnurl(BaseModel):
                except (ValueError, PermissionError, PaymentFailure) as e:
                    raise LnurlValidationError("Failed to pay invoice: " + str(e))
                except Exception as e:
-                    print(str(e))
+                    logger.error(str(e))
                    raise LnurlValidationError("Unexpected error")

    async def use(self, conn) -> bool:
--- a/lnbits/extensions/bleskomat/templates/bleskomat/_api_docs.html
+++ b/lnbits/extensions/bleskomat/templates/bleskomat/_api_docs.html
@ -62,4 +62,5 @@
      </p>
    </q-card-section>
  </q-card>
+  <q-btn flat label="Swagger API" type="a" href="../docs#/Bleskomat"></q-btn>
 </q-expansion-item>
--- a/lnbits/extensions/bleskomat/views_api.py
+++ b/lnbits/extensions/bleskomat/views_api.py
@ -1,6 +1,7 @@
 from http import HTTPStatus

 from fastapi import Depends, Query
+from loguru import logger
 from starlette.exceptions import HTTPException

 from lnbits.core.crud import get_user
@ -60,7 +61,7 @@ async def api_bleskomat_create_or_update(
            currency=fiat_currency, provider=exchange_rate_provider
        )
    except Exception as e:
-        print(e)
+        logger.error(e)
        raise HTTPException(
            status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
            detail=f'Failed to fetch BTC/{fiat_currency} currency pair from "{exchange_rate_provider}"',
--- a/lnbits/extensions/copilot/init.py
+++ b/lnbits/extensions/copilot/init.py
@ -12,7 +12,7 @@ db = Database("ext_copilot")
 copilot_static_files = [
    {
        "path": "/copilot/static",
-        "app": StaticFiles(directory="lnbits/extensions/copilot/static"),
+        "app": StaticFiles(packages=[("lnbits", "extensions/copilot/static")]),
        "name": "copilot_static",
    }
 ]
--- a/lnbits/extensions/copilot/models.py
+++ b/lnbits/extensions/copilot/models.py
@ -1,12 +1,14 @@
-from urllib.parse import urlparse, urlunparse, parse_qs, urlencode, ParseResult
-from starlette.requests import Request
-from fastapi.param_functions import Query
-from typing import Optional, Dict
-from lnbits.lnurl import encode as lnurl_encode  # type: ignore
-from lnurl.types import LnurlPayMetadata  # type: ignore
-from pydantic import BaseModel
 import json
 from sqlite3 import Row
+from typing import Dict, Optional
+from urllib.parse import ParseResult, parse_qs, urlencode, urlparse, urlunparse
+
+from fastapi.param_functions import Query
+from lnurl.types import LnurlPayMetadata  # type: ignore
+from pydantic import BaseModel
+from starlette.requests import Request
+
+from lnbits.lnurl import encode as lnurl_encode  # type: ignore


 class CreateCopilotData(BaseModel):
--- a/lnbits/extensions/copilot/tasks.py
+++ b/lnbits/extensions/copilot/tasks.py
@ -25,7 +25,7 @@ async def wait_for_paid_invoices():
 async def on_invoice_paid(payment: Payment) -> None:
    webhook = None
    data = None
-    if "copilot" != payment.extra.get("tag"):
+    if payment.extra.get("tag") != "copilot":
        # not an copilot invoice
        return

--- a/lnbits/extensions/copilot/templates/copilot/_api_docs.html
+++ b/lnbits/extensions/copilot/templates/copilot/_api_docs.html
@ -14,6 +14,7 @@
    label="API info"
    :content-inset-level="0.5"
  >
+    <q-btn flat label="Swagger API" type="a" href="../docs#/copilot"></q-btn>
    <q-expansion-item group="api" dense expand-separator label="Create copilot">
      <q-card>
        <q-card-section>
@ -31,8 +32,8 @@
          <code>[&lt;copilot_object&gt;, ...]</code>
          <h5 class="text-caption q-mt-sm q-mb-none">Curl example</h5>
          <code
-            >curl -X POST {{ request.base_url }}api/v1/copilot -d '{"title":
-            &lt;string&gt;, "animation": &lt;string&gt;,
+            >curl -X POST {{ request.base_url }}copilot/api/v1/copilot -d
+            '{"title": &lt;string&gt;, "animation": &lt;string&gt;,
            "show_message":&lt;string&gt;, "amount": &lt;integer&gt;,
            "lnurl_title": &lt;string&gt;}' -H "Content-type: application/json"
            -H "X-Api-Key: {{user.wallets[0].adminkey }}"
@ -59,11 +60,11 @@
          <h5 class="text-caption q-mt-sm q-mb-none">Curl example</h5>
          <code
            >curl -X POST {{ request.base_url
-            }}api/v1/copilot/&lt;copilot_id&gt; -d '{"title": &lt;string&gt;,
-            "animation": &lt;string&gt;, "show_message":&lt;string&gt;,
-            "amount": &lt;integer&gt;, "lnurl_title": &lt;string&gt;}' -H
-            "Content-type: application/json" -H "X-Api-Key:
-            {{user.wallets[0].adminkey }}"
+            }}copilot/api/v1/copilot/&lt;copilot_id&gt; -d '{"title":
+            &lt;string&gt;, "animation": &lt;string&gt;,
+            "show_message":&lt;string&gt;, "amount": &lt;integer&gt;,
+            "lnurl_title": &lt;string&gt;}' -H "Content-type: application/json"
+            -H "X-Api-Key: {{user.wallets[0].adminkey }}"
          </code>
        </q-card-section>
      </q-card>
@ -87,8 +88,9 @@
          <code>[&lt;copilot_object&gt;, ...]</code>
          <h5 class="text-caption q-mt-sm q-mb-none">Curl example</h5>
          <code
-            >curl -X GET {{ request.base_url }}api/v1/copilot/&lt;copilot_id&gt;
-            -H "X-Api-Key: {{ user.wallets[0].inkey }}"
+            >curl -X GET {{ request.base_url
+            }}copilot/api/v1/copilot/&lt;copilot_id&gt; -H "X-Api-Key: {{
+            user.wallets[0].inkey }}"
          </code>
        </q-card-section>
      </q-card>
@ -110,8 +112,8 @@
          <code>[&lt;copilot_object&gt;, ...]</code>
          <h5 class="text-caption q-mt-sm q-mb-none">Curl example</h5>
          <code
-            >curl -X GET {{ request.base_url }}api/v1/copilots -H "X-Api-Key: {{
-            user.wallets[0].inkey }}"
+            >curl -X GET {{ request.base_url }}copilot/api/v1/copilots -H
+            "X-Api-Key: {{ user.wallets[0].inkey }}"
          </code>
        </q-card-section>
      </q-card>
@ -136,7 +138,7 @@
          <h5 class="text-caption q-mt-sm q-mb-none">Curl example</h5>
          <code
            >curl -X DELETE {{ request.base_url
-            }}api/v1/copilot/&lt;copilot_id&gt; -H "X-Api-Key: {{
+            }}copilot/api/v1/copilot/&lt;copilot_id&gt; -H "X-Api-Key: {{
            user.wallets[0].adminkey }}"
          </code>
        </q-card-section>
@ -161,9 +163,10 @@
          <code></code>
          <h5 class="text-caption q-mt-sm q-mb-none">Curl example</h5>
          <code
-            >curl -X GET {{ request.base_url }}/api/v1/copilot/ws/&lt;string,
-            copilot_id&gt;/&lt;string, comment&gt;/&lt;string, gif name&gt; -H
-            "X-Api-Key: {{ user.wallets[0].adminkey }}"
+            >curl -X GET {{ request.base_url
+            }}copilot/api/v1/copilot/ws/&lt;string, copilot_id&gt;/&lt;string,
+            comment&gt;/&lt;string, gif name&gt; -H "X-Api-Key: {{
+            user.wallets[0].adminkey }}"
          </code>
        </q-card-section>
      </q-card>
--- a/lnbits/extensions/discordbot/Pipfile
+++ b/lnbits/extensions/discordbot/Pipfile
@ -0,0 +1,11 @@
+[[source]]
+url = "https://pypi.python.org/simple"
+verify_ssl = true
+name = "pypi"
+
+[packages]
+
+[dev-packages]
+
+[requires]
+python_version = "3.9"
--- a/lnbits/extensions/discordbot/README.md
+++ b/lnbits/extensions/discordbot/README.md
@ -0,0 +1,34 @@
+# Discord Bot
+
+## Provide LNbits wallets for all your Discord users
+
+_This extension is a modifed version of LNbits [User Manager](../usermanager/README.md)_
+
+The intended usage of this extension is to connect it to a specifically designed [Discord Bot](https://github.com/chrislennon/lnbits-discord-bot) leveraging LNbits as a community based lightning node.
+
+## Setup
+This bot can target [lnbits.com](https://lnbits.com) or a self hosted instance.
+
+To setup and run the bot instructions are located [here](https://github.com/chrislennon/lnbits-discord-bot#installation) 
+
+## Usage
+This bot will allow users to interact with it in the following ways [full command list](https://github.com/chrislennon/lnbits-discord-bot#commands):
+
+`/create` Will create a wallet for the Discord user 
+  - (currently limiting 1 Discord user == 1 LNbits user == 1 user wallet)
+
+![create](https://imgur.com/CWdDusE.png)
+
+`/balance` Will show the balance of the users wallet.
+
+![balance](https://imgur.com/tKeReCp.png)
+
+`/tip @user [amount]` Will sent money from one user to another
+  - If the recieving user does not have a wallet, one will be created for them
+  - The receiving user will receive a direct message from the bot with a link to their wallet
+
+![tip](https://imgur.com/K3tnChK.png)
+
+`/payme [amount] [description]` Will open an invoice that can be paid by any user
+
+![payme](https://imgur.com/dFvAqL3.png)
--- a/lnbits/extensions/discordbot/init.py
+++ b/lnbits/extensions/discordbot/init.py
@ -0,0 +1,25 @@
+from fastapi import APIRouter
+from fastapi.staticfiles import StaticFiles
+
+from lnbits.db import Database
+from lnbits.helpers import template_renderer
+
+db = Database("ext_discordbot")
+
+discordbot_static_files = [
+    {
+        "path": "/discordbot/static",
+        "app": StaticFiles(packages=[("lnbits", "extensions/discordbot/static")]),
+        "name": "discordbot_static",
+    }
+]
+
+discordbot_ext: APIRouter = APIRouter(prefix="/discordbot", tags=["discordbot"])
+
+
+def discordbot_renderer():
+    return template_renderer(["lnbits/extensions/discordbot/templates"])
+
+
+from .views import *  # noqa
+from .views_api import *  # noqa
--- a/lnbits/extensions/discordbot/config.json
+++ b/lnbits/extensions/discordbot/config.json
@ -0,0 +1,6 @@
+{
+    "name": "Discord Bot",
+    "short_description": "Generate users and wallets",
+    "icon": "person_add",
+    "contributors": ["bitcoingamer21"]
+}
--- a/lnbits/extensions/discordbot/crud.py
+++ b/lnbits/extensions/discordbot/crud.py
@ -0,0 +1,123 @@
+from typing import List, Optional
+
+from lnbits.core.crud import (
+    create_account,
+    create_wallet,
+    delete_wallet,
+    get_payments,
+    get_user,
+)
+from lnbits.core.models import Payment
+
+from . import db
+from .models import CreateUserData, Users, Wallets
+
+### Users
+
+
+async def create_discordbot_user(data: CreateUserData) -> Users:
+    account = await create_account()
+    user = await get_user(account.id)
+    assert user, "Newly created user couldn't be retrieved"
+
+    wallet = await create_wallet(user_id=user.id, wallet_name=data.wallet_name)
+
+    await db.execute(
+        """
+        INSERT INTO discordbot.users (id, name, admin, discord_id)
+        VALUES (?, ?, ?, ?)
+        """,
+        (user.id, data.user_name, data.admin_id, data.discord_id),
+    )
+
+    await db.execute(
+        """
+        INSERT INTO discordbot.wallets (id, admin, name, "user", adminkey, inkey)
+        VALUES (?, ?, ?, ?, ?, ?)
+        """,
+        (
+            wallet.id,
+            data.admin_id,
+            data.wallet_name,
+            user.id,
+            wallet.adminkey,
+            wallet.inkey,
+        ),
+    )
+
+    user_created = await get_discordbot_user(user.id)
+    assert user_created, "Newly created user couldn't be retrieved"
+    return user_created
+
+
+async def get_discordbot_user(user_id: str) -> Optional[Users]:
+    row = await db.fetchone("SELECT * FROM discordbot.users WHERE id = ?", (user_id,))
+    return Users(**row) if row else None
+
+
+async def get_discordbot_users(user_id: str) -> List[Users]:
+    rows = await db.fetchall(
+        "SELECT * FROM discordbot.users WHERE admin = ?", (user_id,)
+    )
+
+    return [Users(**row) for row in rows]
+
+
+async def delete_discordbot_user(user_id: str) -> None:
+    wallets = await get_discordbot_wallets(user_id)
+    for wallet in wallets:
+        await delete_wallet(user_id=user_id, wallet_id=wallet.id)
+
+    await db.execute("DELETE FROM discordbot.users WHERE id = ?", (user_id,))
+    await db.execute("""DELETE FROM discordbot.wallets WHERE "user" = ?""", (user_id,))
+
+
+### Wallets
+
+
+async def create_discordbot_wallet(
+    user_id: str, wallet_name: str, admin_id: str
+) -> Wallets:
+    wallet = await create_wallet(user_id=user_id, wallet_name=wallet_name)
+    await db.execute(
+        """
+        INSERT INTO discordbot.wallets (id, admin, name, "user", adminkey, inkey)
+        VALUES (?, ?, ?, ?, ?, ?)
+        """,
+        (wallet.id, admin_id, wallet_name, user_id, wallet.adminkey, wallet.inkey),
+    )
+    wallet_created = await get_discordbot_wallet(wallet.id)
+    assert wallet_created, "Newly created wallet couldn't be retrieved"
+    return wallet_created
+
+
+async def get_discordbot_wallet(wallet_id: str) -> Optional[Wallets]:
+    row = await db.fetchone(
+        "SELECT * FROM discordbot.wallets WHERE id = ?", (wallet_id,)
+    )
+    return Wallets(**row) if row else None
+
+
+async def get_discordbot_wallets(admin_id: str) -> Optional[Wallets]:
+    rows = await db.fetchall(
+        "SELECT * FROM discordbot.wallets WHERE admin = ?", (admin_id,)
+    )
+    return [Wallets(**row) for row in rows]
+
+
+async def get_discordbot_users_wallets(user_id: str) -> Optional[Wallets]:
+    rows = await db.fetchall(
+        """SELECT * FROM discordbot.wallets WHERE "user" = ?""", (user_id,)
+    )
+    return [Wallets(**row) for row in rows]
+
+
+async def get_discordbot_wallet_transactions(wallet_id: str) -> Optional[Payment]:
+    return await get_payments(
+        wallet_id=wallet_id, complete=True, pending=False, outgoing=True, incoming=True
+    )
+
+
+async def delete_discordbot_wallet(wallet_id: str, user_id: str) -> None:
+    await delete_wallet(user_id=user_id, wallet_id=wallet_id)
+    await db.execute("DELETE FROM discordbot.wallets WHERE id = ?", (wallet_id,))
--- a/lnbits/extensions/discordbot/migrations.py
+++ b/lnbits/extensions/discordbot/migrations.py
@ -0,0 +1,30 @@
+async def m001_initial(db):
+    """
+    Initial users table.
+    """
+    await db.execute(
+        """
+        CREATE TABLE discordbot.users (
+            id TEXT PRIMARY KEY,
+            name TEXT NOT NULL,
+            admin TEXT NOT NULL,
+            discord_id TEXT
+        );
+    """
+    )
+
+    """
+    Initial wallets table.
+    """
+    await db.execute(
+        """
+        CREATE TABLE discordbot.wallets (
+            id TEXT PRIMARY KEY,
+            admin TEXT NOT NULL,
+            name TEXT NOT NULL,
+            "user" TEXT NOT NULL,
+            adminkey TEXT NOT NULL,
+            inkey TEXT NOT NULL
+        );
+    """
+    )
--- a/lnbits/extensions/discordbot/models.py
+++ b/lnbits/extensions/discordbot/models.py
@ -0,0 +1,38 @@
+from sqlite3 import Row
+from typing import Optional
+
+from fastapi.param_functions import Query
+from pydantic import BaseModel
+
+
+class CreateUserData(BaseModel):
+    user_name: str = Query(...)
+    wallet_name: str = Query(...)
+    admin_id: str = Query(...)
+    discord_id: str = Query("")
+
+
+class CreateUserWallet(BaseModel):
+    user_id: str = Query(...)
+    wallet_name: str = Query(...)
+    admin_id: str = Query(...)
+
+
+class Users(BaseModel):
+    id: str
+    name: str
+    admin: str
+    discord_id: str
+
+
+class Wallets(BaseModel):
+    id: str
+    admin: str
+    name: str
+    user: str
+    adminkey: str
+    inkey: str
+
+    @classmethod
+    def from_row(cls, row: Row) -> "Wallets":
+        return cls(**dict(row))
--- a/lnbits/extensions/discordbot/static/stack.png
+++ b/lnbits/extensions/discordbot/static/stack.png
--- a/lnbits/extensions/discordbot/templates/discordbot/_api_docs.html
+++ b/lnbits/extensions/discordbot/templates/discordbot/_api_docs.html
@ -0,0 +1,269 @@
+<q-expansion-item
+  group="extras"
+  icon="swap_vertical_circle"
+  label="Info"
+  :content-inset-level="0.5"
+>
+  <q-card>
+    <q-card-section>
+      <h5 class="text-subtitle1 q-my-none">
+        Discord Bot: Connect Discord users to LNbits.
+      </h5>
+      <p>
+        Connect your LNbits instance to a
+        <a href="https://github.com/chrislennon/lnbits-discord-bot"
+          >Discord Bot</a
+        >
+        leveraging LNbits as a community based lightning node.<br />
+        <small>
+          Created by,
+          <a href="https://github.com/chrislennon">Chris Lennon</a></small
+        >
+        <br />
+        <small>
+          Based on User Manager, by
+          <a href="https://github.com/benarc">Ben Arc</a></small
+        >
+      </p>
+    </q-card-section>
+  </q-card>
+</q-expansion-item>
+<q-expansion-item
+  group="extras"
+  icon="swap_vertical_circle"
+  label="API info"
+  :content-inset-level="0.5"
+>
+  <q-btn flat label="Swagger API" type="a" href="../docs#/discordbot"></q-btn>
+  <q-expansion-item group="api" dense expand-separator label="GET users">
+    <q-card>
+      <q-card-section>
+        <code
+          ><span class="text-light-blue">GET</span>
+          /discordbot/api/v1/users</code
+        >
+        <h5 class="text-caption q-mt-sm q-mb-none">Body (application/json)</h5>
+        <h5 class="text-caption q-mt-sm q-mb-none">
+          Returns 201 CREATED (application/json)
+        </h5>
+        <code>JSON list of users</code>
+        <h5 class="text-caption q-mt-sm q-mb-none">Curl example</h5>
+        <code
+          >curl -X GET {{ request.base_url }}discordbot/api/v1/users -H
+          "X-Api-Key: {{ user.wallets[0].inkey }}"
+        </code>
+      </q-card-section>
+    </q-card>
+  </q-expansion-item>
+  <q-expansion-item group="api" dense expand-separator label="GET user">
+    <q-card>
+      <q-card-section>
+        <code
+          ><span class="text-light-blue">GET</span>
+          /discordbot/api/v1/users/&lt;user_id&gt;</code
+        >
+        <h5 class="text-caption q-mt-sm q-mb-none">Body (application/json)</h5>
+        <h5 class="text-caption q-mt-sm q-mb-none">
+          Returns 201 CREATED (application/json)
+        </h5>
+        <code>JSON list of users</code>
+        <h5 class="text-caption q-mt-sm q-mb-none">Curl example</h5>
+        <code
+          >curl -X GET {{ request.base_url
+          }}discordbot/api/v1/users/&lt;user_id&gt; -H "X-Api-Key: {{
+          user.wallets[0].inkey }}"
+        </code>
+      </q-card-section>
+    </q-card>
+  </q-expansion-item>
+  <q-expansion-item group="api" dense expand-separator label="GET wallets">
+    <q-card>
+      <q-card-section>
+        <code
+          ><span class="text-light-blue">GET</span>
+          /discordbot/api/v1/wallets/&lt;user_id&gt;</code
+        >
+        <h5 class="text-caption q-mt-sm q-mb-none">Headers</h5>
+        <code>{"X-Api-Key": &lt;string&gt;}</code>
+        <h5 class="text-caption q-mt-sm q-mb-none">Body (application/json)</h5>
+        <h5 class="text-caption q-mt-sm q-mb-none">
+          Returns 201 CREATED (application/json)
+        </h5>
+        <code>JSON wallet data</code>
+        <h5 class="text-caption q-mt-sm q-mb-none">Curl example</h5>
+        <code
+          >curl -X GET {{ request.base_url
+          }}discordbot/api/v1/wallets/&lt;user_id&gt; -H "X-Api-Key: {{
+          user.wallets[0].inkey }}"
+        </code>
+      </q-card-section>
+    </q-card>
+  </q-expansion-item>
+  <q-expansion-item group="api" dense expand-separator label="GET transactions">
+    <q-card>
+      <q-card-section>
+        <code
+          ><span class="text-light-blue">GET</span>
+          /discordbot/api/v1/wallets&lt;wallet_id&gt;</code
+        >
+        <h5 class="text-caption q-mt-sm q-mb-none">Headers</h5>
+        <code>{"X-Api-Key": &lt;string&gt;}</code>
+        <h5 class="text-caption q-mt-sm q-mb-none">Body (application/json)</h5>
+        <h5 class="text-caption q-mt-sm q-mb-none">
+          Returns 201 CREATED (application/json)
+        </h5>
+        <code>JSON a wallets transactions</code>
+        <h5 class="text-caption q-mt-sm q-mb-none">Curl example</h5>
+        <code
+          >curl -X GET {{ request.base_url
+          }}discordbot/api/v1/wallets&lt;wallet_id&gt; -H "X-Api-Key: {{
+          user.wallets[0].inkey }}"
+        </code>
+      </q-card-section>
+    </q-card>
+  </q-expansion-item>
+  <q-expansion-item
+    group="api"
+    dense
+    expand-separator
+    label="POST user + initial wallet"
+  >
+    <q-card>
+      <q-card-section>
+        <code
+          ><span class="text-light-green">POST</span>
+          /discordbot/api/v1/users</code
+        >
+        <h5 class="text-caption q-mt-sm q-mb-none">Headers</h5>
+        <code
+          >{"X-Api-Key": &lt;string&gt;, "Content-type":
+          "application/json"}</code
+        >
+        <h5 class="text-caption q-mt-sm q-mb-none">
+          Body (application/json) - "admin_id" is a YOUR user ID
+        </h5>
+        <code
+          >{"admin_id": &lt;string&gt;, "user_name": &lt;string&gt;,
+          "wallet_name": &lt;string&gt;,"discord_id": &lt;string&gt;}</code
+        >
+        <h5 class="text-caption q-mt-sm q-mb-none">
+          Returns 201 CREATED (application/json)
+        </h5>
+        <code
+          >{"id": &lt;string&gt;, "name": &lt;string&gt;, "admin":
+          &lt;string&gt;, "discord_id": &lt;string&gt;}</code
+        >
+        <h5 class="text-caption q-mt-sm q-mb-none">Curl example</h5>
+        <code
+          >curl -X POST {{ request.base_url }}discordbot/api/v1/users -d
+          '{"admin_id": "{{ user.id }}", "wallet_name": &lt;string&gt;,
+          "user_name": &lt;string&gt;, "discord_id": &lt;string&gt;}' -H
+          "X-Api-Key: {{ user.wallets[0].inkey }}" -H "Content-type:
+          application/json"
+        </code>
+      </q-card-section>
+    </q-card>
+  </q-expansion-item>
+  <q-expansion-item group="api" dense expand-separator label="POST wallet">
+    <q-card>
+      <q-card-section>
+        <code
+          ><span class="text-light-green">POST</span>
+          /discordbot/api/v1/wallets</code
+        >
+        <h5 class="text-caption q-mt-sm q-mb-none">Headers</h5>
+        <code
+          >{"X-Api-Key": &lt;string&gt;, "Content-type":
+          "application/json"}</code
+        >
+        <h5 class="text-caption q-mt-sm q-mb-none">
+          Body (application/json) - "admin_id" is a YOUR user ID
+        </h5>
+        <code
+          >{"user_id": &lt;string&gt;, "wallet_name": &lt;string&gt;,
+          "admin_id": &lt;string&gt;}</code
+        >
+        <h5 class="text-caption q-mt-sm q-mb-none">
+          Returns 201 CREATED (application/json)
+        </h5>
+        <code
+          >{"id": &lt;string&gt;, "admin": &lt;string&gt;, "name":
+          &lt;string&gt;, "user": &lt;string&gt;, "adminkey": &lt;string&gt;,
+          "inkey": &lt;string&gt;}</code
+        >
+        <h5 class="text-caption q-mt-sm q-mb-none">Curl example</h5>
+        <code
+          >curl -X POST {{ request.base_url }}discordbot/api/v1/wallets -d
+          '{"user_id": &lt;string&gt;, "wallet_name": &lt;string&gt;,
+          "admin_id": "{{ user.id }}"}' -H "X-Api-Key: {{ user.wallets[0].inkey
+          }}" -H "Content-type: application/json"
+        </code>
+      </q-card-section>
+    </q-card>
+  </q-expansion-item>
+  <q-expansion-item
+    group="api"
+    dense
+    expand-separator
+    label="DELETE user and their wallets"
+  >
+    <q-card>
+      <q-card-section>
+        <code
+          ><span class="text-red">DELETE</span>
+          /discordbot/api/v1/users/&lt;user_id&gt;</code
+        >
+        <h5 class="text-caption q-mt-sm q-mb-none">Headers</h5>
+        <code>{"X-Api-Key": &lt;string&gt;}</code>
+        <h5 class="text-caption q-mt-sm q-mb-none">Curl example</h5>
+        <code
+          >curl -X DELETE {{ request.base_url
+          }}discordbot/api/v1/users/&lt;user_id&gt; -H "X-Api-Key: {{
+          user.wallets[0].inkey }}"
+        </code>
+      </q-card-section>
+    </q-card>
+  </q-expansion-item>
+  <q-expansion-item group="api" dense expand-separator label="DELETE wallet">
+    <q-card>
+      <q-card-section>
+        <code
+          ><span class="text-red">DELETE</span>
+          /discordbot/api/v1/wallets/&lt;wallet_id&gt;</code
+        >
+        <h5 class="text-caption q-mt-sm q-mb-none">Headers</h5>
+        <code>{"X-Api-Key": &lt;string&gt;}</code>
+        <h5 class="text-caption q-mt-sm q-mb-none">Curl example</h5>
+        <code
+          >curl -X DELETE {{ request.base_url
+          }}discordbot/api/v1/wallets/&lt;wallet_id&gt; -H "X-Api-Key: {{
+          user.wallets[0].inkey }}"
+        </code>
+      </q-card-section>
+    </q-card>
+  </q-expansion-item>
+  <q-expansion-item
+    group="api"
+    dense
+    expand-separator
+    label="POST activate extension"
+  >
+    <q-card>
+      <q-card-section>
+        <code
+          ><span class="text-green">POST</span>
+          /discordbot/api/v1/extensions</code
+        >
+        <h5 class="text-caption q-mt-sm q-mb-none">Headers</h5>
+        <code>{"X-Api-Key": &lt;string&gt;}</code>
+        <h5 class="text-caption q-mt-sm q-mb-none">Curl example</h5>
+        <code
+          >curl -X POST {{ request.base_url }}discordbot/api/v1/extensions -d
+          '{"userid": &lt;string&gt;, "extension": &lt;string&gt;, "active":
+          &lt;integer&gt;}' -H "X-Api-Key: {{ user.wallets[0].inkey }}" -H
+          "Content-type: application/json"
+        </code>
+      </q-card-section>
+    </q-card>
+  </q-expansion-item>
+</q-expansion-item>
--- a/lnbits/extensions/discordbot/templates/discordbot/index.html
+++ b/lnbits/extensions/discordbot/templates/discordbot/index.html
@ -0,0 +1,470 @@
+{% extends "base.html" %} {% from "macros.jinja" import window_vars with context
+%} {% block page %}
+<div class="row q-col-gutter-md">
+  <div class="col-12 col-md-8 col-lg-7 q-gutter-y-md">
+    <q-card>
+      <q-card-section>
+        <center><img src="/discordbot/static/stack.png" height="200" /></center>
+        This extension is designed to be used through its API by a Discord Bot,
+        currently you have to install the bot
+        <a
+          href="https://github.com/chrislennon/lnbits-discord-bot/#installation"
+          >yourself</a
+        ><br />
+
+        Soon™ there will be a much easier one-click install discord bot...
+      </q-card-section>
+    </q-card>
+
+    <q-card>
+      <q-card-section>
+        <div class="row items-center no-wrap q-mb-md">
+          <div class="col">
+            <h5 class="text-subtitle1 q-my-none">Users</h5>
+          </div>
+          <div class="col-auto">
+            <q-btn flat color="grey" @click="exportUsersCSV"
+              >Export to CSV</q-btn
+            >
+          </div>
+        </div>
+        <q-table
+          dense
+          flat
+          :data="users"
+          row-key="id"
+          :columns="usersTable.columns"
+          :pagination.sync="usersTable.pagination"
+        >
+          {% raw %}
+          <template v-slot:header="props">
+            <q-tr :props="props">
+              <q-th v-for="col in props.cols" :key="col.name" :props="props">
+                {{ col.label }}
+              </q-th>
+              <q-th auto-width></q-th>
+            </q-tr>
+          </template>
+          <template v-slot:body="props">
+            <q-tr :props="props">
+              <q-td v-for="col in props.cols" :key="col.name" :props="props">
+                {{ col.value }}
+              </q-td>
+              <q-td auto-width>
+                <q-btn
+                  flat
+                  dense
+                  size="xs"
+                  @click="deleteUser(props.row.id)"
+                  icon="cancel"
+                  color="pink"
+                ></q-btn>
+              </q-td>
+            </q-tr>
+          </template>
+          {% endraw %}
+        </q-table>
+      </q-card-section>
+    </q-card>
+
+    <q-card>
+      <q-card-section>
+        <div class="row items-center no-wrap q-mb-md">
+          <div class="col">
+            <h5 class="text-subtitle1 q-my-none">Wallets</h5>
+          </div>
+          <div class="col-auto">
+            <q-btn flat color="grey" @click="exportWalletsCSV"
+              >Export to CSV</q-btn
+            >
+          </div>
+        </div>
+        <q-table
+          dense
+          flat
+          :data="wallets"
+          row-key="id"
+          :columns="walletsTable.columns"
+          :pagination.sync="walletsTable.pagination"
+        >
+          {% raw %}
+          <template v-slot:header="props">
+            <q-tr :props="props">
+              <q-th auto-width></q-th>
+              <q-th v-for="col in props.cols" :key="col.name" :props="props">
+                {{ col.label }}
+              </q-th>
+              <q-th auto-width></q-th>
+            </q-tr>
+          </template>
+          <template v-slot:body="props">
+            <q-tr :props="props">
+              <q-td auto-width>
+                <q-btn
+                  unelevated
+                  dense
+                  size="xs"
+                  icon="account_balance_wallet"
+                  :color="($q.dark.isActive) ? 'grey-7' : 'grey-5'"
+                  type="a"
+                  :href="props.row.walllink"
+                  target="_blank"
+                ></q-btn>
+                <q-tooltip> Link to wallet </q-tooltip>
+              </q-td>
+              <q-td v-for="col in props.cols" :key="col.name" :props="props">
+                {{ col.value }}
+              </q-td>
+              <q-td auto-width>
+                <q-btn
+                  flat
+                  dense
+                  size="xs"
+                  @click="deleteWallet(props.row.id)"
+                  icon="cancel"
+                  color="pink"
+                ></q-btn>
+              </q-td>
+            </q-tr>
+          </template>
+          {% endraw %}
+        </q-table>
+      </q-card-section>
+    </q-card>
+  </div>
+
+  <div class="col-12 col-md-4 col-lg-5 q-gutter-y-md">
+    <q-card>
+      <q-card-section>
+        <h6 class="text-subtitle1 q-my-none">
+          LNbits Discord Bot Extension
+          <!--{{SITE_TITLE}} Discord Bot Extension-->
+        </h6>
+      </q-card-section>
+      <q-card-section class="q-pa-none">
+        <q-separator></q-separator>
+        <q-list> {% include "discordbot/_api_docs.html" %} </q-list>
+      </q-card-section>
+    </q-card>
+  </div>
+
+  <q-dialog v-model="userDialog.show" position="top">
+    <q-card class="q-pa-lg q-pt-xl" style="width: 500px">
+      <q-form @submit="sendUserFormData" class="q-gutter-md">
+        <q-input
+          filled
+          dense
+          v-model.trim="userDialog.data.usrname"
+          label="Username"
+        ></q-input>
+        <q-input
+          filled
+          dense
+          v-model.trim="userDialog.data.walname"
+          label="Initial wallet name"
+        ></q-input>
+        <q-input
+          filled
+          dense
+          v-model.trim="userDialog.data.discord_id"
+          label="Discord ID"
+        ></q-input>
+
+        <q-btn
+          unelevated
+          color="primary"
+          :disable="userDialog.data.walname == null"
+          type="submit"
+          >Create User</q-btn
+        >
+        <q-btn v-close-popup flat color="grey" class="q-ml-auto">Cancel</q-btn>
+      </q-form>
+    </q-card>
+  </q-dialog>
+
+  <q-dialog v-model="walletDialog.show" position="top">
+    <q-card class="q-pa-lg q-pt-xl" style="width: 500px">
+      <q-form @submit="sendWalletFormData" class="q-gutter-md">
+        <q-select
+          filled
+          dense
+          emit-value
+          v-model="walletDialog.data.user"
+          :options="userOptions"
+          label="User *"
+        >
+        </q-select>
+        <q-input
+          filled
+          dense
+          v-model.trim="walletDialog.data.walname"
+          label="Wallet name"
+        ></q-input>
+        <q-btn
+          unelevated
+          color="primary"
+          :disable="walletDialog.data.walname == null"
+          type="submit"
+          >Create Wallet</q-btn
+        >
+        <q-btn v-close-popup flat color="grey" class="q-ml-auto">Cancel</q-btn>
+      </q-form>
+    </q-card>
+  </q-dialog>
+</div>
+{% endblock %} {% block scripts %} {{ window_vars(user) }}
+<script>
+  var mapUserManager = function (obj) {
+    obj.date = Quasar.utils.date.formatDate(
+      new Date(obj.time * 1000),
+      'YYYY-MM-DD HH:mm'
+    )
+    obj.fsat = new Intl.NumberFormat(LOCALE).format(obj.amount)
+    obj.walllink = ['../wallet?usr=', obj.user, '&wal=', obj.id].join('')
+    obj._data = _.clone(obj)
+    return obj
+  }
+
+  new Vue({
+    el: '#vue',
+    mixins: [windowMixin],
+    data: function () {
+      return {
+        wallets: [],
+        users: [],
+
+        usersTable: {
+          columns: [
+            {name: 'id', align: 'left', label: 'ID', field: 'id'},
+            {name: 'name', align: 'left', label: 'Username', field: 'name'},
+            {
+              name: 'discord_id',
+              align: 'left',
+              label: 'discord_id',
+              field: 'discord_id'
+            }
+          ],
+          pagination: {
+            rowsPerPage: 10
+          }
+        },
+        walletsTable: {
+          columns: [
+            {name: 'id', align: 'left', label: 'ID', field: 'id'},
+            {name: 'name', align: 'left', label: 'Name', field: 'name'},
+            {name: 'user', align: 'left', label: 'User', field: 'user'},
+            {
+              name: 'adminkey',
+              align: 'left',
+              label: 'Admin Key',
+              field: 'adminkey'
+            },
+            {name: 'inkey', align: 'left', label: 'Invoice Key', field: 'inkey'}
+          ],
+          pagination: {
+            rowsPerPage: 10
+          }
+        },
+        walletDialog: {
+          show: false,
+          data: {}
+        },
+        userDialog: {
+          show: false,
+          data: {}
+        }
+      }
+    },
+    computed: {
+      userOptions: function () {
+        return this.users.map(function (obj) {
+          console.log(obj.id)
+          return {
+            value: String(obj.id),
+            label: String(obj.id)
+          }
+        })
+      }
+    },
+    methods: {
+      ///////////////Users////////////////////////////
+
+      getUsers: function () {
+        var self = this
+
+        LNbits.api
+          .request(
+            'GET',
+            '/discordbot/api/v1/users',
+            this.g.user.wallets[0].inkey
+          )
+          .then(function (response) {
+            self.users = response.data.map(function (obj) {
+              return mapUserManager(obj)
+            })
+          })
+      },
+
+      openUserUpdateDialog: function (linkId) {
+        var link = _.findWhere(this.users, {id: linkId})
+
+        this.userDialog.data = _.clone(link._data)
+        this.userDialog.show = true
+      },
+      sendUserFormData: function () {
+        if (this.userDialog.data.id) {
+        } else {
+          var data = {
+            admin_id: this.g.user.id,
+            user_name: this.userDialog.data.usrname,
+            wallet_name: this.userDialog.data.walname,
+            discord_id: this.userDialog.data.discord_id
+          }
+        }
+
+        {
+          this.createUser(data)
+        }
+      },
+
+      createUser: function (data) {
+        var self = this
+        LNbits.api
+          .request(
+            'POST',
+            '/discordbot/api/v1/users',
+            this.g.user.wallets[0].inkey,
+            data
+          )
+          .then(function (response) {
+            self.users.push(mapUserManager(response.data))
+            self.userDialog.show = false
+            self.userDialog.data = {}
+            data = {}
+            self.getWallets()
+          })
+          .catch(function (error) {
+            LNbits.utils.notifyApiError(error)
+          })
+      },
+      deleteUser: function (userId) {
+        var self = this
+
+        console.log(userId)
+        LNbits.utils
+          .confirmDialog('Are you sure you want to delete this User link?')
+          .onOk(function () {
+            LNbits.api
+              .request(
+                'DELETE',
+                '/discordbot/api/v1/users/' + userId,
+                self.g.user.wallets[0].inkey
+              )
+              .then(function (response) {
+                self.users = _.reject(self.users, function (obj) {
+                  return obj.id == userId
+                })
+                self.getWallets()
+              })
+              .catch(function (error) {
+                LNbits.utils.notifyApiError(error)
+              })
+          })
+      },
+
+      exportUsersCSV: function () {
+        LNbits.utils.exportCSV(this.usersTable.columns, this.users)
+      },
+
+      ///////////////Wallets////////////////////////////
+
+      getWallets: function () {
+        var self = this
+
+        LNbits.api
+          .request(
+            'GET',
+            '/discordbot/api/v1/wallets',
+            this.g.user.wallets[0].inkey
+          )
+          .then(function (response) {
+            self.wallets = response.data.map(function (obj) {
+              return mapUserManager(obj)
+            })
+          })
+      },
+      openWalletUpdateDialog: function (linkId) {
+        var link = _.findWhere(this.users, {id: linkId})
+
+        this.walletDialog.data = _.clone(link._data)
+        this.walletDialog.show = true
+      },
+      sendWalletFormData: function () {
+        if (this.walletDialog.data.id) {
+        } else {
+          var data = {
+            user_id: this.walletDialog.data.user,
+            admin_id: this.g.user.id,
+            wallet_name: this.walletDialog.data.walname
+          }
+        }
+
+        {
+          this.createWallet(data)
+        }
+      },
+
+      createWallet: function (data) {
+        var self = this
+        LNbits.api
+          .request(
+            'POST',
+            '/discordbot/api/v1/wallets',
+            this.g.user.wallets[0].inkey,
+            data
+          )
+          .then(function (response) {
+            self.wallets.push(mapUserManager(response.data))
+            self.walletDialog.show = false
+            self.walletDialog.data = {}
+            data = {}
+          })
+          .catch(function (error) {
+            LNbits.utils.notifyApiError(error)
+          })
+      },
+      deleteWallet: function (userId) {
+        var self = this
+
+        LNbits.utils
+          .confirmDialog('Are you sure you want to delete this wallet link?')
+          .onOk(function () {
+            LNbits.api
+              .request(
+                'DELETE',
+                '/discordbot/api/v1/wallets/' + userId,
+                self.g.user.wallets[0].inkey
+              )
+              .then(function (response) {
+                self.wallets = _.reject(self.wallets, function (obj) {
+                  return obj.id == userId
+                })
+              })
+              .catch(function (error) {
+                LNbits.utils.notifyApiError(error)
+              })
+          })
+      },
+      exportWalletsCSV: function () {
+        LNbits.utils.exportCSV(this.walletsTable.columns, this.wallets)
+      }
+    },
+    created: function () {
+      if (this.g.user.wallets.length) {
+        this.getUsers()
+        this.getWallets()
+      }
+    }
+  })
+</script>
+{% endblock %}
--- a/lnbits/extensions/discordbot/views.py
+++ b/lnbits/extensions/discordbot/views.py
@ -0,0 +1,15 @@
+from fastapi import Request
+from fastapi.params import Depends
+from starlette.responses import HTMLResponse
+
+from lnbits.core.models import User
+from lnbits.decorators import check_user_exists
+
+from . import discordbot_ext, discordbot_renderer
+
+
+@discordbot_ext.get("/", response_class=HTMLResponse)
+async def index(request: Request, user: User = Depends(check_user_exists)):
+    return discordbot_renderer().TemplateResponse(
+        "discordbot/index.html", {"request": request, "user": user.dict()}
+    )
--- a/lnbits/extensions/discordbot/views_api.py
+++ b/lnbits/extensions/discordbot/views_api.py
@ -0,0 +1,125 @@
+from http import HTTPStatus
+
+from fastapi import Query
+from fastapi.params import Depends
+from starlette.exceptions import HTTPException
+
+from lnbits.core import update_user_extension
+from lnbits.core.crud import get_user
+from lnbits.decorators import WalletTypeInfo, get_key_type
+
+from . import discordbot_ext
+from .crud import (
+    create_discordbot_user,
+    create_discordbot_wallet,
+    delete_discordbot_user,
+    delete_discordbot_wallet,
+    get_discordbot_user,
+    get_discordbot_users,
+    get_discordbot_users_wallets,
+    get_discordbot_wallet,
+    get_discordbot_wallet_transactions,
+    get_discordbot_wallets,
+)
+from .models import CreateUserData, CreateUserWallet
+
+# Users
+
+
+@discordbot_ext.get("/api/v1/users", status_code=HTTPStatus.OK)
+async def api_discordbot_users(wallet: WalletTypeInfo = Depends(get_key_type)):
+    user_id = wallet.wallet.user
+    return [user.dict() for user in await get_discordbot_users(user_id)]
+
+
+@discordbot_ext.get("/api/v1/users/{user_id}", status_code=HTTPStatus.OK)
+async def api_discordbot_user(user_id, wallet: WalletTypeInfo = Depends(get_key_type)):
+    user = await get_discordbot_user(user_id)
+    return user.dict()
+
+
+@discordbot_ext.post("/api/v1/users", status_code=HTTPStatus.CREATED)
+async def api_discordbot_users_create(
+    data: CreateUserData, wallet: WalletTypeInfo = Depends(get_key_type)
+):
+    user = await create_discordbot_user(data)
+    full = user.dict()
+    full["wallets"] = [
+        wallet.dict() for wallet in await get_discordbot_users_wallets(user.id)
+    ]
+    return full
+
+
+@discordbot_ext.delete("/api/v1/users/{user_id}")
+async def api_discordbot_users_delete(
+    user_id, wallet: WalletTypeInfo = Depends(get_key_type)
+):
+    user = await get_discordbot_user(user_id)
+    if not user:
+        raise HTTPException(
+            status_code=HTTPStatus.NOT_FOUND, detail="User does not exist."
+        )
+    await delete_discordbot_user(user_id)
+    raise HTTPException(status_code=HTTPStatus.NO_CONTENT)
+
+
+# Activate Extension
+
+
+@discordbot_ext.post("/api/v1/extensions")
+async def api_discordbot_activate_extension(
+    extension: str = Query(...), userid: str = Query(...), active: bool = Query(...)
+):
+    user = await get_user(userid)
+    if not user:
+        raise HTTPException(
+            status_code=HTTPStatus.NOT_FOUND, detail="User does not exist."
+        )
+    update_user_extension(user_id=userid, extension=extension, active=active)
+    return {"extension": "updated"}
+
+
+# Wallets
+
+
+@discordbot_ext.post("/api/v1/wallets")
+async def api_discordbot_wallets_create(
+    data: CreateUserWallet, wallet: WalletTypeInfo = Depends(get_key_type)
+):
+    user = await create_discordbot_wallet(
+        user_id=data.user_id, wallet_name=data.wallet_name, admin_id=data.admin_id
+    )
+    return user.dict()
+
+
+@discordbot_ext.get("/api/v1/wallets")
+async def api_discordbot_wallets(wallet: WalletTypeInfo = Depends(get_key_type)):
+    admin_id = wallet.wallet.user
+    return [wallet.dict() for wallet in await get_discordbot_wallets(admin_id)]
+
+
+@discordbot_ext.get("/api/v1/transactions/{wallet_id}")
+async def api_discordbot_wallet_transactions(
+    wallet_id, wallet: WalletTypeInfo = Depends(get_key_type)
+):
+    return await get_discordbot_wallet_transactions(wallet_id)
+
+
+@discordbot_ext.get("/api/v1/wallets/{user_id}")
+async def api_discordbot_users_wallets(
+    user_id, wallet: WalletTypeInfo = Depends(get_key_type)
+):
+    return [s_wallet.dict() for s_wallet in await get_discordbot_users_wallets(user_id)]
+
+
+@discordbot_ext.delete("/api/v1/wallets/{wallet_id}")
+async def api_discordbot_wallets_delete(
+    wallet_id, wallet: WalletTypeInfo = Depends(get_key_type)
+):
+    get_wallet = await get_discordbot_wallet(wallet_id)
+    if not get_wallet:
+        raise HTTPException(
+            status_code=HTTPStatus.NOT_FOUND, detail="Wallet does not exist."
+        )
+    await delete_discordbot_wallet(wallet_id, get_wallet.user)
+    raise HTTPException(status_code=HTTPStatus.NO_CONTENT)
--- a/lnbits/extensions/events/crud.py
+++ b/lnbits/extensions/events/crud.py
@ -16,7 +16,7 @@ async def create_ticket(
        INSERT INTO events.ticket (id, wallet, event, name, email, registered, paid)
        VALUES (?, ?, ?, ?, ?, ?, ?)
        """,
-        (payment_hash, wallet, event, name, email, False, False),
+        (payment_hash, wallet, event, name, email, False, True),
    )

    ticket = await get_ticket(payment_hash)
--- a/lnbits/extensions/events/templates/events/_api_docs.html
+++ b/lnbits/extensions/events/templates/events/_api_docs.html
@ -20,4 +20,5 @@
      </p>
    </q-card-section>
  </q-card>
+  <q-btn flat label="Swagger API" type="a" href="../docs#/events"></q-btn>
 </q-expansion-item>
--- a/lnbits/extensions/events/templates/events/display.html
+++ b/lnbits/extensions/events/templates/events/display.html
@ -135,15 +135,7 @@
        var self = this
        axios

-          .post(
-            '/events/api/v1/tickets/' + '{{ event_id }}/{{ event_price }}',
-            {
-              event: '{{ event_id }}',
-              event_name: '{{ event_name }}',
-              name: self.formDialog.data.name,
-              email: self.formDialog.data.email
-            }
-          )
+          .get('/events/api/v1/tickets/' + '{{ event_id }}')
          .then(function (response) {
            self.paymentReq = response.data.payment_request
            self.paymentCheck = response.data.payment_hash
@ -161,7 +153,17 @@

            paymentChecker = setInterval(function () {
              axios
-                .get('/events/api/v1/tickets/' + self.paymentCheck)
+                .post(
+                  '/events/api/v1/tickets/' +
+                    '{{ event_id }}/' +
+                    self.paymentCheck,
+                  {
+                    event: '{{ event_id }}',
+                    event_name: '{{ event_name }}',
+                    name: self.formDialog.data.name,
+                    email: self.formDialog.data.email
+                  }
+                )
                .then(function (res) {
                  if (res.data.paid) {
                    clearInterval(paymentChecker)
--- a/lnbits/extensions/events/templates/events/index.html
+++ b/lnbits/extensions/events/templates/events/index.html
@ -381,10 +381,10 @@
      getTickets: function () {
        var self = this
        LNbits.api
-        .request(
-          'GET',
-          '/events/api/v1/tickets?all_wallets=true',
-          this.g.user.wallets[0].inkey
+          .request(
+            'GET',
+            '/events/api/v1/tickets?all_wallets=true',
+            this.g.user.wallets[0].inkey
          )
          .then(function (response) {
            console.log(response)
--- a/lnbits/extensions/events/templates/events/register.html
+++ b/lnbits/extensions/events/templates/events/register.html
@ -133,7 +133,10 @@
        var self = this

        LNbits.api
-          .request('GET', '/events/api/v1/register/ticket/' + res)
+          .request(
+            'GET',
+            '/events/api/v1/register/ticket/' + res.split('//')[1]
+          )
          .then(function (response) {
            self.$q.notify({
              type: 'positive',
--- a/lnbits/extensions/events/templates/events/ticket.html
+++ b/lnbits/extensions/events/templates/events/ticket.html
@ -13,9 +13,8 @@
          <br />

          <qrcode
-            :value="'{{ ticket_id }}'"
-            :options="{width: 340}"
-            class="rounded-borders"
+            :value="'ticket://{{ ticket_id }}'"
+            :options="{width: 500}"
          ></qrcode>
          <br />
          <q-btn @click="printWindow" color="grey" class="q-ml-auto">
--- a/lnbits/extensions/events/views_api.py
+++ b/lnbits/extensions/events/views_api.py
@ -97,8 +97,8 @@ async def api_tickets(
    return [ticket.dict() for ticket in await get_tickets(wallet_ids)]


-@events_ext.post("/api/v1/tickets/{event_id}/{sats}")
-async def api_ticket_make_ticket(event_id, sats, data: CreateTicket):
+@events_ext.get("/api/v1/tickets/{event_id}")
+async def api_ticket_make_ticket(event_id):
    event = await get_event(event_id)
    if not event:
        raise HTTPException(
@ -107,37 +107,36 @@ async def api_ticket_make_ticket(event_id, sats, data: CreateTicket):
    try:
        payment_hash, payment_request = await create_invoice(
            wallet_id=event.wallet,
-            amount=int(sats),
+            amount=event.price_per_ticket,
            memo=f"{event_id}",
            extra={"tag": "events"},
        )
    except Exception as e:
        raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail=str(e))

-    ticket = await create_ticket(
-        payment_hash=payment_hash,
-        wallet=event.wallet,
-        event=event_id,
-        name=data.name,
-        email=data.email,
-    )
-
-    if not ticket:
-        raise HTTPException(
-            status_code=HTTPStatus.NOT_FOUND, detail=f"Event could not be fetched."
-        )
-
    return {"payment_hash": payment_hash, "payment_request": payment_request}


-@events_ext.get("/api/v1/tickets/{payment_hash}")
-async def api_ticket_send_ticket(payment_hash):
-    ticket = await get_ticket(payment_hash)
-
+@events_ext.post("/api/v1/tickets/{event_id}/{payment_hash}")
+async def api_ticket_send_ticket(event_id, payment_hash, data: CreateTicket):
+    event = await get_event(event_id)
    try:
        status = await api_payment(payment_hash)
        if status["paid"]:
-            await set_ticket_paid(payment_hash=payment_hash)
+            ticket = await create_ticket(
+                payment_hash=payment_hash,
+                wallet=event.wallet,
+                event=event_id,
+                name=data.name,
+                email=data.email,
+            )
+
+            if not ticket:
+                raise HTTPException(
+                    status_code=HTTPStatus.NOT_FOUND,
+                    detail=f"Event could not be fetched.",
+                )
+
            return {"paid": True, "ticket_id": ticket.id}
    except Exception:
        raise HTTPException(status_code=HTTPStatus.NOT_FOUND, detail="Not paid")
--- a/lnbits/extensions/example/README.md
+++ b/lnbits/extensions/example/README.md
@ -0,0 +1,11 @@
+<h1>Example Extension</h1>
+<h2>*tagline*</h2>
+This is an example extension to help you organise and build you own.
+
+Try to include an image
+<img src="https://i.imgur.com/9i4xcQB.png">
+
+
+<h2>If your extension has API endpoints, include useful ones here</h2>
+
+<code>curl -H "Content-type: application/json" -X POST https://YOUR-LNBITS/YOUR-EXTENSION/api/v1/EXAMPLE -d '{"amount":"100","memo":"example"}' -H "X-Api-Key: YOUR_WALLET-ADMIN/INVOICE-KEY"</code>
--- a/lnbits/extensions/example/init.py
+++ b/lnbits/extensions/example/init.py
@ -0,0 +1,16 @@
+from fastapi import APIRouter
+
+from lnbits.db import Database
+from lnbits.helpers import template_renderer
+
+db = Database("ext_example")
+
+example_ext: APIRouter = APIRouter(prefix="/example", tags=["example"])
+
+
+def example_renderer():
+    return template_renderer(["lnbits/extensions/example/templates"])
+
+
+from .views import *  # noqa
+from .views_api import *  # noqa
--- a/lnbits/extensions/example/example.config.json
+++ b/lnbits/extensions/example/example.config.json
@ -0,0 +1,6 @@
+{
+  "name": "Build your own!!",
+  "short_description": "Join us, make an extension",
+  "icon": "info",
+  "contributors": ["github_username"]
+}
--- a/lnbits/extensions/example/migrations.py
+++ b/lnbits/extensions/example/migrations.py
@ -0,0 +1,10 @@
+# async def m001_initial(db):
+#    await db.execute(
+#        f"""
+#        CREATE TABLE example.example (
+#            id TEXT PRIMARY KEY,
+#            wallet TEXT NOT NULL,
+#            time TIMESTAMP NOT NULL DEFAULT {db.timestamp_now}
+#        );
+#    """
+#    )
--- a/lnbits/extensions/example/models.py
+++ b/lnbits/extensions/example/models.py
@ -0,0 +1,5 @@
+# from pydantic import BaseModel
+
+# class Example(BaseModel):
+#    id: str
+#    wallet: str
--- a/lnbits/extensions/example/templates/example/index.html
+++ b/lnbits/extensions/example/templates/example/index.html
@ -0,0 +1,59 @@
+{% extends "base.html" %} {% from "macros.jinja" import window_vars with context
+%} {% block page %}
+<q-card>
+  <q-card-section>
+    <h5 class="text-subtitle1 q-mt-none q-mb-md">
+      Frameworks used by {{SITE_TITLE}}
+    </h5>
+    <q-list>
+      <q-item
+        v-for="tool in tools"
+        :key="tool.name"
+        tag="a"
+        :href="tool.url"
+        target="_blank"
+      >
+        {% raw %}
+        <!-- with raw Flask won't try to interpret the Vue moustaches -->
+        <q-item-section>
+          <q-item-label>{{ tool.name }}</q-item-label>
+          <q-item-label caption>{{ tool.language }}</q-item-label>
+        </q-item-section>
+        {% endraw %}
+      </q-item>
+    </q-list>
+    <q-separator class="q-my-lg"></q-separator>
+    <p>
+      A magical "g" is always available, with info about the user, wallets and
+      extensions:
+    </p>
+    <code class="text-caption">{% raw %}{{ g }}{% endraw %}</code>
+  </q-card-section>
+</q-card>
+{% endblock %} {% block scripts %} {{ window_vars(user) }}
+<script>
+  new Vue({
+    el: '#vue',
+    mixins: [windowMixin],
+    data: function () {
+      return {
+        tools: []
+      }
+    },
+    created: function () {
+      var self = this
+
+      // axios is available for making requests
+      axios({
+        method: 'GET',
+        url: '/example/api/v1/tools',
+        headers: {
+          'X-example-header': 'not-used'
+        }
+      }).then(function (response) {
+        self.tools = response.data
+      })
+    }
+  })
+</script>
+{% endblock %}
--- a/lnbits/extensions/example/views.py
+++ b/lnbits/extensions/example/views.py
@ -0,0 +1,18 @@
+from fastapi import FastAPI, Request
+from fastapi.params import Depends
+from fastapi.templating import Jinja2Templates
+from starlette.responses import HTMLResponse
+
+from lnbits.core.models import User
+from lnbits.decorators import check_user_exists
+
+from . import example_ext, example_renderer
+
+templates = Jinja2Templates(directory="templates")
+
+
+@example_ext.get("/", response_class=HTMLResponse)
+async def index(request: Request, user: User = Depends(check_user_exists)):
+    return example_renderer().TemplateResponse(
+        "example/index.html", {"request": request, "user": user.dict()}
+    )
--- a/lnbits/extensions/example/views_api.py
+++ b/lnbits/extensions/example/views_api.py
@ -0,0 +1,35 @@
+# views_api.py is for you API endpoints that could be hit by another service
+
+# add your dependencies here
+
+# import httpx
+# (use httpx just like requests, except instead of response.ok there's only the
+#  response.is_error that is its inverse)
+
+from . import example_ext
+
+# add your endpoints here
+
+
+@example_ext.get("/api/v1/tools")
+async def api_example():
+    """Try to add descriptions for others."""
+    tools = [
+        {
+            "name": "fastAPI",
+            "url": "https://fastapi.tiangolo.com/",
+            "language": "Python",
+        },
+        {
+            "name": "Vue.js",
+            "url": "https://vuejs.org/",
+            "language": "JavaScript",
+        },
+        {
+            "name": "Quasar Framework",
+            "url": "https://quasar.dev/",
+            "language": "JavaScript",
+        },
+    ]
+
+    return tools
--- a/lnbits/extensions/jukebox/init.py
+++ b/lnbits/extensions/jukebox/init.py
@ -12,7 +12,7 @@ db = Database("ext_jukebox")
 jukebox_static_files = [
    {
        "path": "/jukebox/static",
-        "app": StaticFiles(directory="lnbits/extensions/jukebox/static"),
+        "app": StaticFiles(packages=[("lnbits", "extensions/jukebox/static")]),
        "name": "jukebox_static",
    }
 ]
--- a/lnbits/extensions/jukebox/crud.py
+++ b/lnbits/extensions/jukebox/crud.py
@ -41,7 +41,7 @@ async def update_jukebox(
    q = ", ".join([f"{field[0]} = ?" for field in data])
    items = [f"{field[1]}" for field in data]
    items.append(juke_id)
-    q = q.replace("user", '"user"', 1) # hack to make user be "user"!
+    q = q.replace("user", '"user"', 1)  # hack to make user be "user"!
    await db.execute(f"UPDATE jukebox.jukebox SET {q} WHERE id = ?", (items))
    row = await db.fetchone("SELECT * FROM jukebox.jukebox WHERE id = ?", (juke_id,))
    return Jukebox(**row) if row else None
--- a/lnbits/extensions/jukebox/models.py
+++ b/lnbits/extensions/jukebox/models.py
@ -1,9 +1,9 @@
-from typing import NamedTuple
 from sqlite3 import Row
+from typing import NamedTuple, Optional
+
 from fastapi.param_functions import Query
-from pydantic.main import BaseModel
 from pydantic import BaseModel
-from typing import Optional
+from pydantic.main import BaseModel


 class CreateJukeLinkData(BaseModel):
--- a/lnbits/extensions/jukebox/static/js/index.js
+++ b/lnbits/extensions/jukebox/static/js/index.js
@ -3,9 +3,9 @@
 Vue.component(VueQrcode.name, VueQrcode)

 var mapJukebox = obj => {
-  if(obj.sp_device){
+  if (obj.sp_device) {
    obj._data = _.clone(obj)
-   
+
    obj.sp_id = obj._data.id
    obj.device = obj._data.sp_device.split('-')[0]
    playlists = obj._data.sp_playlists.split(',')
@ -17,11 +17,9 @@ var mapJukebox = obj => {
    obj.playlist = playlistsar.join()
    console.log(obj)
    return obj
-  }
-  else {
+  } else {
    return
  }
-  
 }

 new Vue({
@ -87,14 +85,14 @@ new Vue({
      var link = _.findWhere(this.JukeboxLinks, {id: linkId})

      this.qrCodeDialog.data = _.clone(link)
-    
+
      this.qrCodeDialog.data.url =
        window.location.protocol + '//' + window.location.host
      this.qrCodeDialog.show = true
    },
    getJukeboxes() {
      self = this
-      
+
      LNbits.api
        .request(
          'GET',
@ -103,8 +101,7 @@ new Vue({
        )
        .then(function (response) {
          self.JukeboxLinks = response.data.map(function (obj) {
-
-                return mapJukebox(obj)
+            return mapJukebox(obj)
          })
          console.log(self.JukeboxLinks)
        })
@ -154,7 +151,7 @@ new Vue({
    submitSpotifyKeys() {
      self = this
      self.jukeboxDialog.data.user = self.g.user.id
-      
+
      LNbits.api
        .request(
          'POST',
--- a/lnbits/extensions/jukebox/tasks.py
+++ b/lnbits/extensions/jukebox/tasks.py
@ -16,7 +16,7 @@ async def wait_for_paid_invoices():


 async def on_invoice_paid(payment: Payment) -> None:
-    if "jukebox" != payment.extra.get("tag"):
+    if payment.extra.get("tag") != "jukebox":
        # not a jukebox invoice
        return
    await update_jukebox_payment(payment.payment_hash, paid=True)
--- a/lnbits/extensions/jukebox/templates/jukebox/_api_docs.html
+++ b/lnbits/extensions/jukebox/templates/jukebox/_api_docs.html
@ -24,6 +24,8 @@
  label="API info"
  :content-inset-level="0.5"
 >
+  <q-btn flat label="Swagger API" type="a" href="../docs#/jukebox"></q-btn>
+
  <q-expansion-item group="api" dense expand-separator label="List jukeboxes">
    <q-card>
      <q-card-section>
@ -37,8 +39,8 @@
        <code>[&lt;jukebox_object&gt;, ...]</code>
        <h5 class="text-caption q-mt-sm q-mb-none">Curl example</h5>
        <code
-          >curl -X GET {{ request.base_url }}api/v1/jukebox -H "X-Api-Key: {{
-          user.wallets[0].adminkey }}"
+          >curl -X GET {{ request.base_url }}jukebox/api/v1/jukebox -H
+          "X-Api-Key: {{ user.wallets[0].adminkey }}"
        </code>
      </q-card-section>
    </q-card>
@ -59,8 +61,9 @@
        <code>&lt;jukebox_object&gt;</code>
        <h5 class="text-caption q-mt-sm q-mb-none">Curl example</h5>
        <code
-          >curl -X GET {{ request.base_url }}api/v1/jukebox/&lt;juke_id&gt; -H
-          "X-Api-Key: {{ user.wallets[0].adminkey }}"
+          >curl -X GET {{ request.base_url
+          }}jukebox/api/v1/jukebox/&lt;juke_id&gt; -H "X-Api-Key: {{
+          user.wallets[0].adminkey }}"
        </code>
      </q-card-section>
    </q-card>
@ -86,8 +89,8 @@
        <code>&lt;jukbox_object&gt;</code>
        <h5 class="text-caption q-mt-sm q-mb-none">Curl example</h5>
        <code
-          >curl -X POST {{ request.base_url }}api/v1/jukebox/ -d '{"user":
-          &lt;string, user_id&gt;, "title": &lt;string&gt;,
+          >curl -X POST {{ request.base_url }}jukebox/api/v1/jukebox/ -d
+          '{"user": &lt;string, user_id&gt;, "title": &lt;string&gt;,
          "wallet":&lt;string&gt;, "sp_user": &lt;string,
          spotify_user_account&gt;, "sp_secret": &lt;string,
          spotify_user_secret&gt;, "sp_access_token": &lt;string,
@ -116,8 +119,9 @@
        <code>&lt;jukebox_object&gt;</code>
        <h5 class="text-caption q-mt-sm q-mb-none">Curl example</h5>
        <code
-          >curl -X DELETE {{ request.base_url }}api/v1/jukebox/&lt;juke_id&gt;
-          -H "X-Api-Key: {{ user.wallets[0].adminkey }}"
+          >curl -X DELETE {{ request.base_url
+          }}jukebox/api/v1/jukebox/&lt;juke_id&gt; -H "X-Api-Key: {{
+          user.wallets[0].adminkey }}"
        </code>
      </q-card-section>
    </q-card>
--- a/lnbits/extensions/jukebox/templates/jukebox/index.html
+++ b/lnbits/extensions/jukebox/templates/jukebox/index.html
@ -117,7 +117,7 @@
      >
        <q-step
          :name="1"
-          title="Pick wallet, price"
+          title="1. Pick Wallet and Price"
          icon="account_balance_wallet"
          :done="step > 1"
        >
@ -170,16 +170,25 @@
          <br />
        </q-step>

-        <q-step :name="2" title="Add api keys" icon="vpn_key" :done="step > 2">
+        <q-step
+          :name="2"
+          title="2. Add API keys"
+          icon="vpn_key"
+          :done="step > 2"
+        >
          <img src="/jukebox/static/spotapi.gif" />
          To use this extension you need a Spotify client ID and client secret.
-          You get these by creating an app in the Spotify developers dashboard
-          <a
+          You get these by creating an app in the Spotify Developer Dashboard
+          <br />
+          <br />
+          <q-btn
+            type="a"
            target="_blank"
-            style="color: #43a047"
+            color="primary"
            href="https://developer.spotify.com/dashboard/applications"
-            >here</a
-          >.
+            >Open the Spotify Developer Dashboard</q-btn
+          >
+
          <q-input
            filled
            class="q-pb-md q-pt-md"
@ -231,28 +240,39 @@
          <br />
        </q-step>

-        <q-step :name="3" title="Add Redirect URI" icon="link" :done="step > 3">
+        <q-step
+          :name="3"
+          title="3. Add Redirect URI"
+          icon="link"
+          :done="step > 3"
+        >
          <img src="/jukebox/static/spotapi1.gif" />
-          In the app go to edit-settings, set the redirect URI to this link
+          <p>
+            In the app go to edit-settings, set the redirect URI to this link
+          </p>
+          <q-card
+            class="cursor-pointer word-break"
+            @click="copyText(locationcb + jukeboxDialog.data.sp_id, 'Link copied to clipboard!')"
+          >
+            <q-card-section style="word-break: break-all">
+              {% raw %}{{ locationcb }}{{ jukeboxDialog.data.sp_id }}{% endraw
+              %}
+            </q-card-section>
+            <q-tooltip> Click to copy URL </q-tooltip>
+          </q-card>
          <br />
          <q-btn
-            dense
-            outline
-            unelevated
-            color="primary"
-            size="xs"
-            @click="copyText(locationcb + jukeboxDialog.data.sp_id, 'Link copied to clipboard!')"
-            >{% raw %}{{ locationcb }}{{ jukeboxDialog.data.sp_id }}{% endraw
-            %}<q-tooltip> Click to copy URL </q-tooltip>
-          </q-btn>
-          <br />
-          Settings can be found
-          <a
+            type="a"
            target="_blank"
-            style="color: #43a047"
+            color="primary"
            href="https://developer.spotify.com/dashboard/applications"
-            >here</a
-          >.
+            >Open the Spotify Application Settings</q-btn
+          >
+          <br /><br />
+          <p>
+            After adding the redirect URI, click the "Authorise access" button
+            below.
+          </p>

          <div class="row q-mt-md">
            <div class="col-4">
@ -281,7 +301,7 @@

        <q-step
          :name="4"
-          title="Select playlists"
+          title="4. Select Device and Playlists"
          icon="queue_music"
          active-color="primary"
          :done="step > 4"
--- a/lnbits/extensions/jukebox/views_api.py
+++ b/lnbits/extensions/jukebox/views_api.py
@ -455,5 +455,6 @@ async def api_get_jukebox_currently(
                )
        except:
            raise HTTPException(
-                status_code=HTTPStatus.NOT_FOUND, detail="Something went wrong, or no song is playing yet"
+                status_code=HTTPStatus.NOT_FOUND,
+                detail="Something went wrong, or no song is playing yet",
            )
--- a/lnbits/extensions/livestream/init.py
+++ b/lnbits/extensions/livestream/init.py
@ -12,7 +12,7 @@ db = Database("ext_livestream")
 livestream_static_files = [
    {
        "path": "/livestream/static",
-        "app": StaticFiles(directory="lnbits/extensions/livestream/static"),
+        "app": StaticFiles(packages=[("lnbits", "extensions/livestream/static")]),
        "name": "livestream_static",
    }
 ]
--- a/lnbits/extensions/livestream/tasks.py
+++ b/lnbits/extensions/livestream/tasks.py
@ -1,6 +1,8 @@
 import asyncio
 import json

+from loguru import logger
+
 from lnbits.core import db as core_db
 from lnbits.core.crud import create_payment
 from lnbits.core.models import Payment
@ -20,17 +22,17 @@ async def wait_for_paid_invoices():


 async def on_invoice_paid(payment: Payment) -> None:
-    if "livestream" != payment.extra.get("tag"):
+    if payment.extra.get("tag") != "livestream":
        # not a livestream invoice
        return

    track = await get_track(payment.extra.get("track", -1))
    if not track:
-        print("this should never happen", payment)
+        logger.error("this should never happen", payment)
        return

    if payment.extra.get("shared_with"):
-        print("payment was shared already", payment)
+        logger.error("payment was shared already", payment)
        return

    producer = await get_producer(track.producer)
--- a/lnbits/extensions/livestream/templates/livestream/_api_docs.html
+++ b/lnbits/extensions/livestream/templates/livestream/_api_docs.html
@ -17,6 +17,8 @@
  label="API info"
  :content-inset-level="0.5"
 >
+  <q-btn flat label="Swagger API" type="a" href="../docs#/livestream"></q-btn>
+
  <q-expansion-item
    group="api"
    dense
@ -38,8 +40,8 @@
        <code>[&lt;livestream_object&gt;, ...]</code>
        <h5 class="text-caption q-mt-sm q-mb-none">Curl example</h5>
        <code
-          >curl -X GET {{ request.url_root }}api/v1/livestream -H "X-Api-Key: {{
-          user.wallets[0].inkey }}"
+          >curl -X GET {{ request.base_url }}livestream/api/v1/livestream -H
+          "X-Api-Key: {{ user.wallets[0].inkey }}"
        </code>
      </q-card-section>
    </q-card>
@ -59,8 +61,8 @@
        </h5>
        <h5 class="text-caption q-mt-sm q-mb-none">Curl example</h5>
        <code
-          >curl -X PUT {{ request.url_root
-          }}api/v1/livestream/track/&lt;track_id&gt; -H "X-Api-Key: {{
+          >curl -X PUT {{ request.base_url }}
+          livestream/api/v1/livestream/track/&lt;track_id&gt; -H "X-Api-Key: {{
          user.wallets[0].inkey }}"
        </code>
      </q-card-section>
@ -81,8 +83,8 @@
        </h5>
        <h5 class="text-caption q-mt-sm q-mb-none">Curl example</h5>
        <code
-          >curl -X PUT {{ request.url_root
-          }}api/v1/livestream/fee/&lt;fee_pct&gt; -H "X-Api-Key: {{
+          >curl -X PUT {{ request.base_url }}
+          livestream/api/v1/livestream/fee/&lt;fee_pct&gt; -H "X-Api-Key: {{
          user.wallets[0].inkey }}"
        </code>
      </q-card-section>
@ -109,11 +111,12 @@
        </h5>
        <h5 class="text-caption q-mt-sm q-mb-none">Curl example</h5>
        <code
-          >curl -X POST {{ request.url_root }}api/v1/livestream/tracks -d
-          '{"name": &lt;string&gt;, "download_url": &lt;string&gt;,
-          "price_msat": &lt;integer&gt;, "producer_id": &lt;integer&gt;,
-          "producer_name": &lt;string&gt;}' -H "Content-type: application/json"
-          -H "X-Api-Key: {{ user.wallets[0].adminkey }}"
+          >curl -X POST {{ request.base_url }}
+          livestream/api/v1/livestream/tracks -d '{"name": &lt;string&gt;,
+          "download_url": &lt;string&gt;, "price_msat": &lt;integer&gt;,
+          "producer_id": &lt;integer&gt;, "producer_name": &lt;string&gt;}' -H
+          "Content-type: application/json" -H "X-Api-Key: {{
+          user.wallets[0].adminkey }}"
        </code>
      </q-card-section>
    </q-card>
@ -123,6 +126,7 @@
    dense
    expand-separator
    label="Delete a withdraw link"
+    class="q-pb-md"
  >
    <q-card>
      <q-card-section>
@ -136,8 +140,8 @@
        <code></code>
        <h5 class="text-caption q-mt-sm q-mb-none">Curl example</h5>
        <code
-          >curl -X DELETE {{ request.url_root
-          }}api/v1/livestream/tracks/&lt;track_id&gt; -H "X-Api-Key: {{
+          >curl -X DELETE {{ request.base_url }}
+          livestream/api/v1/livestream/tracks/&lt;track_id&gt; -H "X-Api-Key: {{
          user.wallets[0].inkey }}"
        </code>
      </q-card-section>
--- a/lnbits/extensions/livestream/views.py
+++ b/lnbits/extensions/livestream/views.py
@ -1,5 +1,4 @@
 from http import HTTPStatus
-# from mmap import MAP_DENYWRITE

 from fastapi.param_functions import Depends
 from fastapi.params import Query
@ -14,6 +13,8 @@ from lnbits.decorators import check_user_exists
 from . import livestream_ext, livestream_renderer
 from .crud import get_livestream_by_track, get_track

+# from mmap import MAP_DENYWRITE
+

@livestream_ext.get("/", response_class=HTMLResponse)
 async def index(request: Request, user: User = Depends(check_user_exists)):
--- a/lnbits/extensions/lnaddress/crud.py
+++ b/lnbits/extensions/lnaddress/crud.py
@ -1,6 +1,8 @@
 from datetime import datetime, timedelta
 from typing import List, Optional, Union

+from loguru import logger
+
 from lnbits.helpers import urlsafe_short_hash

 from . import db
@ -186,9 +188,9 @@ async def purge_addresses(domain_id: str):
        )  # give user 1 day to topup is address

        if not paid and pay_expire:
-            print("DELETE UNP_PAY_EXP", r["username"])
+            logger.debug("DELETE UNP_PAY_EXP", r["username"])
            await delete_address(r["id"])

        if paid and expired:
-            print("DELETE PAID_EXP", r["username"])
+            logger.debug("DELETE PAID_EXP", r["username"])
            await delete_address(r["id"])
--- a/lnbits/extensions/lnaddress/lnurl.py
+++ b/lnbits/extensions/lnaddress/lnurl.py
@ -9,6 +9,7 @@ from lnurl import (  # type: ignore
    LnurlPayActionResponse,
    LnurlPayResponse,
 )
+from loguru import logger
 from starlette.requests import Request
 from starlette.responses import HTMLResponse

@ -38,13 +39,12 @@ async def lnurl_response(username: str, domain: str, request: Request):
        "maxSendable": 1000000000,
    }

-    print("RESP", resp)
+    logger.debug("RESP", resp)
    return resp


@lnaddress_ext.get("/lnurl/cb/{address_id}", name="lnaddress.lnurl_callback")
 async def lnurl_callback(address_id, amount: int = Query(...)):
-    print("PING")
    address = await get_address(address_id)
    if not address:
        return LnurlErrorResponse(reason=f"Address not found").dict()
--- a/lnbits/extensions/lnaddress/tasks.py
+++ b/lnbits/extensions/lnaddress/tasks.py
@ -43,13 +43,13 @@ async def call_webhook_on_paid(payment_hash):


 async def on_invoice_paid(payment: Payment) -> None:
-    if "lnaddress" == payment.extra.get("tag"):
+    if payment.extra.get("tag") == "lnaddress":

        await payment.set_pending(False)
        await set_address_paid(payment_hash=payment.payment_hash)
        await call_webhook_on_paid(payment_hash=payment.payment_hash)

-    elif "renew lnaddress" == payment.extra.get("tag"):
+    elif payment.extra.get("tag") == "renew lnaddress":

        await payment.set_pending(False)
        await set_address_renewed(
--- a/lnbits/extensions/lnaddress/templates/lnaddress/_api_docs.html
+++ b/lnbits/extensions/lnaddress/templates/lnaddress/_api_docs.html
@ -31,6 +31,7 @@
  label="API info"
  :content-inset-level="0.5"
 >
+  <q-btn flat label="Swagger API" type="a" href="../docs#/lnaddress"></q-btn>
  <q-expansion-item group="api" dense expand-separator label="GET domains">
    <q-card>
      <q-card-section>
@ -45,7 +46,7 @@
        <code>JSON list of users</code>
        <h5 class="text-caption q-mt-sm q-mb-none">Curl example</h5>
        <code
-          >curl -X GET {{ request.url_root }}lnaddress/api/v1/domains -H
+          >curl -X GET {{ request.base_url }}lnaddress/api/v1/domains -H
          "X-Api-Key: {{ user.wallets[0].inkey }}"
        </code>
      </q-card-section>
@ -81,7 +82,7 @@
        >
        <h5 class="text-caption q-mt-sm q-mb-none">Curl example</h5>
        <code
-          >curl -X POST {{ request.url_root }}lnaddress/api/v1/domains -d
+          >curl -X POST {{ request.base_url }}lnaddress/api/v1/domains -d
          '{"wallet": "{{ user.wallets[0].id }}", "domain": &lt;string&gt;,
          "cf_token": &lt;string&gt;,"cf_zone_id": &lt;string&gt;,"webhook":
          &lt;Optional string&gt; ,"cost": &lt;integer&gt;}' -H "X-Api-Key: {{
@ -101,7 +102,7 @@
        <code>{"X-Api-Key": &lt;string&gt;}</code>
        <h5 class="text-caption q-mt-sm q-mb-none">Curl example</h5>
        <code
-          >curl -X DELETE {{ request.url_root
+          >curl -X DELETE {{ request.base_url
          }}lnaddress/api/v1/domains/&lt;domain_id&gt; -H "X-Api-Key: {{
          user.wallets[0].inkey }}"
        </code>
@ -122,7 +123,7 @@
        <code>JSON list of addresses</code>
        <h5 class="text-caption q-mt-sm q-mb-none">Curl example</h5>
        <code
-          >curl -X GET {{ request.url_root }}lnaddress/api/v1/addresses -H
+          >curl -X GET {{ request.base_url }}lnaddress/api/v1/addresses -H
          "X-Api-Key: {{ user.wallets[0].inkey }}"
        </code>
      </q-card-section>
@ -142,14 +143,20 @@
        <code>JSON list of addresses</code>
        <h5 class="text-caption q-mt-sm q-mb-none">Curl example</h5>
        <code
-          >curl -X GET {{ request.url_root
+          >curl -X GET {{ request.base_url
          }}lnaddress/api/v1/address/&lt;domain&gt;/&lt;username&gt;/&lt;wallet_key&gt;
          -H "X-Api-Key: {{ user.wallets[0].inkey }}"
        </code>
      </q-card-section>
    </q-card>
  </q-expansion-item>
-  <q-expansion-item group="api" dense expand-separator label="POST address">
+  <q-expansion-item
+    group="api"
+    dense
+    expand-separator
+    label="POST address"
+    class="q-pb-md"
+  >
    <q-card>
      <q-card-section>
        <code
@ -160,7 +167,7 @@
        <code>{"X-Api-Key": &lt;string&gt;}</code>
        <h5 class="text-caption q-mt-sm q-mb-none">Curl example</h5>
        <code
-          >curl -X POST {{ request.url_root
+          >curl -X POST {{ request.base_url
          }}lnaddress/api/v1/address/&lt;domain_id&gt; -d '{"domain":
          &lt;string&gt;, "username": &lt;string&gt;,"email": &lt;Optional
          string&gt;, "wallet_endpoint": &lt;string&gt;, "wallet_key":
--- a/lnbits/extensions/lnaddress/templates/lnaddress/display.html
+++ b/lnbits/extensions/lnaddress/templates/lnaddress/display.html
@ -372,7 +372,7 @@
        }
        data.wallet_endpoint = data.wallet_endpoint ?? '{{ root_url }}'
        data.duration = parseInt(data.duration)
-        
+
        axios
          .post('/lnaddress/api/v1/address/{{ domain_id }}', data)
          .then(response => {
--- a/lnbits/extensions/lnaddress/templates/lnaddress/index.html
+++ b/lnbits/extensions/lnaddress/templates/lnaddress/index.html
@ -191,9 +191,13 @@
          type="text"
          label="Cloudflare API token"
        >
-        <template v-slot:hint>
-          Check extension <a href="https://github.com/lnbits/lnbits-legend/tree/master/lnbits/extensions/lnaddress">documentation!</a>
-        </template>
+          <template v-slot:hint>
+            Check extension
+            <a
+              href="https://github.com/lnbits/lnbits-legend/blob/main/lnbits/extensions/lnaddress/README.md"
+              >documentation!</a
+            >
+          </template>
          <q-tooltip class="bg-grey-8" anchor="bottom left" self="top left"
            >Your API key in cloudflare</q-tooltip
          >
--- a/Show more
+++ b/Show more
				`@ -1 +0,0 @@`
				`web: hypercorn -k trio --bind 0.0.0.0:5000 'lnbits.app:create_app()'`